Esempio n. 1
0
        private static void ConfigureCommanding(CloudQueue queue, out ICommandDispatcher dispatcher, out IAzureStorageCommandQueueProcessorFactory listenerFactory)
        {
            ServiceCollection            serviceCollection  = new ServiceCollection();
            CommandingDependencyResolver dependencyResolver = serviceCollection.GetCommandingDependencyResolver(() => _serviceProvider);
            ICommandRegistry             registry           = dependencyResolver.UseCommanding();

            dependencyResolver.UseQueues(
                (msg, cmd, ex) =>
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(msg);
            },
                (msg, cmd, ex) =>
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine(msg);
            },
                (msg, cmd, ex) =>
            {
                Console.ForegroundColor = ConsoleColor.Blue;
                Console.WriteLine(msg);
            })
            .UseAzureStorageCommanding();

            ICommandDispatcher QueueDispatcher() => _serviceProvider.GetService <IAzureStorageQueueDispatcherFactory>().Create(queue);

            registry
            .Register <OutputWorldToConsoleCommandHandler>(1000, dispatcherFactoryFunc: QueueDispatcher)
            .Register <OutputBigglesToConsoleCommandHandler>();

            _serviceProvider = serviceCollection.BuildServiceProvider();
            dispatcher       = _serviceProvider.GetService <ICommandDispatcher>();
            listenerFactory  = _serviceProvider.GetService <IAzureStorageCommandQueueProcessorFactory>();
        }
        public Form1()
        {
            InitializeComponent();
            IServiceCollection            serviceCollection = new ServiceCollection();
            ICommandingDependencyResolver resolver          = new CommandingDependencyResolver((type, instance) => serviceCollection.AddSingleton(type, instance),
                                                                                               (type, impl) => serviceCollection.AddTransient(type, impl),
                                                                                               type => _serviceProvider.GetService(type));
            ICommandRegistry registry = resolver.UseCommanding();

            registry.Register <GetTextCommandHandler>();
            _serviceProvider = serviceCollection.BuildServiceProvider();
            _dispatcher      = _serviceProvider.GetService <ICommandDispatcher>();
        }
Esempio n. 3
0
        private static ICommandDispatcher Configure()
        {
            IServiceCollection           serviceCollection  = new ServiceCollection();
            CommandingDependencyResolver dependencyResolver = serviceCollection.GetCommandingDependencyResolver(() => _serviceProvider);
            Options options = new Options
            {
                DisableCorrelationIds = true, // as a comparison to mediatr we disable correlation IDs
                Reset = true                  // we reset the registry because we allow repeat runs, in a normal app this isn't required
            };

            dependencyResolver.UseCommanding(options)
            .Register <SimpleHandler>();
            _serviceProvider = serviceCollection.BuildServiceProvider();
            return(_serviceProvider.GetService <ICommandDispatcher>());
        }
Esempio n. 4
0
        static ICommandDispatcher Configure()
        {
            Uri uri = new Uri("http://localhost:52933/api/personalDetails");
            ServiceCollection            serviceCollection  = new ServiceCollection();
            CommandingDependencyResolver dependencyResolver = serviceCollection.GetCommandingDependencyResolver(() => _serviceProvider);

            ICommandRegistry registry = dependencyResolver.UseCommanding();

            dependencyResolver.UseHttpCommanding();
            _serviceProvider = serviceCollection.BuildServiceProvider();

            IHttpCommandDispatcherFactory httpCommandDispatcherFactory = _serviceProvider.GetService <IHttpCommandDispatcherFactory>();

            registry.Register <UpdatePersonalDetailsCommand, UpdateResult>(() => httpCommandDispatcherFactory.Create(uri, HttpMethod.Put));

            ICommandDispatcher dispatcher = _serviceProvider.GetService <ICommandDispatcher>();

            return(dispatcher);
        }
Esempio n. 5
0
        protected AbstractDispatchTestBase(Action <ICommandRegistry, CustomDispatcher> registrations)
        {
            var serviceCollection = new ServiceCollection();
            var resolver          = new CommandingDependencyResolver(
                (type, instance) => serviceCollection.AddSingleton(type, instance),
                (type, impl) => serviceCollection.AddTransient(type, impl),
                type => ServiceProvider.GetService(type)
                );

            CommandingConfiguration = new CommandingRuntime();
            var registry = CommandingConfiguration.UseCommanding(resolver);

            CommandTracer = new CommandTracer();
            serviceCollection.AddSingleton(CommandTracer);
            CustomDispatcher = new CustomDispatcher();
            CustomExecuter   = new CustomExecuter();

            registrations(registry, CustomDispatcher);
            ServiceProvider = serviceCollection.BuildServiceProvider();
            Dispatcher      = ServiceProvider.GetRequiredService <ICommandDispatcher>();
        }
        static void Main(string[] args)
        {
            IServiceProvider serviceProvider = null;

            var serviceCollection = new ServiceCollection()
                                    .AddTransient <CustomCommandExecuter>()
                                    .AddTransient <CustomCommandDispatcher>();

            ICommandRegistry registry = new CommandingDependencyResolver(
                (type, instance) => serviceCollection.AddSingleton(type, instance),
                (type, impl) => serviceCollection.AddTransient(type, impl),
                type => serviceProvider.GetService(type)
                )
                                        .UseCommanding();

            registry.Register <Command>(() => serviceProvider.GetService <CustomCommandDispatcher>());

            serviceProvider = serviceCollection.BuildServiceProvider();

            serviceProvider.GetService <ICommandDispatcher>().DispatchAsync(new Command());

            Console.ReadKey();
        }
        public IServiceProvider Build(HostingEnvironment hostingEnvironment)
        {
            IServiceProvider serviceProvider = null;

            var serviceCollection = new ServiceCollection()

                                    .AddTransient <IFileObjectStoreConfig, FileSystemObjectStoreLocalConfig>() //don't like this
                                    .AddTransient <AmazonS3PermissionsProvider>()

                                    .AddTransient <InMemoryQueueClient>()
                                    .AddTransient <AmazonSqsQueueClient>()

                                    .AddTransient <ITime, Time>()
                                    .AddTransient <IFileSystem, FileSystem>()

                                    .AddTransient <IWorkerRecordStoreService, WorkerRecordStoreService>()

                                    .AddTransient <MakeAccidentCountMapper>()
                                    .AddTransient <MostAccidentProneMapper>()

                                    .AddTransient <MakeAccidentCountReducer>()
                                    .AddTransient <MostAccidentProneReducer>()

                                    .AddTransient <MakeAccidentCountFinalReducer>()
                                    .AddTransient <MostAccidentProneFinalReducer>()

                                    .AddTransient <ICommandExecuter, AwsLambdaCommandExecuter>()
                                    .AddTransient <ICommandDispatcher, AwsLambdaCommandDispatcher>()

                                    .AddSingleton <IMemoryObjectStore, MemoryObjectStore>()

                                    .AddTransient <QueueCommandDispatcher>().AddTransient <QueueCommandExecuter>();

            var commandRegistry = new CommandingDependencyResolver(
                (type, instance) => serviceCollection.AddSingleton(type, instance),
                (type, impl) => serviceCollection.AddTransient(type, impl),
                type => serviceProvider.GetService(type)
                )
                                  .UseCommanding()
                                  .Register <IsTerminatedCommandHandler>()
                                  .Register <UpdateMonitoringHandler>()
                                  .Register <MapDataCommandHandler>()
                                  .Register <ReducerFuncHandler>()
                                  .Register <FinalReducerFuncHandler>()

                                  .Register <BatchMapDataCommandHandler>()
                                  .Register <WriteMappedDataCommandHandler>()

                                  .Register <BatchReduceDataCommandHandler>()
                                  .Register <WriteReducedDataCommandHandler>();

            hostingEnvironment
            .RegisterHostingEnvironment(commandRegistry, serviceCollection, () => serviceProvider, x =>
            {
                x
                .RegisterFireAndForgetFunctionImpl <Ingester, IngestCommand>()
                .RegisterFireAndForgetFunctionImpl <Mapper, MapperCommand>()
                .RegisterFireAndForgetFunctionImpl <Reducer, ReducerCommand>()
                .RegisterFireAndForgetFunctionImpl <FinalReducer, FinalReducerCommand>()
                .RegisterFireAndForgetFunctionImpl <WorkerManager, WorkerManagerCommand>()
                .RegisterFireAndForgetFunctionImpl <CommandExecuter, CommandExecuterCommand>();
            });

            serviceProvider = serviceCollection.BuildServiceProvider();

            return(serviceProvider);
        }