func (n *network) Calculate(CLG systemspec.CLG, networkPayload objectspec.NetworkPayload) (objectspec.NetworkPayload, error) {
n.Log.WithTags(systemspec.Tags{C: nil, L: "D", O: n, V: 13}, "call Calculate")
outputs, err := filterError(reflect.ValueOf(CLG.GetCalculate()).Call(networkPayload.GetCLGInput()))
if err != nil {
return nil, maskAny(err)
}
newNetworkPayloadConfig := networkpayload.DefaultConfig()
newNetworkPayloadConfig.Args = outputs
newNetworkPayloadConfig.Context = networkPayload.GetContext()
newNetworkPayloadConfig.Destination = networkPayload.GetDestination()
newNetworkPayloadConfig.Sources = networkPayload.GetSources()
newNetworkPayload, err := networkpayload.New(newNetworkPayloadConfig)
if err != nil {
return nil, maskAny(err)
}
return newNetworkPayload, nil
}
func (a *activator) Activate(CLG systemspec.CLG, networkPayload objectspec.NetworkPayload) (objectspec.NetworkPayload, error) {
a.Log.WithTags(systemspec.Tags{C: nil, L: "D", O: a, V: 13}, "call Activate")
// Fetch the queued network payloads. queue is a string of comma separated
// JSON objects representing a specific network payload.
behaviourID, ok := networkPayload.GetContext().GetBehaviourID()
if !ok {
return nil, maskAnyf(invalidBehaviourIDError, "must not be empty")
}
queueKey := key.NewNetworkKey("activate:queue:behaviour-id:%s:network-payload", behaviourID)
s, err := a.Storage().General().Get(queueKey)
if err != nil {
return nil, maskAny(err)
}
queue, err := stringToQueue(s)
if err != nil {
return nil, maskAny(err)
}
// Merge the given network payload with the queue that we just fetched from
// storage. We store the extended queue directly after merging it with the
// given network payload to definitely track the received network payload,
// even if something goes wrong and we need to return an error on the code
// below. In case the current queue exeeds a certain amount of payloads, it is
// unlikely that the queue is going to be helpful when growing any further.
// Thus we cut the queue at some point beyond the interface capabilities of
// the requested CLG. Note that it is possible to have multiple network
// payloads sent by the same CLG. That might happen in case a specific CLG
// wants to fulfil the interface of the requested CLG on its own, even it is
// not able to do so with the output of a single calculation.
queue = append(queue, networkPayload)
queueBuffer := len(getInputTypes(CLG.GetCalculate())) + 1
if len(queue) > queueBuffer {
queue = queue[1:]
}
err = a.persistQueue(queueKey, queue)
if err != nil {
return nil, maskAny(err)
}
// This is the list of lookup functions which is executed seuqentially.
lookups := []func(CLG systemspec.CLG, queue []objectspec.NetworkPayload) (objectspec.NetworkPayload, error){
a.GetNetworkPayload,
a.New,
}
// Execute one lookup after another. As soon as we find a network payload, we
// return it.
var newNetworkPayload objectspec.NetworkPayload
for _, lookup := range lookups {
newNetworkPayload, err = lookup(CLG, queue)
if IsNetworkPayloadNotFound(err) {
// There could no network payload be found by this lookup. Go on and try
// the next one.
continue
} else if err != nil {
return nil, maskAny(err)
}
// The current lookup was successful. We do not need to execute any further
// lookup, but can go on with the network payload found.
break
}
// Filter all network payloads from the queue that are merged into the new
// network payload.
var newQueue []objectspec.NetworkPayload
for _, s := range newNetworkPayload.GetSources() {
for _, np := range queue {
// At this point there is only one source given. That is the CLG that
// forwarded the current network payload to here. If this is not the case,
// we return an error.
sources := np.GetSources()
if len(sources) != 1 {
return nil, maskAnyf(invalidSourcesError, "there must be one source")
}
if s == sources[0] {
// The current network payload is part of the merged network payload.
// Thus we do not add it to the new queue.
continue
}
newQueue = append(newQueue, np)
}
}
// Update the modified queue in the underlying storage.
err = a.persistQueue(queueKey, newQueue)
if err != nil {
return nil, maskAny(err)
}
// The current lookup was able to find a network payload. Thus we simply
// return it.
return newNetworkPayload, nil
}
func (a *activator) New(CLG systemspec.CLG, queue []objectspec.NetworkPayload) (objectspec.NetworkPayload, error) {
// Track the input types of the requested CLG as string slice to have
// something that is easily comparable and efficient. By convention the first
// input argument of each CLG is a context. We remove the first argument here,
// because we want to match output interfaces against input interfaces. By
// convention output interfaces of CLGs must not have a context as first
// return value. Therefore we align the input and output values to make them
// comparable.
clgTypes := typesToStrings(getInputTypes(CLG.GetCalculate()))[1:]
// Prepare the permutation list to find out which combination of payloads
// satisfies the requested CLG's interface.
newPermutationListConfig := permutation.DefaultListConfig()
newPermutationListConfig.MaxGrowth = len(clgTypes)
newPermutationListConfig.RawValues = queueToValues(queue)
newPermutationList, err := permutation.NewList(newPermutationListConfig)
if err != nil {
return nil, maskAny(err)
}
// Permute the permutation list of the queued network payloads until we found
// all the matching combinations.
var possibleMatches [][]objectspec.NetworkPayload
for {
// Check if the current combination of network payloads already satisfies
// the interface of the requested CLG. This is done in the first place to
// also handle the very first combination of the permutation list. In case
// there does a combination of network payloads match the interface of the
// requested CLG, we capture the found combination and try to find more
// combinations in the upcoming loops.
permutedValues := newPermutationList.GetPermutedValues()
valueTypes := typesToStrings(valuesToTypes(permutedValues))
if equalStrings(clgTypes, valueTypes) {
possibleMatches = append(possibleMatches, valuesToQueue(permutedValues))
}
// Permute the list of the queued network payloads by one further
// permutation step within the current iteration. As soon as the permutation
// list cannot be permuted anymore, we stop the permutation loop to choose
// one random combination of the tracked list in the next step below.
err = a.Service().Permutation().PermuteBy(newPermutationList, 1)
if permutation.IsMaxGrowthReached(err) {
break
} else if err != nil {
return nil, maskAny(err)
}
}
// We fetched all possible combinations if network payloads that match the
// interface of the requested CLG. Now we need to select one random
// combination to cover all possible combinations across all possible CLG
// trees being created over time. This prevents us from choosing always only
// the first matching combination, which would lack discoveries of all
// potential combinations being created.
matchIndex, err := a.Service().Random().CreateMax(len(possibleMatches))
if err != nil {
return nil, maskAny(err)
}
matches := possibleMatches[matchIndex]
// The queued network payloads are able to satisfy the interface of the
// requested CLG. We merge the matching network payloads together and return
// the result after storing the created configuration of the requested CLG.
newNetworkPayload, err := mergeNetworkPayloads(matches)
if err != nil {
return nil, maskAny(err)
}
// Persists the combination of permuted network payloads as configuration for
// the requested CLG. This configuration is stored using references of the
// behaviour IDs associated with CLGs that forwarded signals to this requested
// CLG. Note that the order of behaviour IDs must be preserved, because it
// represents the input interface of the requested CLG.
behaviourID, ok := newNetworkPayload.GetContext().GetBehaviourID()
if !ok {
return nil, maskAnyf(invalidBehaviourIDError, "must not be empty")
}
behaviourIDsKey := key.NewNetworkKey("activate:configuration:behaviour-id:%s:behaviour-ids", behaviourID)
var behaviourIDs []string
for _, behaviourID := range newNetworkPayload.GetSources() {
behaviourIDs = append(behaviourIDs, string(behaviourID))
}
err = a.Storage().General().Set(behaviourIDsKey, strings.Join(behaviourIDs, ","))
if err != nil {
return nil, maskAny(err)
}
return newNetworkPayload, nil
}
