protected virtual void Initialize(StatefulService instance, IStartable starter) { var path = Utility.GetDefaultPath(instance); this.Path = Util.GetWcfUri(path); this.Stateful = instance; this.Starter = starter; }
private void cmdTestStateRight_Click(object sender, EventArgs e) { StatefulService proxy = new StatefulService(); proxy.CookieContainer = cookieContainer; proxy.StoreName("John Smith"); MessageBox.Show("You set: " + proxy.GetName()); }
public ICommunicationListener CreateCommunicationListener(StatefulService service) { if (service == null) { throw new ArgumentNullException(nameof(service)); } return new AspNetCoreCommunicationListener(this, service); }
private void cmdTestStateWrong_Click(object sender, EventArgs e) { // Create the proxy. StatefulService proxy = new StatefulService(); // Set a name. proxy.StoreName("John Smith"); // Try to retrieve the name. MessageBox.Show("You set: " + proxy.GetName()); }
public void ServiceMessage(StatefulService service, string message, params object[] args) { if (this.IsEnabled()) { string finalMessage = string.Format(message, args); this.ServiceMessage( service.Context.ServiceName.ToString(), service.Context.ServiceTypeName, service.Context.ReplicaId, service.Context.PartitionId, service.Context.CodePackageActivationContext.ApplicationName, service.Context.CodePackageActivationContext.ApplicationTypeName, service.Context.NodeContext.NodeName, finalMessage); } }
public void ServiceMessage(StatefulService service, string message, params object[] args) { if (this.IsEnabled()) { string finalMessage = string.Format(message, args); ServiceMessage( service.ServiceInitializationParameters.ServiceName.ToString(), service.ServiceInitializationParameters.ServiceTypeName, service.ServiceInitializationParameters.ReplicaId, service.ServiceInitializationParameters.PartitionId, service.ServiceInitializationParameters.CodePackageActivationContext.ApplicationName, service.ServiceInitializationParameters.CodePackageActivationContext.ApplicationTypeName, FabricRuntime.GetNodeContext().NodeName, finalMessage); } }
public void ServiceMessage(StatefulService service, string message, params object[] args) { // System.IO.File.AppendAllText("jotadebug.txt", string.Format("{0} : {1}{2}", service.ServiceInitializationParameters.ServiceName.ToString(), string.Format(message, args), System.Environment.NewLine)); if (this.IsEnabled()) { string finalMessage = string.Format(message, args); ServiceMessage( service.ServiceInitializationParameters.ServiceName.ToString(), service.ServiceInitializationParameters.ServiceTypeName, service.ServiceInitializationParameters.ReplicaId, service.ServiceInitializationParameters.PartitionId, service.ServiceInitializationParameters.CodePackageActivationContext.ApplicationName, service.ServiceInitializationParameters.CodePackageActivationContext.ApplicationTypeName, FabricRuntime.GetNodeContext().NodeName, finalMessage); } }
public Task RegisterMessageTypeAsync(StatefulService service, Type messageType, Uri brokerServiceName = null, string listenerName = null) { return(Task.CompletedTask); }
protected internal RestorePointOperation(string fabricRequestHeader, string serviceName, string apiVersion, StatefulService statefulService) : base(apiVersion) { this.StatefulService = statefulService; this.FabricRequestHeader = fabricRequestHeader; }
public static IMessageConsumer CreateConsumer(this StatefulService service, ServicePartitionInformation partition) { return(service.Context.CreateConsumer(partition)); }
internal Startup(StatefulService statefulService, SecuritySetting securitySetting, CancellationToken cancellationToken) { this.controllerSetting = new ControllerSetting(statefulService, cancellationToken); this.fabricBrsSecuritySetting = securitySetting; }
public Handler(StatefulService service) { _service = service; }
private RestoreStore(IReliableDictionary <string, RestoreStatus> reliableDictionary, StatefulService statefulService) : base(reliableDictionary, statefulService, TraceRestoreStoreType) { }
internal static async Task <BaseWorkItemQueue> GetNextWorkItemQueue(WorkItemQueueRunType workItemQueueRunType, StatefulService statefulService) { BackupRestoreTrace.TraceSource.WriteInfo("BackupRestore.GetNextWorkItemQueue", "workItemQueueRunType {0} ", workItemQueueRunType); BaseWorkItemQueue baseWorkItemQueue = null; switch (workItemQueueRunType) { case WorkItemQueueRunType.WorkItemQueue: baseWorkItemQueue = await WorkItemQueue1Min.CreateOrGetWorkItemQueue(statefulService); break; case WorkItemQueueRunType.WorkItemQueue1MinDelay: baseWorkItemQueue = await WorkItemQueue2Min.CreateOrGetWorkItemQueue(statefulService); break; case WorkItemQueueRunType.WorkItemQueue2MinDelay: baseWorkItemQueue = await WorkItemQueue4Min.CreateOrGetWorkItemQueue(statefulService); break; case WorkItemQueueRunType.WorkItemQueue4MinDelay: baseWorkItemQueue = await WorkItemQueue8Min.CreateOrGetWorkItemQueue(statefulService); break; case WorkItemQueueRunType.WorkItemQueue8MinDelay: baseWorkItemQueue = await WorkItemQueue8Min.CreateOrGetWorkItemQueue(statefulService); break; } BackupRestoreTrace.TraceSource.WriteInfo("BackupRestore.GetNextWorkItemQueue", "Next WorkItemQueue {0} ", baseWorkItemQueue.GetType()); return(baseWorkItemQueue); }
internal GetAllBackupPolicyOperation(string apiVersion, StatefulService statefulService, string continuationToken = null, int maxResults = 0) : base(apiVersion, statefulService) { this.maxResults = maxResults; this.continuationToken = continuationToken; }
public OwinCommunicationListener(StatefulService statefulService, ServiceContext serviceContext) { this.statefulService = statefulService; this.serviceContext = serviceContext; }
internal void ServiceMessage(StatefulService service, string v) { //throw new NotImplementedException(); }
public SuspendBackupController(ControllerSetting controllerSetting) { this.statefulService = controllerSetting.StatefulService; }
private ConfigStore(IReliableDictionary <string, string> reliableDictionary, StatefulService statefulService) : base(reliableDictionary, statefulService, TraceConfigStoreType) { }
private WorkItemQueue1Min(IReliableQueue <WorkItemProcessInfo> workItemReliableQueue, int maxWaitTimeInMinutes, WorkItemQueueRunType workItemQueueRunType, StatefulService statefulService) : base(workItemReliableQueue, maxWaitTimeInMinutes, workItemQueueRunType, TraceTypeConst, statefulService) { }
internal BaseWorkItemQueue(IReliableQueue <WorkItemProcessInfo> workItemReliableQueue, int maxWaitTimeInMinutes, WorkItemQueueRunType workItemQueueRunType, string traceType, StatefulService statefulService) { BackupRestoreTrace.TraceSource.WriteInfo(traceType, "Constructing BaseWorkItemQueue with following parameters - workItemReliableQueue: {0}, maxWaitTimeInMinutes: {1}, workItemQueueRunType: {2}", workItemReliableQueue.Name, maxWaitTimeInMinutes, workItemQueueRunType); this.WorkItemReliableQueue = workItemReliableQueue; this.StatefulService = statefulService; this.WorkItemStore = WorkItemStore.CreateOrGetWorkItemStore(this.StatefulService).GetAwaiter().GetResult(); this.WorkItemInProcessStore = WorkItemInProcessStore.CreateOrGetWorkItemInProcessStore(this.StatefulService).GetAwaiter().GetResult(); this.MaxWaitTimeInMilliSeconds = maxWaitTimeInMinutes == 0 ? FastQueueWaitTime : maxWaitTimeInMinutes * 60 * 1000; this.AllowedTicks = (this.MaxWaitTimeInMilliSeconds * TimeSpan.TicksPerMillisecond) / 20; this.workItemQueueRunType = workItemQueueRunType; this.TraceType = traceType; this.emptyTraceType = string.Format("{0}.{1}", traceType, "Empty"); this.WorkItemHandlerTimer = new Timer(new TimerCallback(this.ProcessWorkItemHandler), null, this.MaxWaitTimeInMilliSeconds, Timeout.Infinite); }
internal OwinHttpServer(StatefulService statefulService, SecuritySetting fabricBrSecuritySetting, CancellationToken cancellationToken) { this.owinStartup = new Startup(statefulService, fabricBrSecuritySetting, cancellationToken); }
public static IReceiverConnectionFactory WithServiceFabricIntegration(this EventHubClient client, StatefulService service) => client.UseServiceFabricState(service).WithBatchCheckpointing();
public BackupPartitionRequestOperation(string fabricRequestHeader, BackupStorageView backupStorage, int backupTimeoutinMinutes, string apiVersion, StatefulService statefulService) : base(apiVersion, statefulService) { this.fabricRequestHeader = fabricRequestHeader; this.backupStorage = backupStorage; this.backupTimeoutinMinutes = backupTimeoutinMinutes; }
internal ServiceFabricEventHubsBuilder(ITestableEventHubClient client, StatefulService service) { Client = client; Service = service; }
private CleanupStore(IReliableDictionary <string, List <string> > reliableDictionary, StatefulService statefulService) : base(reliableDictionary, statefulService, TraceRestoreStoreType) { }
public static ServiceFabricEventHubsBuilder UseServiceFabricState(this EventHubClient client, StatefulService service) => new ServiceFabricEventHubsBuilder(new TestableEventHubClient(client), service);
private WorkItemStore(IReliableDictionary <Guid, WorkItem> reliableDictionary, StatefulService statefulService) : base(reliableDictionary, statefulService, TraceWorkItemStoreType) { }
internal static ServiceFabricEventHubsBuilder UseServiceFabricState(this ITestableEventHubClient client, StatefulService service) => new ServiceFabricEventHubsBuilder(client, service);
private async Task ProcessBackup(StatefulService statefulService, TimeSpan timeout, CancellationToken cancellationToken, string processQueueTypeTrace) { BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Processing the Backup for request Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId); var timeOutPersecCycle = 30000; var backupPartitionStore = await BackupPartitionStore.CreateOrGetBackupPartitionStore(statefulService); var fabricUri = UtilityHelper.GetBackupMappingKey(this.ServiceUri, this.PartitionId); BackupPartitionStatus backupPartitionStatus; do { var backupNowConfiguration = new BackupNowConfiguration() { StoreInformation = this.GetBackupStoreInformationFromBackupStorage(this.BackupStorage), OperationTimeoutMilliseconds = (int)this.BackupTimeout.TotalMilliseconds }; await UtilityHelper.InvokeWithRetry(async() => { await Program.ServiceAgent.BackupPartitionAsync(new Uri(UtilityHelper.GetUriFromCustomUri(this.ServiceUri)), Guid.Parse(this.PartitionId), this.BackupRequestGuid, backupNowConfiguration, timeout, cancellationToken); }); BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Requested the BackupPartitionAsync Successfully for Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId); await UtilityHelper.InvokeWithRetry(async() => { using (ITransaction transaction = statefulService.StateManager.CreateTransaction()) { var currentBackupPartitionStatus = await backupPartitionStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction); if (currentBackupPartitionStatus.BackupPartitionStatusState == BackupState.Accepted) { var toUpdateBackupPartitionStatus = currentBackupPartitionStatus.ToBuilder().WithState(BackupState.BackupInProgress).Build(); await backupPartitionStore.UpdateValueAsync(fabricUri, toUpdateBackupPartitionStatus, timeout, cancellationToken, transaction); await transaction.CommitAsync(); BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updated the Backup partition request to BackupInProcss for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId); } else { transaction.Abort(); BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Could not Update the BackupPartition request to BackupInProcess for request Service Uri : {0} , PartitionId {1} because currentBackupPartitionStatus value is {2}", this.ServiceUri, this.PartitionId, currentBackupPartitionStatus); } } } ); await Task.Delay(timeOutPersecCycle, cancellationToken); backupPartitionStatus = await backupPartitionStore.GetValueAsync(fabricUri); BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "BackupPartitionstatusState {0},isCancellationRequested {1} for Service Uri : {2} , PartitionId {3}", backupPartitionStatus.BackupPartitionStatusState, cancellationToken.IsCancellationRequested, this.ServiceUri, this.PartitionId); } while ((backupPartitionStatus.BackupPartitionStatusState == BackupState.Accepted || backupPartitionStatus.BackupPartitionStatusState == BackupState.BackupInProgress) && this.BackupRequestGuid.Equals(backupPartitionStatus.OperationId) && !cancellationToken.IsCancellationRequested); cancellationToken.ThrowIfCancellationRequested(); }
public void Initialize(StatefulService stateful) { base.Initialize(stateful, service); service.Initialize(this.Path, stateful); }
public static IMessageConsumer CreateConsumer(this StatefulService service, ServicePartitionInformation partition, IBrokerServiceLocator serviceLocator) { return(service.Context.CreateConsumer(partition, serviceLocator)); }
/// <summary> /// Unregisters this StatefulService as a subscriber for messages of type <typeparam name="T"/> with the <see cref="BrokerService"/>. /// </summary> /// <param name="brokerClient"></param> /// <param name="service"></param> /// <returns></returns> public static Task UnsubscribeAsync <T>(this IBrokerClient brokerClient, StatefulService service) where T : class { return(brokerClient.UnsubscribeAsync(CreateReferenceWrapper(service), typeof(T))); }
public ServiceReference CreateServiceReference(StatefulService service, string listenerName = null) { return(new ServiceReference()); }
internal static Task SubscribeAsync <T>(this IBrokerClient brokerClient, StatefulService service, Type messageType, Func <T, Task> handler, string listenerName = null, string routingKey = null, bool isOrdered = true) where T : class { return(brokerClient.SubscribeAsync(CreateReferenceWrapper(service, listenerName, routingKey), messageType, handler, isOrdered)); }
public Handler(StatefulService service) { _service = service; }
internal static Task UnsubscribeAsync(this IBrokerClient brokerClient, StatefulService service, Type messageType) { return(brokerClient.UnsubscribeAsync(CreateReferenceWrapper(service), messageType)); }
/// <summary> /// Registers this StatefulService as a subscriber for messages of type <typeparam name="T"/> with the <see cref="BrokerService"/>. /// </summary> /// <param name="brokerClient"></param> /// <param name="service"></param> /// <param name="handler"></param> /// <param name="isOrdered"></param> /// <param name="listenerName"></param> /// <param name="routingKey">Optional routing key to filter messages based on content. 'Key=Value' where Key is a message property path and Value is the value to match with message payload content.</param> /// <returns></returns> public static Task SubscribeAsync <T>(this IBrokerClient brokerClient, StatefulService service, Func <T, Task> handler, bool isOrdered = true, string listenerName = null, string routingKey = null) where T : class { return(brokerClient.SubscribeAsync(CreateReferenceWrapper(service, listenerName, routingKey), typeof(T), handler, isOrdered)); }
/// <inheritdoc /> public void Initialize(StatefulService statefulService) { this.statefulService = statefulService; }