static void Run(string[] args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var statistics = new HostStatistics(); var eye = new Beholder.Eyes.SharpDX11.Winforms.WinformsEye(); var graphicsWindowHandle = eye.CreateNewWindow(200, 150, "Stream", true); var colorFormatInfo = eye.Adapters[0].GetSupportedWindowedDisplayFormats().First(x => x.ExplicitFormat == ExplicitFormat.R8G8B8A8_UNORM); #if DEBUG var deviceFlags = DeviceInitializationFlags.Debug; #else var deviceFlags = DeviceInitializationFlags.None; #endif eye.Initialize(eye.Adapters[0], graphicsWindowHandle, new SwapChainDescription(2, colorFormatInfo.ID, false, 0, Sampling.NoMultisampling, true), deviceFlags, new StraightforwardFileSystem()); var device = eye.Device; var pclWorkarounds = new PclWorkarounds(); var byteArrayPool = new ByteArrayPool(); var logger = new FileLogger(); var settings = new HostSettings(); var globalEvents = new HostGlobalEvents(); var broadcaster = settings.FromFile ? (IStreamBroadcaster)new FileStreamBroadcaster() : new TcpStreamBroadcaster(settings, globalEvents, logger); var broadcastingStage = new BroadcastStage(broadcaster); var cpuSideCodec = new CpuSideCodec(pclWorkarounds, byteArrayPool); var cpuCompressionStage = new CpuCompressionStage(statistics, cpuSideCodec); var gpuReadBackStage = new GpuReadBackStage(statistics, device, byteArrayPool, 1); var debugStage = new DebugStage(device); var gpuProcessingStage = new GpuProcessingStage(device); //var screenCaptor = new ScreenCaptor9(statistics, device); var screenCaptor = new ScreenCaptor11(statistics, device); var mainLoop = new MainLoop(statistics, globalEvents, device, screenCaptor); PipelineBuilder .BeginWith(mainLoop) .ContinueWith(gpuProcessingStage) //.ContinueWith(debugStage) .ContinueWith(gpuReadBackStage) .ContinueWith(cpuCompressionStage) .EndWith(broadcastingStage); broadcaster.Start(); cpuCompressionStage.Start(); eye.NewFrame += mainLoop.OnNewFrame; statistics.ShowForm(); using (mainLoop) using (eye) eye.RunLoop(device.PrimarySwapChain.Window); cpuCompressionStage.Stop(); broadcaster.Stop(); }
public static void SendEmail(string from, string to, string cc, string bcc, string subject, string body) { MailMessage email = new MailMessage(); if (!string.IsNullOrEmpty(from)) { email.From = new MailAddress(from); } else { string hostEmail = HostSettings.GetHostSetting("HostEmail"); email.From = new MailAddress(hostEmail); } to.Split(',').ToList().ForEach(t => email.To.Add(t)); if (!string.IsNullOrEmpty(cc)) { cc.Split(',').ToList().ForEach(x => email.CC.Add(x)); } if (!string.IsNullOrEmpty(bcc)) { bcc.Split(',').ToList().ForEach(x => email.Bcc.Add(x)); } email.Subject = subject; email.IsBodyHtml = true; email.BodyEncoding = Encoding.UTF8; email.Body = body; Util.Emailer.SendMail(email); }
public override Task <TransportInfrastructure> Initialize(HostSettings hostSettings, ReceiveSettings[] receivers, string[] sendingAddresses, CancellationToken cancellationToken = default) { ReceiveAddresses = receivers.Select(r => r.ReceiveAddress).ToArray(); return(base.Initialize(hostSettings, receivers, sendingAddresses, cancellationToken)); }
public ConsoleRunHost(HostSettings settings, HostEnvironment environment, ServiceHandle serviceHandle) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (environment == null) { throw new ArgumentNullException(nameof(environment)); } _settings = settings; _environment = environment; _serviceHandle = serviceHandle; #if !NETCORE if (settings.CanSessionChanged) { SystemEvents.SessionSwitch += OnSessionChanged; } if (settings.CanHandlePowerEvent) { SystemEvents.PowerModeChanged += OnPowerModeChanged; } #endif }
protected void ResolveHostConfig() { _logger.LogInformation("Resolving Host Configuration"); var configBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddEnvironmentVariables(prefix: HostSettings.ConfigEnvPrefix); _hostConfig = configBuilder.Build(); _settings = _hostConfig.Get <HostSettings>(); _awsOptions = _hostConfig.GetAWSOptions(); if (_settings.AppSettingsS3Bucket != null && _settings.AppSettingsS3Key != null) { _logger.LogInformation($"Resolved AppSettings S3 source as" + $" [{_settings.AppSettingsS3Bucket}][{_settings.AppSettingsS3Key}]"); var s3 = _awsOptions.CreateServiceClient <IAmazonS3>(); var getResp = s3.GetObjectAsync(_settings.AppSettingsS3Bucket, _settings.AppSettingsS3Key).Result; var localJson = HostSettings.AppSettingsLocalJsonFile; using (getResp) using (var rs = getResp.ResponseStream) using (var fs = File.OpenWrite(localJson)) { rs.CopyTo(fs); } _logger.LogInformation($"Copied AppSettings from S3 source to local file at [{localJson}]"); } }
private void SearchExecute() { int ResultsTabid; if (Settings["SearchResultsModule"] != null) { ResultsTabid = int.Parse(Convert.ToString(Settings["SearchResultsModule"])); } else { //Get Default Page ModuleController objModules = new ModuleController(); ModuleInfo SearchModule = objModules.GetModuleByDefinition(PortalSettings.PortalId, "Search Results"); if (SearchModule == null) { UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("NoSearchModule", LocalResourceFile), ModuleMessageType.YellowWarning); return; } else { ResultsTabid = SearchModule.TabID; } } if (HostSettings.GetHostSetting("UseFriendlyUrls") == "Y") { Response.Redirect(Globals.NavigateURL(ResultsTabid) + "?Search=" + Server.UrlEncode(txtSearch.Text)); } else { Response.Redirect(Globals.NavigateURL(ResultsTabid) + "&Search=" + Server.UrlEncode(txtSearch.Text)); } }
private static LinuxServiceSettings CreateServiceSettings(HostSettings settings, string commandLine) { var currentAssembly = Assembly.GetEntryAssembly(); if (currentAssembly == null) { throw new InstallException(Resources.ServiceMustBeExecutableFile); } var serviceName = settings.Name; if (!string.IsNullOrEmpty(settings.InstanceName)) { serviceName += "@" + settings.InstanceName; } var result = new LinuxServiceSettings { ServiceName = serviceName, DisplayName = settings.DisplayName, Description = settings.Description, ServiceExe = currentAssembly.Location, ServiceArgs = commandLine }; var installSettings = settings as InstallHostSettings; if (installSettings != null) { result.Username = installSettings.Credentials?.Username; result.Dependencies = installSettings.Dependencies; } return(result); }
public RehabServiceHandle(HostSettings settings, ServiceBuilderFactory serviceBuilderFactory) { _settings = settings; _serviceBuilderFactory = serviceBuilderFactory; _service = CreateServiceInAppDomain(); }
private static LinuxServiceSettings CreateServiceSettings(HostSettings settings, string commandLine) { var currentAssembly = Assembly.GetEntryAssembly(); if (currentAssembly == null) { throw new InstallException(Resources.ServiceMustBeExecutableFile); } var serviceName = settings.Name; if (!string.IsNullOrEmpty(settings.InstanceName)) { serviceName += "@" + settings.InstanceName; } var result = new LinuxServiceSettings { ServiceName = serviceName, DisplayName = settings.DisplayName, Description = settings.Description, ServiceExe = currentAssembly.Location, ServiceArgs = commandLine }; var installSettings = settings as InstallHostSettings; if (installSettings != null) { result.Username = installSettings.Credentials?.Username; result.Dependencies = installSettings.Dependencies; } return result; }
public StopAndUninstallHostBuilder(HostEnvironment environment, HostSettings settings, string version = null) { Environment = environment; var serviceName = settings.Name; if (version != null) { serviceName = $"{serviceName.Split('-')[0]}-{version}"; } var serviceInfo = GetWmiServiceInfo(serviceName); if (serviceInfo != null) { serviceName = Convert.ToString(serviceInfo["Name"].Value); _processId = Convert.ToInt32(serviceInfo["ProcessId"].Value); } Settings = new WindowsHostSettings { Name = serviceName, // squirrel hook wait only 15 seconds // so we can't wait for service stop more that 5 seconds StopTimeOut = TimeSpan.FromSeconds(5), }; _stopBuilder = new StopBuilder(Environment, Settings); _uninstallBuilder = new UninstallBuilder(Environment, Settings); _uninstallBuilder.Sudo(); }
protected void Page_Load(Object sender, EventArgs e) { // public attributes if (!String.IsNullOrEmpty(CssClass)) { hypLogin.CssClass = CssClass; } if (Request.IsAuthenticated) { if (!String.IsNullOrEmpty(LogoffText)) { if (LogoffText.IndexOf("src=") != -1) { LogoffText = LogoffText.Replace("src=\"", "src=\"" + PortalSettings.ActiveTab.SkinPath); } hypLogin.Text = LogoffText; } else { hypLogin.Text = Localization.GetString("Logout", Localization.GetResourceFile(this, MyFileName)); } if (HostSettings.GetHostSetting("UseFriendlyUrls") == "Y") { hypLogin.NavigateUrl = Globals.FriendlyUrl(PortalSettings.ActiveTab, Globals.ApplicationURL(PortalSettings.ActiveTab.TabID) + "&portalid=" + PortalSettings.PortalId, "Logoff.aspx"); } else { hypLogin.NavigateUrl = ResolveUrl("~/Admin/Security/Logoff.aspx?tabid=" + PortalSettings.ActiveTab.TabID + "&portalid=" + PortalSettings.PortalId); } } else { if (!String.IsNullOrEmpty(Text)) { if (Text.IndexOf("src=") != -1) { Text = Text.Replace("src=\"", "src=\"" + PortalSettings.ActiveTab.SkinPath); } hypLogin.Text = Text; } else { hypLogin.Text = Localization.GetString("Login", Localization.GetResourceFile(this, MyFileName)); } if (PortalSettings.LoginTabId != -1 && Request.QueryString["override"] == null) { // user defined tab hypLogin.NavigateUrl = Globals.NavigateURL(PortalSettings.LoginTabId); } else { // admin tab hypLogin.NavigateUrl = Globals.NavigateURL("Login"); } } }
/// <summary> /// Initializes a new instance of the <see cref="ServiceAgent"/> class. /// </summary> /// <param name="configuration"></param> /// <param name="clientFactory"></param> public ServiceAgent( IEmConfiguration configuration, IHttpClientFactory clientFactory) { this.configuration = configuration; this.clientFactory = clientFactory; this.hostSettings = this.configuration.ToHostSettings(); }
public InstallServiceSettingsImpl(HostSettings settings, Credentials credentials, HostStartMode startMode, string[] dependencies) { _credentials = credentials; _settings = settings; _startMode = startMode; _dependencies = dependencies; }
static string GetBaseQueueName(IConfigurationProvider configurationProvider, HostSettings hostSettings) { string baseQueueName; if (configurationProvider.TryGetSetting(QueueNameKey, out baseQueueName)) return baseQueueName; return hostSettings.ServiceName.Replace(" ", "_"); }
IMessageReceiver CreateMessagePump(HostSettings hostSettings, ReceiveSettings settings, MessageConverter messageConverter, TimeSpan timeToWaitBeforeTriggeringCircuitBreaker, PrefetchCountCalculation prefetchCountCalculation) { var consumerTag = $"{hostSettings.HostDisplayName} - {hostSettings.Name}"; var receiveAddress = ToTransportAddress(settings.ReceiveAddress); return(new MessagePump(settings, connectionFactory, routingTopology, messageConverter, consumerTag, channelProvider, timeToWaitBeforeTriggeringCircuitBreaker, prefetchCountCalculation, hostSettings.CriticalErrorAction, networkRecoveryInterval)); }
public UninstallBuilder(HostEnvironment environment, HostSettings settings) { _preActions = new List <Action>(); _postActions = new List <Action>(); _environment = environment; _settings = settings; }
public ServiceHandleProxy(HostSettings settings, HostControl hostControl, ServiceBuilderFactory serviceBuilderFactory) { _settings = settings; _hostControl = new HostControlProxy(hostControl); _serviceBuilderFactory = serviceBuilderFactory; _service = CreateServiceInAppDomain(); }
public StartBuilder(HostBuilder builder) { #if !NETCORE _builder = GetParentBuilder(builder); #endif _settings = builder.Settings; _environment = builder.Environment; }
public AcceptanceTestingTransportInfrastructure(HostSettings settings, AcceptanceTestingTransport transportSettings, ReceiveSettings[] receiverSettings) { this.settings = settings; this.transportSettings = transportSettings; this.receiverSettings = receiverSettings; storagePath = transportSettings.StorageLocation ?? Path.Combine(FindSolutionRoot(), ".attransport"); }
/// <summary> /// Service Builder /// </summary> /// <param name="hostSettings">Topshelf Host Settings</param> /// <typeparam name="T">Type of Service</typeparam> /// <returns>The Service</returns> private static T Build <T>(HostSettings hostSettings) where T : class, ITopshelfServiceBase, new() { var serviceClass = new T { HostSettings = hostSettings }; return(serviceClass); }
public UpdateHostBuilder(HostEnvironment environment, HostSettings settings, string version) { Environment = environment; Settings = settings; _stopAndUninstallHostBuilder = new StopAndUninstallHostBuilder(Environment, Settings); _installAndStartHostBuilder = new InstallAndStartHostBuilder(Environment, Settings, version); }
public SpHostServiceInstaller(HostSettings settings, HostConfigurator configurator) { _hostConfigurator = configurator; _installer = CreateInstaller(settings); _transactedInstaller = CreateTransactedInstaller(_installer); }
/// <summary> /// Initializes a new instance of the <see cref="TestService"/> class. /// </summary> /// <param name="settings">The settings<see cref="HostSettings"/></param> /// <param name="logger">The logger<see cref="ILogger{TestService}"/></param> public TestService(HostSettings settings, ILogger <TestService> logger) { _logger = logger; _timer = new Timer(30) { AutoReset = true, Enabled = true }; }
public FakeTransportInfrastructure(FakeTransport.StartUpSequence startUpSequence, HostSettings hostSettings, ReceiveSettings[] receivers, string[] sendingAddresses, FakeTransport transportSettings) { this.startUpSequence = startUpSequence; this.hostSettings = hostSettings; this.receivers = receivers; this.sendingAddresses = sendingAddresses; this.transportSettings = transportSettings; }
public void UninstallService(HostSettings settings, Action beforeUninstall, Action afterUninstall) { var installer = new LinuxHostServiceInstallerImpl(); Action <InstallEventArgs> tryBeforeUninstall = x => beforeUninstall?.Invoke(); Action <InstallEventArgs> tryAfterUninstall = x => afterUninstall?.Invoke(); installer.UninstallService(settings, _arguments, tryBeforeUninstall, tryAfterUninstall); }
public void ImportHostSettings(string path) { SettingsWorker settingsWorker = new SettingsWorker(Catalog.Instance, Catalog.Database); HostSettings hostSettings = Helper.BizTalkSettingsHelper.ParseHostsSettings(path); ImportHostSettings(settingsWorker, hostSettings); RetrieveHostSetting(Name); }
public void UninstallService(HostSettings settings, Action beforeUninstall, Action afterUninstall) { var installer = new WindowsHostServiceInstallerImpl(); Action<InstallEventArgs> tryBeforeUninstall = x => beforeUninstall?.Invoke(); Action<InstallEventArgs> tryAfterUninstall = x => afterUninstall?.Invoke(); installer.UninstallService(settings, _arguments, tryBeforeUninstall, tryAfterUninstall); }
public EventHubFactoryConfigurator() { _observers = new RiderObservable(); _endpointObservers = new ReceiveEndpointObservable(); _endpoints = new List <IEventHubReceiveEndpointSpecification>(); _hostSettings = new HostSettings(); _storageSettings = new StorageSettings(); _producerSpecification = new EventHubProducerSpecification(_hostSettings); }
public BinnerWebHostService(HostSettings hostSettings, WebHostServiceConfiguration config, IWebHostFactory webHostFactory, ILogger <BinnerWebHostService> logger, IServiceProvider serviceProvider) { _hostSettings = hostSettings; _config = config ?? throw new ArgumentNullException(nameof(config)); WebHostFactory = webHostFactory ?? throw new ArgumentNullException(nameof(webHostFactory)); Logger = logger ?? throw new ArgumentNullException(nameof(logger)); ServiceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider)); }
public CaseMonitor(HostSettings settings, ILogger logger, ISystemTime systemTime, IModelBuilder <RecentCaseModel> caseModelBuilder) { _settings = settings; _logger = logger; _systemTime = systemTime; _caseModelBuilder = caseModelBuilder; _interval = TimeSpan.FromSeconds(15); _lastPolled = systemTime.Now.Subtract(_interval); }
public Builder(TopshelfRoleEntryPoint host, HostEnvironment environment, HostSettings settings) { _host = host; _host._settings = settings; _host._environment = environment; _environment = environment; _settings = settings; }
public UninstallHost(HostEnvironment environment, HostSettings settings, IEnumerable<Action> preActions, IEnumerable<Action> postActions, bool sudo) { _environment = environment; _settings = settings; _preActions = preActions; _postActions = postActions; _sudo = sudo; }
public override async Task <TransportInfrastructure> Initialize(HostSettings hostSettings, ReceiveSettings[] receivers, string[] sendingAddresses, CancellationToken cancellationToken = default) { MessageEnumeratorTimeout = TimeSpan.FromMilliseconds(10); var infrastructure = await base.Initialize(hostSettings, receivers, sendingAddresses, cancellationToken); ReceiveQueues = infrastructure.Receivers.Select(r => r.Value.ReceiveAddress).ToArray(); return(infrastructure); }
SuperviseService CreateSuperviseService(HostSettings settings) { var service = new SuperviseService(settings, _serviceBuilderFactory); ServiceAvailability serviceAvailability = new DownFileServiceAvailability(service); service.AddServiceAvailability(serviceAvailability); return(service); }
public CustomConsoleHostBuilder(HostEnvironment environment, HostSettings settings) { if (settings == null) { throw new ArgumentNullException("settings"); } this.environment = environment; this.settings = settings; }
SuperviseService CreateSuperviseService(HostSettings settings) { var service = new SuperviseService(settings, _serviceBuilderFactory); ServiceAvailability serviceAvailability = new DownFileServiceAvailability(service); service.AddServiceAvailability(serviceAvailability); return service; }
public WindowsServiceHost(HostEnvironment environment, HostSettings settings, ServiceHandle serviceHandle) { if (settings == null) throw new ArgumentNullException("settings"); if (serviceHandle == null) throw new ArgumentNullException("serviceHandle"); _settings = settings; _serviceHandle = serviceHandle; _environment = environment; }
public HostBuilder Configure(HostBuilder builder) { if (builder == null) throw new ArgumentNullException("builder"); _settings = builder.Settings; builder.Match<InstallBuilder>(x => x.AfterInstall(ConfigureServiceRecovery)); return builder; }
public void Create(ServiceBuilderFactory serviceBuilderFactory, HostSettings settings, HostLoggerConfigurator loggerConfigurator) { AppDomain.CurrentDomain.UnhandledException += CatchUnhandledException; HostLogger.UseLogger(loggerConfigurator); ServiceBuilder serviceBuilder = serviceBuilderFactory(settings); _serviceHandle = serviceBuilder.Build(settings); }
public ConsoleRunHost(HostSettings settings, HostEnvironment environment, ServiceHandle serviceHandle) { if (settings == null) throw new ArgumentNullException("settings"); if (environment == null) throw new ArgumentNullException("environment"); _settings = settings; _environment = environment; _serviceHandle = serviceHandle; }
public SuperviseService(HostSettings settings, ServiceBuilderFactory serviceBuilderFactory) { _settings = settings; _serviceBuilderFactory = serviceBuilderFactory; _serviceAvailability = new List<ServiceAvailability>(); _fiber = new PoolFiber(); _scheduler = new TimerScheduler(new PoolFiber()); _commandHandlers = CreateCommandHandlers(); }
public Host CreateServiceHost(HostSettings settings, ServiceHandle serviceHandle) { if (MonoHelper.RunningUnderMonoService) { return new WindowsServiceHost(this, settings, serviceHandle, configurator); } else { // TODO: Implement a service host which execs mono-service under the hood. throw new NotImplementedException(); } }
protected override Installer CreateUninstaller(HostSettings settings, string commandLine) { var baseInstallers = new Installer[] { CreateServiceInstaller(settings, new string[] {}, HostStartMode.Automatic), CreateServiceProcessInstaller(ServiceAccount.LocalService, "", "") }; var mainInstaller = new HostInstaller(settings, commandLine, baseInstallers); return CreateTransactedInstaller(mainInstaller); }
private static string BuildCommandLine(HostSettings settings, IDictionary<string, object> arguments) { arguments = (arguments == null) ? new Dictionary<string, object>() : new Dictionary<string, object>(arguments); arguments["instance"] = settings.InstanceName; arguments["displayname"] = settings.DisplayName; arguments["servicename"] = settings.Name; return TopshelfHelper.BuildCommandLine(arguments); }
public InstallHost(HostEnvironment environment, HostSettings settings, HostStartMode startMode, IEnumerable<string> dependencies, Credentials credentials, IEnumerable<Action> preActions, IEnumerable<Action> postActions, bool sudo) { _environment = environment; _settings = settings; _installSettings = new InstallServiceSettingsImpl(settings, credentials, startMode, dependencies.ToArray()); _preActions = preActions; _postActions = postActions; _sudo = sudo; }
private static ServiceInstaller CreateServiceInstaller(HostSettings settings, string[] dependencies, HostStartMode startMode) { var installer = new ServiceInstaller { ServiceName = settings.ServiceName, Description = settings.Description, DisplayName = settings.DisplayName, ServicesDependedOn = dependencies }; SetStartMode(installer, startMode); return installer; }
public WindowsServiceHost(HostEnvironment environment, HostSettings settings, ServiceHandle serviceHandle) { if (settings == null) throw new ArgumentNullException("settings"); if (serviceHandle == null) throw new ArgumentNullException("serviceHandle"); _settings = settings; _serviceHandle = serviceHandle; _environment = environment; CanPauseAndContinue = settings.CanPauseAndContinue; CanShutdown = settings.CanShutdown; }
public SignInStatus Login(string server, string user, string password) { try { var session_settings = new SessionSettings(); var host_settings = new HostSettings(new HostEndpoint(server)); var auth_settings = new ICAuthSettings(user, password); ICSession = new Session(); session_settings.ApplicationName = "DialerNetAPIDemo"; ICSession.ConnectionStateChanged += ICSession_ConnectionStateChanged; ICSession.Connect(session_settings, host_settings, auth_settings, new StationlessSettings()); DialerConfiguration = new DialerConfigurationManager(ICSession); InitializeCampaigns(ICSession); InitializeWorkgroups(ICSession); InitializeContactLists(ICSession); InitializePolicySets(ICSession); return SignInStatus.Success; } catch(ININ.IceLib.Connection.RequestTimeoutException e) { HttpContext.Current.Trace.Warn("CIC", "Timeout while connecting", e); } catch(ININ.IceLib.Connection.SessionDisconnectedException e) { HttpContext.Current.Trace.Warn("CIC", "Unable to connect", e); } catch(ININ.IceLib.IceLibLicenseException e) { HttpContext.Current.Trace.Warn("CIC", "Cannot connect, missing license", e); } catch(ININ.IceLib.IceLibException e) { HttpContext.Current.Trace.Warn("CIC", "Unable to connect", e); } catch(System.ObjectDisposedException e) { HttpContext.Current.Trace.Warn("CIC", "Unable to connect, session was disposed", e); } catch (Exception e) { HttpContext.Current.Trace.Warn("CIC", "Unknown error while connecting", e); } return SignInStatus.Failure; }
public ServiceHandle Build(HostSettings settings) { try { var builder = new ControlServiceBuilder<SuperviseService>(CreateSuperviseService, _serviceEvents); ServiceHandle serviceHandle = builder.Build(settings); return serviceHandle; } catch (Exception ex) { throw new ServiceBuilderException("An exception occurred creating supervise service", ex); } }
public ConsoleRunHost(HostSettings settings, HostEnvironment environment, ServiceHandle serviceHandle) { if (settings == null) throw new ArgumentNullException("settings"); if (environment == null) throw new ArgumentNullException("environment"); _settings = settings; _environment = environment; _serviceHandle = serviceHandle; if (settings.CanSessionChanged) { SystemEvents.SessionSwitch += OnSessionChanged; } }
public WindowsServiceHost(HostEnvironment environment, HostSettings settings, ServiceHandle serviceHandle, HostConfigurator configurator) { if (settings == null) throw new ArgumentNullException("settings"); if (serviceHandle == null) throw new ArgumentNullException("serviceHandle"); _settings = settings; _serviceHandle = serviceHandle; _environment = environment; _configurator = configurator; CanPauseAndContinue = settings.CanPauseAndContinue; CanShutdown = settings.CanShutdown; CanHandleSessionChangeEvent = settings.CanSessionChanged; ServiceName = _settings.ServiceName; }
public ServiceHandle Build(HostSettings settings) { try { ServiceAvailability serviceAvailability = new ServiceAvailabilityImpl(); var builder = new ControlServiceBuilder<SuperviseService>( x => new SuperviseService(x, serviceAvailability, _serviceBuilderFactory), _serviceEvents); ServiceHandle serviceHandle = builder.Build(settings); return serviceHandle; } catch (Exception ex) { throw new ServiceBuilderException("An exception occurred creating supervise service", ex); } }
public LinuxServiceHost(HostSettings settings, ServiceHandle serviceHandle) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (serviceHandle == null) { throw new ArgumentNullException(nameof(serviceHandle)); } _settings = settings; _serviceHandle = serviceHandle; _logWriter = HostLogger.Get<LinuxServiceHost>(); _stopSignal = new ManualResetEvent(false); _signalListener = new LinuxSignalListener(); _signalListener.Subscribe(Signum.SIGINT, SetStopSignal); _signalListener.Subscribe(Signum.SIGTERM, SetStopSignal); }
public void UninstallService(HostSettings settings, IDictionary<string, object> arguments = null, Action<InstallEventArgs> beforeUninstall = null, Action<InstallEventArgs> afterUninstall = null) { var commandLine = BuildCommandLine(settings, arguments); using (var installer = CreateUninstaller(settings, commandLine)) { if (beforeUninstall != null) { installer.BeforeUninstall += (sender, args) => beforeUninstall(args); } if (afterUninstall != null) { installer.AfterUninstall += (sender, args) => afterUninstall(args); } Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); installer.Uninstall(null); } }
public void UninstallService(HostSettings settings, Action beforeUninstall, Action afterUninstall) { var installer = new WindowsHostServiceInstallerImpl(); Action<InstallEventArgs> tryBeforeUninstall = x => { if (beforeUninstall != null) { beforeUninstall(); } }; Action<InstallEventArgs> tryAfterUninstall = x => { if (afterUninstall != null) { afterUninstall(); } }; installer.UninstallService(settings, _arguments, tryBeforeUninstall, tryAfterUninstall); }
static ScheduleMessageService CreateService(HostSettings arg) { var configurationProvider = new FileConfigurationProvider(); return new ScheduleMessageService(configurationProvider); }
public Host CreateServiceHost(HostSettings settings, ServiceHandle serviceHandle) { return new WindowsServiceHost(this, settings, serviceHandle); }