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) { }