private async Task <QueueClient> InitializeQueueClient(string queueName, QueueClientOptions options) { var queueClient = new QueueClient(_settingService.GetStorageAccount(), queueName, options); await queueClient.CreateIfNotExistsAsync(); return(queueClient); }
private QueueClient GetCloudQueueClient(AzureQueueOptions options, ILogger logger) { try { var clientOptions = new QueueClientOptions { Retry = { Mode = RetryMode.Fixed, Delay = AzureQueueDefaultPolicies.PauseBetweenQueueOperationRetries, MaxRetries = AzureQueueDefaultPolicies.MaxQueueOperationRetries, NetworkTimeout = AzureQueueDefaultPolicies.QueueOperationTimeout, } }; var client = options.ServiceUri != null ? new QueueClient(new Uri(options.ServiceUri, QueueName), options.TokenCredential, clientOptions) : new QueueClient(options.ConnectionString, QueueName, clientOptions); return(client); } catch (Exception exc) { logger.Error((int)AzureQueueErrorCode.AzureQueue_14, String.Format("Error creating GetCloudQueueOperationsClient."), exc); throw; } }
// Helper method for creating queueClient async Task <QueueClient> CreateQueueClient() { if (String.IsNullOrWhiteSpace(_connectionString) || String.IsNullOrWhiteSpace(_queueName)) { throw new NullReferenceException("ConnectionString or Queue name is null. Remember to call Init() method, providing a connection string and queue name"); } var queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; // Instantiate a QueueClient which will be used to create and manipulate the queue QueueClient queueClient = new QueueClient(_connectionString, _queueName, queueClientOptions); var logMessagePrefix = $"Ensuring queue '{queueClient.Name}' exists. "; if (await queueClient.ExistsAsync()) { _logger.LogTrace(logMessagePrefix + "Allready exists"); } else { _logger.LogTrace(logMessagePrefix + "Did not exsist. Will create it"); } // Create the queue if it doesn't already exist await queueClient.CreateIfNotExistsAsync(); return(queueClient); }
private QueueServiceClient GetServiceClient_SharedKey_UnInstrumented(QueueClientOptions options = default) => new QueueServiceClient( new Uri(TestConfigDefault.QueueServiceEndpoint), new StorageSharedKeyCredential( TestConfigDefault.AccountName, TestConfigDefault.AccountKey), options ?? GetOptions());
private static QueueClient CreateQueueClient(string queueName) { var options = new QueueClientOptions { MessageEncoding = QueueMessageEncoding.Base64 }; return(new QueueClient(Constants.StorageConnectionStringSetting, queueName, options)); }
private QueueClient GetSecondaryReadQueueClient(TenantConfiguration config, int numberOfReadFailuresToSimulate, out TestExceptionPolicy testExceptionPolicy, bool simulate404 = false, List <RequestMethod> enabledRequestMethods = null) { QueueClientOptions options = getSecondaryStorageOptions(config, out testExceptionPolicy, numberOfReadFailuresToSimulate, simulate404, enabledRequestMethods); return(InstrumentClient( new QueueClient( new Uri(config.QueueServiceEndpoint).AppendToPath(GetNewQueueName()), new StorageSharedKeyCredential(config.AccountName, config.AccountKey), options))); }
private QueueClientOptions getSecondaryStorageOptions(TenantConfiguration config, out TestExceptionPolicy testExceptionPolicy, int numberOfReadFailuresToSimulate = 1, bool simulate404 = false, List <RequestMethod> enabledRequestMethods = null) { QueueClientOptions options = GetOptions(); options.GeoRedundantSecondaryUri = new Uri(config.QueueServiceSecondaryEndpoint); options.Retry.MaxRetries = 4; testExceptionPolicy = new TestExceptionPolicy(numberOfReadFailuresToSimulate, options.GeoRedundantSecondaryUri, simulate404, enabledRequestMethods); options.AddPolicy(testExceptionPolicy, HttpPipelinePosition.PerRetry); return(options); }
public async Task NotifyOnUploadAsync(string message) { var options = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; var queueClient = new QueueClient(_configuration[Defines.STORAGE_ACCOUNT_CONNECTION_STRING_SECTTION], _configuration[Defines.QUEUE_NAME_SECTION], options); queueClient.CreateIfNotExists(); var encodedMessage = Convert.ToBase64String(Encoding.UTF8.GetBytes(message)); await queueClient.SendMessageAsync(encodedMessage); }
public QueueServiceClient GetQueueServiceClient(QueueClientOptions queueClientOptions = default) { if (queueClientOptions == default) { queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; } queueClientOptions.Transport = GetTransport(); return new QueueServiceClient(account.ConnectionString, queueClientOptions); }
public static QueueServiceClient GetQueueServiceClient(this AzuriteFixture azuriteFixture, QueueClientOptions queueClientOptions = default) { if (queueClientOptions == default) { queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; } queueClientOptions.Transport = azuriteFixture.GetTransport(); return(new QueueServiceClient(azuriteFixture.GetAzureAccount().ConnectionString, queueClientOptions)); }
private QueueClient CreateQueueClient(string queueName) { var options = new QueueClientOptions { MessageEncoding = QueueMessageEncoding.Base64 }; var queueClient = new QueueClient(_configuration["AppSettings:Storage"], queueName, options); queueClient.CreateIfNotExists(); return(queueClient); }
public async Task <QueueServiceClient> GetQueueClientService(StorageType storageType) { var accountId = _storage.GetPrimaryAccount(storageType); _log.Verbose($"getting blob container (account_id: {accountId})"); var(name, key) = await _storage.GetStorageAccountNameAndKey(accountId); var accountUrl = new Uri($"https://{name}.queue.core.windows.net"); var options = new QueueClientOptions { MessageEncoding = QueueMessageEncoding.Base64 }; return(new QueueServiceClient(accountUrl, new StorageSharedKeyCredential(name, key), options)); }
public async Task <QueueServiceClient> GetQueueClientService(StorageType storageType) { var accountId = _storage.GetPrimaryAccount(storageType); _log.Verbose($"getting blob container (account_id: {accountId})"); var(name, key) = await _storage.GetStorageAccountNameAndKey(accountId); var endpoint = _storage.GetQueueEndpoint(name); var options = new QueueClientOptions { MessageEncoding = QueueMessageEncoding.Base64 }; return(new QueueServiceClient(endpoint, new StorageSharedKeyCredential(name, key), options)); }
public void ConfigureMessageEncodingAsync() { var connectionString = ConnectionString; var queueName = "foo"; #region Snippet:Azure_Storage_Queues_Samples_Sample03_MessageEncoding_ConfigureMessageEncodingAsync QueueClientOptions queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; QueueClient queueClient = new QueueClient(connectionString, queueName, queueClientOptions); #endregion }
public TestFixture(WebJobsTestEnvironment testEnvironment) { IHost host = new HostBuilder() .ConfigureDefaultTestHost <TestFixture>(b => { b.AddAzureStorageBlobs().AddAzureStorageQueues(); }) .Build(); var queueOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; this.QueueServiceClient = new QueueServiceClient(testEnvironment.PrimaryStorageAccountConnectionString, queueOptions); this.BlobServiceClient = new BlobServiceClient(testEnvironment.PrimaryStorageAccountConnectionString); }
public async Task Publish <T>( T @event, int retries = 3, int retryMs = 1000, bool exponential = true, TimeSpan?ttl = null, TimeSpan?delay = null) where T : PublishedEvent { if (delay != null && delay.Value.TotalMinutes > 7 * 24 * 60) { throw new Exception("delay can't be greater than 7 days"); } if (delay != null && ttl != null && delay.Value.TotalMilliseconds > ttl.Value.TotalMilliseconds) { throw new Exception("delay can't be greater than the ttl"); } var queueName = GetQueueNameFromEvent(typeof(T)); var opts = new QueueClientOptions(QueueClientOptions.ServiceVersion.V2020_10_02); if (retries > 0) { opts.Retry.Delay = TimeSpan.FromMilliseconds(retryMs); opts.Retry.Mode = exponential ? Azure.Core.RetryMode.Exponential : Azure.Core.RetryMode.Fixed; opts.Retry.MaxRetries = retries; } var queue = new QueueClient(_connectionString, queueName, opts); if (!InitializedQueues.Contains(queueName)) { await queue.CreateIfNotExistsAsync(); InitializedQueues.Add(queueName); } var msg = await _objectSerializer.Serialize(@event); await queue.SendMessageAsync( msg, visibilityTimeout : delay, timeToLive : ttl ); }
public static void Run([QueueTrigger("hr-main-new-image-metadata", Connection = "HR_IMAGE_QUEUE_CX")] string myQueueItem, ILogger log) { if (!String.IsNullOrEmpty(myQueueItem)) { //1- Get env variable String queueStorageCx = Environment.GetEnvironmentVariable(_QUEUE_STORAGE_CONNEXION_KEY); String queueNewImageMetaDataForUserAgents = Environment.GetEnvironmentVariable(_QUEUE_FOR_USER_AGENTS_NAME_KEY); //2- Log received info var base64EncodedBytes = Convert.FromBase64String(myQueueItem); String convertedString = Encoding.UTF8.GetString(base64EncodedBytes); log.LogInformation($"C# Queue trigger function processed original value: {myQueueItem}"); log.LogInformation($"C# Queue trigger function processed converted value: {convertedString}"); //3- get or create queueFor user agents // Get the connection string from app settings // Instantiate a QueueClient which will be used to create and manipulate the queue QueueClientOptions queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; QueueClient queueClient = new QueueClient( queueStorageCx, queueNewImageMetaDataForUserAgents, queueClientOptions); queueClient.CreateIfNotExists(); //4- Send message if (queueClient.Exists()) { var queueResponse = queueClient.SendMessage(myQueueItem); } else { log.LogInformation($"Error when creating queue"); } } else { log.LogInformation($"Empty entry"); } }
public static QueueClient getQueueClient(string storName, string queueName) { ManagedIdentityCredential managedIdentityCredential = new ManagedIdentityCredential(); QueueClientOptions queueOptions = new QueueClientOptions { Retry = { MaxRetries = 5, Mode = 0 }, MessageEncoding = QueueMessageEncoding.Base64 }; string queueEndpoint = string.Format("https://{0}.queue.core.windows.net/{1}", storName, queueName); QueueClient queueClient = new QueueClient(new Uri(queueEndpoint), managedIdentityCredential, queueOptions); return(queueClient); }
public static IServiceCollection AddQueueClient(this IServiceCollection services, IConfiguration configuration) { var positionOptions = new MessageQueueOptions(); configuration.GetSection(MessageQueueOptions.SectionName).Bind(positionOptions); positionOptions.ConnectionString.ThrowIfNullOrEmpty(nameof(MessageQueueOptions.ConnectionString)); positionOptions.QueueName.ThrowIfNullOrEmpty(nameof(MessageQueueOptions.QueueName)); services.AddTransient <IQueueService, StorageQueueService>(); services.AddTransient <QueueClient>(x => { var options = new QueueClientOptions { MessageEncoding = QueueMessageEncoding.Base64 }; return(new QueueClient(positionOptions.ConnectionString, positionOptions.QueueName, options)); }); return(services); }
public QueueClientOptions GetOptions() { var options = new QueueClientOptions { Diagnostics = { IsLoggingEnabled = true }, Retry = { Mode = RetryMode.Exponential, MaxRetries = Constants.MaxReliabilityRetries, Delay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.01 : 1), MaxDelay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.1 : 60) }, }; if (Mode != RecordedTestMode.Live) { options.AddPolicy(new RecordedClientRequestIdPolicy(Recording), HttpPipelinePosition.PerCall); } return(InstrumentClientOptions(options)); }
public void MessageDecodingFailedHandlerAsync() { var connectionString = ConnectionString; var queueName = "foo"; #region Snippet:Azure_Storage_Queues_Samples_Sample03_MessageEncoding_MessageDecodingFailedHandlerAsync QueueClientOptions queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; queueClientOptions.MessageDecodingFailed += async(QueueMessageDecodingFailedEventArgs args) => { if (args.PeekedMessage != null) { Console.WriteLine($"Invalid message has been peeked, message id={args.PeekedMessage.MessageId} body={args.PeekedMessage.Body}"); } else if (args.ReceivedMessage != null) { Console.WriteLine($"Invalid message has been received, message id={args.ReceivedMessage.MessageId} body={args.ReceivedMessage.Body}"); if (args.RunSynchronously) { args.Queue.DeleteMessage(args.ReceivedMessage.MessageId, args.ReceivedMessage.PopReceipt); } else { await args.Queue.DeleteMessageAsync(args.ReceivedMessage.MessageId, args.ReceivedMessage.PopReceipt); } } }; QueueClient queueClient = new QueueClient(connectionString, queueName, queueClientOptions); #endregion }
/// <summary> /// Add message in main queue to start thumbnail processing /// </summary> /// <param name="message"></param> /// <returns></returns> public async Task OnNewImageAsync(HRSubmitPictureListItemDto message) { if (message == null) { return; } // Get the connection string from app settings // Instantiate a QueueClient which will be used to create and manipulate the queue QueueClientOptions queueClientOptions = new QueueClientOptions() { MessageEncoding = QueueMessageEncoding.Base64 }; QueueClient queueClient = new QueueClient( _config.Value?.HRSubmittedPictureCx, _config.Value?.HRMainNewImageQueueName, queueClientOptions); // Create the queue if it doesn't already exist queueClient.CreateIfNotExists(); if (queueClient.Exists()) { String messageToString = JsonConvert.SerializeObject(message); var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(messageToString); string message64 = System.Convert.ToBase64String(plainTextBytes); using var queueTask = queueClient.SendMessageAsync(message64); await queueTask; if (!queueTask.IsCompletedSuccessfully) { throw new Exception("queueClient.SendMessageAsync failure."); } } }
/// <summary> /// Initializes a new instance of the <see cref="EncryptedQueueClient"/> /// class. /// </summary> /// <param name="connectionString"> /// A connection string includes the authentication information /// required for your application to access data in an Azure Storage /// account at runtime. /// /// For more information, <see href="https://docs.microsoft.com/en-us/azure/storage/common/storage-configure-connection-string"/>. /// </param> /// <param name="queueName"> /// The name of the encrypted queue in the storage account to reference. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedQueueClient(string connectionString, string queueName, QueueClientOptions options) : base(connectionString, queueName, options) { }
public QueueServiceClient GetServiceClient_SharedKey(QueueClientOptions options = default) => InstrumentClient(GetServiceClient_SharedKey_UnInstrumented(options));
/// <summary> /// Initializes a new instance of the <see cref="EncryptedQueueClient"/> /// class. /// </summary> /// <param name="queueUri"> /// A <see cref="Uri"/> referencing the encrypted queue that includes the /// name of the account, and the name of the queue. /// </param> /// <param name="credential"> /// The shared key credential used to sign requests. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedQueueClient(Uri queueUri, StorageSharedKeyCredential credential, QueueClientOptions options = default) : base(queueUri, credential, options) { }
/// <summary> /// Initializes a new instance of the <see cref="EncryptedQueueClient"/> /// class. /// </summary> /// <param name="queueUri"> /// A <see cref="Uri"/> referencing the encrypted queue that includes the /// name of the account, and the name of the queue. /// </param> /// <param name="credential"> /// The token credential used to sign requests. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedQueueClient(Uri queueUri, TokenCredential credential, QueueClientOptions options = default) : base(queueUri, credential, options) { }
// PRIVATE// private async Task InitializeStorage() { //TODO: #45 Not thread safe if (_isStorageInitialized) { return; } var error = ""; try { //TODO: #45 Swallowing errors if (!string.IsNullOrEmpty(_settingService.GetStorageAccount())) { // Queues Initialization // Retry policy appropriate for a web user interface. var queueClientOptions = new QueueClientOptions(); queueClientOptions.Retry.Mode = RetryMode.Fixed; queueClientOptions.Retry.Delay = TimeSpan.FromSeconds(3); queueClientOptions.Retry.MaxRetries = 3; var tripManagersQueueName = _settingService.GetTripManagersQueueName(); if (!string.IsNullOrEmpty(tripManagersQueueName)) { _tripManagersQueue = await InitializeQueueClient(tripManagersQueueName, queueClientOptions); } else { //TODO: #45 Swallowing errors _loggerService.Log("tripManagersQueueName is empty"); } var tripMonitorsQueueName = _settingService.GetTripMonitorsQueueName(); if (!string.IsNullOrEmpty(tripMonitorsQueueName)) { _tripMonitorsQueue = await InitializeQueueClient(tripMonitorsQueueName, queueClientOptions); } else { _loggerService.Log("tripMonitorsQueueName is empty"); } var tripDemosQueueName = _settingService.GetTripDemosQueueName(); if (!string.IsNullOrEmpty(tripDemosQueueName)) { _tripDemosQueue = await InitializeQueueClient(tripDemosQueueName, queueClientOptions); } else { _loggerService.Log("tripDemosQueueName is empty"); } var tripDriversQueueName = _settingService.GetTripDriversQueueName(); if (!string.IsNullOrEmpty(tripDriversQueueName)) { _tripDriversQueue = await InitializeQueueClient(tripDriversQueueName, queueClientOptions); } else { _loggerService.Log("tripDriversQueueName is empty"); } _isStorageInitialized = true; } } catch (Exception ex) { error = $"Error while initializing storage: {ex.Message}"; throw new Exception(error); } finally { _loggerService.Log($"{LOG_TAG} - InitializeStorage - Error: {error}"); } }
protected override QueueServiceClient CreateClientFromTokenCredential(Uri endpointUri, TokenCredential tokenCredential, QueueClientOptions options) { return(_queueServiceClient); }
protected override QueueServiceClient CreateClientFromConnectionString(string connectionString, QueueClientOptions options) { return(_queueServiceClient); }
/// <summary> /// Initializes a new instance of the <see cref="EncryptedQueueClient"/> /// class. /// </summary> /// <param name="queueUri"> /// A <see cref="Uri"/> referencing the encrypted queue that includes the /// name of the account, and the name of the queue. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedQueueClient(Uri queueUri, QueueClientOptions options = default) : base(queueUri, options) { }