public void CloudStorageAccountClientMethods() { CloudStorageAccount account = new CloudStorageAccount(TestBase.StorageCredentials, false); CloudBlobClient blob = account.CreateCloudBlobClient(); CloudQueueClient queue = account.CreateCloudQueueClient(); CloudTableClient table = account.CreateCloudTableClient(); // check endpoints Assert.AreEqual(account.BlobEndpoint, blob.BaseUri, "Blob endpoint doesn't match account"); Assert.AreEqual(account.QueueEndpoint, queue.BaseUri, "Queue endpoint doesn't match account"); Assert.AreEqual(account.TableEndpoint, table.BaseUri, "Table endpoint doesn't match account"); // check storage uris Assert.AreEqual(account.BlobStorageUri, blob.StorageUri, "Blob endpoint doesn't match account"); Assert.AreEqual(account.QueueStorageUri, queue.StorageUri, "Queue endpoint doesn't match account"); Assert.AreEqual(account.TableStorageUri, table.StorageUri, "Table endpoint doesn't match account"); // check creds Assert.AreEqual(account.Credentials, blob.Credentials, "Blob creds don't match account"); Assert.AreEqual(account.Credentials, queue.Credentials, "Queue creds don't match account"); Assert.AreEqual(account.Credentials, table.Credentials, "Table creds don't match account"); }
static void QueueTest() { CloudStorageAccount storageAccount = ValidateConnection(); if (storageAccount == null) { return; } CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference("testqueue"); queue.CreateIfNotExists(); Console.WriteLine("Queue created"); CloudQueueMessage msg = new CloudQueueMessage("Hello, World"); queue.AddMessage(msg); CloudQueueMessage peekedMessage = queue.PeekMessage(); Console.WriteLine(peekedMessage.AsString); CloudQueueMessage message = queue.GetMessage(); message.SetMessageContent("Updated contents."); // Make it invisible for another 60 seconds. queue.UpdateMessage(message, TimeSpan.FromSeconds(20.0), MessageUpdateFields.Content | MessageUpdateFields.Visibility); msg = new CloudQueueMessage("test1212"); queue.AddMessage(msg); CloudQueueMessage retrievedMessage = queue.GetMessage(); if (retrievedMessage != null) { queue.DeleteMessage(retrievedMessage); } foreach (CloudQueueMessage msg1 in queue.GetMessages(20, TimeSpan.FromMinutes(5))) { // Process all messages in less than 5 minutes, deleting each message after processing. queue.DeleteMessage(msg1); Console.WriteLine("Deleted:" + msg1.AsString); } }
private static async Task ProcessIsues() { CloudStorageAccount storageAccount = null; CloudQueue queue = null; string storageConnectionString = "provide connection to your string"; CloudStorageAccount.TryParse(storageConnectionString, out storageAccount); try { CloudQueueClient cloudQueueClient = storageAccount.CreateCloudQueueClient(); queue = cloudQueueClient.GetQueueReference("que nane in all lower case"); bool createdQueue = await queue.CreateIfNotExistsAsync(); if (createdQueue) { Console.WriteLine("The queue was created."); } Dictionary <string, string> value = new Dictionary <string, string> { { "yes", "no" } }; string json = JsonConvert.SerializeObject(value, Formatting.Indented); CloudQueueMessage message = new CloudQueueMessage(json); await queue.AddMessageAsync(message, new TimeSpan(0, 0, 1, 0), null, null, null); CloudQueueMessage retrievedMessage = await queue.GetMessageAsync(); string messagedata = retrievedMessage.AsString; Console.WriteLine(messagedata); Console.WriteLine(); } catch (Exception ex) { Console.WriteLine("Error returned from Azure Storage: {0}", ex.Message); } }
protected EndToEndTestFixture(string rootPath, string testId) { _settingsManager = ScriptSettingsManager.Instance; FixtureId = testId; string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); QueueClient = storageAccount.CreateCloudQueueClient(); BlobClient = storageAccount.CreateCloudBlobClient(); TableClient = storageAccount.CreateCloudTableClient(); CreateTestStorageEntities(); TraceWriter = new TestTraceWriter(TraceLevel.Verbose); ApiHubTestHelper.SetDefaultConnectionFactory(); ScriptHostConfiguration config = new ScriptHostConfiguration() { RootScriptPath = rootPath, TraceWriter = TraceWriter, FileLoggingMode = FileLoggingMode.Always }; RequestConfiguration = new HttpConfiguration(); RequestConfiguration.Formatters.Add(new PlaintextMediaTypeFormatter()); EventManager = new ScriptEventManager(); ScriptHostEnvironmentMock = new Mock <IScriptHostEnvironment>(); // Reset the timer logs first, since one of the tests will // be checking them TestHelpers.ClearFunctionLogs("TimerTrigger"); TestHelpers.ClearFunctionLogs("ListenerStartupException"); InitializeConfig(config); Host = ScriptHost.Create(ScriptHostEnvironmentMock.Object, EventManager, config, _settingsManager); Host.Start(); }
public void Enqueue(string queueName, string message) { //Cria uma referência a conta de Armazenamento do Azure CloudStorageAccount storageAccountClient = CloudStorageAccount.Parse(Properties.Settings.Default .StorageAccountConnectionString); //Cria um objeto cliente de queue/fila a partir da conta de armazenamento CloudQueueClient queueClient = storageAccountClient.CreateCloudQueueClient(); //Crio um objeto que referencia uma determinada queue/fila CloudQueue cloudQueue = queueClient.GetQueueReference(queueName); //Crio a fila se ela não existir cloudQueue.CreateIfNotExists(); //Crio uma mensagem a partir do objeto serializado CloudQueueMessage cloudQueueMessage = new CloudQueueMessage(message); //Adiciono a mensagem na queue/fila cloudQueue.AddMessage(cloudQueueMessage); }
private void ProcessCommandQueue() { // Retrieve storage account from connection string CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); // Create the queue client CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to CommandQueue CloudQueue commandQueue = queueClient.GetQueueReference(WebRole.AZURE_COMMAND_QUEUE); // Create the queue if it doesn't already exist commandQueue.CreateIfNotExists(); CloudQueueMessage message = commandQueue.GetMessage(); if (message == null) { // Exit this function if there is no message return; } if (message.AsString == Commands.CMD_START_CRAWLER.ToString()) { if (statsEntity.CrawlerState == CrawlerStates.Idle) { // Start crawling if the current state is 'idle' statsEntity.CrawlerState = CrawlerStates.Loading; } } else if (message.AsString == Commands.CMD_CLEAR_CRAWLER.ToString()) { ClearCrawler(); } // After reading the message, the client should delete it commandQueue.DeleteMessage(message); }
/// <summary> /// Set service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="type">Service type</param> /// <param name="properties">Service properties</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> public void SetStorageServiceProperties(StorageServiceType type, ServiceProperties properties, IRequestOptions options, OperationContext operationContext) { CloudStorageAccount account = StorageContext.StorageAccount; switch (type) { case StorageServiceType.Blob: account.CreateCloudBlobClient().SetServiceProperties(properties, (BlobRequestOptions)options, operationContext); break; case StorageServiceType.Queue: account.CreateCloudQueueClient().SetServiceProperties(properties, (QueueRequestOptions)options, operationContext); break; case StorageServiceType.Table: account.CreateCloudTableClient().SetServiceProperties(properties, (TableRequestOptions)options, operationContext); break; default: throw new ArgumentException(Resources.InvalidStorageServiceType, "type"); } }
/// <summary> /// Initializes a new instance of ConnectionSettings using the given storage account name and key as well as /// the provided queue name. /// </summary> /// <param name="storageAccountName"> /// The name of the Azure Storage Account to connect to. /// </param> /// <param name="storageAccountKey"> /// The access key to the Azure Storage Account to connect to. /// </param> /// <param name="queueName"> /// The name of the queue to connect to. /// </param> public ConnectionSettings(string storageAccountName, string storageAccountKey, string queueName) { if (String.IsNullOrWhiteSpace(storageAccountName)) { throw new ArgumentNullException("storageAccountName"); } else if (String.IsNullOrWhiteSpace(storageAccountKey)) { throw new ArgumentNullException("storageAccountKey"); } else if (String.IsNullOrWhiteSpace(queueName)) { throw new ArgumentNullException("queueName"); } StorageCredentials credentials = new StorageCredentials(storageAccountName, storageAccountKey); CloudStorageAccount storageAccount = new CloudStorageAccount(credentials, true); client = storageAccount.CreateCloudQueueClient(); QueueName = queueName; }
/// <inheritdoc /> public CloudQueue GetCloudQueue(string connectionString, string queueName) { if (connectionString == null) { throw new ArgumentNullException("connectionString"); } if (queueName == null) { throw new ArgumentNullException("queueName"); } string queueKey = GetLookupKey(connectionString, queueName); CloudStorageAccount account = QueueAccounts.GetOrAdd( queueKey, key => { CloudStorageAccount storageAccount = GetCloudStorageAccount(connectionString); try { // Ensure that queue exists CloudQueueClient client = storageAccount.CreateCloudQueueClient(); CloudQueue cloudQueue = client.GetQueueReference(queueName); cloudQueue.CreateIfNotExists(); } catch (Exception ex) { string error = GetStorageErrorMessage(ex); string msg = string.Format(CultureInfo.CurrentCulture, AzureStorageResources.StorageManager_InitializationFailure, error); _logger.Error(msg, ex); throw new InvalidOperationException(msg, ex); } return(storageAccount); }); CloudQueueClient cloudClient = account.CreateCloudQueueClient(); return(cloudClient.GetQueueReference(queueName)); }
public ActionResult Index() { var kv = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(PiUiUtil.GetTokenForCurrentApplication)); string piStorageAccountName = kv.GetSecretAsync(CloudConfigurationManager.GetSetting("piStorageAccountName_KvUri")).Result.Value; string piStorageAccountSecretKey = kv.GetSecretAsync(CloudConfigurationManager.GetSetting("piStorageAccountSecretKey_KvUri")).Result.Value; string piStorageAccountCameraContainerName = kv.GetSecretAsync(CloudConfigurationManager.GetSetting("piStorageAccountCameraContainerName_KvUri")).Result.Value; string piStorageAccountCameraStillImagesQueueName = kv.GetSecretAsync(CloudConfigurationManager.GetSetting("piStorageAccountCameraStillImagesQueueName_KvUri")).Result.Value; string storageConnection = String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", piStorageAccountName, piStorageAccountSecretKey); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnection); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference(piStorageAccountCameraStillImagesQueueName); queue.EncodeMessage = true; // Peek at the next message CloudQueueMessage message = queue.GetMessage(); // Display message. Console.WriteLine(); // Create the blob client. CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); // Retrieve reference to a previously created container. CloudBlobContainer container = blobClient.GetContainerReference(piStorageAccountCameraContainerName); // Retrieve reference to a blob ie "picture.jpg". CloudBlockBlob blockBlob = container.GetBlockBlobReference(message.AsString); //------ var newUri = new Uri(blockBlob.Uri.AbsoluteUri); ViewBag.ImageUri = newUri; return(View()); }
public async Task SendMessageAsync <T>(T item) { #region Commented Code //string msgBody = JsonConvert.SerializeObject(item); //CloudStorageAccount acct = CloudStorageAccount.Parse( // config[Constants.KEY_STORAGE_CNN]); //CloudQueueClient qClient = acct.CreateCloudQueueClient(); //CloudQueue orderQueue = qClient.GetQueueReference( // config[Constants.KEY_QUEUE]); //await orderQueue.CreateIfNotExistsAsync(); //await orderQueue.AddMessageAsync( // new CloudQueueMessage(msgBody)); #endregion //serialize the object string msgBody = JsonConvert.SerializeObject(item); //Parse the connection string CloudStorageAccount acct = CloudStorageAccount.Parse( config[Constants.KEY_STORAGE_CONN]); //Create the queue client CloudQueueClient qClient = acct.CreateCloudQueueClient(); //get the queue reference CloudQueue orderQueue = qClient.GetQueueReference( config[Constants.KEY_QUEUE]); //If the queue doesnt exist then create it await orderQueue.CreateIfNotExistsAsync(); //Add the message to the queue await orderQueue.AddMessageAsync( new CloudQueueMessage(msgBody)); }
public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } CostCenter costCenter = await GetCostCenterAsync(costCenterAPIUrl, Expense.SubmitterEmail); if (costCenter != null) { Expense.CostCenter = costCenter.CostCenterName; Expense.ApproverEmail = costCenter.ApproverEmail; } else { Expense.CostCenter = "Unkown"; Expense.ApproverEmail = "Unknown"; } // Write to DB, but don't wait right now _context.Expense.Add(Expense); Task t = _context.SaveChangesAsync(); // Serialize the expense and write it to the Azure Storage Queue CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_queueInfo.ConnectionString); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference(_queueInfo.QueueName); await queue.CreateIfNotExistsAsync(); CloudQueueMessage queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(Expense)); await queue.AddMessageAsync(queueMessage); // Ensure the DB write is complete t.Wait(); return(RedirectToPage("./Index")); }
private void OnStarted() { var connectionString = configuration.GetConnectionString("ImageStore"); CloudStorageAccount account = null; CloudStorageAccount.TryParse(connectionString, out account); var blobClient = account.CreateCloudBlobClient(); var imageContainer = blobClient.GetContainerReference("images"); var imageBlobCreationTask = imageContainer.CreateIfNotExistsAsync(); var tableClient = account.CreateCloudTableClient(); var imageTable = tableClient.GetTableReference("images"); var imageTableCreationTask = imageTable.CreateIfNotExistsAsync(); var queueClient = account.CreateCloudQueueClient(); var imgQueue = queueClient.GetQueueReference("imgprocessing"); var imgQueueCreationTask = imgQueue.CreateIfNotExistsAsync(); var thumbnailContainer = blobClient.GetContainerReference("thumbnails"); var thumbnailBlobCreationTask = thumbnailContainer .CreateIfNotExistsAsync() .ContinueWith ( x => { thumbnailContainer.SetPermissionsAsync( new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); return(true); } ); Task.WaitAll(imageBlobCreationTask, imageTableCreationTask, imgQueueCreationTask, thumbnailBlobCreationTask); }
/// <summary> /// Set service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="type">Service type</param> /// <param name="properties">Service properties</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> public void SetStorageServiceProperties(StorageServiceType type, ServiceProperties properties, IRequestOptions options, OperationContext operationContext) { CloudStorageAccount account = StorageContext.StorageAccount; switch (type) { case StorageServiceType.Blob: account.CreateCloudBlobClient().SetServiceProperties(properties, (BlobRequestOptions)options, operationContext); break; case StorageServiceType.Queue: account.CreateCloudQueueClient().SetServiceProperties(properties, (QueueRequestOptions)options, operationContext); break; case StorageServiceType.Table: account.CreateCloudTableClient().SetServiceProperties(properties, (TableRequestOptions)options, operationContext); break; case StorageServiceType.File: if (null != properties.Logging) { throw new InvalidOperationException(Resources.FileNotSupportLogging); } if (null != properties.HourMetrics || null != properties.MinuteMetrics) { throw new InvalidOperationException(Resources.FileNotSupportMetrics); } FileServiceProperties fileServiceProperties = new FileServiceProperties(); fileServiceProperties.Cors = properties.Cors; account.CreateCloudFileClient().SetServiceProperties(fileServiceProperties, (FileRequestOptions)options, operationContext); break; default: throw new ArgumentException(Resources.InvalidStorageServiceType, "type"); } }
public static void Main(string[] args) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("ConnectionString")); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference("--process_queue--"); CloudQueueMessage peekedMsg = queue.PeekMessage();//get last queue message CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer blobContainer = blobClient.GetContainerReference("--contenedor_de_registros--"); blobContainer.CreateIfNotExists(); //Can not get all message at once.Need to use batch. foreach (CloudQueueMessage item in queue.GetMessages(20, TimeSpan.FromSeconds(100))) { var path = string.Format(@"c:\\Temporal\log{0}.txt", item.Id); using (TextWriter tempFile = File.CreateText(path)) { var msg = queue.GetMessage().AsString; tempFile.WriteLine(msg); Console.WriteLine("CreatedFile"); } using (var fileStream = File.OpenRead(path)) { CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(string.Format("log{0}", item.Id)); blockBlob.UploadFromStream(fileStream); Console.WriteLine("Blob created"); } queue.DeleteMessage(item); } Console.ReadLine(); }
public async Task InitializeAsync() { _copiedRootPath = Path.Combine(Path.GetTempPath(), "FunctionsE2E", DateTime.UtcNow.ToString("yyMMdd-HHmmss")); FileUtility.CopyDirectory(_rootPath, _copiedRootPath); var extensionsToInstall = GetExtensionsToInstall(); if (extensionsToInstall != null && extensionsToInstall.Length > 0) { TestFunctionHost.WriteNugetPackageSources(_copiedRootPath, "http://www.myget.org/F/azure-appservice/api/v2", "https://www.myget.org/F/azure-appservice-staging/api/v2", "https://api.nuget.org/v3/index.json"); var options = new OptionsWrapper <ScriptJobHostOptions>(new ScriptJobHostOptions { RootScriptPath = _copiedRootPath }); var manager = new ExtensionsManager(options, NullLogger <ExtensionsManager> .Instance); await manager.AddExtensions(extensionsToInstall); } string logPath = Path.Combine(Path.GetTempPath(), @"Functions"); Host = new TestFunctionHost(_copiedRootPath, logPath, ConfigureJobHost, configureAppConfiguration: s => { s.AddInMemoryCollection(new Dictionary <string, string>() { { LanguageWorkerConstants.FunctionWorkerRuntimeSettingName, _functionsWorkerRuntime } }); }); string connectionString = Host.JobHostServices.GetService <IConfiguration>().GetWebJobsConnectionString(ConnectionStringNames.Storage); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); QueueClient = storageAccount.CreateCloudQueueClient(); BlobClient = storageAccount.CreateCloudBlobClient(); TableClient = storageAccount.CreateCloudTableClient(); await CreateTestStorageEntities(); }
static void PushPop() { // Retrieve storage account from connection string. CloudStorageAccount storageAccount = CloudStorageAccountHelper.Instance; // Create the queue client. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a container. CloudQueue queue = queueClient.GetQueueReference("myqueue"); // Create the queue if it doesn't already exist queue.CreateIfNotExists(); // Create a message and add it to the queue. CloudQueueMessage message = new CloudQueueMessage("Hello, World"); queue.AddMessage(message); // Update Message Content CloudQueueMessage updateMessage = queue.GetMessage(); updateMessage.SetMessageContent("Updated contents."); queue.UpdateMessage(updateMessage, TimeSpan.FromSeconds(60.0), // Make it invisible for another 60 seconds. MessageUpdateFields.Content | MessageUpdateFields.Visibility); // Peek at the next message CloudQueueMessage peekedMessage = queue.PeekMessage(); // Display message. Console.WriteLine(peekedMessage.AsString); // Delete message CloudQueueMessage retrievedMessage = queue.GetMessage(); queue.DeleteMessage(retrievedMessage); }
public async void QueueWork() { // Parse the connection string and return a reference to the storage account. CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a container. CloudQueue queue = queueClient.GetQueueReference("myqueue"); // Create the queue if it doesn't already exist queue.CreateIfNotExists(); // Create a message and add it to the queue. CloudQueueMessage message = new CloudQueueMessage("Hello, World"); queue.AddMessage(message); // Create a message to put in the queue CloudQueueMessage cloudQueueMessage = new CloudQueueMessage("My message"); // Peek at the next message CloudQueueMessage peekedMessage = queue.PeekMessage(); // Get the next message CloudQueueMessage retrievedMessage = queue.GetMessage(); // ASYNC AWAIT // Async enqueue the message await queue.AddMessageAsync(cloudQueueMessage); // Async dequeue the message CloudQueueMessage retrievedMessage2 = await queue.GetMessageAsync(); // QUEUE LENGTH int?cachedMessageCount = queue.ApproximateMessageCount; }
protected EndToEndTestFixture(string rootPath, string testId, string extensionName = null, string extensionVersion = null) { FixtureId = testId; string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); QueueClient = storageAccount.CreateCloudQueueClient(); BlobClient = storageAccount.CreateCloudBlobClient(); TableClient = storageAccount.CreateCloudTableClient(); CreateTestStorageEntities().Wait(); _copiedRootPath = Path.Combine(Path.GetTempPath(), "FunctionsE2E", DateTime.UtcNow.ToString("yyMMdd-HHmmss")); FileUtility.CopyDirectory(rootPath, _copiedRootPath); // Allow derived classes to limit functions. We'll update host.json in the copied location // so it only affects this fixture's instance. IEnumerable <string> functions = GetActiveFunctions(); string hostJsonPath = Path.Combine(_copiedRootPath, "host.json"); JObject hostJson = JObject.Parse(File.ReadAllText(hostJsonPath)); if (functions != null && functions.Any()) { hostJson["functions"] = JArray.FromObject(functions); } File.WriteAllText(hostJsonPath, hostJson.ToString()); Host = new TestFunctionHost(_copiedRootPath); // We can currently only support a single extension. if (extensionName != null && extensionVersion != null) { Host.SetNugetPackageSources("http://www.myget.org/F/azure-appservice/api/v2", "https://api.nuget.org/v3/index.json"); Host.InstallBindingExtension(extensionName, extensionVersion).Wait(TimeSpan.FromSeconds(30)); } Host.StartAsync().Wait(TimeSpan.FromSeconds(30)); }
public void CloudStorageAccountWithStorageUri() { StorageUri blobEndpoint = new StorageUri( new Uri("http://" + AccountName + BlobService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + BlobService + EndpointSuffix)); StorageUri queueEndpoint = new StorageUri( new Uri("http://" + AccountName + QueueService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + QueueService + EndpointSuffix)); StorageUri fileEndpoint = new StorageUri( new Uri("http://" + AccountName + FileService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + FileService + EndpointSuffix)); CloudStorageAccount account = new CloudStorageAccount(new StorageCredentials(), blobEndpoint, queueEndpoint, null, fileEndpoint); Assert.IsTrue(blobEndpoint.Equals(account.BlobStorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.QueueStorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.FileStorageUri)); account = new CloudStorageAccount(new StorageCredentials(AccountName, TestBase.StorageCredentials.ExportBase64EncodedKey()), false); Assert.IsTrue(blobEndpoint.Equals(account.BlobStorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.QueueStorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.FileStorageUri)); account = CloudStorageAccount.Parse(string.Format("DefaultEndpointsProtocol=http;AccountName={0};AccountKey=", AccountName)); Assert.IsTrue(blobEndpoint.Equals(account.BlobStorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.QueueStorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.FileStorageUri)); Assert.IsTrue(blobEndpoint.Equals(account.CreateCloudBlobClient().StorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.CreateCloudQueueClient().StorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.CreateCloudFileClient().StorageUri)); Assert.IsTrue(blobEndpoint.PrimaryUri.Equals(account.BlobEndpoint)); Assert.IsTrue(queueEndpoint.PrimaryUri.Equals(account.QueueEndpoint)); Assert.IsTrue(fileEndpoint.PrimaryUri.Equals(account.FileEndpoint)); }
public void Run() { this.storageAccount = CloudStorageAccount.Parse(queueStorageConnectionString); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a container. this.queue = queueClient.GetQueueReference(queueName); // Create the queue if it doesn't already exist queue.CreateIfNotExists(); while (true) { var message = this.queue.GetMessage(TimeSpan.FromSeconds(10)); if (message == null) { Thread.Sleep(1000); continue; } var msgbytes = message.AsBytes; var request = DeserializeRequest(msgbytes); Thread.Sleep(8000); //uh ok - we've used almost all our 10 seconds. better ask for more time queue.UpdateMessage(message, TimeSpan.FromSeconds(20), MessageUpdateFields.Visibility); //System.IO.File.WriteAllBytes(request.Image) var result = MakeAnalysisRequest(request.Image).GetAwaiter().GetResult(); Console.WriteLine(result); queue.DeleteMessage(message); } }
/// <summary> /// Executes the action with the specified <paramref name="data" />. /// </summary> /// <param name="data">The data.</param> /// <param name="formSubmitContext">The form submit context.</param> /// <returns> /// <c>true</c> if the action is executed correctly; otherwise <c>false</c> /// </returns> protected override bool Execute(string data, FormSubmitContext formSubmitContext) { Assert.ArgumentNotNull(formSubmitContext, nameof(formSubmitContext)); Assert.ArgumentNotNullOrEmpty(_connectionstring, nameof(_connectionstring)); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_connectionstring); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // Retrieve a reference to a container. use only lowercase!! CloudQueue queue = queueClient.GetQueueReference("stockpickformsqueue"); // Create the queue if it doesn't already exist queue.CreateIfNotExists(); // Create a message var message = new FormFields { FormId = formSubmitContext.FormId.ToString(), Fields = new List <FormFieldSmall>() }; List <Guid> filesource = new List <Guid>(); foreach (var viewModel in formSubmitContext.Fields) { AddFieldData(viewModel, message); filesource.AddRange((IEnumerable <Guid>)GetCommittedFileIds(viewModel)); } if (filesource.Any <Guid>()) { StoreFiles(storageAccount, formSubmitContext, (IEnumerable <Guid>)filesource); } // Create a queue message with JSON and add it to the queue. CloudQueueMessage queuemessage = new CloudQueueMessage(JsonConvert.SerializeObject(message)); queue.AddMessage(queuemessage); return(true); }
private static void Initialize(string[] args) { _semaphore = new SemaphoreSlim(1, 1); _config = new Config(args); _gs = $@"{ _config.Get("GS_BIN")}"; _tempFolder = $@"{ _config.Get("TEMP_FOLDER")}"; _resolution = (int.Parse(_config.Get("IMAGE_RESOLUTION")) / 10).ToString(); if (!Directory.Exists(_tempFolder)) { Directory.CreateDirectory(_tempFolder); } var connectionString = _config.Get("STORAGE_ACCOUNT"); _queueName = _config.Get("QUEUE_NAME"); _imageStorageAccount = _config.Get("IMAGE_STORAGE_ACCOUNT"); _imageStorageBlobContainer = _config.Get("IMAGE_CONTAINER_NAME"); if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentException("connectionString is empty"); } try { _storageAccount = CloudStorageAccount.Parse(connectionString); } catch (Exception ex) { throw new Exception($"Error parsing the storage connection string {connectionString}: {ex.Message}"); } _queueClient = _storageAccount.CreateCloudQueueClient(); _queue = GetQueueAsync(_queueName).GetAwaiter().GetResult(); }
public static void Run([QueueTrigger("changeshappened", Connection = "AzureWebJobsStorage")] string myQueueItem, TraceWriter log) { log.Info($"C# Queue trigger function processed: {myQueueItem}"); var changeInfo = JsonConvert.DeserializeObject <Common.Models.ChangeInfo>(myQueueItem); ClientContext ctx = Common.Helpers.ContextHelper.GetSPContext("https://folkuniversitetetsp2016.sharepoint.com" + changeInfo.SiteUrl).Result; // changeInfo.ListId is list id List list = ctx.Web.Lists.GetById(new Guid(changeInfo.ListId)); ListItem changedItem = list.GetItemById(changeInfo.ItemId); ctx.Load(changedItem, item => item["Title"], item => item["SiteUrl"], item => item["Owner"]); ctx.ExecuteQuery(); string title = changedItem["Title"].ToString(); string owner = changedItem["Owner"].ToString(); GroupHelper.CreateUnifedGroup(title, "groupsite1", "groupsite1", owner); //create queue if not exists CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["AzureWebJobsStorage"]); // Get queue... create if does not exist. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference("provisionqueue"); queue.CreateIfNotExists(); GroupSiteUrl siteUrl = new GroupSiteUrl() { url = changeInfo.SiteUrl }; queue.AddMessage(new CloudQueueMessage(JsonConvert.SerializeObject(siteUrl))); log.Info("Item was updated id = " + changeInfo.SiteUrl); }
/// <summary> /// Push the List of to Azure storage Queue /// </summary> /// <param name="mailList">List<string></param> public async Task PushMailInQueue(List <MessageText> mailList) { ResponseModel response = new ResponseModel(); if (mailList != null) { // Retrieve storage account from connection string. CloudStorageAccount storageAccount = CloudStorageAccount.Parse( System.Configuration.ConfigurationManager.ConnectionStrings["AzureWebJobsStorage"].ConnectionString); foreach (var email in mailList) { // Create the queue client. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); if (queueClient != null) { CloudQueue queue = queueClient.GetQueueReference("gmailqueue"); //CloudQueue queue = queueClient.GetQueueReference("testqueue"); // Create the queue if it doesn't already exist. queue.CreateIfNotExists(); // Create a message and add it to the queue. CloudQueueMessage msg = new CloudQueueMessage(email.msgtxt); queue.AddMessage(msg); } } response.Message = "Following mail will be processing on the Queue"; } else { response.Message = "No emails found to process"; } //return response; }
public FractalForm() { InitializeComponent(); ResetColors(); CloudStorageAccount account = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageAccount"]); CloudQueueClient queueStorage = account.CreateCloudQueueClient(); this.queue = queueStorage.GetQueueReference("fractaltoprocess"); this.queue.CreateIfNotExist(); this.inqueue = queueStorage.GetQueueReference("fractalsectors"); this.inqueue.CreateIfNotExist(); CloudBlobClient blobClient = account.CreateCloudBlobClient(); this.blobContainer = blobClient.GetContainerReference("fractalsectors"); this.blobContainer.CreateIfNotExist(); Thread thread = new Thread(new ThreadStart(this.ProcessQueue)); thread.IsBackground = true; thread.Start(); }
public AzureQueue(string connectionString, string queueName) { if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentException("connectionString is empty"); } if (string.IsNullOrWhiteSpace(queueName)) { throw new ArgumentException("queueName is empty"); } try { _storageAccount = CloudStorageAccount.Parse(connectionString); } catch (Exception ex) { throw new Exception($"Error parsing the storage connection string {connectionString}: {ex.Message}"); } _queueClient = _storageAccount.CreateCloudQueueClient(); _queue = CreateQueueAsync(queueName).GetAwaiter().GetResult(); }
private void InitEnvironment() { storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); queueClient = storageAccount.CreateCloudQueueClient(); queue = queueClient.GetQueueReference(CloudConfigurationManager.GetSetting("PhotoQueueName")); queue.CreateIfNotExists(); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(CloudConfigurationManager.GetSetting("TempBlobContainerNamePhoto")); // Check if the request contains multipart/form-data. if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = HttpContext.Current.Server.MapPath("~/App_Data"); provider = new MultipartFormDataStreamProvider(root); blobPrefixString = CloudConfigurationManager.GetSetting("TempBlobRelativeLocationPhoto"); }
/// <summary> /// Queueへの参照 /// </summary> /// <param name="storageAccount"></param> /// <param name="queueName"></param> /// <returns></returns> private static CloudQueue GetQueueReference(CloudStorageAccount storageAccount, string queueName) { // queue client を作成 CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); // 再試行ポリシーの構成 QueueRequestOptions interactiveRequestOption = new QueueRequestOptions() { RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(1), 5), //geo 冗長ストレージ(GRS)の場合、PrimaryThenSecondaryを設定する //それ以外は、PrimaryOnlyを設定する LocationMode = LocationMode.PrimaryOnly, MaximumExecutionTime = TimeSpan.FromSeconds(10) }; queueClient.DefaultRequestOptions = interactiveRequestOption; // queue名に大文字は使えないので小文字に変換する queueName = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToLower(queueName); // queueへの参照を取得する return(queueClient.GetQueueReference(queueName)); }
public void AddConfigRequestToQueue( string account, string siteUrl, string storageConnectionString) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString); // Get queue... create if does not exist. CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference(SiteModificationManager.StorageQueueName); queue.CreateIfNotExists(); // Pass in data for modification var newSiteConfigRequest = new SiteModificationData() { AccountId = account, SiteUrl = siteUrl }; // Add entry to queue queue.AddMessage(new CloudQueueMessage(JsonConvert.SerializeObject(newSiteConfigRequest))); }
public void CloudQueueOldSASVersion() { CloudQueueClient client = GenerateCloudQueueClient(); CloudQueue queue = client.GetQueueReference(GenerateNewQueueName()); try { queue.Create(); string messageContent = Guid.NewGuid().ToString(); CloudQueueMessage message = new CloudQueueMessage(messageContent); queue.AddMessage(message); // Prepare SAS authentication with full permissions string id = Guid.NewGuid().ToString(); DateTime start = DateTime.UtcNow; DateTime expiry = start.AddMinutes(30); QueuePermissions permissions = new QueuePermissions(); SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update; permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy() { SharedAccessStartTime = start, SharedAccessExpiryTime = expiry, Permissions = queuePerm }); queue.SetPermissions(permissions); Thread.Sleep(30 * 1000); string sasTokenFromId = queue.GetSharedAccessSignature(null, id, Constants.VersionConstants.February2012); StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId); CloudStorageAccount sasAcc = new CloudStorageAccount(sasCredsFromId, new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint), new Uri(TestBase.TargetTenantConfig.QueueServiceEndpoint), new Uri(TestBase.TargetTenantConfig.TableServiceEndpoint)); CloudQueueClient sasClient = sasAcc.CreateCloudQueueClient(); CloudQueue sasQueueFromSasUri = new CloudQueue(sasClient.Credentials.TransformUri(queue.Uri)); CloudQueueMessage receivedMessage = sasQueueFromSasUri.PeekMessage(); Assert.AreEqual(messageContent, receivedMessage.AsString); CloudQueue sasQueueFromSasUri1 = new CloudQueue(new Uri(queue.Uri.ToString() + sasTokenFromId)); CloudQueueMessage receivedMessage1 = sasQueueFromSasUri1.PeekMessage(); Assert.AreEqual(messageContent, receivedMessage1.AsString); CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId); CloudQueueMessage receivedMessage2 = sasQueueFromId.PeekMessage(); Assert.AreEqual(messageContent, receivedMessage2.AsString); string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null); StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy); CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy); CloudQueueMessage receivedMessage3 = sasQueueFromPolicy.PeekMessage(); Assert.AreEqual(messageContent, receivedMessage3.AsString); } finally { queue.DeleteIfExists(); } }
public void CloudStorageAccountWithStorageUri() { StorageUri blobEndpoint = new StorageUri( new Uri("http://" + AccountName + BlobService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + BlobService + EndpointSuffix)); StorageUri queueEndpoint = new StorageUri( new Uri("http://" + AccountName + QueueService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + QueueService + EndpointSuffix)); StorageUri tableEndpoint = new StorageUri( new Uri("http://" + AccountName + TableService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + TableService + EndpointSuffix)); StorageUri fileEndpoint = new StorageUri( new Uri("http://" + AccountName + FileService + EndpointSuffix), new Uri("http://" + AccountName + SecondarySuffix + FileService + EndpointSuffix)); #if WINDOWS_RT || ASPNET_K CloudStorageAccount account = CloudStorageAccount.Create(new StorageCredentials(), blobEndpoint, queueEndpoint, tableEndpoint, fileEndpoint); #else CloudStorageAccount account = new CloudStorageAccount(new StorageCredentials(), blobEndpoint, queueEndpoint, tableEndpoint, fileEndpoint); #endif Assert.IsTrue(blobEndpoint.Equals(account.BlobStorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.QueueStorageUri)); Assert.IsTrue(tableEndpoint.Equals(account.TableStorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.FileStorageUri)); account = new CloudStorageAccount(new StorageCredentials(AccountName, TestBase.StorageCredentials.ExportBase64EncodedKey()), false); Assert.IsTrue(blobEndpoint.Equals(account.BlobStorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.QueueStorageUri)); Assert.IsTrue(tableEndpoint.Equals(account.TableStorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.FileStorageUri)); account = CloudStorageAccount.Parse(string.Format("DefaultEndpointsProtocol=http;AccountName={0};AccountKey=", AccountName)); Assert.IsTrue(blobEndpoint.Equals(account.BlobStorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.QueueStorageUri)); Assert.IsTrue(tableEndpoint.Equals(account.TableStorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.FileStorageUri)); Assert.IsTrue(blobEndpoint.Equals(account.CreateCloudBlobClient().StorageUri)); Assert.IsTrue(queueEndpoint.Equals(account.CreateCloudQueueClient().StorageUri)); Assert.IsTrue(tableEndpoint.Equals(account.CreateCloudTableClient().StorageUri)); Assert.IsTrue(fileEndpoint.Equals(account.CreateCloudFileClient().StorageUri)); Assert.IsTrue(blobEndpoint.PrimaryUri.Equals(account.BlobEndpoint)); Assert.IsTrue(queueEndpoint.PrimaryUri.Equals(account.QueueEndpoint)); Assert.IsTrue(tableEndpoint.PrimaryUri.Equals(account.TableEndpoint)); Assert.IsTrue(fileEndpoint.PrimaryUri.Equals(account.FileEndpoint)); }
public async Task QueueSASTestAsync() { CloudQueueClient client = GenerateCloudQueueClient(); CloudQueue queue = client.GetQueueReference(GenerateNewQueueName()); await queue.CreateAsync(); string messageContent = Guid.NewGuid().ToString(); CloudQueueMessage message = new CloudQueueMessage(messageContent); await queue.AddMessageAsync(message); // Prepare SAS authentication with full permissions string id = Guid.NewGuid().ToString(); DateTime start = DateTime.UtcNow; DateTime expiry = start.AddMinutes(30); QueuePermissions permissions = new QueuePermissions(); SharedAccessQueuePermissions queuePerm = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.ProcessMessages | SharedAccessQueuePermissions.Read | SharedAccessQueuePermissions.Update; permissions.SharedAccessPolicies.Add(id, new SharedAccessQueuePolicy() { SharedAccessStartTime = start, SharedAccessExpiryTime = expiry, Permissions = queuePerm }); await queue.SetPermissionsAsync(permissions); await Task.Delay(30 * 1000); string sasTokenFromId = queue.GetSharedAccessSignature(null, id); StorageCredentials sasCredsFromId = new StorageCredentials(sasTokenFromId); CloudStorageAccount sasAcc = new CloudStorageAccount(sasCredsFromId, null /* blobEndpoint */, new Uri(TestBase.TargetTenantConfig.QueueServiceEndpoint), null /* tableEndpoint */, null /* fileEndpoint */); CloudQueueClient sasClient = sasAcc.CreateCloudQueueClient(); CloudQueue sasQueueFromSasUri = new CloudQueue(sasClient.Credentials.TransformUri(queue.Uri)); CloudQueueMessage receivedMessage = await sasQueueFromSasUri.PeekMessageAsync(); Assert.AreEqual(messageContent, receivedMessage.AsString); CloudQueue sasQueueFromSasUri1 = new CloudQueue(new Uri(queue.Uri.ToString() + sasTokenFromId)); CloudQueueMessage receivedMessage1 = await sasQueueFromSasUri1.PeekMessageAsync(); Assert.AreEqual(messageContent, receivedMessage1.AsString); CloudQueue sasQueueFromId = new CloudQueue(queue.Uri, sasCredsFromId); CloudQueueMessage receivedMessage2 = await sasQueueFromId.PeekMessageAsync(); Assert.AreEqual(messageContent, receivedMessage2.AsString); string sasTokenFromPolicy = queue.GetSharedAccessSignature(permissions.SharedAccessPolicies[id], null); StorageCredentials sasCredsFromPolicy = new StorageCredentials(sasTokenFromPolicy); CloudQueue sasQueueFromPolicy = new CloudQueue(queue.Uri, sasCredsFromPolicy); CloudQueueMessage receivedMessage3 = await sasQueueFromPolicy.PeekMessageAsync(); Assert.AreEqual(messageContent, receivedMessage3.AsString); await queue.DeleteAsync(); }
public void CloudStorageAccountClientUriVerify() { StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey); CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, true); CloudBlobClient blobClient = cloudStorageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference("container1"); Assert.AreEqual(cloudStorageAccount.BlobEndpoint.ToString() + "container1", container.Uri.ToString()); CloudQueueClient queueClient = cloudStorageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference("queue1"); Assert.AreEqual(cloudStorageAccount.QueueEndpoint.ToString() + "queue1", queue.Uri.ToString()); CloudTableClient tableClient = cloudStorageAccount.CreateCloudTableClient(); CloudTable table = tableClient.GetTableReference("table1"); Assert.AreEqual(cloudStorageAccount.TableEndpoint.ToString() + "table1", table.Uri.ToString()); }
public void CloudStorageAccountClientMethods() { CloudStorageAccount account = new CloudStorageAccount(TestBase.StorageCredentials, false); CloudBlobClient blob = account.CreateCloudBlobClient(); CloudQueueClient queue = account.CreateCloudQueueClient(); CloudTableClient table = account.CreateCloudTableClient(); // check endpoints Assert.AreEqual(account.BlobEndpoint, blob.BaseUri, "Blob endpoint doesn't match account"); Assert.AreEqual(account.QueueEndpoint, queue.BaseUri, "Queue endpoint doesn't match account"); Assert.AreEqual(account.TableEndpoint, table.BaseUri, "Table endpoint doesn't match account"); // check storage uris Assert.AreEqual(account.BlobStorageUri, blob.StorageUri, "Blob endpoint doesn't match account"); Assert.AreEqual(account.QueueStorageUri, queue.StorageUri, "Queue endpoint doesn't match account"); Assert.AreEqual(account.TableStorageUri, table.StorageUri, "Table endpoint doesn't match account"); // check creds Assert.AreEqual(account.Credentials, blob.Credentials, "Blob creds don't match account"); Assert.AreEqual(account.Credentials, queue.Credentials, "Queue creds don't match account"); Assert.AreEqual(account.Credentials, table.Credentials, "Table creds don't match account"); }