public static void WriteLogs(string log) { string connectionString = @"DefaultEndpointsProtocol=https;AccountName=hotelmanagerblob;AccountKey=0rIspWPXwm7U22uvlHZshW6mHeJKLw1W5Tu3OQbi8jUasSRVju61eU0teHvNHwtzuGW68vmtRH9uE/rlhoqAnQ==;EndpointSuffix=core.windows.net"; string file = "appendBlop.txt"; CloudStorageAccount account = CloudStorageAccount.Parse(connectionString); if (account == null) return; CloudBlobClient client = account.CreateCloudBlobClient(); if (client == null) return; CloudBlobContainer container = client.GetContainerReference("hotelmanagerlog"); try { container.CreateIfNotExists(); } catch (Exception e) { Debug.WriteLine(e.Message); } CloudAppendBlob blob = container.GetAppendBlobReference(file); if (!blob.Exists()) blob.CreateOrReplace(); blob.AppendText($"{log} {Environment.NewLine}"); }
public Stream CreateFile(FileDescription fileDescription, SignOptions signOptions = null, SaveOptions saveOptions = null) { CloudBlobContainer container = GetContainerReference(); string name = fileDescription.GUID.ToLower(); CloudBlockBlob blob = container.GetBlockBlobReference(name); using (MemoryStream emptyStream = new MemoryStream()) { blob.UploadFromStream(emptyStream); } try { CloudAppendBlob appendBlob = container.GetAppendBlobReference(name); appendBlob.CreateOrReplace(); return(appendBlob.OpenWrite(true)); } catch (Microsoft.WindowsAzure.Storage.StorageException exception) { // Azure Storage Emulator does not support append BLOBs, // so we emulate appending return(new CachingAzureStream(blob)); } }
public static void Read([QueueTrigger("customers", Connection = "AzureWebJobsStorage")] string message, TraceWriter log) { //Deserialize customer from the queue Customer customer = JsonConvert.DeserializeObject <Customer>(message); #if Debug var builder = new ConfigurationBuilder() .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true); IConfiguration Configuration = builder.Build(); string con = Configuration["Values:AzureWebJobsStorage"]; #endif string con = System.Environment.GetEnvironmentVariable("AzureWebJobsStorage"); CloudBlobClient blobClient = CloudStorageAccount.Parse(con).CreateCloudBlobClient(); var folder = "files"; CloudBlobContainer container = blobClient.GetContainerReference(folder); container.CreateIfNotExists(); CloudAppendBlob blob = container.GetAppendBlobReference("customers.txt"); if (!blob.Exists()) { blob.CreateOrReplace(); } blob.AppendText(customer.Name + ";" + customer.Age + ";" + customer.Phone + "\n"); // blob.UploadText(customer.Name + ";" + customer.Age + ";" + customer.Phone); }
protected override void Write(LogEventInfo logEvent) { if (_client == null) { return; } string containerName = Container.Render(logEvent); string blobName = BlobName.Render(logEvent); if (_container == null || _container.Name != containerName) { _container = _client.GetContainerReference(containerName); _blob = null; } if (_blob == null || _blob.Name != blobName) { _blob = _container.GetAppendBlobReference(blobName); if (!_blob.Exists()) { try { _blob.Properties.ContentType = "text/plain"; _blob.CreateOrReplace(AccessCondition.GenerateIfNotExistsCondition(), null, null); } catch (StorageException) { } } } var logMessage = this.Layout.Render(logEvent); _blob.AppendText(logMessage + "\r\n", Encoding.UTF8); }
public static void RunAppendBlob(CloudBlobContainer container, int times) { CloudAppendBlob appendBlob = container.GetAppendBlobReference("x/test.csv"); appendBlob.CreateOrReplace(); int nLabels = 10; string record = FillRecord("thing", nLabels); var watcher = Stopwatch.StartNew(); appendBlob.AppendText(record); for (int i = 0; i < times; i++) { Console.WriteLine(((i + 1.0) / times) * 100 + "%"); appendBlob.AppendText(record); } Console.WriteLine("ElapsedTime: " + watcher.Elapsed); Console.WriteLine("Blob length (bytes): " + appendBlob.Properties.Length); Console.Read(); }
public void UploadToAppendBlob() { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference("my-append-blobs"); container.CreateIfNotExists(); CloudAppendBlob appendBlob = container.GetAppendBlobReference("append-blob.log"); if (!appendBlob.Exists()) { appendBlob.CreateOrReplace(); } int numBlocks = 10; Random rnd = new Random(); byte[] bytes = new byte[numBlocks]; rnd.NextBytes(bytes); //Simulate a logging operation by writing text data and byte data to the end of the append blob. for (int i = 0; i < numBlocks; i++) { appendBlob.AppendText(string.Format("Timestamp: {0:u} \tLog Entry: {1}{2}", DateTime.UtcNow, bytes[i], Environment.NewLine)); } Console.WriteLine(appendBlob.DownloadText()); }
private void uploadToBlob(string fileName, string message) { CloudAppendBlob blob = this.container.GetAppendBlobReference(fileName); //make sure the file exsits if (!blob.Exists()) { blob.CreateOrReplace(); } try { blob.AppendText(message); } catch (StorageException e1) { //retry after sleep System.Threading.Thread.Sleep(10); try { blob.AppendText(message); } catch (StorageException e) { writeToLocalFile(fileName, message + "\r\n" + e.ToString() + "\r\n"); } } }
public void CreateAppendBlob(string filePath) { CloudAppendBlob blockBlob = this.cloudBlobContainer.GetAppendBlobReference(filePath); if (!blockBlob.Exists()) { blockBlob.CreateOrReplace(); } }
public static void Run([TimerTrigger("0 0 */4 * * *")] TimerInfo myTimer, TraceWriter log) { bool found = true; storageAccount = CloudStorageAccount.Parse(storageAcct); queueClient = storageAccount.CreateCloudQueueClient(); loggingQueue = queueClient.GetQueueReference(loggingQueueName); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer blobContainer = blobClient.GetContainerReference("logging"); blobContainer.CreateIfNotExists(); loggingQueue.FetchAttributes(); int?cachedMessageCount = loggingQueue.ApproximateMessageCount; if (cachedMessageCount == 0 || cachedMessageCount == null) { return; } string createddate = Convert.ToDateTime(DateTime.UtcNow).ToString("yyyy-MM-dd/HH-mm/"); string blobName = "log/" + createddate + "telemetry.json"; CloudAppendBlob appendBlob = blobContainer.GetAppendBlobReference(blobName); appendBlob.Properties.ContentType = "text/json"; appendBlob.CreateOrReplace(); while (cachedMessageCount > 0 && found) { found = false; int?messagesToRetrieve = cachedMessageCount > 32 ? 32 : cachedMessageCount; cachedMessageCount = cachedMessageCount - messagesToRetrieve; foreach (CloudQueueMessage message in loggingQueue.GetMessages((int)messagesToRetrieve, TimeSpan.FromMinutes(2))) { found = true; try { appendBlob.AppendText(message.AsString + Environment.NewLine); loggingQueue.DeleteMessage(message); } catch { log.Info("problem logging data"); } } } }
private CloudAppendBlob GetAppendBlob() { CloudAppendBlob blob = this.container.GetAppendBlobReference($"{DateTimeOffset.Now.ToString("yyyyMMdd")}/{DateTimeOffset.Now.ToString("yyyyMMddTHH")}.nm4"); if (!blob.Exists()) { blob.CreateOrReplace(); } return(blob); }
private CloudAppendBlob NewCloudAppendBlob(string userId) { lock (cloudAppendBlobDictionary) { CloudAppendBlob cloudAppendBlob = this.container.GetAppendBlobReference($"{userId}_{DateTime.Now.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture)}.log"); if (!cloudAppendBlob.Exists()) { cloudAppendBlob.CreateOrReplace(); } cloudAppendBlobDictionary[userId] = cloudAppendBlob; return(cloudAppendBlobDictionary[userId]); } }
public void AddStringToFile(string containerName, string fileName, string content) { var container = OpenOrInitializeContainer(containerName); CloudAppendBlob appendBlob = container.GetAppendBlobReference(fileName); //Create the append blob. Note that if the blob already exists, the CreateOrReplace() method will overwrite it. //You can check whether the blob exists to avoid overwriting it by using CloudAppendBlob.Exists(). appendBlob.CreateOrReplace(); appendBlob.AppendText($"Timestamp: {DateTime.UtcNow} \tLog Entry: {content}"); appendBlob.DownloadText(); }
/// <summary> /// Sends the events. /// </summary> /// <param name="events">The events that need to be send.</param> /// <remarks> /// <para> /// The subclass must override this method to process the buffered events. /// </para> /// </remarks> protected override void SendBuffer(LoggingEvent[] events) { CloudAppendBlob appendBlob = _cloudBlobContainer.GetAppendBlobReference(Filename(_directoryName)); if (!appendBlob.Exists()) { appendBlob.CreateOrReplace(); } else { _lineFeed = Environment.NewLine; } Parallel.ForEach(events, ProcessEvent); }
private CloudAppendBlob GetBlob(DateTime eventTime) { string tagName = eventTime.ToString("yyyy-MM-dd"); if (tagName != _currentTagName) { _currentTagName = tagName; _appendBlob = _blobContainer.GetAppendBlobReference($"{_blobNamePrefix}{_currentTagName}.txt"); if (!_appendBlob.Exists()) { _appendBlob.CreateOrReplace(); } } return(_appendBlob); }
protected override void Write(LogEventInfo logEvent) { var connectionString = ConnectionString.Render(logEvent); if (_client == null || !string.Equals(_connectionString, connectionString, System.StringComparison.OrdinalIgnoreCase)) { _client = CloudStorageAccount.Parse(connectionString).CreateCloudBlobClient(); InternalLogger.Debug("Initialized connection to {0}", connectionString); } string containerName = Container.Render(logEvent); string blobName = BlobName.Render(logEvent); if (_container == null || _container.Name != containerName) { _container = _client.GetContainerReference(containerName); InternalLogger.Debug("Got container reference to {0}", containerName); if (_container.CreateIfNotExists()) { InternalLogger.Debug("Created container {0}", containerName); } _blob = null; } if (_blob == null || _blob.Name != blobName) { _blob = _container.GetAppendBlobReference(blobName); if (!_blob.Exists()) { try { _blob.Properties.ContentType = "text/plain"; _blob.CreateOrReplace(AccessCondition.GenerateIfNotExistsCondition()); InternalLogger.Debug("Created blob: {0}", blobName); } catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict) { // to be expected } } } _blob.AppendText(Layout.Render(logEvent) + "\r\n", Encoding.UTF8); }
public void Log(object data, string source, string message = null) { try { string dataString = (data != null) ? data as string : "null"; if (dataString == null) { dataString = JsonConvert.SerializeObject(data); } var sasUri = new Uri(this.configuration.ObjectLogSASUrl); var accountName = sasUri.Host.TrimEndString(".blob.core.windows.net"); StorageCredentials creds = new StorageCredentials(sasUri.Query); CloudStorageAccount strAcc = new CloudStorageAccount(creds, accountName, endpointSuffix: null, useHttps: true); CloudBlobClient blobClient = strAcc.CreateCloudBlobClient(); //Setup our container we are going to use and create it. CloudBlobContainer container = blobClient.GetContainerReference(configuration.ObjectLogBlobContainer); container.CreateIfNotExistsAsync(); // Build my typical log file name. DateTime date = DateTime.Now; // This creates a reference to the append blob we are going to use. CloudAppendBlob appBlob = container.GetAppendBlobReference( $"{date.ToString("yyyy-MM")}/{date.ToString("dd")}/{date.ToString("HH")}-{source}.log"); // Now we are going to check if todays file exists and if it doesn't we create it. if (!appBlob.Exists()) { appBlob.CreateOrReplace(); } // Add the entry to our log. var logMessage = $"{date.ToString("o")}|{message}|{dataString}{Environment.NewLine}"; using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(logMessage))) { // Append a block. AppendText is not safe across multiple threads & servers so use AppendBlock instead. appBlob.AppendBlock(ms); } } catch (Exception ex) { this.logger.Error("Error logging data to the permanent store", ex); } }
public async Task SaveDataToBlobAsync(string data) { try { CloudAppendBlob blob = _dataContainer.GetAppendBlobReference(GetBlobName()); if (!blob.Exists()) { blob.CreateOrReplace(); } await blob.AppendTextAsync(data); } catch (Exception ex) { _errorLogger.ErrorFormat("SaveDataToBlobAsync function encounter error : {0}", ex.ToString().Replace("\r\n", " ")); } }
private void InitializeAzureStorage() { string containerName = "hackfest"; remoteFileName = "test" + partitionID + ".txt"; string accName = ConfigurationManager.AppSettings["blobStorageAccountName"]; string accKey = ConfigurationManager.AppSettings["blobStorageAccountKey"]; StorageCredentials creds = new StorageCredentials(accName, accKey); CloudStorageAccount storageAccount = new CloudStorageAccount(creds, true); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference(containerName); container.CreateIfNotExists(); appBlob = container.GetAppendBlobReference(remoteFileName); appBlob.CreateOrReplace(); }
/// <summary> /// Sends the events. /// </summary> /// <param name="events">The events that need to be send.</param> /// <remarks> /// <para> /// The subclass must override this method to process the buffered events. /// </para> /// </remarks> protected override void SendBuffer(LoggingEvent[] events) { CloudAppendBlob appendBlob = _cloudBlobContainer.GetAppendBlobReference(Filename(_directoryName, _filenamePrefixDateTimeFormat, _filenameSuffix)); if (!appendBlob.Exists()) { appendBlob.CreateOrReplace(); } else { _lineFeed = Environment.NewLine; } foreach (var e in events) { ProcessEvent(e); } }
protected override void SendBuffer(LoggingEvent[] events) { CloudAppendBlob appendBlob = _cloudBlobContainer.GetAppendBlobReference(Filename(DirectoryName)); if (!appendBlob.Exists()) { appendBlob.CreateOrReplace(); } StringBuilder sb = new StringBuilder(); foreach (var loggingEvent in events) { sb.Append(RenderLoggingEvent(loggingEvent)); } appendBlob.AppendText(sb.ToString()); }
private void WriteToAppendBlob(string logLevel, string log) { DateTime date = DateTime.Today; DateTime dateLogEntry = DateTime.UtcNow; try { CloudAppendBlob appBlob = _container.GetAppendBlobReference(string.Format("{0}{1}", date.ToString("yyyy-MM-dd"), ".log")); if (!appBlob.Exists()) { appBlob.CreateOrReplace(); } appBlob.AppendText(string.Format("{0}\t{1}\t{2}\r\n", dateLogEntry.ToString("o"), logLevel, log)); } catch (Exception) { ; } }
private void InstanciateStorageBlob(string formattedStorageContainerName, string formattedStorageBlobName) { if ((_appendBlob == null) || (_appendBlob.Name != formattedStorageBlobName)) { _appendBlob = _blobContainer.GetAppendBlobReference(formattedStorageBlobName); if (!_appendBlob.Exists()) { try { _appendBlob.CreateOrReplace(AccessCondition.GenerateIfNotExistsCondition(), null, null); } catch (StorageException storageException) { WriteDebugError(String.Format("NLog.AzureStorage - Failed to create Azure Storage Append Blob '{0}' in the Container '{1}' - Storage Exception: {2} {3}", formattedStorageBlobName, formattedStorageContainerName, storageException.Message, GetStorageExceptionHttpStatusMessage(storageException))); throw; } } } }
/// <summary> /// Initializes the BLOB. /// </summary> /// <param name="blobName">Name of the BLOB.</param> private void InitializeBlob(string blobName) { if (_appendBlob == null || _appendBlob.Name != blobName) { _appendBlob = _container.GetAppendBlobReference(blobName); if (!_appendBlob.Exists()) { try { _appendBlob.Properties.ContentType = "text/plain"; _appendBlob.CreateOrReplace(AccessCondition.GenerateIfNotExistsCondition()); } catch (StorageException ex) { InternalLogger.Error(ex, "Initialize Blob Exception"); throw; } } } }
/// <summary> /// Create the blob storage refrences /// </summary> /// <param name="containerref">name of the container references ///</param> /// <param name="blockref">name of the blob reference</param> public StorageClient(string containerref, string blockref) { // Parse the connection string and return a reference to the storage account. CloudStorageAccount storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); // Retrieve a reference to a container. CloudBlobContainer container = blobClient.GetContainerReference(containerref); // Create the container if it doesn't already exist. container.CreateIfNotExists(); // Retrieve reference to a blob named "myblob". _blockBlob = container.GetAppendBlobReference(blockref); if (!_blockBlob.Exists()) { _blockBlob.CreateOrReplace(); } }
public static List <long> AppendToWasbContainer(CloudBlobClient blobClient, string containerName, string blobName, int numIterations, byte[] contents) { CloudBlobContainer appendContainer = blobClient.GetContainerReference(containerName); CloudAppendBlob appendBlob = appendContainer.GetAppendBlobReference(blobName); appendBlob.CreateOrReplace(); appendContainer.CreateIfNotExists(); var perfMetrics = new List <long>(); for (int i = 0; i < numIterations; i++) { using (var stream = new MemoryStream(contents)) { var watch = Stopwatch.StartNew(); appendBlob.AppendBlock(stream); watch.Stop(); perfMetrics.Add(watch.ElapsedMilliseconds); } } return(perfMetrics); }
/// <summary> /// create a new append blob with random properties and metadata /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">blob name</param> /// <returns>CloudAppendBlob object</returns> public CloudAppendBlob CreateAppendBlob(CloudBlobContainer container, string blobName, bool createBigBlob = false) { CloudAppendBlob appendBlob = container.GetAppendBlobReference(blobName); int size = createBigBlob ? random.Next(1024 * 1024 * 50, 1024 * 1024 * 100) : random.Next(1024 * 1024); appendBlob.CreateOrReplace(); byte[] buffer = new byte[size]; // fill in random data random.NextBytes(buffer); using (MemoryStream ms = new MemoryStream(buffer)) { appendBlob.UploadFromStream(ms); } string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer)); appendBlob.Properties.ContentMD5 = md5sum; GenerateBlobPropertiesAndMetaData(appendBlob); Test.Info(string.Format("create append blob '{0}' in container '{1}', md5 = {2}", blobName, container.Name, md5sum)); return(appendBlob); }
public static void AppendToBlob(string fileName, string textToAppend) { CloudStorageAccount account = CloudStorageAccount.Parse(AmbientConnectionStringProvider.Instance.GetConnectionString("blobConnection")); CloudBlobClient client = account.CreateCloudBlobClient(); CloudBlobContainer container = client.GetContainerReference("images"); CloudAppendBlob appendBlob = container.GetAppendBlobReference(fileName); if (!appendBlob.Exists()) { appendBlob.CreateOrReplace(); } MemoryStream stream = new MemoryStream(); StreamWriter writer = new StreamWriter(stream); writer.Write(textToAppend + Environment.NewLine); writer.Flush(); stream.Position = 0; appendBlob.AppendBlock(stream); }
protected override void Write(LogEventInfo logEvent) { if (_client == null) { return; } string containerName = Container.Render(logEvent); string blobName = BlobName.Render(logEvent); if (_container == null || _container.Name != containerName) { _container = _client.GetContainerReference(containerName); _blob = null; } if (_blob == null || _blob.Name != blobName) { _blob = _container.GetAppendBlobReference(blobName); if (!_blob.Exists()) { try { _blob.Properties.ContentType = "text/plain"; _blob.CreateOrReplace(AccessCondition.GenerateIfNotExistsCondition()); } catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict) { // to be expected } } } _blob.AppendText(Layout.Render(logEvent) + "\r\n", Encoding.UTF8); }
private static async Task AppendBlobProcessAsync() { CloudStorageAccount storageAccount = null; CloudBlobContainer cloudBlobContainer = null; string sourceFile = null; string destinationFile = null; // Retrieve 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 = ConfigurationManager.AppSettings["StorageConnectionString"]; //Environment.GetEnvironmentVariable("StorageConnectionString"); //storageAccount = CloudStorageAccount.DevelopmentStorageAccount; // Check whether the connection string can be parsed. if (CloudStorageAccount.TryParse(storageConnectionString, out storageAccount)) { try { // Create the CloudBlobClient that represents the Blob storage endpoint for the storage account. ////CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient(); //127.0.0.1:10000/devstoreaccount1/testcont // Create a container called 'quickstartblobs' and append a GUID value to it to make the name unique. ////cloudBlobContainer = cloudBlobClient.GetContainerReference("testcontappendblob");// "quickstartblobs" + Guid.NewGuid().ToString()); ////await cloudBlobContainer.CreateIfNotExistsAsync(); ////Console.WriteLine("Created container '{0}'", cloudBlobContainer.Name); ////Console.WriteLine(); ////// Set the permissions so the blobs are public. ////BlobContainerPermissions permissions = new BlobContainerPermissions ////{ //// PublicAccess = BlobContainerPublicAccessType.Blob ////}; ////await cloudBlobContainer.SetPermissionsAsync(permissions); // Get a reference to the blob address, then upload the file to the blob. // Use the value of localFileName for the blob name. CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient(); cloudBlobContainer = cloudBlobClient.GetContainerReference("testcont"); cloudBlobContainer.CreateIfNotExists(); CloudAppendBlob cloudAppendBlob = cloudBlobContainer.GetAppendBlobReference("1.txt"); cloudAppendBlob.CreateOrReplace(); cloudAppendBlob.AppendText("Content added"); cloudAppendBlob.AppendText("More content added"); cloudAppendBlob.AppendText("Even more content added"); string appendBlobContent = cloudAppendBlob.DownloadText(); //cloudAppendBlob.UploadFromFile(sourceFile); // List the blobs in the container. Console.WriteLine("Listing blobs in container."); BlobContinuationToken blobContinuationToken = null; do { var results = await cloudBlobContainer.ListBlobsSegmentedAsync(null, blobContinuationToken); // Get the value of the continuation token returned by the listing call. blobContinuationToken = results.ContinuationToken; foreach (IListBlobItem item in results.Results) { Console.WriteLine(item.Uri); } } while (blobContinuationToken != null); // Loop while the continuation token is not null. destinationFile = sourceFile.Replace(".txt", "_DOWNLOADED.txt"); Console.WriteLine("Downloading blob to {0}", destinationFile); Console.WriteLine(); await cloudAppendBlob.DownloadToFileAsync(destinationFile, FileMode.Create); File.WriteAllText(sourceFile, "Hello, World, I am good, how is your health!"); await cloudAppendBlob.UploadFromFileAsync(sourceFile); await cloudAppendBlob.DeleteAsync(); } catch (StorageException ex) { Console.WriteLine("Error returned from the service: {0}", ex.Message); } finally { // Console.WriteLine("Press any key to delete the sample files and example container."); Console.ReadLine(); // Clean up resources. This includes the container and the two temp files. //Console.WriteLine("Deleting the container and any blobs it contains"); if (cloudBlobContainer != null) { // await cloudBlobContainer.DeleteIfExistsAsync(); } File.Delete(sourceFile); File.Delete(destinationFile); } } else { Console.WriteLine( "A connection string has not been defined in the system environment variables. " + "Add a environment variable named 'storageconnectionstring' with your storage " + "connection string as a value."); } }
public void RequestResultErrorCode() { Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint); CloudBlobClient client = new CloudBlobClient(baseAddressUri, TestBase.StorageCredentials); CloudBlobContainer container = client.GetContainerReference(Guid.NewGuid().ToString("N")); byte[] buffer = TestBase.GetRandomBuffer(4 * 1024 * 1024); MD5 md5 = MD5.Create(); string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer)); try { RequestResult requestResult; XmlWriterSettings settings; StringBuilder sb; container.Create(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); List <string> blocks = new List <string>(); for (int i = 0; i < 2; i++) { blocks.Add(Convert.ToBase64String(Guid.NewGuid().ToByteArray())); } // Verify the ErrorCode property is set and that it is serialized correctly using (MemoryStream memoryStream = new MemoryStream(buffer)) { memoryStream.Seek(0, SeekOrigin.Begin); blob.PutBlock(blocks[0], memoryStream, contentMD5); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); StorageException e = TestHelper.ExpectedException <StorageException>( () => blob.PutBlock(blocks[1], memoryStream, contentMD5), "Invalid MD5 should fail with mismatch"); Assert.AreEqual(e.RequestInformation.ErrorCode, StorageErrorCodeStrings.Md5Mismatch); requestResult = new RequestResult(); settings = new XmlWriterSettings(); settings.Indent = true; sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { e.RequestInformation.WriteXml(writer); } using (XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()))) { requestResult.ReadXml(reader); } // ExtendedErrorInformation.ErrorCode will be depricated, but it should still match on a non HEAD request Assert.AreEqual(e.RequestInformation.ErrorCode, requestResult.ErrorCode); Assert.AreEqual(e.RequestInformation.ExtendedErrorInformation.ErrorCode, requestResult.ErrorCode); } // Verify the ErrorCode property is set on a HEAD request CloudAppendBlob blob2 = container.GetAppendBlobReference("blob2"); blob2.CreateOrReplace(); StorageException e2 = TestHelper.ExpectedException <StorageException>( () => blob2.FetchAttributes(AccessCondition.GenerateIfMatchCondition("garbage")), "Mismatched etag should fail"); Assert.AreEqual(e2.RequestInformation.ErrorCode, StorageErrorCodeStrings.ConditionNotMet); // Verify the ErrorCode property is not set on a successful request and that it is serialized correctly OperationContext ctx = new OperationContext(); blob2.FetchAttributes(operationContext: ctx); Assert.AreEqual(ctx.RequestResults[0].ErrorCode, null); requestResult = new RequestResult(); settings = new XmlWriterSettings(); settings.Indent = true; sb = new StringBuilder(); using (XmlWriter writer = XmlWriter.Create(sb, settings)) { ctx.RequestResults[0].WriteXml(writer); } using (XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()))) { requestResult.ReadXml(reader); } Assert.AreEqual(ctx.RequestResults[0].ErrorCode, requestResult.ErrorCode); } finally { container.DeleteIfExists(); } }