func stringToQueue(s string) ([]spec.NetworkPayload, error) {
var queue []spec.NetworkPayload
for _, s := range strings.Split(s, ",") {
np := networkpayload.MustNew()
err := json.Unmarshal([]byte(s), &np)
if err != nil {
return nil, maskAny(err)
}
queue = append(queue, np)
}
return queue, nil
}
func (n *network) EventListener(canceler <-chan struct{}) error {
invokeEventHandler := func() error {
// Fetch the next network payload from the queue. This call blocks until one
// network payload was fetched from the queue. As soon as we receive the
// network payload, it is removed from the queue automatically, so it is not
// handled twice.
eventKey := key.NewNetworkKey("event:network-payload")
element, err := n.Storage().General().PopFromList(eventKey)
if err != nil {
return maskAny(err)
}
networkPayload := networkpayload.MustNew()
err = json.Unmarshal([]byte(element), &networkPayload)
if err != nil {
return maskAny(err)
}
// Lookup the CLG that is supposed to be executed. The CLG object is
// referenced by name. When being executed it is referenced by its behaviour
// ID. The behaviour ID represents a specific peer within a connection path.
clgName, ok := networkPayload.GetContext().GetCLGName()
if !ok {
return maskAnyf(invalidCLGNameError, "must not be empty")
}
CLG, ok := n.CLGs[clgName]
if !ok {
return maskAnyf(clgNotFoundError, "name: %s", clgName)
}
// Invoke the event handler to execute the given CLG using the given network
// payload. Here we execute one distinct behaviour within its own scope. The
// CLG decides if and how it is activated, how it calculates its output, if
// any, and where to forward signals to, if any.
err = n.EventHandler(CLG, networkPayload)
if err != nil {
return maskAny(err)
}
return nil
}
for {
select {
case <-canceler:
return maskAny(workerCanceledError)
default:
n.logNetworkError(invokeEventHandler())
}
}
}