Exemplo n.º 1
0
        public static Result <DistributedCacheServiceRunningTracker> Create(
            OperationContext context,
            IClock clock,
            IAbsFileSystem fileSystem,
            DistributedCacheServiceConfiguration configuration,
            TimeSpan startUpTime)
        {
            return(context.PerformOperation(Tracer,
                                            () =>
            {
                var logIntervalSeconds = configuration.DistributedContentSettings.ServiceRunningLogInSeconds;
                if (logIntervalSeconds == null)
                {
                    context.TraceInfo(ServiceStartedTrace(startUpTime));
                    return new Result <DistributedCacheServiceRunningTracker>($"{nameof(DistributedCacheServiceRunningTracker)} is disabled");
                }

                var logFilePath = configuration.LocalCasSettings.GetCacheRootPathWithScenario(LocalCasServiceSettings.DefaultCacheName) / FileName;

                var serviceTracker = new DistributedCacheServiceRunningTracker(context, clock, fileSystem, logIntervalSeconds.Value, logFilePath);

                serviceTracker.Start(context, startUpTime).ThrowIfFailure();

                return new Result <DistributedCacheServiceRunningTracker>(serviceTracker);
            }));
        }
Exemplo n.º 2
0
        /// <summary>
        /// Creates and runs a distributed cache service
        /// </summary>
        /// <exception cref="CacheException">thrown when cache startup fails</exception>
        public static async Task RunAsync(DistributedCacheServiceArguments arguments)
        {
            // Switching to another thread.
            await Task.Yield();

            var host        = arguments.Host;
            var startUpTime = Stopwatch.StartNew();

            // NOTE(jubayard): this is the entry point for running CASaaS. At this point, the Logger inside the
            // arguments holds the client's implementation of our logging interface ILogger. Here, we may override the
            // client's decision with our own.
            // The disposableToken helps ensure that we shutdown properly and all logs are sent to their final
            // destination.
            var loggerReplacement = CreateReplacementLogger(arguments);

            arguments.Logger          = loggerReplacement.Logger;
            using var disposableToken = loggerReplacement.DisposableToken;

            if (arguments.BuildCopyInfrastructure != null)
            {
                var(copier, pathTransformer, copyRequester) = arguments.BuildCopyInfrastructure(arguments.Logger);
                arguments.Copier          = copier;
                arguments.PathTransformer = pathTransformer;
                arguments.CopyRequester   = copyRequester;
            }

            var logger  = arguments.Logger;
            var factory = new CacheServerFactory(arguments);

            await host.OnStartingServiceAsync();

            // Technically, this method doesn't own the file copier, but no one actually owns it.
            // So to clean up the resources (and print some stats) we dispose it here.
            using (arguments.Copier as IDisposable)
                using (var server = factory.Create())
                {
                    var context = new Context(logger);
                    var ctx     = new OperationContext(context);

                    try
                    {
                        var startupResult = await server.StartupAsync(context);

                        if (!startupResult)
                        {
                            throw new CacheException(startupResult.ToString());
                        }

                        host.OnStartedService();

                        using var serviceRunningTracker = DistributedCacheServiceRunningTracker.Create(
                                  ctx,
                                  SystemClock.Instance,
                                  new PassThroughFileSystem(),
                                  arguments.Configuration,
                                  startUpTime.Elapsed).GetValueOrDefault();

                        await arguments.Cancellation.WaitForCancellationAsync();

                        context.Always("Exit event set");
                    }
                    finally
                    {
                        var        timeoutInMinutes = arguments?.Configuration?.DistributedContentSettings?.MaxShutdownDurationInMinutes ?? 30;
                        BoolResult result           = await ShutdownWithTimeoutAsync(context, server, TimeSpan.FromMinutes(timeoutInMinutes));

                        if (!result)
                        {
                            context.Warning($"Failed to shutdown local content server: {result}");
                        }

                        host.OnTeardownCompleted();
                    }
                }
        }