コード例 #1
0
 public static void Run(IHostedService service, string[] args)
 {
     var consoleArg = Array.Find(args,
                                 arg => string.Equals(arg, "/console", StringComparison.CurrentCultureIgnoreCase));
     var host = consoleArg != null ? (IServiceHost) new ConsoleServiceHost() : new WindowsServiceHost();
     host.Run(service);
 }
コード例 #2
0
 public void Run(IHostedService service)
 {
     _service = service;
     ServiceName = _service.Name;
     Logger.SetLogger(new EventLogLogger(EventLog));
     _service.Attach(this);
     Run(this);
 }
        public override void SetUp()
        {
            base.SetUp();

            workitemWriterMock = Repository.StrictMock<WorkitemWriter>();
            eventManagerMock = Repository.StrictMock<IEventManager>();

            eventManager = new EventManager();
            service = new WorkitemWriterHostedService();

            service.Initialize(null, eventManager, null);
        }
コード例 #4
0
ファイル: WindowsServiceHost.cs プロジェクト: dbremner/cassia
 public void Run(IHostedService service)
 {
     if (service == null)
     {
         throw new ArgumentNullException(nameof(service));
     }
     _service = service;
     ServiceName = _service.Name;
     Logger.SetLogger(new EventLogLogger(EventLog));
     _service.Attach(this);
     Run(this);
 }
        public QueuedHostedServiceTest()
        {
            var logger = new NullLogger <QueuedHostedService>();

            var services = new ServiceCollection();

            services.AddBackgroundQueue();
            services.AddSingleton <ILogger <QueuedHostedService> >(logger);

            var serviceProvider = services.BuildServiceProvider();

            BackgroundQueue = serviceProvider.GetService <IBackgroundTaskQueue>();
            HostedService   = serviceProvider.GetService <IHostedService>();
        }
コード例 #6
0
        public TasksMessagingServiceTests()
        {
            _eventConnectionContextMock = new Mock <IEventConnectionContext>();
            _taskEventAccessorMock      = new Mock <ITaskEventAccessor>();
            _eventScopeMock             = new Mock <IEventScope>();
            _tasksHubStorage            = new Mock <ITasksHubUsersStorage>();
            _hubClientMock = new Mock <IHubClient <TasksHub> >();

            _eventConnectionContextMock.Setup(x => x.EventScope()).Returns(_eventScopeMock.Object);
            _tasksHubStorage.Setup(x => x.Get(ProjectId, CreatorId)).Returns(_connectionIds);

            _messagingService = new TasksMessagingService(_eventConnectionContextMock.Object,
                                                          _taskEventAccessorMock.Object, _hubClientMock.Object, _tasksHubStorage.Object);
        }
コード例 #7
0
            public void Start()
            {
                IoC.Container.Install(FromAssembly.This());

                hostedService = IoC.Container.Resolve<IHostedService>();
                startEvents = IoC.Container.ResolveAll<IStartServiceEvent>();
                stopEvents = IoC.Container.ResolveAll<IStopServiceEvent>();

                foreach (var startServiceEvent in startEvents.OrderBy(e => e.Order))
                {
                    startServiceEvent.Execute();
                }

                hostedService.Start();
            }
コード例 #8
0
 public void Run(IHostedService service)
 {
     service.Attach(this);
     Logger.Log(string.Format("Starting service {0}...", service.Name));
     service.Start();
     Logger.Log("Service started.");
     ConsoleKeyInfo key;
     do
     {
         key = Console.ReadKey(true);
     } while (key.Key != ConsoleKey.D || key.Modifiers != ConsoleModifiers.Control);
     Logger.Log(string.Format("Stopping service {0}...", service.Name));
     service.Stop();
     Logger.Log("Service stopped.");
 }
コード例 #9
0
            public void Start()
            {
                IoC.Container.Install(FromAssembly.This());

                hostedService = IoC.Container.Resolve <IHostedService>();
                startEvents   = IoC.Container.ResolveAll <IStartServiceEvent>();
                stopEvents    = IoC.Container.ResolveAll <IStopServiceEvent>();

                foreach (var startServiceEvent in startEvents.OrderBy(e => e.Order))
                {
                    startServiceEvent.Execute();
                }

                hostedService.Start();
            }
コード例 #10
0
ファイル: ConsoleServiceHost.cs プロジェクト: nerodark/Suncat
        public void Run(IHostedService service)
        {
            service.Attach(this);
            Logger.Log(string.Format("Starting service {0}...", service.Name));
            service.Start();
            Logger.Log("Service started.");
            ConsoleKeyInfo key;

            do
            {
                key = Console.ReadKey(true);
            } while (key.Key != ConsoleKey.D || key.Modifiers != ConsoleModifiers.Control);
            Logger.Log(string.Format("Stopping service {0}...", service.Name));
            service.Stop();
            Logger.Log("Service stopped.");
        }
コード例 #11
0
ファイル: Systemd.cs プロジェクト: Underwood12/csharp
        /// <summary>启动服务</summary>
        /// <param name="service"></param>
        public override void Run(IHostedService service)
        {
            if (service == null)
            {
                throw new ArgumentNullException(nameof(service));
            }

            _service = service;

            var source = new CancellationTokenSource();

            service.StartAsync(source.Token);

            // 阻塞
            Thread.Sleep(-1);
        }
コード例 #12
0
        public static async Task Main(string[] args)
        {
            var basePath = PlatformServices.Default.Application.ApplicationBasePath;

            if (basePath.ToLower().Contains("inventorymanagementqa"))
            {
                var builderRunAsService = new HostBuilder()
                                          .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService <WindowsServiceHost>();
                });

                await builderRunAsService.RunAsServiceAsync();
            }
            else
            {
                StartUpConfiguration startUpConfiguration = new StartUpConfiguration();
                startUpConfiguration.Startup();

                IHostedService sendInventoryManagementMessages    = startUpConfiguration.SendingHostedService();
                IHostedService receiveInventoryManagementMessages = startUpConfiguration.ReceivingHostedService();
                IHostedService processMessages = startUpConfiguration.ProcessMessagesHostedService();

                var builder = new HostBuilder().ConfigureAppConfiguration((hostingContext, config) => { })
                              .ConfigureServices((hostContext, services) =>
                {
                    services.AddTransient <IHostedService>(provider => processMessages);
                })
                              .ConfigureServices((hostContext, services) =>
                {
                    services.AddTransient <IHostedService>(provider => sendInventoryManagementMessages);
                })
                              .ConfigureServices((hostContext, services) =>
                {
                    services.AddTransient <IHostedService>(provider => receiveInventoryManagementMessages);
                })
                              .ConfigureLogging((hostingContext, logging) =>
                {
                    logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
                    logging.AddConsole();
                });

                builder.RunConsoleAsync().Wait();
            }
        }
コード例 #13
0
        private Task StartHostedService(bool runOnce, [NotNull] IHostedService process, string name)
        {
            // Run the hosted process, wrapped in polly retry logic.
            return(BuildWrappedPolicy().ExecuteAndCaptureAsync(process.StartAsync, _cancellation.Token)
                   .ContinueWith(p =>
            {
                if (p.IsFaulted)
                {
                    _logger?.LogError(p.Exception, $"Error running hosted process {name} execution {p.Exception?.Message}");
                    ProcessError(null, p.Exception, !runOnce);
                }

                if (p.Status == TaskStatus.Canceled)
                {
                    _logger?.LogWarning("Hosted process cancelled");
                }
            }));
        }
コード例 #14
0
        public async Task FromException()
        {
            Routable routable = null;

            this.errorComponent.Reset();
            this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
            {
                routable = x;
            });
            this.processComponent.Reset();

            IHostedService service = this.GetHostedService(true);
            await service.StartAsync(CancellationToken.None);

            await service.StopAsync(CancellationToken.None);

            Assert.IsNull(routable);
        }
コード例 #15
0
        public async Task ErrorComponentErrors()
        {
            Routable routable = null;

            this.errorComponent.Reset();
            this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
            {
                routable = x;
                throw new ProcessException("Manual Error", new IndexOutOfRangeException("Random index"));
            });

            IHostedService service = this.GetHostedService(false, false, true);
            await service.StartAsync(CancellationToken.None);

            await service.StopAsync(CancellationToken.None);

            Assert.IsTrue(this.IsInError(routable, "Error Component"));
        }
コード例 #16
0
        public async Task AtomicError()
        {
            Routable routable = null;

            this.errorComponent.Reset();
            this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
            {
                routable = x;
            });
            this.processComponent.Reset();

            IHostedService service = this.GetHostedService(false, false, true);
            await service.StartAsync(CancellationToken.None);

            await service.StopAsync(CancellationToken.None);

            Assert.IsTrue(this.IsInError(routable, "Atomic Component"));
        }
コード例 #17
0
        public async Task CanRunDIComponent()
        {
            AutoResetEvent autoResetEvent = new AutoResetEvent(false);
            Routable       routable       = null;

            this.diProcessor.Reset();
            this.diProcessor.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
            {
                routable = x;
            });
            IHostedService service = this.SetupDIComponent();

            await service.StartAsync(CancellationToken.None);

            autoResetEvent.WaitOne(TimeSpan.FromSeconds(5));
            await service.StopAsync(CancellationToken.None);

            Assert.AreEqual("Yes", routable.Headers["ComponentRan"]);
        }
コード例 #18
0
 public DeviceManagerFactory(IHostingEnvironment env, IOptionsMonitor <PlayerConfiguration> playerConfigurationOptions,
                             IHostedService hs, ILoggerFactory lf)
 {
     this.env = env;
     this.schedulerService = hs as SchedulerService;
     managers                 = new Dictionary <DeviceIdentifier, DeviceManager>(new DeviceComparer());
     loggerFactory            = lf;
     log                      = loggerFactory.CreateLogger <DeviceManagerFactory>();
     musicServerUrl           = null;
     this.playerConfiguration = playerConfigurationOptions.CurrentValue;
     playerConfigurationOptions.OnChangeWithDelay((opt) =>
     {
         this.playerConfiguration = opt;
         foreach (var item in managers)
         {
             item.Value.ReplacePlayConfiguration(this.playerConfiguration);
         }
     });
 }
コード例 #19
0
ファイル: ConsoleServiceHost.cs プロジェクト: dbremner/cassia
 public void Run(IHostedService service)
 {
     if (service == null)
     {
         throw new ArgumentNullException(nameof(service));
     }
     service.Attach(this);
     Logger.Log(string.Format("Starting service {0}...", service.Name));
     service.Start();
     Logger.Log("Service started.");
     ConsoleKeyInfo key;
     do
     {
         key = Console.ReadKey(true);
     } while (key.Key != ConsoleKey.D || key.Modifiers != ConsoleModifiers.Control);
     Logger.Log(string.Format("Stopping service {0}...", service.Name));
     service.Stop();
     Logger.Log("Service stopped.");
 }
コード例 #20
0
ファイル: ConsoleServiceHost.cs プロジェクト: dbremner/cassia
        public void Run(IHostedService service)
        {
            if (service == null)
            {
                throw new ArgumentNullException(nameof(service));
            }
            service.Attach(this);
            Logger.Log(string.Format("Starting service {0}...", service.Name));
            service.Start();
            Logger.Log("Service started.");
            ConsoleKeyInfo key;

            do
            {
                key = Console.ReadKey(true);
            } while (key.Key != ConsoleKey.D || key.Modifiers != ConsoleModifiers.Control);
            Logger.Log(string.Format("Stopping service {0}...", service.Name));
            service.Stop();
            Logger.Log("Service stopped.");
        }
コード例 #21
0
        public TestBase()
        {
            var services      = new ServiceCollection();
            var configuration = ConfigurationRootCreator.Create(services);

            services.Configure <RabbitMqOption>(configuration);
            services.ConfigureBus();
            services.AddSingleton <ISubscribeSynchronousToAll, RabbitMqEventPublisher>();

            Resolver = EventFlowOptions.New
                       .UseServiceCollection(services)
                       .RegisterModule <BookingDomainModule>()
                       .RegisterModule <CommandModule>()
                       .RegisterModule <CommandHandlersModule>()
                       .RegisterServices(r => r.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>())
                       .CreateResolver(false);

            CommandBus    = Resolver.Resolve <ICommandBus>();
            HostedService = Resolver.Resolve <IHostedService>();
        }
コード例 #22
0
        public void Register <T>(IHostedService service, string friendlyName) where T : class, IHostedService
        {
            if (typeof(T) != service.GetType())
            {
                throw new ArgumentException($"Type mismatch: {nameof(T)} is {typeof(T).Name}, but {nameof(service)} is {service.GetType()}.");
            }

            if (IsStartAllAsyncStarted)
            {
                throw new InvalidOperationException("Services are already started.");
            }

            lock (ServicesLock)
            {
                if (AnyNoLock <T>())
                {
                    throw new InvalidOperationException($"{typeof(T).Name} is already registered.");
                }
                Services.Add(new HostedService(service, friendlyName));
            }
        }
コード例 #23
0
        public async Task ComponentError()
        {
            Routable routable = null;

            this.errorComponent.Reset();
            this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
            {
                routable = x;
            });
            this.processComponent.Reset();
            this.processComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
            {
                throw new Kyameru.Core.Exceptions.ProcessException("Manual Error");
            });

            IHostedService service = this.GetHostedService();
            await service.StartAsync(CancellationToken.None);

            await service.StopAsync(CancellationToken.None);

            Assert.IsTrue(this.IsInError(routable, "Processing component"));
        }
コード例 #24
0
        public static void Initialize(TestContext context)
        {
            var pollerConfig = new PollerConfig
            {
                Interval         = TimeSpan.Zero,
                WatchedUserIds   = new [] { "mockuser" },
                StoreSentUpdates = true
            };

            IServiceCollection addHostedService = new ServiceCollection()
                                                  .AddLogging(builder => builder.AddTestsLogging(context))
                                                  .AddUpdatesProducerMockRepositories()
                                                  .AddSingleton <IUpdatesPublisher, MockUpdatesPublisher>()
                                                  .AddSingleton <IUpdatesProvider, MockUpdatesProvider>()
                                                  .AddUpdatesPollerService(pollerConfig);

            var services = addHostedService
                           .BuildServiceProvider();

            _publisher = (MockUpdatesPublisher)services.GetService <IUpdatesPublisher>();
            _service   = services.GetService <IHostedService>();
        }
コード例 #25
0
        private CommandLineBackgroundServiceUnit(Action <IServiceCollection> configureDelegate, string[] args)
        {
            Reporter = new TestReporter();

            IServiceCollection collection = new ServiceCollection();

            configureDelegate?.Invoke(collection);

            IServiceProviderFactory <IServiceCollection> factory = new DefaultServiceProviderFactory();
            IServiceProvider provider = factory.CreateServiceProvider(collection);

            IHostApplicationLifetime appLifetime = new TestApplicationLifetime(() =>
            {
                StopCount++;
                commandPipelineOperation.SetResult(true);
            });

            Assembly assembly = typeof(CommandLineBackgroundServiceUnit).Assembly;

            context                  = new CommandContext(args, assembly);
            hostedService            = new CommandLineBackgroundService(provider, appLifetime, context, Reporter);
            commandPipelineOperation = new TaskCompletionSource <bool>();
        }
コード例 #26
0
		private Task createTask(IHostedService service, CancellationToken cancellationToken)
		{
			cancellationToken.Register(service.Cancel);

			return new Task(service.Start, cancellationToken, TaskCreationOptions.LongRunning);
		}
コード例 #27
0
		public Guid Install(IHostedService service)
		{
			this.WriteDebugMessage(string.Format("Installing hosted service {0}({1}).", service.GetType().Name, service.Name));

			var serviceId = Guid.NewGuid();

			var cancellationTokenSource = new CancellationTokenSource();
			var cancellationToken = cancellationTokenSource.Token;

			var task = createTask(service, cancellationToken);

			_taskMap.Add(serviceId, task);

			_taskTokenSources.Add(serviceId, cancellationTokenSource);

			Services.Add(serviceId, service);

			this.WriteInfoMessage(string.Format("Installed hosted service {0}.", service.Name));

			return serviceId;
		}
コード例 #28
0
 public ValuesController(IHostedService listenerService)
 {
     this.listenerService = listenerService;
 }
コード例 #29
0
        public void Startup()
        {
            //
            //	get configuration information
            //

            MessageQueueAppConfig messageQueueAppConfig = new MessageQueueAppConfig();
            ConnectionStrings     connectionStrings     = new ConnectionStrings();

            var basePath = PlatformServices.Default.Application.ApplicationBasePath;

            if (basePath.ToLower().Contains("salesordermanagementqa"))
            {
                CodeProject.Shared.Common.Models.AppSettings.MessageQueueAppSettings appSettings = new CodeProject.Shared.Common.Models.AppSettings.MessageQueueAppSettings();

                string readContents;
                using (StreamReader streamReader = new StreamReader(basePath + @"\AppSettings.QA.json", Encoding.UTF8))
                {
                    readContents = streamReader.ReadToEnd();
                }

                appSettings = CodeProject.Shared.Common.Utilities.SerializationFunction <CodeProject.Shared.Common.Models.AppSettings.MessageQueueAppSettings> .ReturnObjectFromString(readContents);

                messageQueueAppConfig.MessageQueueHostName    = appSettings.MessageQueueAppConfig.MessageQueueHostName;
                messageQueueAppConfig.MessageQueueUserName    = appSettings.MessageQueueAppConfig.MessageQueueUserName;
                messageQueueAppConfig.MessageQueuePassword    = appSettings.MessageQueueAppConfig.MessageQueuePassword;
                messageQueueAppConfig.MessageQueueEnvironment = appSettings.MessageQueueAppConfig.MessageQueueEnvironment;
                messageQueueAppConfig.ExchangeName            = appSettings.MessageQueueAppConfig.ExchangeName;
                messageQueueAppConfig.RoutingKey            = appSettings.MessageQueueAppConfig.RoutingKey;
                messageQueueAppConfig.InboundMessageQueue   = appSettings.MessageQueueAppConfig.InboundMessageQueue;
                messageQueueAppConfig.OutboundMessageQueues = appSettings.MessageQueueAppConfig.OutboundMessageQueues;
                messageQueueAppConfig.LoggingExchangeName   = appSettings.MessageQueueAppConfig.LoggingExchangeName;
                messageQueueAppConfig.LoggingMessageQueue   = appSettings.MessageQueueAppConfig.LoggingMessageQueue;
                messageQueueAppConfig.OriginatingQueueName  = appSettings.MessageQueueAppConfig.OriginatingQueueName;
                messageQueueAppConfig.SendToLoggingQueue    = appSettings.MessageQueueAppConfig.SendToLoggingQueue;
                messageQueueAppConfig.AcknowledgementMessageExchangeSuffix = appSettings.MessageQueueAppConfig.AcknowledgementMessageExchangeSuffix;
                messageQueueAppConfig.AcknowledgementMessageQueueSuffix    = appSettings.MessageQueueAppConfig.AcknowledgementMessageQueueSuffix;
                messageQueueAppConfig.TriggerExchangeName       = appSettings.MessageQueueAppConfig.TriggerExchangeName;
                messageQueueAppConfig.TriggerQueueName          = appSettings.MessageQueueAppConfig.TriggerQueueName;
                messageQueueAppConfig.QueueImmediately          = appSettings.MessageQueueAppConfig.QueueImmediately;
                messageQueueAppConfig.InboundSemaphoreKey       = appSettings.MessageQueueAppConfig.InboundSemaphoreKey;
                messageQueueAppConfig.OutboundSemaphoreKey      = appSettings.MessageQueueAppConfig.OutboundSemaphoreKey;
                messageQueueAppConfig.ProcessingIntervalSeconds = appSettings.MessageQueueAppConfig.ProcessingIntervalSeconds;
                messageQueueAppConfig.SendingIntervalSeconds    = appSettings.MessageQueueAppConfig.SendingIntervalSeconds;
                messageQueueAppConfig.ReceivingIntervalSeconds  = appSettings.MessageQueueAppConfig.ReceivingIntervalSeconds;
                messageQueueAppConfig.SignalRHubUrl             = appSettings.MessageQueueAppConfig.SignalRHubUrl;
                messageQueueAppConfig.RunAsService = appSettings.MessageQueueAppConfig.RunAsService;

                connectionStrings.PrimaryDatabaseConnectionString = appSettings.ConnectionStrings.PrimaryDatabaseConnectionString;

                using (var sw = File.AppendText(Path))
                {
                    sw.WriteLine("HostName=" + messageQueueAppConfig.MessageQueueHostName + "*");
                }
            }
            else
            {
                string environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
                string jsonFile    = $"AppSettings.{environment}.json";

                var configBuilder = new ConfigurationBuilder()
                                    .SetBasePath(Directory.GetCurrentDirectory())
                                    .AddJsonFile(jsonFile, optional: true, reloadOnChange: true);

                IConfigurationRoot configuration = configBuilder.Build();

                configuration.GetSection("MessageQueueAppConfig").Bind(messageQueueAppConfig);
                configuration.GetSection("ConnectionStrings").Bind(connectionStrings);
            }

            //
            //	set up sending queue
            //

            IMessageQueueConnection sendingQueueConnection = new MessageQueueConnection(messageQueueAppConfig);

            sendingQueueConnection.CreateConnection();

            List <IMessageQueueConfiguration> messageQueueConfigurations = new List <IMessageQueueConfiguration>();

            IMessageQueueConfiguration salesOrderSubmittedConfiguration = new MessageQueueConfiguration(MessageQueueExchanges.SalesOrderSubmitted, messageQueueAppConfig, sendingQueueConnection);

            salesOrderSubmittedConfiguration.AddQueue(MessageQueueEndpoints.InventoryQueue);
            salesOrderSubmittedConfiguration.AddQueue(MessageQueueEndpoints.LoggingQueue);

            salesOrderSubmittedConfiguration.InitializeOutboundMessageQueueing();
            messageQueueConfigurations.Add(salesOrderSubmittedConfiguration);

            ISalesOrderManagementDataService salesOrderManagementDataService = new SalesOrderManagementDataService();
            IMessageQueueProcessing          messageProcessing = new MessageProcessing(salesOrderManagementDataService);

            _sendSalesOrderManagementMessages =
                new SendMessages(sendingQueueConnection, messageProcessing, messageQueueAppConfig,
                                 connectionStrings, messageQueueConfigurations, MessageQueueEndpoints.SalesOrderQueue);


            //
            //	set up receiving queue
            //

            IMessageQueueConnection receivingConnection = new MessageQueueConnection(messageQueueAppConfig);

            receivingConnection.CreateConnection();

            List <IMessageQueueConfiguration> inboundMessageQueueConfigurations = new List <IMessageQueueConfiguration>();
            IMessageQueueConfiguration        inboundConfiguration = new MessageQueueConfiguration(messageQueueAppConfig, receivingConnection);

            inboundMessageQueueConfigurations.Add(inboundConfiguration);

            inboundConfiguration.InitializeInboundMessageQueueing(MessageQueueEndpoints.SalesOrderQueue);
            inboundConfiguration.InitializeLoggingExchange(MessageQueueExchanges.Logging, MessageQueueEndpoints.LoggingQueue);
            ISalesOrderManagementDataService inboundSalesOrderManagementDataService = new SalesOrderManagementDataService();
            IMessageQueueProcessing          inboundMessageProcessing = new MessageProcessing(inboundSalesOrderManagementDataService);

            _receiveSalesOrderManagementMessages = new ReceiveMessages(receivingConnection, inboundMessageProcessing, messageQueueAppConfig, connectionStrings, inboundMessageQueueConfigurations);

            //
            //	Set Up Message Processing
            //

            ISalesOrderManagementDataService salesOrderManagementProcessingDataService = new SalesOrderManagementDataService();
            IMessageQueueProcessing          messageProcessor = new MessageProcessing(salesOrderManagementProcessingDataService);

            _processMessages = new ProcessMessages(messageProcessor, messageQueueAppConfig, connectionStrings);

            var builder = new HostBuilder().ConfigureAppConfiguration((hostingContext, config) =>
            {
            })
                          .ConfigureServices((hostContext, services) =>
            {
                services.AddTransient <IHostedService>(provider => _sendSalesOrderManagementMessages);
            })
                          .ConfigureServices((hostContext, services) =>
            {
                services.AddTransient <IHostedService>(provider => _processMessages);
            })
                          .ConfigureServices((hostContext, services) =>
            {
                services.AddTransient <IHostedService>(provider => _receiveSalesOrderManagementMessages);
            });
        }
コード例 #30
0
        public ErrorHandlingMiddleware(RequestDelegate next, IHostingEnvironment environment, IHostedService loggingService)
        {
            _environment    = environment;
            _loggingService = loggingService as LoggingService;

            this.next = next;
        }
コード例 #31
0
 public HostedService(IHostedService service, string friendlyName)
 {
     Service      = Guard.NotNull(nameof(service), service);
     FriendlyName = Guard.NotNull(nameof(friendlyName), friendlyName);
 }
コード例 #32
0
 public ValuesController(IHubContext <ValuesHub> hub, IHostedService hostedService)
 {
     _hostedService = hostedService as GenerateRandom;
 }
コード例 #33
0
ファイル: ConfigureBackups.cs プロジェクト: asimshah/Services
        public ConfigureBackups(ILoggerFactory loggerFactory, WebDbContextFactory dbf, IHostedService hostedService,
                                IOptionsMonitor <ServiceOptions> options) : base(loggerFactory)
        {
            //log.LogInformation("Configuration constructor called");
            this.dbf = dbf;
            //dbf.GetWebDbContext<ServiceDb>().Database.EnsureCreated();
            this.options          = options.CurrentValue;
            this.schedulerService = hostedService as SchedulerService;
            options.OnChangeWithDelay((opt) =>
            {
                this.options = opt;
                SetupPipeline();
                log.LogInformation("Configuration (appsettings) changed, starting ConfigureBackups");
                this.schedulerService.ExecuteNow <ConfigureBackups>();
            });
            var backupSchedule = this.options.ServiceSchedules?.FirstOrDefault(sc => string.Compare(sc.Name, this.GetType().Name) == 0);

            schedule = backupSchedule?.Schedule ?? "0 0 1 */12 *";// default is At 00:00 AM, on day 1 of the month, every 12 months!! not useful!
            SetupPipeline();
        }
コード例 #34
0
        public void OnStop_stops_started_hosted_service([Frozen] IServiceProvider services, WindowsService sut, IHostedService hostedService, HostControl control)
        {
            Mock.Get(services).Setup(p => p.GetService(typeof(IEnumerable <IHostedService>))).Returns(new[] { hostedService });

            sut.OnStart(control);

            sut.OnStop(control);

            Mock.Get(hostedService).Verify(p => p.StopAsync(It.IsAny <CancellationToken>()));
        }
コード例 #35
0
 public ValuesController(RandomStringProvider randomStringProvider, IHostedService dataRefreshService)
 {
     _randomStringProvider = randomStringProvider;
     _dataRefreshService   = dataRefreshService;
 }
コード例 #36
0
ファイル: Startup.cs プロジェクト: liaoxuezhi/consuleTest
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime lifetime, IConsulClient consulClient, IHostedService hostedService)
        {
            loggerFactory.AddConsole();
            var _logger = loggerFactory.CreateLogger <Startup>();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseMvc();

            app.UseSwagger(c =>
            {
                c.PreSerializeFilters.Add((swagger, httpReq) => swagger.Host = httpReq.Host.Value);
            });

            app.UseSwaggerUI(c =>
            {
                c.SwaggerEndpoint("/swagger/v1/swagger.json", "V1 Docs");
            });

            lifetime.ApplicationStopping.Register(() =>
            {
                _logger.LogInformation("Deregistering from Consul");
                try
                {
                    hostedService.StopAsync(new CancellationToken());
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, $"Deregisteration failed");
                }
            });

            app.Map("/health", appBulider =>
            {
                appBulider.Run(async context => await context.Response.WriteAsync("health"));
            });
            app.UseWelcomePage();
        }
コード例 #37
0
 internal HostedServiceWrapper(IHostedService inner, ILogger <HostedServiceWrapper> logger)
 {
     _inner  = inner;
     _logger = logger;
     Name    = inner.GetType().Name.Replace("HostedService", "");
 }
コード例 #38
0
 public TrainingService(IDatabaseRepository <TrainingSession> trainingRepository, IHostedService hostedService)
 {
     this.trainingRepository = trainingRepository;
     this.hostedService      = hostedService;
 }
コード例 #39
0
 public HostedServiceWrapper(TService hostedService)
 {
     _hostedService = (IHostedService)hostedService;
 }