public OperationFetcher(IStateReplicator stateReplicator, OperationProcessorInfo copyOperationProcessor, OperationProcessorInfo replicationOperationProcessor, bool drainQueuesInParallel) { Requires.Argument("partition", stateReplicator).NotNull(); Requires.Argument("copyOperationProcessor", copyOperationProcessor).NotNull(); Requires.Argument("replicationOperationProcessor", replicationOperationProcessor).NotNull(); if (copyOperationProcessor.Callback == null) { throw new ArgumentException("copyOperationProcessor.Callback cannot be null"); } if (replicationOperationProcessor.Callback == null) { throw new ArgumentException("replicationOperationProcessor.Callback cannot be null"); } this.copyOperationQueue = new OperationQueue(() => stateReplicator.GetCopyStream(), copyOperationProcessor) { Name = "CopyQueue" }; this.replicationOperationQueue = new OperationQueue(() => stateReplicator.GetReplicationStream(), replicationOperationProcessor) { Name = "ReplicationQueue" }; this.drainQueuesInParallel = drainQueuesInParallel; this.role = ReplicaRole.None; }
public void Open( RecoveredOrCopiedCheckpointLsn recoveredOrCopiedCheckpointLsn, RoleContextDrainState roleContextDrainState, OperationProcessor recordsProcessor, IStateReplicator fabricReplicator, IBackupManager backupManager, CheckpointManager checkpointManager, TransactionManager transactionManager, ReplicatedLogManager replicatedLogManager, IStateManager stateManager, TransactionalReplicatorSettings replicatorSettings, RecoveryManager recoveryManager, ITracer tracer) { this.recoveredOrCopiedCheckpointLsn = recoveredOrCopiedCheckpointLsn; this.recoveryManager = recoveryManager; this.replicatorSettings = replicatorSettings; this.stateManager = stateManager; this.tracer = tracer; this.roleContextDrainState = roleContextDrainState; this.recordsProcessor = recordsProcessor; this.fabricReplicator = fabricReplicator; this.backupManager = backupManager; this.transactionManager = transactionManager; this.checkpointManager = checkpointManager; this.replicatedLogManager = replicatedLogManager; }
public OperationReplicator(IStateReplicator replicator, StateProvider stateProvider, Logger logger, Serializer serializer) { this.replicator = replicator; this.stateProvider = stateProvider; this.logger = logger; this.serializer = serializer; var options = new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 1, BoundedCapacity = 128 }; this.replicationWorker = new ActionBlock <ReplicationRequest>(this.InitiateOrderedReplication, options); this.completionWorker = new ActionBlock <ReplicationRequest>(this.CompleteOrderedReplication, options); }
public void Open( ITracer tracer, Func <bool, BeginCheckpointLogRecord> appendCheckpointCallback, IndexingLogRecord currentHead, RoleContextDrainState roleContextDrainState, IStateReplicator fabricReplicator) { this.appendCheckpointCallback = appendCheckpointCallback; this.RoleContextDrainState = roleContextDrainState; this.fabricReplicator = fabricReplicator; this.tracer = tracer; this.CurrentLogHeadRecord = currentHead; this.replicationSerializationBinaryWritersPoolClearTimer.Change(Constants.ReplicationWriteMemoryStreamsBufferPoolCleanupMilliseconds, Timeout.Infinite); }
/// <inheritdoc/> protected override async Task RunAsync(CancellationToken cancellationToken) { // Find a better log directory this.operationLoggerPrimary = new OperationLogger(this.Context.CodePackageActivationContext.LogDirectory); FabricReplicator replicator = null; while ((replicator = this.serviceContext.Replicator) == null) { await Task.Delay(125).ConfigureAwait(false); } this.stateReplicator = replicator.StateReplicator; this.cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); var unusedTask = Task.Run(this.ProcessIncomingRequests); ServiceEventSource.Current.ServiceMessage(this.Context, "Replicator is ready"); try { while (!cancellationToken.IsCancellationRequested) { ServiceEventSource.Current.ServiceMessage( this.Context, "RunAsync alive: {0} - pending operations {1} LSN {2}", DateTime.UtcNow, this.pendingOperations.Count, this.lastSequenceNumber); await Task.Delay(1000 * 30, cancellationToken).ConfigureAwait(false); } } catch (TaskCanceledException) { } }
/// <summary> /// Opens the replica. /// </summary> /// <param name="openMode">Replica open mode (new or existent).</param> /// <param name="partition">Stateful partition object.</param> /// <param name="cancellationToken">Propagates notification that operations should be canceled.</param> /// <returns></returns> public virtual async Task <IReplicator> OpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition, CancellationToken cancellationToken) { // // Check arguments. // if (null == partition) { AppTrace.TraceSource.WriteError("StatefulServiceReplica.Open", "{0}", this.ToString()); throw new ArgumentNullException("partition"); } // // Perform local open functionality. // AppTrace.TraceSource.WriteNoise("StatefulServiceReplica.Open", "{0}", this.ToString()); // // Set partition related members. // this.servicePartition = partition; this.serviceGroupPartition = partition as IServiceGroupPartition; this.servicePartitionEx = partition as IStatefulServicePartitionEx; // // Create an implementation of the state provider broker. // this.stateProviderBroker = this.CreateStateProviderBroker(); if (null == this.stateProviderBroker) { AppTrace.TraceSource.WriteError("StatefulServiceReplica.Open", "{0} invalid state provider broker", this.ToString()); throw new InvalidOperationException(); } // // Extract state providers. // this.stateProvider = this.stateProviderBroker as IStateProvider; this.atomicGroupStateProvider = this.stateProviderBroker as IAtomicGroupStateProvider; this.atomicGroupStateProviderEx = this.stateProviderBroker as IAtomicGroupStateProviderEx; if (null == this.stateProvider && null == this.atomicGroupStateProvider && null == this.atomicGroupStateProviderEx) { AppTrace.TraceSource.WriteError("StatefulServiceReplica.Open", "{0} invalid state providers", this.ToString()); throw new InvalidOperationException(); } // // Create replicator settings (replication and log). // For service groups, these settings are specified in the service manifest. // ReplicatorSettings replicatorSettings = null; if (null != this.serviceGroupPartition) { replicatorSettings = this.ReplicatorSettings; } ReplicatorLogSettings replicatorLogSettings = null; if (null != this.atomicGroupStateProviderEx && null != this.serviceGroupPartition) { replicatorLogSettings = this.ReplicatorLogSettings; } // // Create replicator. // FabricReplicator replicator = null; FabricReplicatorEx replicatorEx = null; if (null == this.atomicGroupStateProviderEx) { AppTrace.TraceSource.WriteInfo("StatefulServiceReplica.Open", "{0} creating replicator", this.ToString()); // // v1 replicator. // replicator = this.servicePartition.CreateReplicator(this.stateProvider, replicatorSettings); this.stateReplicator = replicator.StateReplicator; this.atomicGroupStateReplicator = this.stateReplicator as IAtomicGroupStateReplicator; } else { AppTrace.TraceSource.WriteInfo("StatefulServiceReplica.Open", "{0} creating atomic group replicator", this.ToString()); // // v2 replicator. // replicatorEx = this.servicePartitionEx.CreateReplicatorEx(this.atomicGroupStateProviderEx, replicatorSettings, replicatorLogSettings); this.atomicGroupStateReplicatorEx = replicatorEx.StateReplicator; } // // Perform local open functionality. Initialize and open state provider broker. // this.stateProviderBroker.Initialize(this.initializationParameters); await this.stateProviderBroker.OpenAsync( openMode, this.servicePartitionEx, this.atomicGroupStateReplicatorEx, cancellationToken); // // Perform custom open functionality. // await this.OnOpenAsync(openMode, cancellationToken); // // Change current replica state. // this.replicaState = ReplicaState.Opened; AppTrace.TraceSource.WriteNoise("StatefulServiceReplica.State", "{0} is {1}", this.ToString(), this.replicaState); // // Done. // return((null != replicator) ? replicator as IReplicator : replicatorEx as IReplicator); }
public OperationReceiver(IOperationApplier applier, IStateReplicator replicator, Logger logger) { this.applier = applier; this.replicator = replicator; this.logger = logger; }
/// <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; } }