internal StatefulServiceReplicaAdapter(
StatefulServiceContext context,
IStatefulUserServiceReplica userServiceReplica)
{
this.serviceContext = context;
this.traceId = ServiceTrace.GetTraceIdForReplica(context.PartitionId, context.ReplicaId);
this.serviceHelper = new ServiceHelper(TraceType, this.traceId);
this.servicePartition = null;
this.replicaListeners = null;
this.communicationListeners = null;
this.endpointCollection = new ServiceEndpointCollection();
this.runAsynCancellationTokenSource = null;
this.executeRunAsyncTask = null;
this.userServiceReplica = userServiceReplica;
this.userServiceReplica.Addresses = this.endpointCollection.ToReadOnlyDictionary();
// The state provider replica should ideally be initialized
// here (this.stateProviderReplica.Initialize()) with ServiceContext.
// However the initialize function takes in StatefulServiceInitializationParameter
// and resides in the DATA layer. DATA layer lies below SERVICES layer
// and is agnostic of services and ServiceContext lies in SERVICES layer.
// For now state provider replica is initialized when runtime calls
// IStatefulServiceReplica.Initialize(StatefulServiceInitializationParameters initializationParameters)
this.stateProviderReplica = this.userServiceReplica.CreateStateProviderReplica();
}
public async Task <IReplicator> OpenAsync(
ReplicaOpenMode openMode,
IStatefulServicePartition servicePartition,
CancellationToken cancellationToken)
{
var self = this.serviceParameters;
this.logger = new Logger(self)
{
Prefix = () => $"[{this.unsafeRole}] "
};
this.logger.Log("OpenAsync");
IReplicator result;
StateProvider provider;
lock (this.replicaLock)
{
this.partition = servicePartition;
provider = this.stateProvider = new StateProvider(this.logFilePath, this.logger, this.serializer);
var replicatorSettings = ReplicatorSettings.LoadFrom(
self.CodePackageActivationContext,
ConfigPackageName,
ReplicatorConfigSectionName);
replicatorSettings.BatchAcknowledgementInterval = TimeSpan.FromMilliseconds(1);
result = this.fabricReplicator = servicePartition.CreateReplicator(this.stateProvider, replicatorSettings);
}
await provider.Initialize();
this.logger.Log("Completed OpenAsync");
return(result);
}
public WindowsUpdateServiceCoordinator(IConfigStore configStore, string configSection, KeyValueStoreReplica kvsReplica, IStatefulServicePartition partition, IExceptionHandlingPolicy exceptionPolicy)
{
configStore.ThrowIfNull("configStore");
configSection.ThrowIfNullOrWhiteSpace("configSectionName");
kvsReplica.ThrowIfNull("kvsReplica");
partition.ThrowIfNull("partition");
exceptionPolicy.ThrowIfNull("exceptionPolicy");
this.commandProcessor = new FabricClientWrapper();
this.store = kvsReplica;
this.partition = partition;
this.packageRetriever = new UpdatePackageRetriever();
this.serviceName = new Uri(Constants.SystemServicePrefix + configSection);
this.configStore = configStore;
this.configSectionName = configSection;
this.exceptionPolicy = exceptionPolicy;
// Read all the configuration values
string coordinatorType = configStore.ReadUnencryptedString(configSection, Constants.ConfigurationSection.CoordinatorType);
this.testMode = false;
this.testSrcDir = string.Empty;
if (coordinatorType.Equals(Constants.ConfigurationSection.WUTestCoordinator))
{
this.testSrcDir = configStore.ReadUnencryptedString(configSection, Constants.WUSCoordinator.TestCabFolderParam);
this.testMode = true;
}
this.waitTimeBeforePolling = TimeSpan.FromMinutes(Constants.WUSCoordinator.PollingIntervalInMinutesDefault);
this.windowsUpdateApiTimeout = TimeSpan.FromMinutes(Constants.WUSCoordinator.WuApiTimeoutInMinutesDefault);
}
public Task <IReplicator> OpenAsync(
ReplicaOpenMode openMode,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
return(Task.FromResult <IReplicator>(null));
}
Task <IReplicator> IStateProviderReplica.OpenAsync(
ReplicaOpenMode openMode,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
this.servicePartition = partition;
return(this.stateManager.OpenAsync(openMode, partition, cancellationToken));
}
public RestartPartitionAction(IReliableStateManager stateManager, IStatefulServicePartition partition, RestartPartitionState state, PartitionSelector partitionSelector, RestartPartitionMode restartPartitionMode, TimeSpan requestTimeout, TimeSpan operationTimeout)
: base(stateManager, partition, state, requestTimeout, operationTimeout)
{
ThrowIf.Null(partitionSelector, "partitionSelector");
this.PartitionSelector = partitionSelector;
this.RestartPartitionMode = restartPartitionMode;
}
public Task <IReplicator> OpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition, CancellationToken cancellationToken)
{
return(Task.Factory.StartNew <IReplicator>(() =>
{
ServiceImplementationHelper.HandleOpen(this.initParams.InitializationData, this.replicaId);
return partition.CreateReplicator(this, null);
}));
}
public void Reuse(IStatefulServicePartition partition)
{
this.partition = partition;
this.ReplicaRole = ReplicaRole.Unknown;
this.DrainingStream = DrainingStream.Invalid;
this.ApplyRedoContext = ApplyContext.Invalid;
this.IsClosing = false;
}
public InvokeQuorumLossAction(IReliableStateManager stateManager, IStatefulServicePartition partition, InvokeQuorumLossState state, PartitionSelector partitionSelector, QuorumLossMode quorumLossMode, TimeSpan quorumLossDuration, TimeSpan requestTimeout, TimeSpan operationTimeout)
: base(stateManager, partition, state, requestTimeout, operationTimeout)
{
ThrowIf.Null(partitionSelector, "partitionSelector");
this.PartitionSelector = partitionSelector;
this.QuorumLossMode = quorumLossMode;
this.QuorumLossDuration = quorumLossDuration;
}
internal ChaosScheduler(IReliableStateManager stateManager, IStatefulServicePartition partition)
{
this.StateManager = stateManager;
this.partition = partition;
this.stateSemaphore = new SemaphoreSlim(1, 1);
this.state = new SchedulerState(SchedulerState.NoChaosScheduleStopped);
this.scheduleDescription = new ChaosScheduleDescription();
}
public static Task SetStoppedNodeStateAsync(Guid operationId, IStatefulServicePartition partition, IReliableStateManager stateManager, IReliableDictionary <string, bool> stoppedNodeTable, string nodeName, bool setStopped, CancellationToken cancellationToken)
{
return(FaultAnalysisServiceUtility.RunAndReportFaultOnRepeatedFailure(
operationId,
() => SetStoppedNodeStateInnerAsync(operationId, stateManager, stoppedNodeTable, nodeName, setStopped, cancellationToken),
partition,
"FaultAnalysisServiceUtility.SetStoppedNodeStateAsync",
3,
cancellationToken));
}
public Task <IReplicator> OpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition, CancellationToken cancellationToken)
{
LogMessage(nameof(OpenAsync));
log = new InMemoryLog(LogMessage);
replicator = partition.CreateReplicator(this, new ReplicatorSettings());
return(Task.FromResult((IReplicator)replicator));
}
/// <summary>
/// Initialize a FabricApiCallDescription object
/// </summary>
/// <param name="data"></param>
/// <param name="parameters"></param>
/// <param name="statefulServicePartition"></param>
public FabricApiCallDescription(
FabricMonitoringData data,
FabricMonitoringParameters parameters,
IStatefulServicePartition statefulServicePartition)
{
this.monitoringData = data;
this.monitoringParameters = parameters;
this.hasExpired = false;
this.partition = statefulServicePartition;
}
Task <IReplicator> IStateProviderReplica.OpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
this.partition = partition;
isBackupInProgress = 0;
backupCallbackCts = null;
backupCallbackTask = null;
isClosingOrAborting = false;
return(storeReplica.OpenAsync(openMode, partition, cancellationToken));
}
/// <summary>
/// Sets the partition info of the provided <paramref name="service"/>.
/// </summary>
/// <param name="partition">partition to set</param>
/// <param name="service"></param>
/// <returns></returns>
public static void SetPartition(this StatefulServiceBase service, IStatefulServicePartition partition)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
//protected IStatefulServicePartition Partition { get; private set; }
var propertyInfo = typeof(StatefulServiceBase).GetProperty("Partition", BindingFlags.Instance | BindingFlags.NonPublic);
propertyInfo?.SetValue(service, partition, BindingFlags.Instance | BindingFlags.NonPublic, null, null, CultureInfo.InvariantCulture);
}
public FabricJokesService(
StatefulServiceContext context,
IStatefulServicePartition partition,
IReliableStateManager manager)
{
this.mapperConfiguration = new MapperConfiguration(config => config.CreateMap <JokeImportModel, JokeModel>());
this.context = context;
this.partition = partition;
this.manager = manager;
}
/// <summary>
/// Initializes an instance of the ReplicatorApiMonitor class
/// ReplicatorApiMonitor takes ServiceContext, StatefulServicePartition and Replicator setttings as arguments.
/// The default value of SlowApiMonitoringDuration in the replicator settings object is 120 seconds
/// </summary>
/// <param name="serviceContext">Current service serviceContext</param>
/// <param name="statefulPartition">Current statefulPartition</param>
/// <param name="settings">Current replicator settings</param>
public void Initialize(ServiceContext serviceContext, IStatefulServicePartition statefulPartition, TransactionalReplicatorSettings settings)
{
this.replicatorSettings = settings;
this.context = serviceContext;
this.partition = statefulPartition;
this.traceType = string.Format("{0}.{1}.{2}", SR.ReplicatorApiMonitor_TraceTypeBase, this.context.PartitionId, this.context.ReplicaOrInstanceId);
var monitorParameters = new MonitoringComponentParameters(this.replicatorSettings.PublicSettings.SlowApiMonitoringDuration.Value);
this.fabricMonitor = new FabricApiMonitoringComponent(monitorParameters);
this.initialized = true;
}
public BackupStore(
Uri endpoint,
StorageCredentials credentials,
IStatefulServicePartition servicePartition,
StatefulServiceInitializationParameters statefulServiceInitializationParameters)
{
this.cloudBlobClient = new CloudBlobClient(endpoint, credentials);
this.servicePartition = servicePartition;
this.statefulServiceInitializationParameters = statefulServiceInitializationParameters;
this.backupBlobContainer = this.GetBackupBlobContainer();
}
public PaasCoordinator(
IConfigStore configStore,
string configSectionName,
KeyValueStoreReplica kvsStore,
IStatefulServicePartition partition)
{
configStore.ThrowIfNull("configStore");
configSectionName.ThrowIfNullOrWhiteSpace("configSectionName");
partition.ThrowIfNull("partition");
this.Initialize(configStore, configSectionName, kvsStore, partition);
}
Task <IReplicator> IStateProviderReplica.OpenAsync(
ReplicaOpenMode openMode,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
var fabricReplicator = partition.CreateReplicator(this, this.GetReplicatorSettings());
this.replicator = fabricReplicator.StateReplicator2;
this.servicePartition = partition;
return(Task.FromResult <IReplicator>(fabricReplicator));
}
public Task <IReplicator> OpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition, CancellationToken cancellationToken)
{
this.TraceInfo("IStatefulServiceReplica::OpenAsync invoked. Open mode: {0}.", openMode);
this.partition = partition;
ReplicatorSettings replicatorSettings = this.CreateReplicatorSettings();
this.replicator = partition.CreateReplicator(this, replicatorSettings);
this.TraceInfo("IStatefulServiceReplica::OpenAsync completed.");
return(Task.FromResult(this.replicator as IReplicator));
}
public ReliableFaultsEngine(ActionStore actionStore, bool isTestMode, IStatefulServicePartition partition, int commandStepRetryBackoffInSeconds)
{
ThrowIf.Null(actionStore, "actionStore");
this.random = new Random();
this.actionStore = actionStore;
this.isTestMode = isTestMode;
this.partition = partition;
this.commandStepRetryBackoffInSeconds = commandStepRetryBackoffInSeconds;
}
public BackupStore(
Uri endpoint,
StorageCredentials credentials,
IStatefulServicePartition servicePartition,
Guid testId,
StatefulServiceInitializationParameters statefulServiceInitializationParameters)
{
this.cloudBlobClient = new CloudBlobClient(endpoint, credentials);
this.servicePartition = servicePartition;
this.testId = testId;
this.statefulServiceInitializationParameters = statefulServiceInitializationParameters;
this.backupBlobContainer = this.GetBackupBlobContainer();
}
protected override Task OnOpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition, CancellationToken cancellationToken)
{
partition.ThrowIfNull("partition");
this.partition = partition;
Trace.WriteInfo(
TraceType,
"OpenAsync: serviceId = {0}, configSectionName = {1}, OpenMode = {2}",
this.serviceId,
this.configSectionName,
openMode);
return(base.OnOpenAsync(openMode, partition, cancellationToken));
}
/// <summary>
/// Constructor. Arguments break down into three groups: (1) Service Fabric objects so this library can access
/// Service Fabric facilities, (2) Event Hub-related arguments which indicate what event hub to receive from and
/// how to process the events, and (3) advanced, which right now consists only of the ability to replace the default
/// reliable dictionary-based checkpoint manager with a user-provided implementation.
/// </summary>
/// <param name="serviceFabricServiceName">Service Fabric Uri found in StatefulServiceContext</param>
/// <param name="serviceFabricPartitionId">Service Fabric partition id found in StatefulServiceContext</param>
/// <param name="stateManager">Service Fabric-provided state manager, provides access to reliable dictionaries</param>
/// <param name="partition">Service Fabric-provided partition information</param>
/// <param name="userEventProcessor">User's event processor implementation</param>
/// <param name="eventHubConnectionString">Connection string for user's event hub</param>
/// <param name="eventHubConsumerGroup">Name of event hub consumer group to receive from</param>
/// <param name="options">Optional: Options structure for ServiceFabricProcessor library</param>
/// <param name="checkpointManager">Very advanced/optional: user-provided checkpoint manager implementation</param>
public ServiceFabricProcessor(Uri serviceFabricServiceName, Guid serviceFabricPartitionId, IReliableStateManager stateManager, IStatefulServicePartition partition, IEventProcessor userEventProcessor,
string eventHubConnectionString, string eventHubConsumerGroup,
EventProcessorOptions options = null, ICheckpointMananger checkpointManager = null)
{
if (serviceFabricServiceName == null)
{
throw new ArgumentNullException("serviceFabricServiceName is null");
}
if (serviceFabricPartitionId == null)
{
throw new ArgumentNullException("serviceFabricPartitionId is null");
}
if (stateManager == null)
{
throw new ArgumentNullException("stateManager is null");
}
if (partition == null)
{
throw new ArgumentNullException("partition is null");
}
if (userEventProcessor == null)
{
throw new ArgumentNullException("userEventProcessor is null");
}
if (string.IsNullOrEmpty(eventHubConnectionString))
{
throw new ArgumentException("eventHubConnectionString is null or empty");
}
if (string.IsNullOrEmpty(eventHubConsumerGroup))
{
throw new ArgumentException("eventHubConsumerGroup is null or empty");
}
this.serviceFabricServiceName = serviceFabricServiceName;
this.serviceFabricPartitionId = serviceFabricPartitionId;
this.serviceStateManager = stateManager;
this.servicePartition = partition;
this.userEventProcessor = userEventProcessor;
this.ehConnectionString = new EventHubsConnectionStringBuilder(eventHubConnectionString);
this.consumerGroupName = eventHubConsumerGroup;
this.options = options ?? new EventProcessorOptions();
this.checkpointManager = checkpointManager ?? new ReliableDictionaryCheckpointMananger(this.serviceStateManager);
this.EventHubClientFactory = new EventHubWrappers.EventHubClientFactory();
this.TestMode = false;
this.MockMode = null;
}
public static async Task <ChaosStatus> GetCurrentStatusAsync(
this IReliableDictionary <string, byte[]> statusDictionary,
ITransaction tx,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
return(await FaultAnalysisServiceUtility.RunAndReportFaultOnRepeatedFailure(
ChaosOperationID,
() => GetCurrentStatusPrivateAsync(statusDictionary, tx, cancellationToken),
partition,
"GetCurrentStatusPrivateAsync",
FASConstants.MaxRetriesForReliableDictionary,
cancellationToken).ConfigureAwait(false));
}
public static async Task <long> GetLastStartTimeInTicksAsync(
this IReliableDictionary <string, byte[]> startimeDictionary,
ITransaction tx,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
return(await FaultAnalysisServiceUtility.RunAndReportFaultOnRepeatedFailure(
Guid.NewGuid(),
() => GetLastStartTimeInTicksPrivateAsync(startimeDictionary, tx, cancellationToken),
partition,
"GetLastStartTimeInTicksPrivateAsync",
FASConstants.MaxRetriesForReliableDictionary,
cancellationToken).ConfigureAwait(false));
}
public static async Task RegisterCurrentStatusAsync(
this IReliableStateManager stateManager,
ChaosStatus currentStatus,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
await FaultAnalysisServiceUtility.RunAndReportFaultOnRepeatedFailure(
ChaosOperationID,
() => RegisterCurrentStatusPrivateAsync(stateManager, currentStatus, cancellationToken),
partition,
"RegisterCurrentStatusPrivateAsync",
FASConstants.MaxRetriesForReliableDictionary,
cancellationToken).ConfigureAwait(false);
}
/// <inheritdoc />
public Task <IReplicator> OpenAsync(ReplicaOpenMode openMode, IStatefulServicePartition partition, CancellationToken cancellationToken)
{
// TODO: open a service host
this.listenerUri = new Uri("tcp://127.0.0.1:1234");
var replicatorSettings = this.GetReplicatorSettings();
ServiceEventSource.Current.ServiceMessage(this.serviceContext.ServiceContext, "ReplicatorSettings: {0}", replicatorSettings.ToString());
this.replicator = partition.CreateReplicator(this, replicatorSettings);
this.serviceContext.Replicator = this.replicator;
return(Task.FromResult <IReplicator>(this.replicator));
}
public static bool GetPartitionRange(this IStatefulServicePartition partition, out long lowKey, out long highKey)
{
var result = false;
lowKey = long.MinValue;
highKey = long.MaxValue;
if (partition?.PartitionInfo is Int64RangePartitionInformation)
{
var partitionInfo = (Int64RangePartitionInformation)partition.PartitionInfo;
lowKey = partitionInfo.LowKey;
highKey = partitionInfo.HighKey;
result = true;
}
return(result);
}
public static async Task <bool> ChaosWasRunningAsync(
this IReliableStateManager stateManager,
IStatefulServicePartition partition,
CancellationToken cancellationToken)
{
TestabilityTrace.TraceSource.WriteInfo(TraceType, "Enter ChaosWasRunningAsync");
return(await FaultAnalysisServiceUtility.RunAndReportFaultOnRepeatedFailure(
ChaosOperationID,
() => ChaosWasRunningAsyncPrivate(stateManager, cancellationToken),
partition,
"ShouldStopAsyncPrivate",
FASConstants.MaxRetriesForReliableDictionary,
cancellationToken));
}
