public DefaultCommandBus(IEnvelopeBus envelopeBus , List<IMessageProcessor> inboundChain , List<IMessageProcessor> outboundChain) { _commandReceiver = new DefaultCommandReceiver(envelopeBus, inboundChain); _commandSender = new DefaultCommandSender(envelopeBus, outboundChain); }
private DataFeed ProcessFeedItem(string groupSelector, bool infiniteLoop = false) { var config = this.configProvider.GetConfigurationSection <FeedProcessingConfig>(); using (ICommandReceiver receiver = Factory.GetInstance <ICommandReceiver>().Open(config.InputQueueId, groupSelector)) { DataFeed command; do { command = receiver.GetCommand <DataFeed>(); if (command == null) { return(null); } if (command.IsSequenceTerminator) { this.ProcessTerminator(command); } else { this.ProcessFeed(command); } }while (infiniteLoop); return(command); } }
public static ICommandReceiver <T> Trace <T>( this ICommandReceiver <T> receiver) => receiver.UseMiddleware( receive: async(handle, timeout, next) => { return(await next(async delivery => { using (var operation = Log.Receive(delivery)) { var result = await handle(delivery); Log.Completion(operation, delivery, result); return result; } }, timeout)); }, subscribe: (onNext, next) => { using (Log.Subscribe <T>()) { return(next(async delivery => { using (var operation1 = Log.Receive(delivery)) { var result1 = await onNext(delivery); Log.Completion(operation1, delivery, result1); return result1; } })); } });
/// <summary> /// Initializes a new instance of the <see cref="CommandRunner"/> class. /// </summary> /// <param name="processor">The <see cref="IMessageProcessor"/>.</param> /// <param name="receiver">The <see cref="ICommandReceiver"/>.</param> /// <param name="degreeOfParallelism">The maximum degree of parallelism.</param> public CommandRunner(IMessageProcessor processor, ICommandReceiver receiver, int degreeOfParallelism) { if (processor == null) { throw new ArgumentNullException("processor"); } if (receiver == null) { throw new ArgumentNullException("receiver"); } if (degreeOfParallelism <= 0) { throw new ArgumentOutOfRangeException("degreeOfParallelism"); } this.runners = new CommandQueueRunner[degreeOfParallelism]; this.receiver = receiver; for (int i = 0; i < this.runners.Length; i++) { var runner = new CommandQueueRunner(processor, receiver); this.runners[i] = runner; } }
internal static void TrySubscribeDiscoveredHandler <T>( Configuration configuration, Type commandType, PocketContainer c, ICommandReceiver <T> receiver) { foreach (var handlerDescription in configuration.CommandHandlerDescriptions .Where(t => t.HandledCommandType == commandType)) { var handler = c.Resolve(handlerDescription.HandlerInterface) as ICommandHandler <T>; if (configuration.Properties.TracingEnabled) { handler = handler.Trace(); } var subscription = receiver.Subscribe(handler); configuration.RegisterForDisposal(subscription); Logger <Configuration> .Log.Trace( "Subscribing discovered command handler: {handler} to handle commands of type {commandType}", handlerDescription.ConcreteHandlerType, handlerDescription.HandledCommandType); } }
protected void InitCommands() { m_CommandReceiver = new CommandReceiver(); m_CommandReceiver.AddCommand <IdleCommand>(CommandType.Idle, CheckIdle); m_CommandReceiver.AddCommand <AutoMoveCommand>(CommandType.Runto, CheckRunTo); m_CommandReceiver.AddCommand <UseSkillCommand>(CommandType.Useskill, CheckUseSkill); m_CommandReceiver.AddCommand <DeadCommand>(CommandType.Dead, CheckDead); m_CommandReceiver.AddCommand <TurnToCommand>(CommandType.TurnTo, CheckTurnTo); m_CommandReceiver.AddCommand <MoveCommand>(CommandType.Moveto, CheckMoveTo); m_CommandReceiver.AddCommand <TalkCommand>(CommandType.Talk, CheckTalk); m_CommandReceiver.AddCommand <FrostCommand>(CommandType.Frost, CheckFrost); m_CommandReceiver.AddCommand <StunCommand>(CommandType.Stun, CheckStun); m_CommandReceiver.AddCommand <PalsyCommand>(CommandType.Palsy, CheckPalsy); m_CommandReceiver.AddCommand <SleepCommand>(CommandType.Sleep, CheckSleep); m_CommandReceiver.AddCommand <BlindCommand>(CommandType.Blind, CheckBlind); m_CommandReceiver.AddCommand <FearCommand>(CommandType.Fear, CheckFear); m_CommandReceiver.AddCommand <FixBodyCommand>(CommandType.Fixbody, CheckFixBody); m_CommandReceiver.AddCommand <WoundCommand>(CommandType.Wound, CheckWound); m_CommandReceiver.AddCommand <BeatDownCommand>(CommandType.Beatdown, CheckBeatDown); m_CommandReceiver.AddCommand <BeatBackCommand>(CommandType.Beatback, CheckBeatBack); m_CommandReceiver.AddCommand <BeatFlyCommand>(CommandType.Beatfly, CheckBeatFly); m_CommandReceiver.AddCommand <FlyCommand>(CommandType.Fly, CheckFly); m_CommandReceiver.AddCommand <HookCommand>(CommandType.Hook, CheckHook); m_CommandReceiver.AddCommand <GrabCommand>(CommandType.Grab, CheckGrab); m_CommandReceiver.AddCommand <VariationCommand>(CommandType.Variation, CheckVariation); m_CommandReceiver.AddCommand <RideCommand>(CommandType.Ride, CheckRide); m_CommandReceiver.AddCommand <JumpCommand>(CommandType.Jump, CheckJump); m_CommandReceiver.AddCommand <StealthCommand>(CommandType.Stealth, CheckStealth); m_CommandReceiver.AddCommand <RebornCommand>(CommandType.Reborn, CheckReborn); m_CommandReceiver.AddCommand <CollectMineCommand>(CommandType.Mine, CheckMine); m_CommandReceiver.AddCommand <InteractiveCommand>(CommandType.Interactive, CheckInteractive); }
public Floor(int number, ICommandReceiver receiver, bool canMoveUp, bool canMoveDown) { Number = number; _receiver = receiver; CanMoveUp = canMoveUp; CanMoveDown = canMoveDown; }
public static async Task <ICommandDeliveryResult> Receive <T>( this ICommandReceiver <T> receiver, Func <ICommandDelivery <T>, ICommandDeliveryResult> handle, TimeSpan?timeout = null) => await receiver.Receive( async delivery => await Task.Run(() => handle(delivery)), timeout);
public static IDisposable Subscribe <TReceive, THandle>( this ICommandReceiver <TReceive> receiver, ICommandHandler <THandle> handler) where THandle : TReceive { async Task <ICommandDeliveryResult> OnNext(ICommandDelivery <TReceive> delivery) { switch (delivery) { case ICommandDelivery <THandle> handled: return(await handler.Handle(handled)); default: if (!(delivery.Command is THandle command)) { return(null); } var clone = new CommandDelivery <THandle>( command, delivery.DueTime, delivery.OriginalDueTime, delivery.IdempotencyToken, delivery.NumberOfPreviousAttempts); return(await handler.Handle(clone)); } } return(receiver.Subscribe(OnNext)); }
public static async Task <ICommandDeliveryResult> Receive <T>( this ICommandReceiver <T> receiver, ICommandHandler <T> handler, TimeSpan?timeout = null) => await receiver.Receive( async delivery => await handler.Handle(delivery), timeout);
public void AddCommandReceiver(ICommandReceiver commandReceiver, Func <Command, Task <bool> > commandFilter = null, int priority = 0) { if (commandReceiver == null) { throw new ArgumentNullException(nameof(commandReceiver)); } AddEnvelopeReceiver(_commandReceivers, () => commandReceiver, commandFilter, priority); }
public static ICommandReceiver <T> UseMiddleware <T>( this ICommandReceiver <T> receiver, CommandReceivingMiddleware <T> receive, CommandSubscribingMiddleware <T> subscribe) => Create <T>( receive: (handle, timeout) => receive(handle, timeout, receiver.Receive), subscribe: onNext => subscribe(onNext, receiver.Subscribe));
public AkkaCommandBus(IConfigurationManager configurationManager, ILogger logger, IActorRef actorReference, ICommandSender <TAuthenticationToken> commandSender, ICommandReceiver <TAuthenticationToken> commandReceiver) { ConfigurationManager = configurationManager; Logger = logger; ActorReference = actorReference; CommandSender = commandSender; CommandReceiver = commandReceiver; }
public GameCommandInvoker() { this.commands = new List <Command>(); this.gameCommandReciever = new GameCommandReciever(); this.currentComand = 0; this.gameState = new GameState(); this.gameStates = new List <IDictionary <string, string> >(); this.savedState = null; this.renderer = new ConsoleRenderer(); }
public AkkaCommandBus(IBusHelper busHelper, IAuthenticationTokenHelper <TAuthenticationToken> authenticationTokenHelper, ICorrelationIdHelper correlationIdHelper, IDependencyResolver dependencyResolver, ILogger logger, ICommandPublisher <TAuthenticationToken> commandPublisher, ICommandReceiver <TAuthenticationToken> commandReceiver) { Logger = logger; BusHelper = busHelper; AuthenticationTokenHelper = authenticationTokenHelper; CorrelationIdHelper = correlationIdHelper; DependencyResolver = dependencyResolver; EventWaits = new ConcurrentDictionary <Guid, IList <IEvent <TAuthenticationToken> > >(); CommandPublisher = commandPublisher; CommandReceiver = commandReceiver; }
public static void EventFunction(ICommandReceiver handler, BaseEventData eventData) { var parameterType = eventData.GetType(); if (!map_class_methodinfo.ContainsKey(parameterType)) { map_class_methodinfo[parameterType] = typeof(Actor).GetFirstMethodsBySig(parameterType); } map_class_methodinfo[parameterType].Invoke(handler, new object[] { eventData }); }
public void RegisterCommandReceiver(CommandCode code, ICommandReceiver receiver) { var typeName = code; if (receivers.ContainsKey(typeName)) { Debug.LogError($"Attempt to register 2 receivers for {code}, aborting"); return; } receivers[typeName] = receiver; }
public void Run() { using (ICommandReceiver receiver = Factory.GetInstance <ICommandReceiver>().Open(CONST_MembersDeltaQueueName)) { while (true) { UpdateMembersDeltaCommand command = null; try { command = receiver.GetCommand <UpdateMembersDeltaCommand>(); if (command == null) { this.log.Debug("No export command found. Processing stopped."); return; } using (this.unitOfWorkProvider.CreateUnitOfWork()) { var state = this.vkGroupRepository.GetProcessingState(command.VkGroupId, DataFeedType.MembersInfo); if (state == null) { this.log.WarnFormat("MembersInfo processing state is not found for VkGroupId = \"{0}\"", command.VkGroupId); return; } if (command.Version < state.Version) { this.log.WarnFormat("Processing state of command is outdate. Command.Version = {0} and State.Version = {1}", command.Version, state.Version); return; } this.log.DebugFormat("Processing member delta for vkgroup = \"{0}\" on \"{1}\" for version = {2}", command.VkGroupId, command.SendingDate, command.Version); this.deltaUpdater.CalculateMembersDelta(command.VkGroupId, DateTime.UtcNow); } } catch (Exception exc) { this.log.ErrorFormat("Exception is occured while updating members delta for the group with Id = {0}: {1}", command != null ? command.VkGroupId : 0, exc.ToString()); } finally { if (command != null) { command.MarkAsCompleted(); } } } } }
public static void Main(string[] args) { switch (mode) { case Mode.Keyboard: receiver = new KeyboardCommandReceiver(); break; case Mode.Socket: receiver = new SocketCommandReceiver(); break; default: Console.WriteLine("Unknown mode: " + mode.ToString ()); Environment.ExitCode = 1; return; } if (!test) { port = new SerialPort ("/dev/tty.usbmodem1421", 9600); port.Open (); } try { CancellationTokenSource cancelStop = null; char? lastCmd = null; do { char cmd = receiver.BlockUntilNextCmd(); if (cancelStop != null) cancelStop.Cancel(); if (lastCmd == null || lastCmd.Value != cmd) { Send(cmd); } lastCmd = cmd; cancelStop = new CancellationTokenSource(); Task.Delay(TimeSpan.FromMilliseconds(750), cancelStop.Token) .ContinueWith(task => { if (!task.IsCanceled) { cancelStop = null; lastCmd = null; Send('Q'); } }); } while (receiver.AnotherCommand()); Send('Q'); } finally { port.Close(); } }
public AkkaCommandBus(IConfigurationManager configurationManager, IBusHelper busHelper, IAuthenticationTokenHelper <TAuthenticationToken> authenticationTokenHelper, ICorrelationIdHelper correlationIdHelper, IDependencyResolver dependencyResolver, ILogger logger, IActorRef actorReference, ICommandSender <TAuthenticationToken> commandSender, ICommandReceiver <TAuthenticationToken> commandReceiver) { ConfigurationManager = configurationManager; Logger = logger; ActorReference = actorReference; CommandSender = commandSender; CommandReceiver = commandReceiver; AuthenticationTokenHelper = authenticationTokenHelper; CorrelationIdHelper = correlationIdHelper; DependencyResolver = dependencyResolver; BusHelper = busHelper; EventWaits = new ConcurrentDictionary <Guid, IList <IEvent <TAuthenticationToken> > >(); }
public CommandableCache(ICommandReceiver commandReceiver, int cacheExpiryInSeconds) : base(cacheExpiryInSeconds) { _commandReceiver = commandReceiver; try { // subscribe for the command to burst the routing cache. Pass a cache // reference into the cache buster that handles incoming BurstRoutingCache commands _commandReceiver.ReceiveCommand(new RoutingCacheBuster(_routingInfoCache, _cacheLock, _cacheExpiryInSeconds)); } catch (MessageException cex) { Log.Warn("Failed to subscribe for Routing Cache Bust commands - the cache cannot be remotely commanded.", cex); } }
private CreateProjectResultCommand DoGetCreateProjectStatus(string ticketId) { using (ICommandReceiver receiver = Factory.GetInstance <ICommandReceiver>().Open(CONST_CreateProjectResultQueueName, string.Format("TicketId = '{0}'", ticketId))) { CreateProjectResultCommand result = receiver.GetCommand <CreateProjectResultCommand>(); if (result != null) { result.MarkAsCompleted(); } return(result); } }
private ExportResultCommand GetExportResult(string ticketId) { using (ICommandReceiver receiver = Factory.GetInstance <ICommandReceiver>().Open(CONST_ExportResultQueueName, string.Format("TicketId = '{0}'", ticketId))) { ExportResultCommand result = receiver.GetCommand <ExportResultCommand>(); if (result != null) { result.MarkAsCompleted(); } return(result); } }
public CommandQueueRunner(IMessageProcessor processor, ICommandReceiver receiver) { if (processor == null) { throw new ArgumentNullException("processor"); } if (receiver == null) { throw new ArgumentNullException("receiver"); } this.receiver = receiver; this.processor = processor; }
private static OperationExecutionReport ExecuteCommand(Command command, ICommandReceiver receiver) { OperationExecutionReport report; try { report = (OperationExecutionReport)((dynamic)receiver).OnReceive((dynamic)command); } catch (Exception e) { report = new OperationExecutionReport("Ошибка при обработке команды"); report.Errors.Add(new Error(e)); } return(report); }
public void Execute() { using (ICommandReceiver commandReceiver = Factory.GetInstance <ICommandReceiver>().Open("FeedJobQueue")) { while (true) { var feedQueueItem = commandReceiver.GetCommand <FeedQueueItem>(); if (feedQueueItem == null) { break; } feedQueueItem.MarkAsCompleted(); } } }
/// <summary> /// Enables message queuing. /// </summary> /// <param name="configuration">The <see cref="ProcessorConfiguration"/>.</param> /// <param name="degreeOfParallelism">The maximum degree of parallelism.</param> /// <param name="sender">The <see cref="ICommandSender"/> used to send commands.</param> /// <param name="receiver">The <see cref="ICommandReceiver"/> used to receive commands.</param> public static void EnableMessageQueuing(this ProcessorConfiguration configuration, int degreeOfParallelism, ICommandSender sender, ICommandReceiver receiver) { if (configuration == null) { throw Error.ArgumentNull("configuration"); } var innerWorker = configuration.Services.GetCommandWorker(); configuration.Services.Replace(typeof(ICommandWorker), new CommandQueueWorker(innerWorker)); configuration.Services.Replace(typeof(ICommandSender), sender); configuration.Services.Replace(typeof(ICommandReceiver), receiver); configuration.RegisterForDispose(sender as IDisposable); if (!object.ReferenceEquals(sender, receiver)) { configuration.RegisterForDispose(receiver as IDisposable); } Action<ProcessorConfiguration> defaultInitializer = configuration.Initializer; configuration.Initializer = originalConfig => { MessageProcessor processor = null; try { CommandHandlerSettings settings = new CommandHandlerSettings(originalConfig); settings.Services.Replace(typeof(ICommandWorker), innerWorker); var config = ProcessorConfiguration.ApplyHandlerSettings(settings, originalConfig); config.Initializer = defaultInitializer; processor = new MessageProcessor(config); var commandReceiver = originalConfig.Services.GetCommandReceiver(); originalConfig.CommandBroker = new CommandRunner(processor, commandReceiver, degreeOfParallelism); originalConfig.RegisterForDispose(processor); processor = null; } finally { if (processor != null) { processor.Dispose(); } } defaultInitializer(originalConfig); }; }
public AccessPointService( IServiceProvider ServiceProvider, IMediator mediator, IButtonService buttonService, ISwitchService switchService, IRfidReader rfidReader, IRelayControlService relayControlService, IPirSensorService pirSensorService, AccessPointState state, ICommandReceiver commandReceiver, IServiceEventClient serviceEventClient) { _serviceProvider = ServiceProvider; _mediator = mediator; _buttonService = buttonService; _switchService = switchService; _rfidReader = rfidReader; _relayControlService = relayControlService; _pirSensorService = pirSensorService; _state = state; _commandReceiver = commandReceiver; WhenButtonPressedOpened = Observable.FromEventPattern( handler => _buttonService.Pressed += handler, handler => _buttonService.Pressed -= handler); WhenButtonReleasedClosed = Observable.FromEventPattern( handler => _buttonService.Released += handler, handler => _buttonService.Released -= handler); WhenSwitchOpened = Observable.FromEventPattern( handler => _switchService.Opened += handler, handler => _switchService.Opened -= handler); WhenSwitchClosed = Observable.FromEventPattern( handler => _switchService.Closed += handler, handler => _switchService.Closed -= handler); WhenMotionDetected = Observable.FromEventPattern( handler => _pirSensorService.MotionDetected += handler, handler => _pirSensorService.MotionDetected -= handler); WhenMotionNotDetected = Observable.FromEventPattern( handler => _pirSensorService.MotionNotDetected += handler, handler => _pirSensorService.MotionNotDetected -= handler); }
public void ProcessExportQueue() { using (ICommandReceiver receiver = Factory.GetInstance <ICommandReceiver>().Open(CONST_ExportQueueName)) { while (true) { ExportReportCommand exportCommand = null; try { exportCommand = receiver.GetCommand <ExportReportCommand>(); if (exportCommand == null) { this.log.Debug("No export command found. Processing stopped."); return; } string fileName = this.GenerateFileName(exportCommand); IFileSystem fileSystem = this.fileSystemFactory.CreateFileSystem(exportCommand.InitiatorUserId); byte[] exportResult = this.dataProvider.ExportToXlsx(exportCommand.VkGroupId, exportCommand.DateRange); string virtualFilePath = fileSystem.SaveToFile(fileName, exportResult); this.SendExportFinished(exportCommand, true, virtualFilePath); } catch (Exception exc) { this.log.ErrorFormat("Exception is occured while processing a group Id = {0}, for userId = {1}: {2}", exportCommand != null ? exportCommand.VkGroupId : 0, exportCommand != null ? exportCommand.InitiatorUserId : 0, exc.ToString()); if (exportCommand != null) { this.SendExportFinished(exportCommand, isSuccess: false); } } finally { if (exportCommand != null) { exportCommand.MarkAsCompleted(); } } } } }
public void ProcessNextQueueItem() { this.log.Info("GetFeedsFromVKAction process started"); var processingConfig = this.configProvider.GetConfigurationSection <FeedProcessingConfig>(); var selector = !string.IsNullOrWhiteSpace(processingConfig.FeedFilter) ? processingConfig.FeedFilter : null; using (ICommandReceiver commandReceiver = Factory.GetInstance <ICommandReceiver>().Open(processingConfig.InputQueueId, selector)) { IVkDataProvider vkDataProvider = this.vkConnectionBuilder.GetVkDataProvider(); for (int i = 0; i < CONST_BatchProcessingSize; i++) { FeedQueueItem queueItem = null; try { queueItem = commandReceiver.GetCommand <FeedQueueItem>(); if (queueItem == null) { this.log.Info("No items in queue found. Processing stopped."); return; } this.ProcessQueueItem(queueItem, vkDataProvider, processingConfig); } finally { if (queueItem != null) { queueItem.MarkAsCompleted(); using (ICommandSender commandSender = Factory.GetInstance <ICommandSender>().Open(processingConfig.InputQueueId)) { commandSender.SendCommand(queueItem.Copy()); } } } } } }
public void Run() { using (ICommandReceiver receiver = Factory.GetInstance <ICommandReceiver>().Open(CONST_CreateProjectQueueName)) { while (true) { CreateProjectCommand createProjectCommand = null; try { createProjectCommand = receiver.GetCommand <CreateProjectCommand>(); if (createProjectCommand == null) { this.log.Debug("No create project command found."); return; } var project = this.CreateProject(createProjectCommand); this.SendCreateProjectFinished(createProjectCommand, project, true); } catch (Exception exc) { this.log.ErrorFormat("Exception is occured while creating a project VkUrl {0}, Title {1} for userId = {2}: {3}", createProjectCommand != null ? createProjectCommand.Url : string.Empty, createProjectCommand != null ? createProjectCommand.Title : string.Empty, createProjectCommand != null ? createProjectCommand.AccountId : 0, exc.ToString()); if (createProjectCommand != null) { this.SendCreateProjectFinished(createProjectCommand, new Project(), isSuccess: false); } } finally { if (createProjectCommand != null) { createProjectCommand.MarkAsCompleted(); } } } } }
private void ProcessSpecificGroupFeeds(FeedProcessingConfig processingConfig) { using (ICommandReceiver groupReceiver = Factory.GetInstance <ICommandReceiver>().Open(processingConfig.GroupQueueId)) { while (true) { GroupQueueItem commandMessage = null; try { commandMessage = groupReceiver.GetCommand <GroupQueueItem>(); if (commandMessage == null) { this.log.Error("No groups found to process. Processing stopped."); return; } this.ProcessGroup(commandMessage.VkGroupId); } catch (Exception exc) { this.log.ErrorFormat("Exception is occured while processing a group Id = {0}: {1}", commandMessage != null ? commandMessage.VkGroupId : 0, exc.ToString()); return; } finally { if (commandMessage != null) { commandMessage.MarkAsCompleted(); using (ICommandSender groupSender = Factory.GetInstance <ICommandSender>().Open(processingConfig.GroupQueueId)) { groupSender.SendCommand(new GroupQueueItem(commandMessage.VkGroupId)); } } } } } }
public CommandPipe(ICommandReceiver receiver) { this.receiver = receiver; }
public MyCommand(ICommandReceiver receiver) { _receiver = receiver; }
public ConsoleReceiver(ICommandReceiver commandReceiver) { _commandReceiver = commandReceiver; }