public static void Configure(HostConfigurator config)
        {
            // http://docs.topshelf-project.com/en/latest/
            Logger.Debug("Configuring windows service");
            config.Service<WindowsService>(ConfigureServiceClass);

            // prompt for credentials - Sys Admins will need to type password for SchTasks.Admin user
            config.RunAsPrompt();

            config.SetDescription("Cyrus MicroServices Background Processing (Multiple Mini-Apps)");
            config.SetDisplayName("Cyrus MicroServices");
            config.SetServiceName("Cyrus.MicroServices");

            //TODO: windows service settings
            //config.SetDescription(AppSettings.Default.WindowsService.Description);
            //config.SetDisplayName(AppSettings.Default.WindowsService.DisplayName);
            //config.SetServiceName(AppSettings.Default.WindowsService.Name);

            config.StartAutomatically();
            config.UseNLog();

            config.EnableServiceRecovery(rc =>
            {
                rc.RestartService(delayInMinutes: 2);
                //rc.RestartService(AppSettings.Default.WindowsService.RecoverRestartAfterMins);
            });

            Logger.Debug("Windows service configured");
        }
Example #2
0
 private void SetupService(HostConfigurator configurator, ILifetimeScope container)
 {
     configurator.AutofacService<IAgarIoService>(container, serviceConfigurator =>
     {
         serviceConfigurator.WhenStarted(s => s.Start());
         serviceConfigurator.WhenStopped(s => s.Stop());
     });
     configurator.SetServiceName("AgarIo.Service");
     configurator.SetDisplayName("AgarIo Service");
     configurator.SetDescription("Serves AgarIo Game");
     configurator.UseNLog();
 }
Example #3
0
        private void CreateServiceConfiguration(HostConfigurator x)
        {
            

            var config = container.Resolve<RendezvousConfiguration>();

            x.Service<IRendezvousService>(s =>
                                          {
                                              s.ConstructUsing(_ => CreateServiceInstance());
                                              s.WhenStarted(rs => rs.Start());
                                              s.WhenStopped(ServiceStop);
                                          });
            x.RunAsPrompt();
            x.SetServiceName(config.ServiceName);
            x.SetDisplayName(config.ServiceName);
            x.SetDescription($"{config.ServiceName} Service");
        }
Example #4
0
        void ConfigureHost(HostConfigurator x)
        {
            x.UseSerilog(_container.Resolve<ILogger>());
            x.Service<PapercutServerService>(
                s =>
                {
                    s.ConstructUsing(serviceFactory => _container.Resolve<PapercutServerService>());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                    s.WhenShutdown(ts => _container.Dispose());
                });

            x.RunAsLocalSystem();

            x.SetDescription("Papercut SMTP Backend Service");
            x.SetDisplayName("Papercut SMTP Service");
            x.SetServiceName("PapercutServerService");
        }
 public void ApplyTo(HostConfigurator configurator)
 {
     configurator.SetDescription(_description);
 }
Example #6
0
        private static void CreateHost(HostConfigurator config, out AppServiceOptions serviceOptions)
        {
            // Чтение параметров командной строки
            var parameters = config.SelectPlatform(i => i.AddStringParameter("packageId")
                                                         .AddStringParameter("packageVersion")
                                                         .AddStringParameter("packageInstance")
                                                         .AddStringParameter("packageDirectory")
                                                         .AddStringParameter("packageTimeout")
                                                         .AddStringParameter("startOptions"));

            serviceOptions = ParseServiceOptions(parameters);

            // Установка текущего каталога приложения
            Directory.SetCurrentDirectory(serviceOptions.PackageDirectory);

            // Установка таймаута для запуска и остановки

            var serviceTimeout = TimeSpan.MaxValue;

            if (serviceOptions.PackageTimeout != null)
            {
                serviceTimeout = TimeSpan.FromSeconds(serviceOptions.PackageTimeout.Value);
                config.SetStartTimeout(serviceTimeout);
                config.SetStopTimeout(serviceTimeout);
            }

            config.Service<AppServiceHost>(s =>
                                           {
                                               // Создание экземпляра приложения
                                               s.ConstructUsing(hostSettings =>
                                                                {
                                                                    try
                                                                    {
                                                                        var instance = new AppServiceHost();
                                                                        return instance;
                                                                    }
                                                                    catch (Exception exception)
                                                                    {
                                                                        Console.WriteLine(exception);
                                                                        throw;
                                                                    }
                                                                });

                                               // Запуск экземпляра приложения
                                               s.WhenStarted((instance, hostControl) =>
                                                             {
                                                                 try
                                                                 {
                                                                     instance.Start(serviceTimeout);
                                                                     return true;
                                                                 }
                                                                 catch (Exception exception)
                                                                 {
                                                                     Console.WriteLine(exception);
                                                                     throw;
                                                                 }
                                                             });

                                               // Остановка экземпляра приложения
                                               s.WhenStopped((instance, hostControl) =>
                                                             {
                                                                 try
                                                                 {
                                                                     instance.Stop(serviceTimeout);
                                                                     return true;
                                                                 }
                                                                 catch (Exception exception)
                                                                 {
                                                                     Console.WriteLine(exception);
                                                                     throw;
                                                                 }
                                                             });
                                           });

            // Установка имени службы

            var serviceName = GetServiceName(serviceOptions);
            config.SetServiceName(serviceName);
            config.SetDisplayName(serviceName);
            config.SetDescription(serviceName);

            // Установка экземпляра службы

            var serviceInstance = serviceOptions.PackageInstance;

            if (!string.IsNullOrWhiteSpace(serviceInstance))
            {
                config.SetInstanceName(serviceInstance);
            }
        }