public BackgroundServerHost(IBackgroundServer server, TaskScheduler scheduler, IKernel kernel, Action <string> output, CancellationToken?token = null)
        {
            if (server == null)
            {
                throw new ArgumentNullException(nameof(server));
            }
            if (scheduler == null)
            {
                throw new ArgumentNullException(nameof(scheduler));
            }
            if (kernel == null)
            {
                throw new ArgumentNullException(nameof(kernel));
            }
            if (output == null)
            {
                throw new ArgumentNullException(nameof(output));
            }

            _server    = server;
            _scheduler = scheduler;
            _token     = token.GetValueOrDefault(kernel.Resolve <IShutdown>().Token);
            _output    = message => output($"[{this}]: {message}");
            _context   = new RestartableContext(kernel);
            _uptime    = kernel.Resolve <IUptimeTextGenerator>();
        }
예제 #2
0
        public HouseKeeping(IKernel kernel, InternalConfiguration configuration, Action <string> output)
        {
            if (kernel == null)
            {
                throw new ArgumentNullException(nameof(kernel));
            }
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }
            if (output == null)
            {
                throw new ArgumentNullException(nameof(output));
            }

            _logger        = kernel.Resolve <ILogger>();
            _uptime        = kernel.Resolve <IUptimeTextGenerator>();
            _configuration = configuration;
            _output        = message => output($"[{this}]: {message}");
            _cancellation  = new CancellationTokenSource();

            TaskScheduler scheduler = TaskScheduler.Current;

            IBackgroundServer[] servers = kernel
                                          .ResolveAll <IBackgroundWorker>()
                                          .Select(worker => new BackgroundWorkerServer(worker, scheduler))
                                          .Concat(kernel.ResolveAll <IBackgroundServer>())
                                          .ToArray();

            CancellationToken token = kernel.Resolve <IShutdown>().Token;

            _heartbeatLogging = CreateHeartbeatLoggingServerHost(_configuration, scheduler, kernel);

            _servers = servers
                       .Select(server => new BackgroundServerHost(server, scheduler, kernel, output))
                       .Concat(new[] { _heartbeatLogging })
                       .SkipNulls()
                       .ToArray();

            // To keep track of which servers are actually running.
            _isRunning = new HashSet <BackgroundServerHost>();

            // Spin off the housekeeping background server
            _task = Start(kernel, scheduler, token);

            // Keep track of when Housekeeping was started.
            _startedAt = Time.UtcNow;
        }