public void IsEquivalentToDetectsEqualOptionSets() { var customPolicy = Mock.Of <EventHubRetryPolicy>(); var first = new RetryOptions { CustomRetryPolicy = customPolicy }; var second = new RetryOptions { CustomRetryPolicy = customPolicy }; Assert.That(first.IsEquivalentTo(second), Is.True); }
public void Receive_Retry_BufferFull_Ignore() { SetupTestReceiveThrows((timer, mockConsumer, retryConsumer) => { int[] intArray = { 1, 2, 3, 4 }; retryConsumer.Receive(intArray); mockConsumer.Verify(c => c.Receive(intArray), Times.Once); timer.Call(); mockConsumer.Verify(c => c.Receive(intArray), Times.Once); }, RetryOptions.Retry(bufferSizeBytes: 1)); }
public void Receive_Retry_BufferFull_Throw() { SetupTestReceiveThrows((timer, mockConsumer, retryConsumer) => { int[] intArray = { 1, 2, 3, 4 }; Assert.Throws <InvalidOperationException>(() => { retryConsumer.Receive(intArray); }); mockConsumer.Verify(c => c.Receive(intArray), Times.Once); timer.Call(); mockConsumer.Verify(c => c.Receive(intArray), Times.Once); }, RetryOptions.Retry(bufferSizeBytes: 1, bufferOverflow: BufferOverflow.ThrowException)); }
public void Receive_NoRetry_Ignore() { SetupTestReceiveThrows((timer, mockConsumer, retryConsumer) => { int[] intArray = { 1, 2, 3, 4 }; retryConsumer.Receive(intArray); mockConsumer.Verify(c => c.Receive(intArray), Times.Once); timer.Call(); mockConsumer.Verify(c => c.Receive(intArray), Times.Once); }, RetryOptions.NoRetry()); }
public SqlServerConnectionFactoryWithRetry(RetryOptions retryOptions, string connectionString = null) { if (retryOptions == null) { throw new ArgumentNullException(nameof(retryOptions)); } _proxy = RetryProxy.Create <IConnectionFactory>( String.IsNullOrEmpty(connectionString) ? new SqlServerConnectionFactory() : new SqlServerConnectionFactory(connectionString), retryOptions, new SqlServerTransientErrorTester()); }
public void ConfigureServices(IServiceCollection services) { var cosmosDbConnectionContentPages = configuration.GetSection(CosmosDbContentPagesConfigAppSettings).Get <CosmosDbConnection>(); var cosmosRetryOptions = new RetryOptions { MaxRetryAttemptsOnThrottledRequests = 20, MaxRetryWaitTimeInSeconds = 60 }; services.AddContentPageServices <ContentPageModel>(cosmosDbConnectionContentPages, env.IsDevelopment(), cosmosRetryOptions); services.AddApplicationInsightsTelemetry(); services.AddHttpContextAccessor(); services.AddTransient <IPagesControlerHelpers, PagesControlerHelpers>(); services.AddTransient <IEventMessageService <ContentPageModel>, EventMessageService <ContentPageModel> >(); services.AddTransient <ICacheReloadService, CacheReloadService>(); services.AddTransient <IWebhooksService, WebhooksService>(); services.AddTransient <IWebhookContentProcessor, WebhookContentProcessor>(); services.AddTransient <IPageLocatonUpdater, PageLocatonUpdater>(); services.AddTransient <IContentItemUpdater, ContentItemUpdater>(); services.AddTransient <IMarkupContentItemUpdater <CmsApiHtmlModel>, MarkupContentItemUpdater <CmsApiHtmlModel> >(); services.AddTransient <IMarkupContentItemUpdater <CmsApiHtmlSharedModel>, MarkupContentItemUpdater <CmsApiHtmlSharedModel> >(); services.AddTransient <IMarkupContentItemUpdater <CmsApiSharedContentModel>, MarkupContentItemUpdater <CmsApiSharedContentModel> >(); services.AddTransient <IMarkupContentItemUpdater <CmsApiFormModel>, MarkupContentItemUpdater <CmsApiFormModel> >(); services.AddTransient <IEventGridService, EventGridService>(); services.AddTransient <IEventGridClientService, EventGridClientService>(); services.AddAutoMapper(typeof(Startup).Assembly); services.AddSingleton(configuration.GetSection(nameof(CmsApiClientOptions)).Get <CmsApiClientOptions>() ?? new CmsApiClientOptions()); services.AddSingleton(configuration.GetSection(nameof(EventGridPublishClientOptions)).Get <EventGridPublishClientOptions>() ?? new EventGridPublishClientOptions()); services.AddSingleton(configuration.GetSection(nameof(AppRegistryClientOptions)).Get <AppRegistryClientOptions>() ?? new AppRegistryClientOptions()); services.AddSingleton(configuration.GetSection(nameof(CacheReloadTimerOptions)).Get <CacheReloadTimerOptions>() ?? new CacheReloadTimerOptions()); services.AddHostedServiceTelemetryWrapper(); services.AddSubscriptionBackgroundService(configuration); services.AddHostedService <CacheReloadBackgroundService>(); services.AddHostedService <CacheReloadTimedHostedService>(); const string AppSettingsPolicies = "Policies"; var policyOptions = configuration.GetSection(AppSettingsPolicies).Get <PolicyOptions>() ?? new PolicyOptions(); var policyRegistry = services.AddPolicyRegistry(); services.AddApiServices(configuration, policyRegistry); services .AddPolicies(policyRegistry, nameof(AppRegistryClientOptions), policyOptions) .AddHttpClient <IAppRegistryApiService, AppRegistryApiService, AppRegistryClientOptions>(configuration, nameof(AppRegistryClientOptions), nameof(PolicyOptions.HttpRetry), nameof(PolicyOptions.HttpCircuitBreaker)); services.AddMvc(config => { config.RespectBrowserAcceptHeader = true; config.ReturnHttpNotAcceptable = true; }) .AddNewtonsoftJson() .SetCompatibilityVersion(CompatibilityVersion.Version_3_0); }
public void ConfigureServices(IServiceCollection services) { var cosmosDbConnectionJobGroup = configuration.GetSection(CosmosDbJobGroupConfigAppSettings).Get <CosmosDbConnection>(); var cosmosDbConnectionSharedContent = configuration.GetSection(CosmosDbSharedContentConfigAppSettings).Get <CosmosDbConnection>(); var cosmosRetryOptions = new RetryOptions { MaxRetryAttemptsOnThrottledRequests = 20, MaxRetryWaitTimeInSeconds = 60 }; services.AddDocumentServices <JobGroupModel>(cosmosDbConnectionJobGroup, env.IsDevelopment(), cosmosRetryOptions); services.AddDocumentServices <ContentItemModel>(cosmosDbConnectionSharedContent, env.IsDevelopment(), cosmosRetryOptions); services.AddApplicationInsightsTelemetry(); services.AddHttpContextAccessor(); services.AddHostedServiceTelemetryWrapper(); services.AddAutoMapper(typeof(Startup).Assembly); services.AddHostedService <SharedContentCacheReloadBackgroundService>(); services.AddSubscriptionBackgroundService(configuration); services.AddTransient <IJobGroupCacheRefreshService, JobGroupCacheRefreshService>(); services.AddTransient <IJobGroupPublishedRefreshService, JobGroupPublishedRefreshService>(); services.AddTransient <IWebhooksService, WebhooksService>(); services.AddTransient <IWebhooksContentService, WebhooksContentService>(); services.AddTransient <IWebhooksDeleteService, WebhooksDeleteService>(); services.AddTransient <ISharedContentCacheReloadService, SharedContentCacheReloadService>(); services.AddTransient <IApiConnector, ApiConnector>(); services.AddTransient <IApiDataConnector, ApiDataConnector>(); services.AddSingleton(configuration.GetSection(nameof(EventGridClientOptions)).Get <EventGridClientOptions>() ?? new EventGridClientOptions()); services.AddTransient <IEventGridService, EventGridService>(); services.AddTransient <IEventGridClientService, EventGridClientService>(); var policyOptions = configuration.GetSection(AppSettingsPolicies).Get <PolicyOptions>() ?? new PolicyOptions(); var policyRegistry = services.AddPolicyRegistry(); services.AddSingleton(configuration.GetSection(nameof(LmiTransformationApiClientOptions)).Get <LmiTransformationApiClientOptions>() ?? new LmiTransformationApiClientOptions()); services.AddSingleton(configuration.GetSection(nameof(JobGroupDraftApiClientOptions)).Get <JobGroupDraftApiClientOptions>() ?? new JobGroupDraftApiClientOptions()); services.AddApiServices(configuration, policyRegistry); services .AddPolicies(policyRegistry, nameof(LmiTransformationApiClientOptions), policyOptions) .AddHttpClient <ILmiTransformationApiConnector, LmiTransformationApiConnector, LmiTransformationApiClientOptions>(nameof(LmiTransformationApiClientOptions), nameof(PolicyOptions.HttpRetry), nameof(PolicyOptions.HttpCircuitBreaker)); services .AddPolicies(policyRegistry, nameof(JobGroupDraftApiClientOptions), policyOptions) .AddHttpClient <IJobGroupApiConnector, JobGroupApiConnector, JobGroupDraftApiClientOptions>(nameof(JobGroupDraftApiClientOptions), nameof(PolicyOptions.HttpRetry), nameof(PolicyOptions.HttpCircuitBreaker)); services.AddMvc(config => { config.RespectBrowserAcceptHeader = true; config.ReturnHttpNotAcceptable = true; }) .AddNewtonsoftJson() .SetCompatibilityVersion(CompatibilityVersion.Version_3_0); }
public void IsEquivalentToDetectsNullArgument() { var first = new RetryOptions { Mode = RetryMode.Fixed, MaximumRetries = 99, MaximumDelay = TimeSpan.FromMinutes(3), Delay = TimeSpan.FromSeconds(4), TryTimeout = TimeSpan.Zero }; Assert.That(first.IsEquivalentTo((RetryOptions)null), Is.False); }
public static async Task <bool> SimpleActivityRetrySuccceds([OrchestrationTrigger] IDurableOrchestrationContext ctx) { (TimeSpan firstRetry, TimeSpan maxRetry) = ctx.GetInput <(TimeSpan, TimeSpan)>(); RetryOptions retry = new RetryOptions(firstRetry, 5) { MaxRetryInterval = maxRetry, }; await ctx.CallActivityWithRetryAsync <Guid>(nameof(TestActivities.NewGuid), retry, null); return(true); }
public void IsEquivalentToDetectsSameInstance() { var first = new RetryOptions { Mode = RetryMode.Fixed, MaximumRetries = 99, MaximumDelay = TimeSpan.FromMinutes(3), Delay = TimeSpan.FromSeconds(4), TryTimeout = TimeSpan.Zero }; Assert.That(first.IsEquivalentTo(first), Is.True); }
public static async Task <object> NewWorker( [OrchestrationTrigger] DurableOrchestrationContext ctx, TraceWriter log ) { int retryattempts = 1; var query = ctx.GetInput <string>(); var retryOptions = new RetryOptions( firstRetryInterval: TimeSpan.FromSeconds(5), maxNumberOfAttempts: retryattempts); var getcookietask = ctx.CallActivityWithRetryAsync <string>("Authenticate", retryOptions, "credentials"); getcookietask.ContinueWith(t => { return("Failed"); }, TaskContinuationOptions.OnlyOnFaulted); await getcookietask; var cookiesjsonb64 = getcookietask.Result; var cookies = CookieConverter.DecodeCookie(cookiesjsonb64); if (!ctx.IsReplaying) { log.Warning($"Successfully retrieved {cookies.Length} cookies."); } var querygurutask = ctx.CallActivityWithRetryAsync <int>("QueryGuru", retryOptions, new Tuple <string, string>(query, cookiesjsonb64)); querygurutask.ContinueWith(t => { return("Failed"); }, TaskContinuationOptions.OnlyOnFaulted); var pages = await querygurutask; if (!ctx.IsReplaying) { log.Warning($"Query successfully returned {pages}."); } var workload = await ctx.CallActivityAsync <List <int> >("CreateWorkload", pages); //log.Warning(ctx.InstanceId); var worker = ctx.CallSubOrchestratorAsync("WorkerWork", new WorkerWorkArgs { query = query, cookiestext = cookiesjsonb64, workload = workload, total = workload.Count }); string result = await ctx.WaitForExternalEvent <string>("Finished"); return(result); }
public async Task <List <WorkflowStepResult> > StartProvisionUserWithMultipleGroupsOrchestrator( [OrchestrationTrigger] IDurableOrchestrationContext context, ILogger logger) { var input = context.GetInput <ProvisionNewUserMultipleGroups>(); if (!context.IsReplaying) { logger.LogInformation($"Executing User provisioning workflow with InstanceId: {input.CorrelationId.ToString()}"); } var retryOptions = new RetryOptions(TimeSpan.FromSeconds(5), 3); var outputs = new List <WorkflowStepResult>(); var createUserResult = await context.CallActivityWithRetryAsync <WorkflowStepResult>(Constants.FunctionNames.Activity.CreateUser, retryOptions, (input.OperatorEmail, input.User, input.GroupIds)); outputs.Add(createUserResult); if (createUserResult.Successfull) { var assignUserToGroupTasks = new Task <WorkflowStepResult> [input.GroupIds.Count]; for (int i = 0; i < input.GroupIds.Count; i++) { assignUserToGroupTasks[i] = context.CallActivityWithRetryAsync <WorkflowStepResult>(Constants.FunctionNames.Activity.AssignUserToGroup, retryOptions, new AssignUserToGroupModel(input.GroupIds[i], createUserResult.OutputId)); } var paralellOutputs = await Task.WhenAll(assignUserToGroupTasks); outputs.AddRange(paralellOutputs); var unassignedGroups = paralellOutputs.Where(x => !x.Successfull).ToList(); if (unassignedGroups.Any()) { var unassignGroupFromUserTasks = new Task <WorkflowStepResult> [unassignedGroups.Count]; for (int i = 0; i < unassignedGroups.Count; i++) { unassignGroupFromUserTasks[i] = context.CallActivityWithRetryAsync <WorkflowStepResult>(Constants.FunctionNames.Activity.UnassignGroupFromUser, retryOptions, (createUserResult.OutputId, unassignedGroups[i].OutputId.ToString())); } } } await context.CallActivityWithRetryAsync <WorkflowStepResult>(Constants.FunctionNames.Activity.SendEmail, retryOptions, new MailItemModel( from : string.Empty, to : input.OperatorEmail, subject : $"Provisioning User {input.User.FirstName} {input.User.FirstName} with Groups {string.Join(',', input.GroupIds)}", htmlBody : outputs.ToProvisioningUserMailBody(input.User))); return(outputs); }
public static void RetryOptions_Default() { // Arrange var optionsString = string.Empty; // Act var options = new RetryOptions(optionsString); // Assert Assert.Equal(0, options.MaxRetryCount); Assert.Equal(0, options.RetryDelay); Assert.Equal(false, options.RetryFails); Assert.Equal(0, options.RetryTimeout); }
public static void RetryOptions_OptionsString_WithPrefix() { // Arrange var optionsString = "Transfer Max Retry Count = 10;Transfer Retry Delay = 5;Transfer Retry Fails = true;Transfer Retry Timeout = 250"; // Act var options = new RetryOptions(optionsString, "Transfer"); // Assert Assert.Equal(10, options.MaxRetryCount); Assert.Equal(5, options.RetryDelay); Assert.Equal(true, options.RetryFails); Assert.Equal(250, options.RetryTimeout); }
/// <summary> /// Initializes a new instance of the <see cref="InstanceIdClient"/> class. /// </summary> /// <param name="clientFactory">A default implentation of the HTTP client factory.</param> /// <param name="credential">An instance of the <see cref="GoogleCredential"/> class.</param> /// <param name="retryOptions">An instance of the <see cref="RetryOptions"/> class.</param> internal InstanceIdClient( HttpClientFactory clientFactory, GoogleCredential credential, RetryOptions retryOptions = null) { this.httpClient = new ErrorHandlingHttpClient <FirebaseMessagingException>( new ErrorHandlingHttpClientArgs <FirebaseMessagingException>() { HttpClientFactory = clientFactory.ThrowIfNull(nameof(clientFactory)), Credential = credential.ThrowIfNull(nameof(credential)), RequestExceptionHandler = MessagingErrorHandler.Instance, ErrorResponseHandler = InstanceIdErrorHandler.Instance, DeserializeExceptionHandler = MessagingErrorHandler.Instance, RetryOptions = retryOptions, }); }
public static void RetryOptions_OptionsString() { // Arrange var optionsString = "Max Retry Count = 10;Retry Delay = 5;Retry Fails = true;Retry Timeout = 250"; // Act var options = new RetryOptions(optionsString); // Assert Assert.Equal(10, options.MaxRetryCount); Assert.Equal(5, options.RetryDelay); Assert.Equal(true, options.RetryFails); Assert.Equal(250, options.RetryTimeout); }
private GoogleLogger GetLogger( IConsumer <LogEntry> consumer = null, LogLevel logLevel = LogLevel.Information, Dictionary <string, string> labels = null, IServiceProvider serviceProvider = null, string logName = null, MonitoredResource monitoredResource = null, LogTarget logTarget = null, RetryOptions retryOptions = null) { consumer = consumer ?? new Mock <IConsumer <LogEntry> >(MockBehavior.Strict).Object; monitoredResource = monitoredResource ?? MonitoredResourceBuilder.GlobalResource; logTarget = logTarget ?? s_defaultLogTarget; LoggerOptions options = LoggerOptions.Create(logLevel, logName, labels, monitoredResource, retryOptions: retryOptions); return(new GoogleLogger(consumer, logTarget, options, LogName, s_clock, serviceProvider)); }
public static async Task ProcessOrderOrchestrator( [OrchestrationTrigger] DurableOrchestrationContext context, ILogger log) { var policy = context.GetInput <WhatIfDemoDbDataContext.Policy>(); // Configuring retries for SavePolicyToDb activity var retryOptions = new RetryOptions(TimeSpan.FromSeconds(5), 3); policy = await context.CallActivityWithRetryAsync <WhatIfDemoDbDataContext.Policy>(nameof(SavePolicyToDb), retryOptions, policy); // Now let's start charging the customer via a sub-orchestration await context.CallSubOrchestratorAsync(nameof(ProcessOrderSubOrchestrator), policy); }
internal UnitOfWork( IDbConnection connection, bool transactional = false, IsolationLevel isolationLevel = IsolationLevel.ReadCommitted, RetryOptions retryOptions = null) { _connection = connection; _retryOptions = retryOptions; if (transactional) { _transaction = connection.BeginTransaction(isolationLevel); } }
public void Receive_Retry_MaxRetries_Ignore() { SetupTestReceiveThrows((timer, mockConsumer, retryConsumer) => { int[] intArray = { 1, 2, 3, 4 }; retryConsumer.Receive(intArray); timer.Call(); timer.Call(); // Extra call to ensure buffer is emptied. timer.Call(); mockConsumer.Verify(c => c.Receive(intArray), Times.Exactly(3)); }, RetryOptions.Retry(retryAttempts: 2)); }
public static void Execute_RetryFails() { // Arrange var options = new RetryOptions() { MaxRetryCount = 1, RetryFails = true }; // Act Assert.Throws <TimeoutException>(() => RetryHelper.Execute(options, () => false)); // Assert }
public static Schema ReadSchema(string connectionString) { Schema result = new Schema(); var retryOptions = new RetryOptions(30, TimeSpan.FromSeconds(60)); IConnectionFactory connectionFactory = new SqlServerConnectionFactoryWithRetry(retryOptions); using (var connection = connectionFactory.Open(connectionString)) using (var reader = new SqlReader(connection, new SqlServerParameterFactory(), new SqlServerDataAdapterFactory())) { using (var schemas = reader.Read(Resources.GetSchemasSql)) { if (schemas.Tables.Count != 1) { throw new ApplicationException("no schemas found"); } result.Schemas = schemas.Tables[0].Rows.ToArray <IItemName, ItemName>(); } using (var tables = reader.Read(Resources.GetTablesSql)) { if (tables.Tables.Count != 1) { throw new ApplicationException("no tables found"); } result.Tables = tables.Tables[0].Rows.ToArray <IEntityName, EntityName>(); } using (var procedures = reader.Read(Resources.GetProceduresSql)) { if (procedures.Tables.Count != 1) { throw new ApplicationException("no procedures found"); } result.Procedures = procedures.Tables[0].Rows.ToArray <Procedure>().ToDictionary(p => p.ToString()); } using (var procedureParams = reader.Read(Resources.GetProcedureParametersSql)) { if (procedureParams.Tables.Count != 1) { throw new ApplicationException("no parameters found"); } var parameters = procedureParams.Tables[0].Rows.ToArray <ProcedureParameter>(); foreach (var procedure in result.Procedures) { procedure.Value.ProcedureParameters = (from p in parameters where p.Schema == procedure.Value.Schema && p.Procedure == procedure.Value.Name orderby p.Order select p).ToArray(); } } } return(result); }
public static void RetryOptions_OptionsString_WithPrefix_NoMatch() { // Arrange var optionsString = "Max Retry Count = 10;Retry Delay = 5;Retry Fails = true;Retry Timeout = 250"; // Act var options = new RetryOptions(optionsString, "Transfer"); // Assert Assert.Equal(0, options.MaxRetryCount); Assert.Equal(0, options.RetryDelay); Assert.Equal(false, options.RetryFails); Assert.Equal(0, options.RetryTimeout); }
public void Receive_Retry_MaxRetries_Throw() { SetupTestReceiveThrows((timer, mockConsumer, retryConsumer) => { int[] intArray = { 1, 2, 3, 4 }; retryConsumer.Receive(intArray); timer.Call(); Assert.Throws <InvalidOperationException>(() => { timer.Call(); }); // Extra call to ensure buffer is emptied. timer.Call(); mockConsumer.Verify(c => c.Receive(intArray), Times.Exactly(3)); }, RetryOptions.Retry(exceptionHandling: ExceptionHandling.Propagate, retryAttempts: 2)); }
private static Dictionary <string, object> ToDictionary(RetryOptions retryOptions) { var result = new Dictionary <string, object>() { { "firstRetryIntervalInMilliseconds", ToIntMilliseconds(retryOptions.FirstRetryInterval) }, { "maxNumberOfAttempts", retryOptions.MaxNumberOfAttempts } }; AddOptionalValue(result, "backoffCoefficient", retryOptions.BackoffCoefficient, x => x); AddOptionalValue(result, "maxRetryIntervalInMilliseconds", retryOptions.MaxRetryInterval, ToIntMilliseconds); AddOptionalValue(result, "retryTimeoutInMilliseconds", retryOptions.RetryTimeout, ToIntMilliseconds); return(result); }
public static async Task OrchestrateConsumersFunc([OrchestrationTrigger] DurableOrchestrationContext ctx) { var changedProducts = ctx.GetInput <IEnumerable <string> >(); var retryOptions = new RetryOptions(firstRetryInterval: TimeSpan.FromSeconds(5), maxNumberOfAttempts: 3); var consumers = Environment.GetEnvironmentVariable("CONSUMERS", EnvironmentVariableTarget.Process) ?.Split('|'); var parallelTasks = consumers.Select(x => CallSendToConsumerActivityAsync(ctx, retryOptions, x, changedProducts)); await Task.WhenAll(parallelTasks); }
public async Task CallActivityWithRetryAsync_is_calling_extension_method() { var retryOptions = new RetryOptions(TimeSpan.FromSeconds(10), 5); var durableOrchestrationContextBaseMock = new Mock <IDurableOrchestrationContext> { }; durableOrchestrationContextBaseMock .Setup(x => x.CallActivityWithRetryAsync <object>(FunctionName, retryOptions, this.inputObject)) .Returns(this.taskFromTen); var result = durableOrchestrationContextBaseMock.Object.CallActivityWithRetryAsync(FunctionName, retryOptions, this.inputObject); var resultValue = await(Task <object>) result; resultValue.Should().Be(this.stateValueTen); }
public async Task <List <WorkflowStepResult> > StartProvisionUserWithSingleGroupOrchestrator( [OrchestrationTrigger] IDurableOrchestrationContext context, ILogger logger) { var input = context.GetInput <ProvisionNewUserSingleGroup>(); if (!context.IsReplaying) { logger.LogInformation($"Started User provisioning workflow with InstanceId: {input.CorrelationId.ToString()}"); } var retryOptions = new RetryOptions(TimeSpan.FromSeconds(5), 3); var outputs = new List <WorkflowStepResult>(); var createUserResult = await context.CallActivityWithRetryAsync <WorkflowStepResult>(Constants.FunctionNames.Activity.CreateUser, retryOptions, (input.OperatorEmail, input.User, new List <Guid> { input.GroupId })); outputs.Add(createUserResult); if (createUserResult.Successfull) { var assignUserToGroupResult = await context.CallActivityWithRetryAsync <WorkflowStepResult>( Constants.FunctionNames.Activity.AssignUserToGroup, retryOptions, new AssignUserToGroupModel(input.GroupId, createUserResult.OutputId)); outputs.Add(assignUserToGroupResult); if (!assignUserToGroupResult.Successfull) { var unassignGroupFromUserResult = await context.CallActivityWithRetryAsync <WorkflowStepResult>( Constants.FunctionNames.Activity.UnassignGroupFromUser, retryOptions, (createUserResult.OutputId, assignUserToGroupResult.OutputId)); outputs.Add(unassignGroupFromUserResult); } } await context.CallActivityWithRetryAsync <WorkflowStepResult>(Constants.FunctionNames.Activity.SendEmail, retryOptions, new MailItemModel( from : string.Empty, to : input.OperatorEmail, subject : $"Provisioning User {input.User.FirstName} {input.User.LastName} with Group {input.GroupId}", htmlBody : outputs.ToProvisioningUserMailBody(input.User))); return(outputs); }
public void ReceiveAsyncRespectsTheRetryPolicy(RetryOptions retryOptions) { var eventHub = "eventHubName"; var consumerGroup = "$DEFAULT"; var partition = "3"; var eventPosition = EventPosition.FromOffset(123); var trackLastEnqueued = false; var ownerLevel = 123L; var tokenValue = "123ABC"; var retryPolicy = new BasicRetryPolicy(retryOptions); var retriableException = new EventHubsException(true, "Test"); var mockConverter = new Mock <AmqpMessageConverter>(); var mockCredential = new Mock <TokenCredential>(); var mockScope = new Mock <AmqpConnectionScope>(); using var cancellationSource = new CancellationTokenSource(); mockCredential .Setup(credential => credential.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.Is <CancellationToken>(value => value == cancellationSource.Token))) .Returns(new ValueTask <AccessToken>(new AccessToken(tokenValue, DateTimeOffset.MaxValue))); mockScope .Setup(scope => scope.OpenConsumerLinkAsync( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <EventPosition>(), It.IsAny <TimeSpan>(), It.IsAny <uint>(), It.IsAny <long?>(), It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Throws(retriableException); var consumer = new AmqpConsumer(eventHub, consumerGroup, partition, eventPosition, trackLastEnqueued, ownerLevel, null, mockScope.Object, Mock.Of <AmqpMessageConverter>(), retryPolicy); Assert.That(async() => await consumer.ReceiveAsync(100, null, cancellationSource.Token), Throws.InstanceOf(retriableException.GetType())); mockScope .Verify(scope => scope.OpenConsumerLinkAsync( It.Is <string>(value => value == consumerGroup), It.Is <string>(value => value == partition), It.Is <EventPosition>(value => value == eventPosition), It.IsAny <TimeSpan>(), It.IsAny <uint>(), It.Is <long?>(value => value == ownerLevel), It.Is <bool>(value => value == trackLastEnqueued), It.IsAny <CancellationToken>()), Times.Exactly(1 + retryOptions.MaximumRetries)); }
public static async Task ActivityWithRetry_NullRetryOptions([OrchestrationTrigger] DurableOrchestrationContext ctx) { string message = ctx.GetInput <string>(); if (string.IsNullOrEmpty(message)) { // This throw happens directly in the orchestration. throw new ArgumentNullException(nameof(message)); } RetryOptions options = null; // This throw happens in the implementation of an activity. await ctx.CallActivityWithRetryAsync(nameof(TestActivities.ThrowActivity), options, message); }