// Helper method to retrieve retrieve the CloudBlobClient object in order to interact with the storage account
// The method reads an environment variable that is used to store the connection string to the storage account.
// The retry policy on the CloudBlobClient object is set to an Exponential retry policy with a back off of 2 seconds
// and a max attempts of 10 times.
public static CloudBlobClient GetCloudBlobClient()
{
// Load the connection string for use with the application. The storage connection string is stored
// in an environment variable on the machine running the application called storageconnectionstring.
// If the environment variable is created after the application is launched in a console or with Visual
// studio the shell needs to be closed and reloaded to take the environment variable into account.
string storageConnectionString = Environment.GetEnvironmentVariable("storageconnectionstring");
if (storageConnectionString == null)
{
Console.WriteLine(
"A connection string has not been defined in the system environment variables. " +
"Add a environment variable name 'storageconnectionstring' with the actual storage " +
"connection string as a value.");
}
try
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(2), 10);
blobClient.DefaultRequestOptions.RetryPolicy = exponentialRetryPolicy;
return(blobClient);
}
catch (StorageException ex)
{
Console.WriteLine("Error returned from the service: {0}", ex.Message);
throw;
}
}
private string DownloadSamplePackage(PackageId packageId, NuGetVersion version,
NuGetPackageDownloader nuGetPackageDownloader)
{
return(ExponentialRetry.ExecuteWithRetry(
DownloadMostRecentSamplePackageFromPublicFeed,
result => result != null,
3,
() => ExponentialRetry.Timer(ExponentialRetry.Intervals),
"Run command while retry transient restore error")
.ConfigureAwait(false).GetAwaiter().GetResult());
string DownloadMostRecentSamplePackageFromPublicFeed()
{
try
{
return(nuGetPackageDownloader.DownloadPackageAsync(
packageId, version, includePreview: true,
packageSourceLocation: new PackageSourceLocation(
sourceFeedOverrides: new[] { "https://api.nuget.org/v3/index.json" })).GetAwaiter()
.GetResult());
}
catch (Exception)
{
return(null);
}
}
}
public void CreateConsumerInvokesTheTransportClient()
{
var transportClient = new ObservableTransportClientMock();
var client = new InjectableTransportClientMock(transportClient, "Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessKeyName=DummyKey;SharedAccessKey=[not_real];EntityPath=fake");
var expectedOptions = new EventHubConsumerOptions {
Retry = Retry.Default
};
var expectedPosition = EventPosition.FromOffset(65);
var expectedPartition = "2123";
var expectedConsumerGroup = EventHubConsumer.DefaultConsumerGroup;
client.CreateConsumer(expectedConsumerGroup, expectedPartition, expectedPosition, expectedOptions);
(var actualConsumerGroup, var actualPartition, var actualPosition, var actualOptions) = transportClient.CreateConsumerCalledWith;
Assert.That(actualPartition, Is.EqualTo(expectedPartition), "The partition should have been passed.");
Assert.That(actualConsumerGroup, Is.EqualTo(expectedConsumerGroup), "The consumer groups should match.");
Assert.That(actualPosition.Offset, Is.EqualTo(expectedPosition.Offset), "The event position to receive should match.");
Assert.That(actualOptions, Is.Not.Null, "The consumer options should have been set.");
Assert.That(actualPosition.Offset, Is.EqualTo(expectedPosition.Offset), "The event position to receive should match.");
Assert.That(actualOptions.OwnerLevel, Is.EqualTo(expectedOptions.OwnerLevel), "The owner levels should match.");
Assert.That(actualOptions.Identifier, Is.EqualTo(expectedOptions.Identifier), "The identifiers should match.");
Assert.That(actualOptions.PrefetchCount, Is.EqualTo(expectedOptions.PrefetchCount), "The prefetch counts should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)actualOptions.Retry, (ExponentialRetry)expectedOptions.Retry), "The retries should match.");
Assert.That(actualOptions.MaximumReceiveWaitTimeOrDefault, Is.EqualTo(expectedOptions.MaximumReceiveWaitTimeOrDefault), "The wait times should match.");
}
/// <summary>
/// Saves the document's content to the given file path.
/// </summary>
public void Save(string path)
{
//On Windows:
// Readers will prevent the file from being overwritten due to FileShare.Read.
// Readers can read in parallel, but when there's contention with a writer, the retrying will kick in to resolve it.
//On Unix:
// FileShare.Read does nothing, but...
// File.Replace is implemented with rename system call that will mean that even though writers can overwrite while
// reading is happening, each reader will see file before or after overwrite, not in between
EnsureContent();
var tempPath = Path.Combine(Path.GetDirectoryName(path), Path.GetRandomFileName());
using (var stream = File.Open(tempPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
Save(stream);
}
ExponentialRetry.ExecuteWithRetryOnIOException(() =>
{
if (File.Exists(path))
{
File.Replace(
sourceFileName: tempPath,
destinationFileName: path,
destinationBackupFileName: null,
ignoreMetadataErrors: true);
}
else
{
File.Move(sourceFileName: tempPath, destFileName: path);
}
}, maxRetryCount: 3);
}
internal static MemoryStream GetAssetFromIntermediaryStorage(string containerName, string fileName)
{
//Bitmap sourceBitmap;
CloudBlobClient blobClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.IntermediateStorage.CreateCloudBlobClient();
//Create and set retry policy
IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromMilliseconds(500), 8);
blobClient.DefaultRequestOptions.RetryPolicy = exponentialRetryPolicy;
//Creat/Connect to the Blob Container
blobClient.GetContainerReference(containerName).CreateIfNotExists(BlobContainerPublicAccessType.Blob); //<-- Create and make public
CloudBlobContainer blobContainer = blobClient.GetContainerReference(containerName);
//Get reference to the picture blob or create if not exists.
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(fileName);
//using(var ms = new MemoryStream())
//{
var ms = new MemoryStream();
blockBlob.DownloadToStream(ms);
return(ms);
//sourceBitmap = new Bitmap(ms);
//}
//return sourceBitmap;
}
public void CreateEventSenderCreatesDefaultWhenNoOptionsArePassed()
{
var clientOptions = new EventHubClientOptions
{
Retry = new ExponentialRetry(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), 5),
DefaultTimeout = TimeSpan.FromHours(24)
};
var expected = new SenderOptions
{
Retry = clientOptions.Retry,
Timeout = clientOptions.DefaultTimeout
};
var actual = default(SenderOptions);
var connectionString = "Endpoint=value.com;SharedAccessKeyName=[value];SharedAccessKey=[value];EntityPath=[value]";
var mockClient = new Mock <EventHubClient>(connectionString, clientOptions)
{
CallBase = true
};
mockClient
.Protected()
.Setup <EventSender>("BuildEventSender", ItExpr.IsAny <ConnectionType>(), ItExpr.IsAny <string>(), ItExpr.IsAny <SenderOptions>())
.Returns(Mock.Of <EventSender>())
.Callback <ConnectionType, string, SenderOptions>((type, path, options) => actual = options);
mockClient.Object.CreateSender();
Assert.That(actual, Is.Not.Null, "The sender options should have been set.");
Assert.That(actual.PartitionId, Is.EqualTo(expected.PartitionId), "The partition identifiers should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)actual.Retry, (ExponentialRetry)expected.Retry), "The retries should match.");
Assert.That(actual.TimeoutOrDefault, Is.EqualTo(expected.TimeoutOrDefault), "The timeouts should match.");
}
private void BackupFile(CloudPageBlob fileInfo, ExponentialRetry retryPolicy)
{
var backupBlobName = fileInfo.Name + ".bak";
var backupBlob = this._container.GetPageBlobReference(backupBlobName);
backupBlob.StartCopyFromBlob(fileInfo, options: new BlobRequestOptions {
RetryPolicy = retryPolicy
});
while (true) // wait for copy operation to complete
{
backupBlob.FetchAttributes();
switch (backupBlob.CopyState.Status)
{
case CopyStatus.Pending:
Thread.Sleep(500);
break;
case CopyStatus.Success:
return;
case CopyStatus.Aborted:
this.BackupFile(fileInfo, retryPolicy); // try again
return;
case CopyStatus.Invalid:
case CopyStatus.Failed:
throw new InvalidOperationException(string.Format("Failed to backup {0} to {1}. Status: {2}. Description: {3}",
fileInfo.Name, backupBlobName, backupBlob.CopyState.Status, backupBlob.CopyState.StatusDescription));
default:
throw new ArgumentOutOfRangeException();
}
}
}
private string DownloadSamplePackage(PackageId packageId)
{
NuGetPackageDownloader nuGetPackageDownloader = new NuGetPackageDownloader(_tempDirectory, null,
new MockFirstPartyNuGetPackageSigningVerifier(),
_logger, restoreActionConfig: new RestoreActionConfig(NoCache: true));
return(ExponentialRetry.ExecuteWithRetry <string>(
action: DownloadMostRecentSamplePackageFromPublicFeed,
shouldStopRetry: result => result != null,
maxRetryCount: 3,
timer: () => ExponentialRetry.Timer(ExponentialRetry.Intervals),
taskDescription: "Run command while retry transient restore error")
.ConfigureAwait(false).GetAwaiter().GetResult());
string DownloadMostRecentSamplePackageFromPublicFeed()
{
try
{
return(nuGetPackageDownloader.DownloadPackageAsync(
new PackageId("Microsoft.iOS.Ref"), null, includePreview: true,
packageSourceLocation: new PackageSourceLocation(
sourceFeedOverrides: new[] { "https://api.nuget.org/v3/index.json" })).GetAwaiter()
.GetResult());
}
catch (Exception)
{
return(null);
}
}
}
public void CloneProducesACopy()
{
var options = new ReceiverOptions
{
ConsumerGroup = "custom$consumer",
BeginReceivingAt = EventPosition.FromOffset(65),
ExclusiveReceiverPriority = 99,
Retry = new ExponentialRetry(TimeSpan.FromSeconds(4), TimeSpan.FromSeconds(5), 6),
DefaultMaximumReceiveWaitTime = TimeSpan.FromMinutes(65),
Identifier = "an_event_receiver"
};
var clone = options.Clone();
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(clone.ConsumerGroup, Is.EqualTo(options.ConsumerGroup), "The consumer group of the clone should match.");
Assert.That(clone.BeginReceivingAt, Is.EqualTo(options.BeginReceivingAt), "The position to begin reading events of the clone should match.");
Assert.That(clone.ExclusiveReceiverPriority, Is.EqualTo(options.ExclusiveReceiverPriority), "The exclusive priority of the clone should match.");
Assert.That(clone.DefaultMaximumReceiveWaitTime, Is.EqualTo(options.DefaultMaximumReceiveWaitTime), "The default maximum wait time of the clone should match.");
Assert.That(clone.Identifier, Is.EqualTo(options.Identifier), "The identifier of the clone should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)clone.Retry, (ExponentialRetry)options.Retry), "The retry of the clone should be considered equal.");
Assert.That(clone.Retry, Is.Not.SameAs(options.Retry), "The retry of the clone should be a copy, not the same instance.");
}
public void CreateProducerCreatesDefaultWhenOptionsAreNotSet()
{
var clientOptions = new EventHubClientOptions
{
Retry = new ExponentialRetry(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), 5),
DefaultTimeout = TimeSpan.FromHours(24)
};
var producerOptions = new EventHubProducerOptions
{
PartitionId = "123",
Retry = null,
Timeout = TimeSpan.Zero
};
var expected = new EventHubProducerOptions
{
PartitionId = producerOptions.PartitionId,
Retry = clientOptions.Retry,
Timeout = clientOptions.DefaultTimeout
};
var connectionString = "Endpoint=value.com;SharedAccessKeyName=[value];SharedAccessKey=[value];EntityPath=[value]";
var mockClient = new ReadableOptionsMock(connectionString, clientOptions);
mockClient.CreateProducer(producerOptions);
Assert.That(mockClient.ProducerOptions, Is.Not.Null, "The producer options should have been set.");
Assert.That(mockClient.ProducerOptions, Is.Not.SameAs(producerOptions), "The options should have been cloned.");
Assert.That(mockClient.ProducerOptions.PartitionId, Is.EqualTo(expected.PartitionId), "The partition identifiers should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)mockClient.ProducerOptions.Retry, (ExponentialRetry)expected.Retry), "The retries should match.");
Assert.That(mockClient.ProducerOptions.TimeoutOrDefault, Is.EqualTo(expected.TimeoutOrDefault), "The timeouts should match.");
}
private static void ClearPlatformStorageAccounts()
{
//var response = new DataAccessResponseType { isSuccess = false };
//Loop through all tables named by schema for this account and delete
CloudTableClient cloudTableClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.PlatformStorage.CreateCloudTableClient();
//Create and set retry policy
IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(1), 16);
//IRetryPolicy linearRetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 3);
cloudTableClient.DefaultRequestOptions.RetryPolicy = exponentialRetryPolicy;
IEnumerable <CloudTable> tables = cloudTableClient.ListTables();
foreach (CloudTable table in tables)
{
try
{
table.Delete();
}
catch
{
//response.isSuccess = false;
}
}
}
public async Task BatchRequestRetryPolicyNoExceptionNoRetries()
{
TimeSpan deltaBackoff = TimeSpan.FromSeconds(0);
const int maxRetries = 5;
int serviceRequestFuncCallCount = 0;
var request = new BatchRequest <
JobScheduleListOptions,
AzureOperationResponse <IPage <ProxyModels.CloudJobSchedule> > >(null, CancellationToken.None);
request.ServiceRequestFunc = (token) =>
{
++serviceRequestFuncCallCount;
return(Task.FromResult(default(AzureOperationResponse <IPage <ProxyModels.CloudJobSchedule> >)));
};
IRetryPolicy policy = new ExponentialRetry(deltaBackoff, maxRetries);
request.RetryPolicy = policy;
AzureOperationResponse <IPage <ProxyModels.CloudJobSchedule> > result = await request.ExecuteRequestAsync();
Assert.Null(result);
Assert.Equal(1, serviceRequestFuncCallCount);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
try
{
/// On start up, CreateIfNotExists CloudBreadAdminLog table on Azure Table Storage
/// On start up, CreateIfNotExists messagestoadminlog table on Azure Queue Service
if (globalVal.StorageConnectionString != "")
{
/// this table is used for CloudBread admin log saving
/// Azure Storage connection retry policy
var retryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(2), 10);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(globalVal.StorageConnectionString);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
tableClient.DefaultRequestOptions.RetryPolicy = retryPolicy;
var cloudTable = tableClient.GetTableReference("CloudBreadAdminLog");
cloudTable.CreateIfNotExists();
cloudTable = tableClient.GetTableReference("CloudBreadAdminErrorLog");
cloudTable.CreateIfNotExists();
/// this queue is used for CloudBread queue method admin log saving
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
queueClient.DefaultRequestOptions.RetryPolicy = retryPolicy;
CloudQueue queue = queueClient.GetQueueReference("messagestoadminlog"); /// must be lowercase
queue.CreateIfNotExists();
}
}
catch (System.Exception ex)
{
throw ex;
}
}
public async Task ExponentialRetryAbortsRetriesAfterMaxRetryCount()
{
const int delayInSeconds = 3;
TimeSpan interval = TimeSpan.FromSeconds(delayInSeconds);
const int maxRetries = 5;
ExponentialRetry exponentialRetry = new ExponentialRetry(interval, maxRetries);
TimeoutException timeoutException = new TimeoutException();
OperationContext context = new OperationContext();
RetryDecision retryDecision = null;
int requestCount = 0;
while (retryDecision == null || retryDecision.ShouldRetry)
{
context.RequestResults.Add(new RequestResult(new RequestInformation(), timeoutException));
retryDecision = await exponentialRetry.ShouldRetryAsync(timeoutException, context);
Assert.NotNull(retryDecision);
if (retryDecision.ShouldRetry)
{
TimeSpan expectedDelay = TimeSpan.FromSeconds(Math.Pow(2, requestCount) * delayInSeconds);
Assert.Equal(expectedDelay, retryDecision.RetryDelay);
}
++requestCount;
}
Assert.Equal(maxRetries, requestCount - 1); //request count is retry count + 1
}
public void CreateConsumerCreatesDefaultWhenNoOptionsArePassed()
{
var clientOptions = new EventHubClientOptions
{
Retry = new ExponentialRetry(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), 5),
DefaultTimeout = TimeSpan.FromHours(24)
};
var expectedOptions = new EventHubConsumerOptions
{
Retry = clientOptions.Retry,
DefaultMaximumReceiveWaitTime = clientOptions.DefaultTimeout
};
var expectedConsumerGroup = EventHubConsumer.DefaultConsumerGroup;
var expectedPartition = "56767";
var expectedPosition = EventPosition.FromEnqueuedTime(DateTime.Parse("2015-10-27T12:00:00Z"));
var connectionString = "Endpoint=value.com;SharedAccessKeyName=[value];SharedAccessKey=[value];EntityPath=[value]";
var mockClient = new ReadableOptionsMock(connectionString, clientOptions);
mockClient.CreateConsumer(expectedConsumerGroup, expectedPartition, expectedPosition);
var actualOptions = mockClient.ConsumerOptions;
Assert.That(actualOptions, Is.Not.Null, "The consumer options should have been set.");
Assert.That(actualOptions.OwnerLevel, Is.EqualTo(expectedOptions.OwnerLevel), "The owner levels should match.");
Assert.That(actualOptions.Identifier, Is.EqualTo(expectedOptions.Identifier), "The identifiers should match.");
Assert.That(actualOptions.PrefetchCount, Is.EqualTo(expectedOptions.PrefetchCount), "The prefetch counts should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)actualOptions.Retry, (ExponentialRetry)expectedOptions.Retry), "The retries should match.");
Assert.That(actualOptions.MaximumReceiveWaitTimeOrDefault, Is.EqualTo(expectedOptions.MaximumReceiveWaitTimeOrDefault), "The wait times should match.");
}
public static DataAccessResponseType DeleteImageBlobs(string storagePartition, string containerName, string blobPath)
{
//CloudBlobClient blobClient = Sahara.Core.Settings.Azure.Storage.StorageConnections.AccountsStorage.CreateCloudBlobClient();
CloudBlobClient blobClient = Settings.Azure.Storage.GetStoragePartitionAccount(storagePartition).CreateCloudBlobClient();
//Create and set retry policy
IRetryPolicy exponentialRetryPolicy = new ExponentialRetry(TimeSpan.FromMilliseconds(400), 6);
blobClient.DefaultRequestOptions.RetryPolicy = exponentialRetryPolicy;
//Creat/Connect to the Blob Container
blobClient.GetContainerReference(containerName).CreateIfNotExists(BlobContainerPublicAccessType.Blob); //<-- Create and make public
CloudBlobContainer blobContainer = blobClient.GetContainerReference(containerName);
var blockBlobMainUri = blobPath;
var blockBlobSMUri = blobPath.Replace(".jpg", "_sm.jpg").Replace(".gif", "_sm.gif").Replace(".png", "_sm.png");
var blockBlobXSUri = blobPath.Replace(".jpg", "_xs.jpg").Replace(".gif", "_xs.gif").Replace(".png", "_xs.png");
//Get references to the blobs.
CloudBlockBlob blockBlobMain = blobContainer.GetBlockBlobReference(blockBlobMainUri);
CloudBlockBlob blockBlobSM = blobContainer.GetBlockBlobReference(blockBlobSMUri);
CloudBlockBlob blockBlobXS = blobContainer.GetBlockBlobReference(blockBlobXSUri);
try { blockBlobMain.Delete(); } catch { }
try { blockBlobSM.Delete(); } catch { }
try { blockBlobXS.Delete(); } catch { }
return(new DataAccessResponseType {
isSuccess = true
});
}
public void CreateConsumerCreatesDefaultWhenOptionsAreNotSet()
{
var clientOptions = new EventHubClientOptions
{
Retry = new ExponentialRetry(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), 5),
DefaultTimeout = TimeSpan.FromHours(24)
};
var expectedOptions = new EventHubConsumerOptions
{
OwnerLevel = 251,
Identifier = "Bob",
PrefetchCount = 600,
Retry = clientOptions.Retry,
DefaultMaximumReceiveWaitTime = clientOptions.DefaultTimeout
};
var expectedConsumerGroup = "SomeGroup";
var expectedPartition = "56767";
var expectedPosition = EventPosition.FromSequenceNumber(123);
var connectionString = "Endpoint=value.com;SharedAccessKeyName=[value];SharedAccessKey=[value];EntityPath=[value]";
var mockClient = new ReadableOptionsMock(connectionString, clientOptions);
mockClient.CreateConsumer(expectedConsumerGroup, expectedPartition, expectedPosition, expectedOptions);
var actualOptions = mockClient.ConsumerOptions;
Assert.That(actualOptions, Is.Not.Null, "The consumer options should have been set.");
Assert.That(actualOptions, Is.Not.SameAs(expectedOptions), "A clone of the options should have been made.");
Assert.That(actualOptions.OwnerLevel, Is.EqualTo(expectedOptions.OwnerLevel), "The owner levels should match.");
Assert.That(actualOptions.Identifier, Is.EqualTo(expectedOptions.Identifier), "The identifiers should match.");
Assert.That(actualOptions.PrefetchCount, Is.EqualTo(expectedOptions.PrefetchCount), "The prefetch counts should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)actualOptions.Retry, (ExponentialRetry)expectedOptions.Retry), "The retries should match.");
Assert.That(actualOptions.MaximumReceiveWaitTimeOrDefault, Is.EqualTo(expectedOptions.MaximumReceiveWaitTimeOrDefault), "The wait times should match.");
}
public AzureStorageConfigurationBuilder(CloudStorageAccount account)
{
// defaults
// Retry up to 450 times with max 2 seconds delay between each retry (so wait up to 15 mins)
var retry = new ExponentialRetry(TimeSpan.FromSeconds(0.2), 15);
this._queueConfig = client =>
{
client.RetryPolicy = retry;
client.MaximumExecutionTime = TimeSpan.FromMinutes(15);
client.ServerTimeout = TimeSpan.FromMinutes(15);
};
this._blobConfig = client =>
{
client.RetryPolicy = retry;
client.MaximumExecutionTime = TimeSpan.FromMinutes(15);
client.ServerTimeout = TimeSpan.FromMinutes(15);
};
this._tableConfig = client => client.RetryPolicy = retry;
if (account.Credentials.AccountName == "devstoreaccount1")
{
this._blobConfig += client =>
{
// http://stackoverflow.com/questions/4897826/
// local dev store works poorly with multi-thread uploads
client.ParallelOperationThreadCount = 1;
};
}
this._account = account;
this._accountId = account.Credentials.AccountName;
}
public async Task <string> GetTokenForInstallation(long installationId)
{
if (TryGetCachedToken(installationId, out AccessToken cachedToken))
{
_logger.LogInformation($"Cached token obtained for GitHub installation {installationId}. Expires at {cachedToken.ExpiresAt}.");
return(cachedToken.Token);
}
return(await ExponentialRetry.RetryAsync(
async() =>
{
string jwt = GetAppToken();
var product = new ProductHeaderValue(Options.ApplicationName, Options.ApplicationVersion);
var appClient = new Octokit.GitHubClient(product)
{
Credentials = new Credentials(jwt, AuthenticationType.Bearer)
};
AccessToken token = await appClient.GitHubApps.CreateInstallationToken(installationId);
_logger.LogInformation($"New token obtained for GitHub installation {installationId}. Expires at {token.ExpiresAt}.");
UpdateTokenCache(installationId, token);
return token.Token;
},
ex => _logger.LogError(ex, $"Failed to get a github token for installation id {installationId}, retrying"),
ex => ex is ApiException && ((ApiException)ex).StatusCode == HttpStatusCode.InternalServerError));
}
public void CreatePartitionReceiverCreatesDefaultWhenNoOptionsArePassed()
{
var clientOptions = new EventHubClientOptions
{
Retry = new ExponentialRetry(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), 5),
DefaultTimeout = TimeSpan.FromHours(24)
};
var expectedOptions = new ReceiverOptions
{
Retry = clientOptions.Retry,
DefaultMaximumReceiveWaitTime = clientOptions.DefaultTimeout
};
var expectedPartition = "56767";
var connectionString = "Endpoint=value.com;SharedAccessKeyName=[value];SharedAccessKey=[value];EntityPath=[value]";
var mockClient = new ReadableOptionsMock(connectionString, clientOptions);
var receiver = mockClient.CreateReceiver(expectedPartition);
var actualOptions = mockClient.ReceiverOptions;
Assert.That(receiver.PartitionId, Is.EqualTo(expectedPartition), "The partition should match.");
Assert.That(actualOptions, Is.Not.Null, "The receiver options should have been set.");
Assert.That(actualOptions.BeginReceivingAt.Offset, Is.EqualTo(expectedOptions.BeginReceivingAt.Offset), "The beginning position to receive should match.");
Assert.That(actualOptions.ConsumerGroup, Is.EqualTo(expectedOptions.ConsumerGroup), "The consumer groups should match.");
Assert.That(actualOptions.ExclusiveReceiverPriority, Is.EqualTo(expectedOptions.ExclusiveReceiverPriority), "The exclusive priorities should match.");
Assert.That(actualOptions.Identifier, Is.EqualTo(expectedOptions.Identifier), "The identifiers should match.");
Assert.That(actualOptions.PrefetchCount, Is.EqualTo(expectedOptions.PrefetchCount), "The prefetch counts should match.");
Assert.That(ExponentialRetry.HaveSameConfiguration((ExponentialRetry)actualOptions.Retry, (ExponentialRetry)expectedOptions.Retry), "The retries should match.");
Assert.That(actualOptions.MaximumReceiveWaitTimeOrDefault, Is.EqualTo(expectedOptions.MaximumReceiveWaitTimeOrDefault), "The wait times should match.");
}
internal static IRetryPolicy GetRetryPolicy(string policyName, TimeSpan deltaBackoff, int maxAttempts)
{
IRetryPolicy policy;
switch (policyName)
{
case "Exponential":
policy = new ExponentialRetry(deltaBackoff, maxAttempts);
break;
case "Linear":
policy = new LinearRetry(deltaBackoff, maxAttempts);
break;
case "NoRetry":
policy = new NoRetry();
break;
default:
policy = new NoRetry();
break;
}
return(policy);
}
/// Timer trigger of CBProcessBPITrigger
public static void CBProcessBPITrigger([TimerTrigger("0 5 12 * * *")] TimerInfo timer) // every day 12:05
{
try
{
Console.WriteLine("CB task timer starting at CBProcessBPITrigger");
// send message to cloudbread-batch queue
/// Azure Queue Storage connection retry policy
var queueStorageRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(2), 10);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ConnectionString);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
queueClient.DefaultRequestOptions.RetryPolicy = queueStorageRetryPolicy;
CloudQueue queue = queueClient.GetQueueReference("cloudbread-batch");
/// send message to queue - Dormant
CBBatchJob bj = new CBBatchJob();
bj.JobID = "CDBatch-BPI";
bj.JobTitle = "Best Purchased Item Batch";
bj.JobTriggerDT = DateTimeOffset.UtcNow.ToString();
bj.JobTrackID = Guid.NewGuid().ToString();
queue.AddMessage(new CloudQueueMessage(JsonConvert.SerializeObject(bj)));
Console.WriteLine("CB task timer done at CBProcessBPITrigger");
}
catch (Exception ex)
{
throw ex;
}
}
//////////////////////////////////////////////////////////////
/// @brief Timer trigger of testProcess. one time test on startup and every two min(set it "0 */2 * * * *") . trigger
//////////////////////////////////////////////////////////////
public static void testProcess([TimerTrigger("0 */5 * * * *", RunOnStartup = true)] TimerInfo timer)
{
try
{
Console.WriteLine("CB test timer starting");
CBBatchJob bj = new CBBatchJob();
bj.JobID = "test";
bj.JobTitle = "this is developer test job";
bj.JobTriggerDT = DateTimeOffset.UtcNow.ToString();
bj.JobTrackID = Guid.NewGuid().ToString();
/// send message to cloudbread-batch queue
/// Azure Queue Storage connection retry policy
var queueStorageRetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(2), 10);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ConnectionString);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
queueClient.DefaultRequestOptions.RetryPolicy = queueStorageRetryPolicy;
CloudQueue queue = queueClient.GetQueueReference("cloudbread-batch");
queue.AddMessage(new CloudQueueMessage(JsonConvert.SerializeObject(bj)));
Console.WriteLine("CB test timer done");
}
catch (Exception ex)
{
throw ex;
}
}
public BlobStorageDataBus(CloudBlobContainer container, DataBusSettings settings, IAsyncTimer timer)
{
this.container = container;
this.settings = settings;
this.timer = timer;
retryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(settings.BackOffInterval), settings.MaxRetries);
}
public void ShouldRetry_ShouldReturn_ExponentiallyIncreasingRetryInterval(uint currentRetryCount, double min, double max)
{
var retry = new ExponentialRetry(TimeSpan.FromSeconds(4), 3);
retry.ShouldRetry(currentRetryCount, HttpStatusCode.RequestTimeout, out var retryInterval);
Assert.InRange(retryInterval.TotalSeconds, min, max);
}
public void CloneProducesACopy()
{
var retry = new ExponentialRetry(TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(2), 123);
var clone = retry.Clone() as ExponentialRetry;
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(ExponentialRetry.HaveSameConfiguration(clone, retry), Is.True, "The clone should be considered equal.");
Assert.That(clone, Is.Not.SameAs(retry), "The clone should be a copy, not the same instance.");
}
public void ExponentialRetryPropertiesSetCorrect()
{
TimeSpan interval = TimeSpan.FromSeconds(5);
const int maxRetries = 10;
ExponentialRetry exponentialRetry = new ExponentialRetry(interval, maxRetries);
Assert.Equal(interval, exponentialRetry.DeltaBackoff);
Assert.Equal(maxRetries, exponentialRetry.MaximumRetries);
}
public void TestExponentialRetry()
{
IReconnectRetryPolicy exponentialRetry = new ExponentialRetry(5000);
Assert.False(exponentialRetry.ShouldRetry(0, 0));
Assert.True(exponentialRetry.ShouldRetry(1, 5600));
Assert.True(exponentialRetry.ShouldRetry(2, 6050));
Assert.False(exponentialRetry.ShouldRetry(2, 4050));
}
public async Task ExponentialRetryDoesNotRetryOnValidationExceptions()
{
TimeSpan deltaBackoff = TimeSpan.FromSeconds(1);
const int maxRetries = 3;
IRetryPolicy policy = new ExponentialRetry(deltaBackoff, maxRetries);
await this.AssertPolicyDoesNotRetryOnValidationExceptions(policy);
}
/// <summary>
/// Initializes a new instance of the <see cref="TransferRetryPolicy"/> class.
/// </summary>
/// <param name="deltaBackoff">Back-off in ExponentialRetry retry policy.</param>
/// <param name="maxAttemptsXMsError">Max retry count when meets x-ms error.</param>
/// <param name="maxAttemptsOtherError">Max retry count when meets non x-ms error.</param>
public TransferRetryPolicy(TimeSpan deltaBackoff, int maxAttemptsXMsError, int maxAttemptsOtherError)
{
Debug.Assert(
maxAttemptsXMsError >= maxAttemptsOtherError,
"We should retry more times when meets x-ms errors than the other errors.");
this.retryPolicy = new ExponentialRetry(deltaBackoff, maxAttemptsXMsError);
this.maxAttemptsOtherError = maxAttemptsOtherError;
}
