/// <inheritdoc />
        public override string GetCommandLineArgs(LocalServerConfiguration localContentServerConfiguration = null, string scenario = null, bool logAutoFlush = false, bool passMaxConnections = false)
        {
            var args = new StringBuilder(base.GetCommandLineArgs(localContentServerConfiguration, scenario, logAutoFlush, false));

            if (!string.IsNullOrEmpty(StampId))
            {
                args.AppendFormat(" /stampId:{0}", StampId);
            }

            if (!string.IsNullOrEmpty(RingId))
            {
                args.AppendFormat(" /ringId:{0}", RingId);
            }

            if (!string.IsNullOrEmpty(CacheName))
            {
                args.AppendFormat(" /cacheName:{0}", CacheName);
            }

            if (CachePath != null)
            {
                args.AppendFormat(" /cachePath:{0}", CachePath.Path);
            }

            return(args.ToString());
        }
示例#2
0
        /// <inheritdoc />
        public override string GetCommandLineArgs(LocalServerConfiguration localContentServerConfiguration = null, string scenario = null, bool logAutoFlush = false, bool passMaxConnections = false)
        {
            var args = new StringBuilder(base.GetCommandLineArgs(localContentServerConfiguration, scenario, logAutoFlush, false));

            args.AppendFormat(" /hashType:{0}", HashType.ToString());
            args.AppendFormat(" /path:{0}", SourcePath.Path);

            return(args.ToString());
        }
示例#3
0
 /// <nodoc />
 public LocalContentServer(
     IAbsFileSystem fileSystem,
     ILogger logger,
     string scenario,
     Func <AbsolutePath, IContentStore> contentStoreFactory,
     LocalServerConfiguration localContentServerConfiguration)
     : base(logger, fileSystem, scenario, contentStoreFactory, localContentServerConfiguration)
 {
     _grpcContentServer = new GrpcContentServer(logger, Capabilities.ContentOnly, this, StoresByName, localContentServerConfiguration);
 }
示例#4
0
 /// <nodoc />
 public LocalContentServer(
     IAbsFileSystem fileSystem,
     ILogger logger,
     string scenario,
     Func <AbsolutePath, IContentStore> contentStoreFactory,
     LocalServerConfiguration localContentServerConfiguration,
     IGrpcServiceEndpoint[]?additionalEndpoints = null,
     IColdStorage?coldStorage = null)
     : base(logger, fileSystem, scenario, contentStoreFactory, localContentServerConfiguration, additionalEndpoints)
 {
     GrpcContentServer = new GrpcContentServer(logger, Capabilities.ContentOnly, this, StoresByName, localContentServerConfiguration, coldStorage);
 }
示例#5
0
        /// <nodoc />
        protected LocalContentServerBase(
            ILogger logger,
            IAbsFileSystem fileSystem,
            string scenario,
            Func <AbsolutePath, TStore> contentStoreFactory,
            LocalServerConfiguration localContentServerConfiguration,
            IGrpcServiceEndpoint[]?additionalEndpoints)
        {
            Contract.Requires(logger != null);
            Contract.Requires(fileSystem != null);
            Contract.Requires(localContentServerConfiguration != null);
            Contract.Requires(localContentServerConfiguration.GrpcPort > 0, "GrpcPort must be provided");

            logger.Debug($"{Name} process id {Process.GetCurrentProcess().Id}");
            logger.Debug($"{Name} constructing {nameof(ServiceConfiguration)}: {localContentServerConfiguration}");

            GrpcEnvironment.Initialize(logger, localContentServerConfiguration.GrpcEnvironmentOptions, overwriteSafeOptions: true);

            FileSystem = fileSystem;
            Logger     = logger;
            Config     = localContentServerConfiguration;

            _additionalEndpoints     = additionalEndpoints ?? Array.Empty <IGrpcServiceEndpoint>();
            _serviceReadinessChecker = new ServiceReadinessChecker(logger, scenario);
            _sessionHandles          = new ConcurrentDictionary <int, ISessionHandle <TSession, TSessionData> >();

            var storesByName = new Dictionary <string, TStore>();

            foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
            {
                fileSystem.CreateDirectory(kvp.Value);
                var store = contentStoreFactory(kvp.Value);
                storesByName.Add(kvp.Key, store);
            }
            StoresByName = new ReadOnlyDictionary <string, TStore>(storesByName);

            foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
            {
                _tempFolderForStreamsByCacheName[kvp.Key] = kvp.Value / "TempFolder";
            }

            if (!string.IsNullOrEmpty(localContentServerConfiguration.GrpcPortFileName))
            {
                var portSharingFactory = new MemoryMappedFileGrpcPortSharingFactory(logger, localContentServerConfiguration.GrpcPortFileName);
                var portExposer        = portSharingFactory.GetPortExposer();
                _portDisposer = portExposer.Expose(localContentServerConfiguration.GrpcPort);
            }
        }
示例#6
0
        /// <nodoc />
        public LocalContentServer(
            IAbsFileSystem fileSystem,
            ILogger logger,
            string scenario,
            Func <AbsolutePath, IContentStore> contentStoreFactory,
            LocalServerConfiguration localContentServerConfiguration)
            : base(logger, fileSystem, scenario, contentStoreFactory, localContentServerConfiguration)
        {
            var nameByDrive = new Dictionary <string, string>();

            foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
            {
                nameByDrive.Add(kvp.Value.DriveLetter.ToString(), kvp.Key);
            }

            _grpcContentServer = new GrpcContentServer(logger, Capabilities.ContentOnly, this, nameByDrive, StoresByName);
        }
示例#7
0
        private void InitializeAndStartGrpcServer(Context context, LocalServerConfiguration config)
        {
            GrpcCoreServerOptions?grpcCoreServerOptions = config.GrpcCoreServerOptions;

            GrpcEnvironment.WaitUntilInitialized();

            bool?encryptionEnabled = grpcCoreServerOptions?.EncryptionEnabled;

            Tracer.Info(context, $"Grpc Encryption Enabled = {encryptionEnabled == true}, Encrypted GRPC Port: {config.EncryptedGrpcPort}, Unencrypted GRPC Port: {config.GrpcPort}");

            _grpcServer = new Server(GrpcEnvironment.GetServerOptions(grpcCoreServerOptions))
            {
                Ports = { new ServerPort(IPAddress.Any.ToString(), config.GrpcPort, ServerCredentials.Insecure) },
                RequestCallTokensPerCompletionQueue = config.RequestCallTokensPerCompletionQueue,
            };

            if (encryptionEnabled == true)
            {
                try
                {
                    ServerCredentials?serverSSLCreds = TryGetEncryptedCredentials(context, grpcCoreServerOptions);
                    if (serverSSLCreds != null)
                    {
                        _grpcServer.Ports.Add(new ServerPort(IPAddress.Any.ToString(), config.EncryptedGrpcPort, serverSSLCreds));
                        Tracer.Debug(context, $"Server creating Encrypted Grpc channel on port {config.EncryptedGrpcPort}");
                    }
                    else
                    {
                        Tracer.Error(context, message: $"Failed to get SSL Credentials. Not creating encrypted Grpc channel.");
                    }
                }
                catch (Exception ex)
                {
                    Tracer.Error(context, ex, $"Creating SSL Secured Grpc Channel Failed.");
                }
            }

            foreach (var endpoint in GrpcEndpoints)
            {
                endpoint.BindServices(_grpcServer.Services);
            }

            _grpcServer.Start();
        }
示例#8
0
        /// <summary>
        ///     Initializes a new instance of the <see cref="ServiceProcess"/> class.
        /// </summary>
        public ServiceProcess
        (
            ServiceConfiguration configuration,
            LocalServerConfiguration localContentServerConfiguration,
            string scenario,
            int waitForServerReadyTimeoutMs,
            int waitForExitTimeoutMs,
            bool logAutoFlush = true
        )
        {
            Contract.Requires(configuration != null);

            _configuration = configuration;
            _localContentServerConfiguration = localContentServerConfiguration;
            _scenario = scenario;
            _waitForServerReadyTimeoutMs = waitForServerReadyTimeoutMs;
            _waitForExitTimeoutMs        = waitForExitTimeoutMs;
            _logAutoFlush = logAutoFlush;
        }
        /// <nodoc />
        protected LocalContentServerBase(
            ILogger logger,
            IAbsFileSystem fileSystem,
            string scenario,
            Func <AbsolutePath, TStore> contentStoreFactory,
            LocalServerConfiguration localContentServerConfiguration)
        {
            Contract.Requires(logger != null);
            Contract.Requires(fileSystem != null);
            Contract.Requires(localContentServerConfiguration != null);
            Contract.Requires(localContentServerConfiguration.GrpcPort > 0, "GrpcPort must be provided");

            logger.Debug($"{Name} process id {Process.GetCurrentProcess().Id}");
            logger.Debug($"{Name} constructing {nameof(ServiceConfiguration)}: {localContentServerConfiguration}");

            FileSystem = fileSystem;
            Logger     = logger;
            Config     = localContentServerConfiguration;

            _serviceReadinessChecker = new ServiceReadinessChecker(Tracer, logger, scenario);
            _sessionHandles          = new ConcurrentDictionary <int, SessionHandle <TSession> >();

            foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
            {
                fileSystem.CreateDirectory(kvp.Value);
                var store = contentStoreFactory(kvp.Value);
                StoresByName.Add(kvp.Key, store);
            }

            foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
            {
                _tempFolderForStreamsByCacheName[kvp.Key] = kvp.Value / "TempFolder";
            }

            if (!string.IsNullOrEmpty(localContentServerConfiguration.GrpcPortFileName))
            {
                var portSharingFactory = new MemoryMappedFileGrpcPortSharingFactory(logger, localContentServerConfiguration.GrpcPortFileName);
                var portExposer        = portSharingFactory.GetPortExposer();
                _portDisposer = portExposer.Expose(localContentServerConfiguration.GrpcPort);
            }
        }
示例#10
0
        /// <summary>
        /// Create the command line arguments to match this configuration.
        /// </summary>
        public virtual string GetCommandLineArgs(LocalServerConfiguration localContentServerConfiguration = null, string scenario = null, bool logAutoFlush = false, bool passMaxConnections = true)
        {
            var args = new StringBuilder(GetVerb());

            if (passMaxConnections)
            {
                args.AppendFormat(" /maxConnections={0}", MaxConnections);
            }

            if (GrpcPort != ServiceConfiguration.GrpcDisabledPort)
            {
                args.AppendFormat(" /grpcPort={0}", GrpcPort);
            }

            if (GrpcPortFileName != null)
            {
                args.AppendFormat(" /grpcPortFileName={0}", GrpcPortFileName);
            }

            if (localContentServerConfiguration?.UnusedSessionTimeout != null)
            {
                args.AppendFormat(" /unusedSessionTimeoutSeconds={0}", localContentServerConfiguration.UnusedSessionTimeout.TotalSeconds);
            }

            if (localContentServerConfiguration?.UnusedSessionHeartbeatTimeout != null)
            {
                args.AppendFormat(" /unusedSessionHeartbeatTimeoutSeconds={0}", localContentServerConfiguration.UnusedSessionHeartbeatTimeout.TotalSeconds);
            }

            var namedCacheRoots = NamedCacheRoots;

            if (namedCacheRoots.Any())
            {
                var sbNames = new StringBuilder();
                var sbRoots = new StringBuilder();

                foreach (var kvp in namedCacheRoots)
                {
                    sbNames.AppendFormat(",{0}", kvp.Key);
                    sbRoots.AppendFormat(",{0}", kvp.Value);
                }

                args.AppendFormat(" /names={0}", sbNames.ToString().TrimStart(','));
                args.AppendFormat(" /paths={0}", sbRoots.ToString().TrimStart(','));
            }

            if (DataRootPath != null)
            {
                args.AppendFormat(" /dataRootPath={0}", DataRootPath.Path);
            }

            if (scenario != null)
            {
                args.AppendFormat(" /scenario={0}", scenario);
            }

            if (logAutoFlush)
            {
                args.Append(" /logautoflush");
            }

            return(args.ToString());
        }
示例#11
0
        /// <nodoc />
        public static async Task HibernateSessionsAsync(
            Context context,
            IDictionary <int, ISessionHandle <IContentSession, LocalContentServerSessionData> > sessionHandles,
            LocalServerConfiguration config,
            Tracer tracer,
            IAbsFileSystem fileSystem)
        {
            var sessionInfoList = new List <HibernatedContentSessionInfo>(sessionHandles.Count);

            foreach (var(sessionId, handle) in sessionHandles)
            {
                IContentSession session = handle.Session;

                if (session is IHibernateContentSession hibernateSession)
                {
                    if (config.ShutdownEvictionBeforeHibernation)
                    {
                        // Calling shutdown of eviction before hibernating sessions to prevent possible race condition of evicting pinned content
                        await hibernateSession.ShutdownEvictionAsync(context).ThrowIfFailure();
                    }

                    var pinnedContentHashes = hibernateSession.EnumeratePinnedContentHashes().Select(x => x.Serialize()).ToList();

                    tracer.Debug(context, $"Hibernating session {handle.ToString(sessionId)}.");
                    sessionInfoList.Add(new HibernatedContentSessionInfo(
                                            sessionId,
                                            handle.SessionData.Name,
                                            handle.SessionData.ImplicitPin,
                                            handle.CacheName,
                                            pinnedContentHashes,
                                            handle.SessionExpirationUtcTicks,
                                            handle.SessionData.Capabilities));
                }
                else
                {
                    tracer.Warning(context, $"Shutdown of non-hibernating dangling session. {sessionId.AsTraceableSessionId()}");
                }

                await session.ShutdownAsync(context).ThrowIfFailure();

                session.Dispose();
            }

            if (sessionInfoList.Any())
            {
                var hibernatedSessions = new HibernatedSessions <HibernatedContentSessionInfo>(sessionInfoList);

                try
                {
                    var sw = Stopwatch.StartNew();
                    hibernatedSessions.Write(fileSystem, config.DataRootPath, HibernatedSessionsFileName);
                    sw.Stop();
                    tracer.Debug(
                        context, $"Wrote hibernated sessions to root=[{config.DataRootPath}] in {sw.Elapsed.TotalMilliseconds}ms");
                }
                catch (Exception exception)
                {
                    tracer.Error(context, exception, $"Failed to write hibernated sessions root=[{config.DataRootPath}]");
                }
            }
        }