CXO update Root

handle.go

// in this example the Event is an event, that requires updates in our Root
func startHandlingSomePack(events <-chan Event, pack *skyobject.Pack,
	n *node.Node, wg *sync.WaitGroup) {

	go handleSomePack(n, pack, events, n.Quiting(), wg)
}

func handleSomePack(n *node.Node, pack *cxo.Pack, events <-chan Event,
	quit <-chan struct{}, wg *sync.WaitGroup) {

	defer wg.Done()

	for {
		select {
		case evt := <-events:
			// perform changes using the evt (Event)
			performCahnges(pack, evt)
			perfomAllChangesPossible(quit, events, pack, n)
		case <-quit:
			return
		}
	}
}

func performAllCahgnesPossible(quit <-chan struct{}, events <-chan Event,
	pack *skyobject.Pack, n *node.Node) {

	tm := time.NewTimer(MinPublishInterval)
	defer tm.Stop()

	// perform all changes possible and publish
	for {
		select {
		case <-quit:
			return
		case evt := <-events:
			performCahnges(pack, evt)
		case <-tm.C:
			// to many changes performed but not published yet
			publish(n, pack)
			tm.Reset(MinPubishInterval) // start the timer again
		default:
			// no more events, no more changes
			publish(n, pack)
			return
		}
	}
}

func publish(n *node.Node, pack *skyobject.Pack) {
	if _, err := pack.Save(); err != nil {
		// fatality: handle the err
	}
	n.Publish(pack.Root())
}

func performCahgnes(pack *skyobject.Pack, evt Event) {
	// stuff
}