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;
        }

        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();
        }

        static string GetBaseQueueName(IConfigurationProvider configurationProvider, HostSettings hostSettings)
        {
            string baseQueueName;
            if (configurationProvider.TryGetSetting(QueueNameKey, out baseQueueName))
                return baseQueueName;

            return hostSettings.ServiceName.Replace(" ", "_");
        }

        public SpHostServiceInstaller(HostSettings settings, HostConfigurator configurator)
        {
            _hostConfigurator = configurator;

            _installer = CreateInstaller(settings);

            _transactedInstaller = CreateTransactedInstaller(_installer);
        }

        public ServiceHandleProxy(HostSettings settings, HostControl hostControl, ServiceBuilderFactory serviceBuilderFactory)
        {
            _settings = settings;
            _hostControl = new HostControlProxy(hostControl);
            _serviceBuilderFactory = serviceBuilderFactory;

            _service = CreateServiceInAppDomain();
        }

        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 UninstallHost(HostEnvironment environment, HostSettings settings, IEnumerable<Action> preActions,
     IEnumerable<Action> postActions,
     bool sudo)
 {
     _environment = environment;
     _settings = settings;
     _preActions = preActions;
     _postActions = postActions;
     _sudo = sudo;
 }

        SuperviseService CreateSuperviseService(HostSettings settings)
        {

            var service = new SuperviseService(settings, _serviceBuilderFactory);
            
            ServiceAvailability serviceAvailability = new DownFileServiceAvailability(service);
            service.AddServiceAvailability(serviceAvailability);

            return service;
        }

        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 void Create(ServiceBuilderFactory serviceBuilderFactory, HostSettings settings,
            HostLoggerConfigurator loggerConfigurator)
        {
            AppDomain.CurrentDomain.UnhandledException += CatchUnhandledException;

            HostLogger.UseLogger(loggerConfigurator);

            ServiceBuilder serviceBuilder = serviceBuilderFactory(settings);

            _serviceHandle = serviceBuilder.Build(settings);
        }

        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 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();
			}
		}

		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);
		}

		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);
		}

        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);
            }
        }