Example #1
0
        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();
        }
Example #2
0
        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);
        }
Example #3
0
        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));
        }
Example #4
0
        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
        }
Example #5
0
        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));
            }
        }
Example #7
0
        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();
        }
Example #11
0
        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");
                }
            }
        }
Example #12
0
 /// <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();
 }
Example #13
0
 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;
        }
Example #17
0
        public ServiceHandleProxy(HostSettings settings, HostControl hostControl, ServiceBuilderFactory serviceBuilderFactory)
        {
            _settings = settings;
            _hostControl = new HostControlProxy(hostControl);
            _serviceBuilderFactory = serviceBuilderFactory;

            _service = CreateServiceInAppDomain();
        }
Example #18
0
        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");
        }
Example #20
0
        /// <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);
        }
Example #21
0
            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);
        }
Example #23
0
        public ServiceHandleProxy(HostSettings settings, HostControl hostControl, ServiceBuilderFactory serviceBuilderFactory)
        {
            _settings              = settings;
            _hostControl           = new HostControlProxy(hostControl);
            _serviceBuilderFactory = serviceBuilderFactory;

            _service = CreateServiceInAppDomain();
        }
Example #24
0
        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
     };
 }
Example #26
0
 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;
 }
Example #27
0
        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);
        }
Example #28
0
        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);
 }
Example #31
0
 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));
 }
Example #32
0
 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);
 }
Example #33
0
            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;
 }
Example #35
0
    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);
        }
Example #37
0
        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;
        }
Example #43
0
        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);
		}
Example #47
0
        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;
        }
Example #50
0
        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);
            }
        }
Example #52
0
        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;
            }
        }
Example #53
0
        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);
            }
        }
Example #55
0
        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);
		}
Example #58
0
 public InstallServiceSettingsImpl(HostSettings settings, Credentials credentials, HostStartMode startMode,
     string[] dependencies)
 {
     _credentials = credentials;
     _settings = settings;
     _startMode = startMode;
     _dependencies = dependencies;
 }
Example #59
0
        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);
 }