/// <summary>
        /// Updates the replicator settings. Security credentials is the only setting that can be changed using this API
        /// </summary>
        /// <param name="updatedSettings"> New settings to be updated</param>
        protected void UpdateReplicatorSettings(ReliableStateManagerReplicatorSettings updatedSettings)
        {
            if (this.replicaState != ReplicaState.Opened)
            {
                throw new FabricException(FabricErrorCode.NotReady);
            }

            this.transactionalReplicator.LoggingReplicator.UpdateReplicatorSettings(updatedSettings);
        }
Example #2
0
        private static ReliableStateManagerReplicatorSettings GetReplicatorSettings(string endpoint)
        {
            var replicatorSettings = new ReliableStateManagerReplicatorSettings()
            {
                ReplicatorAddress   = endpoint,
                SecurityCredentials = SecurityCredentials.LoadClusterSettings()
            };

            return(replicatorSettings);
        }
        private void UpdateReplicatorSettings(string endpoint)
        {
            ReliableStateManagerReplicatorSettings replicatorSettings = GetReplicatorSettings(endpoint, true);
            IStateProviderReplica stateProviderReplica = ((ReliableStateManager)this.StateManager).Replica;

            Microsoft.ServiceFabric.Data.ReliableStateManagerImpl impl = (Microsoft.ServiceFabric.Data.ReliableStateManagerImpl)stateProviderReplica;
            impl.Replicator.LoggingReplicator.UpdateReplicatorSettings(replicatorSettings);

            UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Updated replicator settings");
        }
        private void UpdateReplicatorSettings(string endpoint)
        {
            ReliableStateManagerReplicatorSettings replicatorSettings = GetReplicatorSettings(endpoint);

            var stateProviderReplica = ((ReliableStateManager)this.StateManager).Replica;
            var impl = (ReliableStateManagerImpl)stateProviderReplica;

            impl.Replicator.LoggingReplicator.UpdateReplicatorSettings(replicatorSettings);

            BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Updated replicator settings");
        }
        private static ReliableStateManagerReplicatorSettings GetReplicatorSettings(string endpoint, bool enableEndpointV2)
        {
            SecurityCredentials securityCredentials = null;

            if (enableEndpointV2)
            {
                securityCredentials = SecurityCredentials.LoadClusterSettings();
            }

            ReliableStateManagerReplicatorSettings replicatorSettings = new ReliableStateManagerReplicatorSettings()
            {
                ReplicatorAddress   = endpoint,
                SecurityCredentials = securityCredentials
            };

            return(replicatorSettings);
        }
        internal static void SetupLoggerPath(
            ref ReliableStateManagerReplicatorSettings replicatorSettings,
            ref StatefulServiceInitializationParameters initializationParameters)
        {
            string pathToSharedContainer;

            // Use this when running with the kernel mode logger as all replicas for all nodes should use the same log
            if (string.IsNullOrEmpty(replicatorSettings.SharedLogId) ||
                string.IsNullOrEmpty(replicatorSettings.SharedLogPath))
            {
                string fabricDataRoot;

                try
                {
                    fabricDataRoot = System.Fabric.Common.FabricEnvironment.GetDataRoot();
                }
                catch (Exception)
                {
                    //
                    // If the Fabric Data Root does not exist then we may be running in a container. And in
                    // this case we count on the driver to do the mapping into the host path. So pick a random
                    // path here knowing it will be mapped.
                    //
                    fabricDataRoot = "q:\\";
                }

                // Use default log id and location {3CA2CCDA-DD0F-49c8-A741-62AAC0D4EB62}
                var staticLogContainerGuid = Constants.DefaultSharedLogContainerGuid;

                pathToSharedContainer = System.IO.Path.Combine(
                    fabricDataRoot,
                    Constants.DefaultSharedLogSubdirectory);
                pathToSharedContainer = System.IO.Path.Combine(pathToSharedContainer, Constants.DefaultSharedLogName);

                replicatorSettings.SharedLogId   = staticLogContainerGuid;
                replicatorSettings.SharedLogPath = pathToSharedContainer;
            }
        }
        /// <summary>
        /// OpenAsync is called when the replica is going to be actually used
        /// </summary>
        /// <param name="openMode">Open mode.</param>
        /// <param name="partitionObject">Service partition</param>
        /// <param name="cancellationToken">Cancellation token.</param>
        /// <returns>Task that represents the asynchronous operation.</returns>
        async Task <IReplicator> IStatefulServiceReplica.OpenAsync(
            ReplicaOpenMode openMode,
            IStatefulServicePartition partitionObject,
            CancellationToken cancellationToken)
        {
            FabricEvents.Events.Lifecycle(
                this.tracer.Type,
                "OpenAsync" + " openMode: " + openMode + " replica: " + this.initializationParameters.ReplicaId);

            TaskScheduler.UnobservedTaskException += this.ProcessUnobservedTaskException;

            // Store the partitionObject
            this.partition = partitionObject;

            var statefulServiceContext = new StatefulServiceContext(
                FabricRuntime.GetNodeContext(),
                this.initializationParameters.CodePackageActivationContext,
                this.initializationParameters.ServiceTypeName,
                this.initializationParameters.ServiceName,
                this.initializationParameters.InitializationData,
                this.initializationParameters.PartitionId,
                this.initializationParameters.ReplicaId);

            this.transactionalReplicator.Initialize(statefulServiceContext, partitionObject);

            FabricEvents.Events.Lifecycle(this.tracer.Type, "OpenAsync: StateManager initialized");

            // create the replicator
            // The Windows Fabric Replicator is used to actually replicate the data
            // The ReplicatorSettings are used for configuring the replicator - here we ask for them from the derived class
            // When using service groups Replicator Settings are described in the Settings.xml inside the configuration package.
            // So when the service is part of a service group it should use null as its Replicator Setting.
            FabricReplicator replicator;
            ReliableStateManagerReplicatorSettings replicatorSettings = null;
            var onOpenInvoked = false;

            try
            {
                if (this.Partition is IServiceGroupPartition)
                {
                    replicatorSettings = new ReliableStateManagerReplicatorSettings();
                    ReliableStateManagerReplicatorSettingsUtil.LoadDefaultsIfNotSet(ref replicatorSettings);
                    replicator = this.partition.CreateReplicator(
                        this.transactionalReplicator,
                        ReliableStateManagerReplicatorSettingsUtil.ToReplicatorSettings(replicatorSettings));
                }
                else
                {
                    replicatorSettings = await this.OnOpenAsync(cancellationToken).ConfigureAwait(false);

                    onOpenInvoked = true;

                    if (replicatorSettings == null)
                    {
                        replicatorSettings = new ReliableStateManagerReplicatorSettings();
                    }

                    ReliableStateManagerReplicatorSettingsUtil.LoadDefaultsIfNotSet(ref replicatorSettings);
                    replicator = this.partition.CreateReplicator(
                        this.transactionalReplicator,
                        ReliableStateManagerReplicatorSettingsUtil.ToReplicatorSettings(replicatorSettings));
                }

                ServiceReplicaUtils.SetupLoggerPath(ref replicatorSettings, ref this.initializationParameters);
                var transactionalReplicatorSettings = new TransactionalReplicatorSettings
                {
                    PublicSettings = replicatorSettings
                };

                ReliableStateManagerReplicatorSettingsUtil.LoadInternalSettingsDefault(ref transactionalReplicatorSettings);

                this.stateReplicator = replicator.StateReplicator;
                this.transactionalReplicator.LoggingReplicator.FabricReplicator = this.stateReplicator;
                this.transactionalReplicator.LoggingReplicator.Tracer           = this.tracer;

                // Starting local recovery
                await this.transactionalReplicator.OpenAsync(openMode, transactionalReplicatorSettings).ConfigureAwait(false);

                // Change state
                this.replicaState = ReplicaState.Opened;

                FabricEvents.Events.Lifecycle(
                    this.tracer.Type,
                    "OpenAsync: Finished opening replica " + this.initializationParameters.ReplicaId + " ReplicatorAddress: " + replicatorSettings.ReplicatorAddress
                    + " ReplicatorListenAddress: " + replicatorSettings.ReplicatorListenAddress
                    + " ReplicatorPublishAddress: " + replicatorSettings.ReplicatorPublishAddress);

                return(replicator);
            }
            catch (Exception e)
            {
                int innerHResult       = 0;
                var flattenedException = Utility.FlattenException(e, out innerHResult);

                FabricEvents.Events.Exception_TStatefulServiceReplica(
                    this.tracer.Type,
                    "OpenAsync",
                    flattenedException.GetType().ToString(),
                    flattenedException.Message,
                    flattenedException.HResult != 0 ? flattenedException.HResult : innerHResult,
                    flattenedException.StackTrace);

                if (onOpenInvoked)
                {
                    this.OnAbort();
                }

                TaskScheduler.UnobservedTaskException -= this.ProcessUnobservedTaskException;
                throw;
            }
        }