public BlobClientOptions GetOptions(bool parallelRange = false)
{
var options = new BlobClientOptions(_serviceVersion)
{
Diagnostics = { IsLoggingEnabled = true },
Retry =
{
Mode = RetryMode.Exponential,
MaxRetries = Storage.Constants.MaxReliabilityRetries,
Delay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.01 : 1),
MaxDelay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.1 : 60),
NetworkTimeout = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 100 : 400),
},
};
if (Mode != RecordedTestMode.Live)
{
options.AddPolicy(new RecordedClientRequestIdPolicy(Recording, parallelRange), HttpPipelinePosition.PerCall);
}
return(InstrumentClientOptions(options));
}
public BlobClientOptions GetOptions()
{
var options = new BlobClientOptions
{
Diagnostics = { IsLoggingEnabled = true },
Retry =
{
Mode = RetryMode.Exponential,
MaxRetries = Constants.MaxReliabilityRetries,
Delay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.01 : 0.5),
MaxDelay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.1 : 10)
},
Transport = GetTransport()
};
if (Mode != RecordedTestMode.Live)
{
options.AddPolicy(new RecordedClientRequestIdPolicy(Recording), HttpPipelinePosition.PerCall);
}
return(InstrumentClientOptions(options));
}
static async Task Main(string[] args)
{
var connectionString = Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING");
var blobClientOptions = new BlobClientOptions();
// When using an HTTPS _faultInjectorUri, you must either trust the .NET developer certificate,
// or uncomment the following line to disable SSL validation.
// blobClientOptions.Transport = new HttpClientTransport(new System.Net.Http.HttpClient(new System.Net.Http.HttpClientHandler()
// {
// ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true
// }));
// FaultInjectionPolicy should be per-retry to run as late as possible in the pipeline. For example, some
// clients compute a request signature as a per-retry policy, and FaultInjectionPolicy should run after the
// signature is computed to avoid altering the signature.
blobClientOptions.AddPolicy(new FaultInjectionPolicy(_faultInjectorUri), HttpPipelinePosition.PerRetry);
// The request can be redirected to the HttpFaultInjector using either a Transport or a Policy.
// A Policy is recommended by default.
// blobClientOptions.Transport = new FaultInjectionTransport(blobClientOptions.Transport, _faultInjectorUri);
// Use a single fast retry instead of the default settings
blobClientOptions.Retry.Mode = RetryMode.Fixed;
blobClientOptions.Retry.Delay = TimeSpan.Zero;
blobClientOptions.Retry.MaxRetries = 1;
var blobClient = new BlobClient(connectionString, "sample", "sample.txt", blobClientOptions);
Console.WriteLine("Sending request...");
var response = await blobClient.DownloadAsync();
var content = (new StreamReader(response.Value.Content)).ReadToEnd();
Console.WriteLine($"Content: {content}");
}
public static void AddPolicy(this BlobClientOptions options, HttpPipelinePolicy policy, HttpPipelinePosition position)
{
options.AddPolicy(position, policy);
}
public async Task ProcessEvents()
{
#region Snippet:EventHubs_Processor_Sample06_ChooseStorageVersion
var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>";
var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>";
/*@@*/
/*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString;
/*@@*/ blobContainerName = _storageScope.ContainerName;
var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>";
var eventHubName = "<< NAME OF THE EVENT HUB >>";
var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>";
/*@@*/
/*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
/*@@*/ eventHubName = _eventHubScope.EventHubName;
/*@@*/ consumerGroup = _eventHubScope.ConsumerGroups.First();
var storageClientOptions = new BlobClientOptions();
storageClientOptions.AddPolicy(
new StorageApiVersionPolicy(),
HttpPipelinePosition.PerCall);
var storageClient = new BlobContainerClient(
storageConnectionString,
blobContainerName,
storageClientOptions);
var processor = new EventProcessorClient(
storageClient,
consumerGroup,
eventHubsConnectionString,
eventHubName);
try
{
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(30));
// The event handlers are not relevant for this sample; for
// illustration, they're delegating the implementation to the
// host application.
processor.ProcessEventAsync += Application.ProcessorEventHandler;
processor.ProcessErrorAsync += Application.ProcessorErrorHandler;
try
{
await processor.StartProcessingAsync(cancellationSource.Token);
await Task.Delay(Timeout.Infinite, cancellationSource.Token);
}
catch (TaskCanceledException)
{
// This is expected if the cancellation token is
// signaled.
}
finally
{
// This may take up to the length of time defined
// as part of the configured TryTimeout of the processor;
// by default, this is 60 seconds.
await processor.StopProcessingAsync();
}
}
catch
{
// The processor will automatically attempt to recover from any
// failures, either transient or fatal, and continue processing.
// Errors in the processor's operation will be surfaced through
// its error handler.
//
// If this block is invoked, then something external to the
// processor was the source of the exception.
}
finally
{
// It is encouraged that you unregister your handlers when you have
// finished using the Event Processor to ensure proper cleanup. This
// is especially important when using lambda expressions or handlers
// in any form that may contain closure scopes or hold other references.
processor.ProcessEventAsync -= Application.ProcessorEventHandler;
processor.ProcessErrorAsync -= Application.ProcessorErrorHandler;
}
#endregion
}
static async Task Main(string[] args)
{
// Listen to events produced from all Azure SDK clients
using AzureEventSourceListener listener = AzureEventSourceListener.CreateConsoleLogger();
// We don't want to use connection string, since it is highly insecure
//string connectionString = Environment.GetEnvironmentVariable("ITPRODEV_STORAGE_ACCOUNT_CONNECTION_STRING");
//BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
// We can configure and extend the HTTP pipeline through XxxClientOptions
BlobClientOptions options = new BlobClientOptions();
options.Retry.MaxRetries = 10;
options.Diagnostics.IsTelemetryEnabled = false;
options.AddPolicy(new MyCustomPolicy(), HttpPipelinePosition.PerCall);
// Get a reference to our storage account. We use the public Uri and DefaultAzureCredential for authentication
Uri blobServiceUri = new Uri("https://itprodev2020storage.blob.core.windows.net/");
BlobServiceClient blobServiceClient = new BlobServiceClient(blobServiceUri, new DefaultAzureCredential(), options);
// Get a reference to "itprodev-container" container. This clients inherits the HTTP Pipeline options from BlobServiceClient
BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient("itprodev-container");
// Create container if not exists
await blobContainerClient.CreateIfNotExistsAsync();
// Create a dummy file
string path = Utilities.CreateTempFile();
// Get a reference to a blob
BlobClient blob = blobContainerClient.GetBlobClient(Utilities.RandomName());
// Upload file to blob
await blob.UploadAsync(path);
// Delete local file
Utilities.DeleteFile(path);
// asynchronously iterate through all blobs
await foreach (BlobItem item in blobContainerClient.GetBlobsAsync())
{
// Get a path on disk where we can download the file
string downloadPath = $"{item.Name}.txt";
// Get a reference to blob and download its contents
BlobDownloadInfo download = await blobContainerClient.GetBlobClient(item.Name).DownloadAsync();
// Copy its contents to disk
using FileStream file = File.OpenWrite(downloadPath);
await download.Content.CopyToAsync(file);
}
// When a service call fails Azure.RequestFailedException would get thrown.
// The exception type provides a Status property with an HTTP status code an an ErrorCode property with a service-specific error code.
try
{
//...
}
// handle exception with status code 404
catch (RequestFailedException e) when(e.Status == 404)
{
Console.WriteLine("ErrorCode " + e.ErrorCode);
}
}
/// <summary>
/// Runs the sample using the specified Event Hubs and Azure storage connection information.
/// </summary>
///
/// <param name="eventHubsConnectionString">The connection string for the Event Hubs namespace that the sample should target.</param>
/// <param name="eventHubName">The name of the Event Hub, sometimes known as its path, that the sample should run against.</param>
/// <param name="blobStorageConnectionString">The connection string for the storage account where checkpoints and state should be persisted.</param>
/// <param name="blobContainerName">The name of the blob storage container where checkpoints and state should be persisted.</param>
///
public async Task RunAsync(string eventHubsConnectionString,
string eventHubName,
string blobStorageConnectionString,
string blobContainerName)
{
// Sometimes the environment you are targeting uses a service version that's different from the one set by default by the
// SDK. The SDK targets the Azure cloud by default, and you may need to manually specify a different version in case you
// are trying to run in another platform.
//
// For instance, this will happen when you try to run the Event Processor Client on an Azure Stack Hub version 2002. The
// processor makes use of the Azure Storage SDK, which sets a default Azure Storage service version that's different from
// the ones expected by the Azure Stack Hub. This sample illustrates how to work around this issue by using a pipeline
// policy to request the Azure Storage SDK to change its service version.
//
// In order to do this, create a Blob Client Options instance and add a Storage Api Version Policy to it. These options
// will be passed to the Blob Container Client used by the processor. The implementation of the policy is provided at
// the end of this sample.
string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
BlobClientOptions storageClientOptions = new BlobClientOptions();
storageClientOptions.AddPolicy(new StorageApiVersionPolicy(), HttpPipelinePosition.PerCall);
BlobContainerClient storageClient = new BlobContainerClient(blobStorageConnectionString, blobContainerName, storageClientOptions);
EventProcessorClient processor = new EventProcessorClient(storageClient, consumerGroup, eventHubsConnectionString, eventHubName);
// For this example, we'll create a simple event handler that writes to the
// console each time it was invoked.
int eventsProcessed = 0;
Task processEventHandler(ProcessEventArgs eventArgs)
{
if (eventArgs.CancellationToken.IsCancellationRequested)
{
return(Task.CompletedTask);
}
if (eventArgs.HasEvent)
{
++eventsProcessed;
Console.WriteLine($"Event Received: { Encoding.UTF8.GetString(eventArgs.Data.Body.ToArray()) }");
}
return(Task.CompletedTask);
}
// For this example, exceptions will just be logged to the console.
Task processErrorHandler(ProcessErrorEventArgs eventArgs)
{
if (eventArgs.CancellationToken.IsCancellationRequested)
{
return(Task.CompletedTask);
}
Console.WriteLine("===============================");
Console.WriteLine($"The error handler was invoked during the operation: { eventArgs.Operation ?? "Unknown" }, for Exception: { eventArgs.Exception.Message }");
Console.WriteLine("===============================");
Console.WriteLine();
return(Task.CompletedTask);
}
processor.ProcessEventAsync += processEventHandler;
processor.ProcessErrorAsync += processErrorHandler;
try
{
// To begin, we'll publish a batch of events for our processor to receive. Because we are not specifying any routing hints,
// the Event Hubs service will automatically route it to a single partition.
var expectedEvents = new List <EventData>()
{
new EventData(Encoding.UTF8.GetBytes("First Event, Single Batch")),
new EventData(Encoding.UTF8.GetBytes("Second Event, Single Batch")),
new EventData(Encoding.UTF8.GetBytes("Third Event, Single Batch"))
};
await using (var producer = new EventHubProducerClient(eventHubsConnectionString, eventHubName))
{
using EventDataBatch eventBatch = await producer.CreateBatchAsync();
for (int index = 0; index < expectedEvents.Count; ++index)
{
eventBatch.TryAdd(expectedEvents[index]);
}
await producer.SendAsync(eventBatch);
}
Console.WriteLine("Starting the Event Processor client...");
Console.WriteLine();
await processor.StartProcessingAsync();
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(90));
while ((!cancellationSource.IsCancellationRequested) && (eventsProcessed < expectedEvents.Count))
{
await Task.Delay(TimeSpan.FromMilliseconds(250));
}
// Once we arrive at this point, either cancellation was requested or we have processed all of our events. In
// both cases, we'll want to shut down the processor.
Console.WriteLine();
Console.WriteLine("Stopping the processor...");
await processor.StopProcessingAsync();
}
finally
{
// It is encouraged that you unregister your handlers when you have finished
// using the Event Processor to ensure proper cleanup. This is especially
// important when using lambda expressions or handlers in any form that may
// contain closure scopes or hold other references.
processor.ProcessEventAsync -= processEventHandler;
processor.ProcessErrorAsync -= processErrorHandler;
}
// The Event Processor client has been stopped and is not explicitly disposable; there
// is nothing further that we need to do for cleanup.
Console.WriteLine();
}