public override BehaviorStatus UpdateTick(BehaviorContext context) { var unit = (Unit) context[_subjectVar]; var targetStack = (Stack_Object) context[_targetStack]; var potentialClues = unit.GetPotentialClues(); if (potentialClues.Length == 0) return BehaviorStatus.Failure; if (targetStack.Count == 0) { targetStack = new Stack_Object(potentialClues); context[_targetStack] = targetStack; } else { for (var i = 0; i < potentialClues.Length; i++) { targetStack.Push(potentialClues[i]); } } return BehaviorStatus.Success; }
public void Invoke(BehaviorContext context, Action next) { // for now we cheat and pull it from the behavior context: var callbackInvoked = context.Get<bool>(CallbackInvocationBehavior.CallbackInvokedKey); var messageHandlers = new LoadedMessageHandlers(); foreach (var messageToHandle in context.Get<LogicalMessages>()) { var handlerTypedToInvoke = HandlerRegistry.GetHandlerTypes(messageToHandle.MessageType).ToList(); if (!callbackInvoked && !handlerTypedToInvoke.Any()) { var error = string.Format("No handlers could be found for message type: {0}", messageToHandle.MessageType); throw new InvalidOperationException(error); } foreach (var handlerType in handlerTypedToInvoke) { messageHandlers.AddHandler(messageToHandle.MessageType, context.Builder.Build(handlerType)); } } context.Set(messageHandlers); next(); }
public void Invoke(BehaviorContext context, Action next) { var messageWasHandled = HandleCorrelatedMessage(context.TransportMessage, context.Get<LogicalMessages>()); context.Set(CallbackInvokedKey, messageWasHandled); next(); }
public BehaviorContext GetNewContext() { var newContext = new BehaviorContext(); behaviorContexts.Add(new WeakReferenceT<BehaviorContext>(newContext)); return newContext; }
void DispatchMessageToHandlersBasedOnType(IBuilder builder, LogicalMessage toHandle, LoadedMessageHandlers loadedHandlers, BehaviorContext context) { foreach (var loadedHandler in loadedHandlers.GetHandlersFor(toHandle.MessageType)) { if (loadedHandler.InvocationDisabled) continue; var handlerInstance = loadedHandler.Instance; try { //until we have a outgoing pipeline that inherits context from the main one if (handlerInstance is ISaga) { SagaContext.Current = (ISaga) handlerInstance; } var handlerTypeToInvoke = handlerInstance.GetType(); //for backwards compatibility (users can have registered their own factory var factory = GetDispatcherFactoryFor(handlerTypeToInvoke, builder); if (factory != null) { var dispatchers = factory.GetDispatcher(handlerTypeToInvoke, builder, toHandle.Instance).ToList(); dispatchers.ForEach(dispatch => { log.DebugFormat("Dispatching message '{0}' to handler '{1}'", toHandle.MessageType, handlerTypeToInvoke); try { dispatch(); } catch (Exception e) { log.Warn(handlerTypeToInvoke.Name + " failed handling message.", e); throw new TransportMessageHandlingFailedException(e); } }); } else { loadedHandler.Invocation(handlerInstance, toHandle.Instance); } //for now we have to check of the chain is aborted but this will go away when we refactor the handlers to be a subpipeline if (context.ChainAborted) { log.DebugFormat("Handler {0} requested downstream handlers of message {1} to not be invoked", handlerTypeToInvoke,toHandle.MessageType); return; } } finally { SagaContext.Current = null; } } }
internal IncomingContext(BehaviorContext parentContext, TransportMessage transportMessage) : base(parentContext) { handleCurrentMessageLaterWasCalled = false; Set(IncomingPhysicalMessageKey, transportMessage); LogicalMessages = new List<LogicalMessage>(); }
public void Invoke(BehaviorContext context, Action next) { var msg = context.TransportMessage; log.DebugFormat("Received message with ID {0} from sender {1}", msg.Id, msg.ReplyToAddress); next(); log.Debug("Finished handling message."); }
public void InvokeBehavior(IBuilder builder) { var runner = new UnitOfWorkBehavior(); using (var context = new BehaviorContext(builder, new TransportMessage(), new BehaviorContextStacker())) { runner.Invoke(context, () => { }); } }
public ReceivePhysicalMessageContext(BehaviorContext parentContext, TransportMessage transportMessage, bool messageHandlingDisabled) : base(parentContext) { handleCurrentMessageLaterWasCalled = false; Set(IncomingPhysicalMessageKey, transportMessage); Set("MessageHandlingDisabled", messageHandlingDisabled); LogicalMessages = new List<LogicalMessage>(); }
public void Invoke(BehaviorContext context, Action next) { var mutators = context.Builder.BuildAll<IMutateIncomingTransportMessages>(); foreach (var mutator in mutators) { mutator.MutateIncoming(context.TransportMessage); } next(); }
public virtual void Initialize(GameController gameController) { _gameController = gameController; var bState = gameController.behaviorState; _behaviorContext = bState.GetNewContext(); InitializeBehaviorContext(_behaviorContext); InitializeBehaviorTree(bState); }
public void Invoke(BehaviorContext context, Action next) { var messageHandlers = context.Get<LoadedMessageHandlers>(); foreach (var messageToHandle in context.Get<LogicalMessages>()) { ExtensionMethods.CurrentMessageBeingHandled = messageToHandle.Instance; DispatchMessageToHandlersBasedOnType(context.Builder, messageToHandle, messageHandlers,context); } ExtensionMethods.CurrentMessageBeingHandled = null; next(); }
public override BehaviorPriority DeterminePriority(BehaviorContext context) { foreach (Entity other in context.OtherEntities) { if (other.IsAiControlled) continue; var offset = Entity.PositionData.Placement.Pos - other.PositionData.Placement.Pos; if (offset.Length < 4) { return BehaviorPriority.Value(4); } } return BehaviorPriority.NA; }
public void Invoke(BehaviorContext context, Action next) { next(); if (ForwardReceivedMessagesTo != null && ForwardReceivedMessagesTo != Address.Undefined) { MessageSender.ForwardMessage(context.TransportMessage, TimeToBeReceivedOnForwardedMessages, ForwardReceivedMessagesTo); } //To cope with people hacking UnicastBus.ForwardReceivedMessagesTo at runtime. will be removed when we remove UnicastBus.ForwardReceivedMessagesTo if (UnicastBus.ForwardReceivedMessagesTo != ForwardReceivedMessagesTo) { if (UnicastBus.ForwardReceivedMessagesTo != null && UnicastBus.ForwardReceivedMessagesTo != Address.Undefined) { MessageSender.ForwardMessage(context.TransportMessage, UnicastBus.TimeToBeReceivedOnForwardedMessages, UnicastBus.ForwardReceivedMessagesTo); } } }
public override void Behave(BehaviorContext context) { var horizontal = Entity.PositionData.Placement.Orientation.Horizontal; if (context.ElapsedDuration.Seconds >= 10.0 * Rng.NextExp()) { horizontal = Rng.NextDouble() * 2 * Math.PI; } else if (context.ElapsedDuration.Seconds > 1.0 * Rng.NextExp()) { horizontal += (Rng.NextDouble() * 2 - 1) * 0.25; } var orientation = Entity.PositionData.Placement.Orientation = new EntityOrientation(horizontal, 0); var velocity = -0.125 * context.PhysicsValues.PlayerMovementSpeed * (EntityOffset)orientation; Entity.PositionData.Velocity.X = velocity.X; Entity.PositionData.Velocity.Z = velocity.Z; }
public void Invoke(BehaviorContext context, Action next) { foreach (var logicalMessage in context.Get<LogicalMessages>()) { foreach (var mutator in context.Builder.BuildAll<IMutateIncomingMessages>()) { var current = logicalMessage.Instance; //message mutators may need to assume that this has been set (eg. for the purposes of headers). ExtensionMethods.CurrentMessageBeingHandled = current; logicalMessage.UpdateMessageInstance(mutator.MutateIncoming(current)); } } next(); }
public void Invoke(BehaviorContext context, Action next) { var principal = ExtractIncomingPrincipal.GetPrincipal(context.TransportMessage); if (principal == null) { next(); return; } var previousPrincipal = Thread.CurrentPrincipal; try { Thread.CurrentPrincipal = principal; next(); } finally { Thread.CurrentPrincipal = previousPrincipal; } }
public void Invoke(BehaviorContext context, Action next) { try { foreach (var uow in context.Builder.BuildAll<IManageUnitsOfWork>()) { unitsOfWork.Push(uow); uow.Begin(); } next(); while (unitsOfWork.Count > 0) { unitsOfWork.Pop().End(); } } catch (Exception exception) { AppendEndExceptionsAndRethrow(exception); } }
public void Invoke(BehaviorContext context, Action next) { var logicalMessages = new LogicalMessages(); context.Set(logicalMessages); if (SkipDeserialization || UnicastBus.SkipDeserialization) { return; } var transportMessage = context.TransportMessage; object[] rawMessages; try { rawMessages = Extract(transportMessage); } catch (Exception exception) { throw new SerializationException(string.Format("An error occurred while attempting to extract logical messages from transport message {0}", transportMessage), exception); } if (!transportMessage.IsControlMessage() && !rawMessages.Any()) { log.Warn("Received an empty message - ignoring."); return; } foreach (var rawMessage in rawMessages) { var messageType = MessageMapper.GetMappedTypeFor(rawMessage.GetType()); logicalMessages.Add(new LogicalMessage(messageType,rawMessage)); } next(); }
private void LogOrderReceived(BehaviorContext <BurgerOrderStateInstance, OrderCreated> context) { _logger.LogInformation("Order recieved: {0}", context.Data.AggregateId); }
public KafkaMessageSender(IRoutingTopology routingTopology, IChannelProvider channelProvider, BehaviorContext context) { this.routingTopology = routingTopology; this.channelProvider = channelProvider; this.context = context; }
protected virtual void InitBehaviourTree() { const string SUBJECT = "S_SUBJECT"; _behaviorContext = new BehaviorContext(); _behaviorContext[SUBJECT] = this; if (BehaviorTreeGlobals.behaviorTrees.ContainsKey(BaseUnitBehaviorTreeKey) && BehaviorTreeGlobals.behaviorTrees[BaseUnitBehaviorTreeKey].IsAlive) { behaviourTree = BehaviorTreeGlobals.behaviorTrees[BaseUnitBehaviorTreeKey].Target; } else { behaviourTree = new EntryNode( new IsNullNode("Ghello") , BaseUnitBehaviorTreeKey); } // BehaviorTreeGlobals.EntryNodes.Add(new WeakReferenceT<INode>(behaviourTree)); BehaviorTreeGlobals.behaviorContexts.Add(new WeakReferenceT<BehaviorContext>(_behaviorContext)); }
public static Task RespondAsync <TInstance, TData, T>(this BehaviorContext <TInstance, TData> context, object values) where T : class { return(GetConsumeContext(context).RespondAsync <T>(values)); }
public static Task Publish <TInstance, TData, T>(this BehaviorContext <TInstance, TData> context, T message, IPipe <SendContext <T> > sendPipe) where T : class { return(GetConsumeContext(context).Publish(message, sendPipe)); }
public static Task Publish <TInstance, TData>(this BehaviorContext <TInstance, TData> context, object message, Type messageType, IPipe <SendContext> sendPipe) { return(GetConsumeContext(context).Publish(message, messageType, sendPipe)); }
public static Task <ISendEndpoint> GetSendEndpoint <TInstance, TData>(this BehaviorContext <TInstance, TData> context, Uri address) { return(GetConsumeContext(context).GetSendEndpoint(address)); }
Task Behavior <TInstance> .Execute <T>(BehaviorContext <TInstance, T> context) { return(_next.Faulted(_context)); }
Task Activity <TInstance> .Execute <TData>(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next) { return(next.Execute(context)); }
Task Behavior <TInstance> .Execute <T>(BehaviorContext <TInstance, T> context) { return(TaskUtil.Completed); }
protected override bool OnExecute(BehaviorContext context) { return(!child.Execute(context)); }
public static Task Faulted <TInstance, TData>(Behavior <TInstance, TData> behavior, BehaviorContext <TInstance, TData> context, Exception exception) { if (exception == null) { throw new ArgumentNullException(nameof(exception)); } return(GetOrAdd(exception.GetType()).Faulted(behavior, context, exception)); }
private void Initialize(BehaviorContext <BurgerOrderStateInstance, SubmitBurgerOrder> context) { _logger.LogInformation("Initializing: {0}", context.Data.OrderId); InitializeInstance(context.Instance, context.Data); }
private void LogOrderProcessed(BehaviorContext <BurgerOrderStateInstance, BurgerOrderProcessed> context) { _logger.LogInformation("Order processed: {0}", context.Data.OrderId); }
/// <summary> /// Creates a new instance of <see cref="OutgoingContext"/>. /// </summary> /// <param name="parentContext">The parent context.</param> /// <param name="deliveryOptions">The delivery options.</param> /// <param name="message">The actual message to be sent out.</param> public OutgoingContext(BehaviorContext parentContext, DeliveryOptions deliveryOptions, LogicalMessage message) : base(parentContext) { Set(deliveryOptions); Set(OutgoingLogicalMessageKey, message); }
public void OnSavingChild(BehaviorContext context) { if (!syncEnabled) { return; } var child = context.AffectedItem; var parent = context.Parent; var initialState = parent.ChildState; var childInducedState = child.GetCollectionState(); if (parent.ChildState == CollectionState.IsEmpty) { // no previous child state parent.ChildState = childInducedState; context.UnsavedItems.Add(parent); return; } if (Is(initialState, CollectionState.IsLarge)) { CollectionState newState = CollectionState.IsLarge; if (parent.Children.FindCount(Parameter.IsNull("ZoneName") & Parameter.Equal("Visible", true) & Parameter.Equal("AlteredPermissions", Permission.None)) > 0) { newState |= CollectionState.ContainsVisiblePublicPages; } if (parent.Children.FindCount(Parameter.IsNull("ZoneName") & Parameter.Equal("Visible", false) & Parameter.Equal("AlteredPermissions", Permission.None)) > 0) { newState |= CollectionState.ContainsHiddenPublicPages; } if (parent.Children.FindCount(Parameter.IsNull("ZoneName") & Parameter.Equal("Visible", true) & Parameter.NotEqual("AlteredPermissions", Permission.None)) > 0) { newState |= CollectionState.ContainsVisibleSecuredPages; } if (parent.Children.FindCount(Parameter.IsNull("ZoneName") & Parameter.Equal("Visible", false) & Parameter.NotEqual("AlteredPermissions", Permission.None)) > 0) { newState |= CollectionState.ContainsHiddenSecuredPages; } if (parent.Children.FindCount(Parameter.IsNotNull("ZoneName") & Parameter.Equal("AlteredPermissions", Permission.None)) > 0) { newState |= CollectionState.ContainsPublicParts; } if (parent.Children.FindCount(Parameter.IsNotNull("ZoneName") & Parameter.NotEqual("AlteredPermissions", Permission.None)) > 0) { newState |= CollectionState.ContainsSecuredParts; } if (newState != initialState) { parent.ChildState = newState; context.UnsavedItems.Add(parent); } return; } var reducedState = ReduceExistingStates(null, parent, initialState); if (reducedState == CollectionExtensions.None) { if (Is(initialState, childInducedState)) { // unchanged child state return; } // added child state parent.ChildState |= childInducedState; } else { // changed child state parent.ChildState ^= reducedState; parent.ChildState |= childInducedState; } context.UnsavedItems.Add(parent); }
protected WriterBase(BehaviorContext behaviorContext) { BehaviorContext = behaviorContext; }
public static Task Publish <TInstance, TData, T>(this BehaviorContext <TInstance, TData> context, object values, IPipe <SendContext> sendPipe) where T : class { return(GetConsumeContext(context).Publish <T>(values, sendPipe)); }
public async Task Execute <T>(BehaviorContext <TInstance, T> context, Behavior <TInstance, T> next) { await Execute(context); await next.Execute(context); }
public static Task Publish <TInstance, TData>(this BehaviorContext <TInstance, TData> context, object message) { return(GetConsumeContext(context).Publish(message)); }
public HandlerInvocationContext(BehaviorContext parentContext, MessageHandler messageHandler) : base(parentContext) { Set(messageHandler); }
public static void Respond <TInstance, TData, T>(this BehaviorContext <TInstance, TData> context, T message) where T : class { GetConsumeContext(context).Respond(message); }
public Task Execute(BehaviorContext <TInstance, Fault <TRequest> > context, Behavior <TInstance, Fault <TRequest> > next) { request.Accessor.SetFaulted(context, request.GetItem(context, context.CreateConsumeContext().RequestId.Value), context.Data); return(next.Execute(context)); }
void ISavingBehavior.OnSaving(BehaviorContext context) { }
public static Task RespondAsync <TInstance, TData>(this BehaviorContext <TInstance, TData> context, object message, IPipe <SendContext> sendPipe) { return(GetConsumeContext(context).RespondAsync(message, sendPipe)); }
public SendPhysicalMessageContext(BehaviorContext parentContext, SendOptions sendOptions, TransportMessage message) : base(parentContext) { Set(sendOptions); Set(message); }
public override void Behave(BehaviorContext context) { Entity.PositionData.Velocity.X = 0; Entity.PositionData.Velocity.Z = 0; }
public void Invoke(BehaviorContext context, Action next) { UnicastBus.OnMessageReceived(context.TransportMessage); next(); }
// 실제 이 Activity 에서의 수행내용. protected abstract Task Execute(BehaviorContext <TInstance> context);
protected override void InitializeBehaviorContext(BehaviorContext behaviorContext) { base.InitializeBehaviorContext(behaviorContext); behaviorContext[U_SQUAD] = _squad; behaviorContext.DefineStack(STACK_POTENTIAL_CLUES); }
public void OnAdding(BehaviorContext context) { }
public static Task RespondAsync <TInstance, TData>(this BehaviorContext <TInstance, TData> context, object message, Type messageType) { return(GetConsumeContext(context).RespondAsync(message, messageType)); }
public HandlerInvocationContext(BehaviorContext parentContext, MessageHandler messageHandler) : base(parentContext) { Set(messageHandler); }
public SendLogicalMessagesContext(BehaviorContext parentContext, SendOptions sendOptions,IEnumerable<LogicalMessage> messages) : base(parentContext) { Set(sendOptions); Set(messages); }
public static Task RespondAsync <TInstance, TData, T>(this BehaviorContext <TInstance, TData> context, T message, IPipe <SendContext> sendPipe) where T : class { return(GetConsumeContext(context).RespondAsync(message, sendPipe)); }
public override Task Execute(BehaviorContext <DeleteDocumentState, DocumentDeletedEmailSentEvent> context, Behavior <DeleteDocumentState, DocumentDeletedEmailSentEvent> next) { return(Execute(context, next, context.Data.PayLoad.ToEmptyDocumentWithId())); }
public void OnRemoving(BehaviorContext context) { }
public override BehaviorPriority DeterminePriority(BehaviorContext context) { return BehaviorPriority.Value(1); }
async Task Activity <TInstance> .Execute <T>(BehaviorContext <TInstance, T> context, Behavior <TInstance, T> next) { await Execute(context).ConfigureAwait(false); await next.Execute(context).ConfigureAwait(false); }
public ReceiveLogicalMessageContext(BehaviorContext parentContext, LogicalMessage message) : base(parentContext) { Set(message); }
Task Behavior <TInstance> .Execute <T>(BehaviorContext <TInstance, T> context) { return(_activity.Execute(context, Behavior.Empty <TInstance, T>())); }