void IStateProviderReplica.Initialize(StatefulServiceInitializationParameters initializationParameters)
{
this.initiParams = initializationParameters;
this.traceId = ActorTrace.GetTraceIdForReplica(this.initiParams.PartitionId, this.initiParams.ReplicaId);
var statefulServiceContext = new StatefulServiceContext(
FabricRuntime.GetNodeContext(),
this.initiParams.CodePackageActivationContext,
this.initiParams.ServiceTypeName,
this.initiParams.ServiceName,
this.initiParams.InitializationData,
this.initiParams.PartitionId,
this.initiParams.ReplicaId);
var stateManagerConfig = this.userDefinedStateManagerConfig;
if (stateManagerConfig == null)
{
var actorImplType = this.actorTypeInformation.ImplementationType;
stateManagerConfig = new ReliableStateManagerConfiguration(
ActorNameFormat.GetConfigPackageName(actorImplType),
ActorNameFormat.GetFabricServiceReplicatorSecurityConfigSectionName(actorImplType),
ActorNameFormat.GetFabricServiceReplicatorConfigSectionName(actorImplType));
}
this.stateManager = new ReliableStateManager(statefulServiceContext, stateManagerConfig);
ReleaseAssert.AssertIfNull(this.onDataLossAsyncFunc, "onDataLossAsync event handler cannot be null.");
this.stateManager.OnDataLossAsync = this.onDataLossAsyncFunc;
this.stateManager.Initialize(this.initiParams);
}
internal static async Task <UsersService.UsersService> CreateUsersService(IReliableStateManagerReplica stateManager = null,
IUsersRepository usersRepository = null, IActorFactory actorFactory = null, IServiceFactory serviceFactory = null,
bool invokeRunAsync = true)
{
var context = MockStatefulServiceContextFactory.Default;
if (stateManager == null)
{
stateManager = new MockReliableStateManager();
}
if (usersRepository == null)
{
usersRepository = new Mock <IUsersRepository>().Object;
}
if (actorFactory == null)
{
actorFactory = new Mock <IActorFactory>().Object;
}
if (serviceFactory == null)
{
serviceFactory = new Mock <IServiceFactory>().Object;
}
var service = new UsersService.UsersService(context, stateManager, usersRepository, actorFactory, serviceFactory);
if (invokeRunAsync)
{
await service.InvokeRunAsync();
}
return(service);
}
public NationalService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica)
: base(serviceContext, reliableStateManagerReplica)
{
this.StateManager.StateManagerChanged += this.StateManager_StateManagerChanged;
this.StateManager.TryAddStateSerializer <NationalCountyStats>(new NationalCountyStatsSerializer());
InitStats();
}
public CountyService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica)
: base(serviceContext, reliableStateManagerReplica)
{
InitConfig();
this.StateManager.TryAddStateSerializer <CountyDoctorStats>(new CountyDoctorStatsSerializer());
this.indexCalculator = new HealthIndexCalculator(serviceContext);
}
protected StatefulDispatcherService(StatefulServiceContext serviceContext,
IReliableStateManagerReplica reliableStateManagerReplica, IReliableDispatcher <T> reliableDispatcher)
: base(serviceContext, reliableStateManagerReplica)
{
Requires.IsNotNull(reliableDispatcher, nameof(reliableDispatcher));
ReliableDispatcher = reliableDispatcher;
}
public ShowService(StatefulServiceContext serviceContext,
IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext,
reliableStateManagerReplica)
{
_showRepository = new ShowRepository(StateManager);
_backupManager = new BackupManager(
new ServiceContextInfo(Context, Partition, StateManager),
new BackupContextInfo(BackupAsync, "showRequestHistory", "showBackupCountDict"));
}
public ExampleClient(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica,
IActorEventSubscriptionHelper subscriptionHelper, IActorProxyFactory actorProxyFactory)
: base(serviceContext, reliableStateManagerReplica)
{
if (actorProxyFactory == null)
{
throw new ArgumentNullException(nameof(actorProxyFactory));
}
_subscriptionHelper = subscriptionHelper ?? new ActorEventSubscriptionHelper();
_actorProxyFactory = actorProxyFactory;
}
public VehiclesService(StatefulServiceContext context, IReliableStateManagerReplica stateManager, IVehiclesRepository vehiclesRepository,
IActorFactory actorFactory = null, IServiceFactory serviceFactory = null)
: base(context, stateManager, actorFactory, serviceFactory)
{
if (vehiclesRepository == null)
{
throw new ArgumentNullException(nameof(vehiclesRepository));
}
this.vehiclesRepository = vehiclesRepository;
}
/// <summary>
/// Creates a new instance, using the provided arguments.
/// </summary>
/// <param name="context"></param>
/// <param name="reliableStateManagerReplica"></param>
/// <param name="centralBackupStore"></param>
/// <param name="logCallback"></param>
protected BackupRestoreService(StatefulServiceContext context, IReliableStateManagerReplica reliableStateManagerReplica, ICentralBackupStore centralBackupStore, Action <string> logCallback)
: base(context, reliableStateManagerReplica)
{
if (centralBackupStore == null)
{
throw new ArgumentNullException(nameof(centralBackupStore));
}
_centralBackupStore = centralBackupStore;
_logCallback = logCallback;
}
public ReservationService(StatefulServiceContext serviceContext,
IReliableStateManagerReplica reliableStateManagerReplica,
IServiceFactory <IShowService> showServiceFactory) : base(serviceContext,
reliableStateManagerReplica)
{
_reservationRepository = new ReservationRepository(StateManager);
_showServiceFactory = showServiceFactory;
_backupManager = new BackupManager(
new ServiceContextInfo(Context, Partition, StateManager),
new BackupContextInfo(BackupAsync, "reservationRequestHistory", "reservationBackupCountDict"));
}
private async Task SetInvoiceNumberInDictionaryAsync(IReliableStateManagerReplica stateManager, string yearKey, uint invoiceNumber)
{
var invoiceNumbersDictionary = await stateManager.GetOrAddAsync <IReliableDictionary <string, uint> >(InvoicesService.InvoiceNumbersDictionaryKeyName);
using (var tx = stateManager.CreateTransaction())
{
await invoiceNumbersDictionary.AddAsync(tx, yearKey, invoiceNumber);
await tx.CommitAsync();
}
}
/// <summary>
/// This constructor is currently only used for testing purposes
/// </summary>
/// <param name="context"></param>
/// <param name="reliableStateManagerReplica"></param>
public CoreService(StatefulServiceContext context, IReliableStateManagerReplica reliableStateManagerReplica, ILogger logger)
: base(context, reliableStateManagerReplica)
{
this._logger = logger;
var config = context.CodePackageActivationContext.GetConfigurationPackageObject("Config");
var section = config?.Settings.Sections["AppSettings"];
_backupCxnString = section?.Parameters["BackupStoreCxn"].Value ?? "mongodb://*****:*****@ds111791.mlab.com:11791/config-svc-backup";
_backupDbName = section?.Parameters["BackupDbName"].Value ?? "config-svc-backup";
_backupKvpCollection = section?.Parameters["BackupKvpCollection"].Value ?? "kvp-settings";
}
public MailService(StatefulServiceContext context, IReliableStateManagerReplica stateManager,
MailAdapterBase mailAdapter, IActorFactory actorFactory = null, IServiceFactory serviceFactory = null)
: base(context, stateManager, actorFactory, serviceFactory)
{
if (mailAdapter == null)
{
throw new ArgumentNullException(nameof(mailAdapter));
}
this.mailAdapter = mailAdapter;
this.mailAdapter.SetParent(this);
}
/// <summary>
/// Creates a new instance using the provided context and registers this instance for automatic discovery if needed.
/// </summary>
/// <param name="serviceContext"></param>
/// <param name="reliableStateManagerReplica"></param>
/// <param name="enableAutoDiscovery"></param>
protected BrokerService(StatefulServiceContext serviceContext,
IReliableStateManagerReplica reliableStateManagerReplica, bool enableAutoDiscovery = true)
: base(serviceContext, reliableStateManagerReplica)
{
if (enableAutoDiscovery)
{
new BrokerServiceLocator().RegisterAsync(Context.ServiceName)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
}
public ActorService(
StatefulServiceContext context,
ActorTypeInformation actorTypeInfo,
Func <Microsoft.ServiceFabric.Actors.Runtime.ActorService, ActorId, ActorBase> actorFactory = null,
Func <Microsoft.ServiceFabric.Actors.Runtime.ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null,
IActorStateProvider stateProvider = null,
ActorServiceSettings settings = null,
IReliableStateManagerReplica reliableStateManagerReplica = null) :
base(context, actorTypeInfo, actorFactory, stateManagerFactory, stateProvider, settings)
{
StateManager = reliableStateManagerReplica ??
(IReliableStateManagerReplica) new ReliableStateManager(context, (ReliableStateManagerConfiguration)null);
}
protected EventStoredActorService
(StatefulServiceContext context,
ActorTypeInformation actorTypeInfo,
Func <Microsoft.ServiceFabric.Actors.Runtime.ActorService, ActorId, ActorBase> actorFactory = null,
Func <Microsoft.ServiceFabric.Actors.Runtime.ActorBase, IActorStateProvider, IActorStateManager> stateManagerFactory = null,
IActorStateProvider stateProvider = null,
ActorServiceSettings settings = null,
IReliableStateManagerReplica reliableStateManagerReplica = null,
IEventStreamReader <TEventStream> eventStreamReader = null)
: base(context, actorTypeInfo, actorFactory, stateManagerFactory, stateProvider, settings, reliableStateManagerReplica)
{
StateProviderEventStreamReader = eventStreamReader ?? new EventStreamReader <TEventStream>(StateProvider, EventStoredActor <TAggregateRoot, TEventStream> .EventStreamStateKey);
}
/// <summary>
/// Ctor used for mocking and tests
/// </summary>
/// <param name="context"></param>
/// <param name="reliableStateManagerReplica"></param>
/// <param name="bigBrother"></param>
/// <param name="serviceBusManager"></param>
/// <param name="proxyFactory"></param>
/// <param name="settings"></param>
public EventReaderService(
StatefulServiceContext context,
IReliableStateManagerReplica reliableStateManagerReplica,
IBigBrother bigBrother,
IServiceBusManager serviceBusManager,
IActorProxyFactory proxyFactory,
ConfigurationSettings settings)
: base(context, reliableStateManagerReplica)
{
_bigBrother = bigBrother;
_serviceBusManager = serviceBusManager;
_proxyFactory = proxyFactory;
_settings = settings;
ParseOutInitData(context.InitializationData);
}
// This constructor is used during unit testing by setting a mock IReliableStateManagerReplica
public OrderBook(StatefulServiceContext context, IReliableStateManagerReplica reliableStateManagerReplica, Order ask = null, Order bid = null, int maxPendingAsks = 10, int maxPendingBids = 10)
: base(context, reliableStateManagerReplica)
{
this.maxPendingAsks = maxPendingAsks;
this.maxPendingBids = maxPendingBids;
this.asks = new OrderSet(reliableStateManagerReplica, AskBookName);
if (ask != null)
{
this.asks.SecondaryIndex = this.asks.SecondaryIndex.Add(ask);
}
this.bids = new OrderSet(reliableStateManagerReplica, BidBookName);
if (bid != null)
{
this.bids.SecondaryIndex = this.bids.SecondaryIndex.Add(bid);
}
}
private async Task <uint?> GetInvoiceNumberInDictionaryAsync(IReliableStateManagerReplica stateManager, string yearKey)
{
var invoiceNumbersDictionary = await stateManager.GetOrAddAsync <IReliableDictionary <string, uint> >(InvoicesService.InvoiceNumbersDictionaryKeyName);
uint newInvoiceNumber = 0;
using (var tx = stateManager.CreateTransaction())
{
var value = await invoiceNumbersDictionary.TryGetValueAsync(tx, yearKey);
if (!value.HasValue)
{
return(null);
}
newInvoiceNumber = value.Value;
}
return(newInvoiceNumber);
}
/// <summary>
/// Creates a new instance of MetricReliableStateManager.
/// </summary>
/// <param name="context"></param>
/// <param name="serializerResolver"></param>
/// <param name="configProvider"></param>
/// <param name="stateManager">
/// Best to leave this null and let the constructor create one that's configured with a fast binary serializer.
/// Beware: if you pass in your own instance of ReliableStateManager, it will use DataContract.
/// </param>
public MetricReliableStateManager(
StatefulServiceContext context, IReliableStateSerializerResolver serializerResolver, MetricConfiguration config = null,
IReliableStateManagerReplica stateManager = null)
{
this.serializerResolver = serializerResolver;
this.config = config ?? new MetricConfigurationSettingsXml(context);
this.stateManagerReplica =
stateManager ??
new ReliableStateManager(
context,
new ReliableStateManagerConfiguration(
onInitializeStateSerializersEvent: () =>
{
this.stateManagerReplica.StateManagerChanged += this.StateManagerReplica_StateManagerChanged;
this.stateManagerReplica.TransactionChanged += this.StateManagerReplica_TransactionChanged;
return(Task.FromResult(this.stateManagerReplica.TryAddStateSerializer <BinaryValue>(new BinaryValueStateSerializer())));
}));
}
protected StatefulServiceBase(StatefulServiceContext context, IReliableStateManagerReplica stateManager,
IActorFactory actorFactory = null, IServiceFactory serviceFactory = null)
: base(context, stateManager)
{
if (actorFactory == null)
{
this.actorFactory = new ReliableFactory();
}
else
{
this.actorFactory = actorFactory;
}
if (serviceFactory == null)
{
this.serviceFactory = new ReliableFactory();
}
else
{
this.serviceFactory = serviceFactory;
}
}
public RestockRequestManagerService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica)
: base(serviceContext, reliableStateManagerReplica)
{
}
public RestaurantService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica)
: base(serviceContext, reliableStateManagerReplica)
{
}
public QueryableServiceBase(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
StateManager = reliableStateManagerReplica;
}
public ResourceManagerService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica, ILogger logger) : base(serviceContext, reliableStateManagerReplica)
{
this.Logger = logger;
}
public SubscribingToRelayStatefulService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
}
public SampleQueueListeningStatefulService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
}
public SampleSubscriptionListeningStatefulService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
}
public InventoryService(StatefulServiceContext context, IReliableStateManagerReplica stateManagerReplica) : base(context, stateManagerReplica)
{
}
public NoOp(StatefulServiceContext context, IReliableStateManagerReplica replica) : base(context, replica)
{
}
public FeedBackService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
}
public Tracker(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
}
public MessageBoxService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
{
}
