public void SetBlobContentWithProperties(StorageBlob.BlobType blobType) { string filePath = FileUtil.GenerateOneTempTestFile(); StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(); Hashtable properties = new Hashtable(); properties.Add("CacheControl", Utility.GenNameString(string.Empty)); properties.Add("ContentEncoding", Utility.GenNameString(string.Empty)); properties.Add("ContentLanguage", Utility.GenNameString(string.Empty)); properties.Add("ContentMD5", Utility.GenNameString(string.Empty)); properties.Add("ContentType", Utility.GenNameString(string.Empty)); try { Test.Assert(agent.SetAzureStorageBlobContent(filePath, container.Name, blobType, string.Empty, true, -1, properties), "set blob content with property should succeed"); StorageBlob.ICloudBlob blob = container.GetBlobReferenceFromServer(Path.GetFileName(filePath)); blob.FetchAttributes(); ExpectEqual(properties["CacheControl"].ToString(), blob.Properties.CacheControl, "Cache control"); ExpectEqual(properties["ContentEncoding"].ToString(), blob.Properties.ContentEncoding, "Content Encoding"); ExpectEqual(properties["ContentLanguage"].ToString(), blob.Properties.ContentLanguage, "Content Language"); ExpectEqual(properties["ContentMD5"].ToString(), blob.Properties.ContentMD5, "Content MD5"); ExpectEqual(properties["ContentType"].ToString(), blob.Properties.ContentType, "Content Type"); } finally { blobUtil.RemoveContainer(container.Name); FileUtil.RemoveFile(filePath); } }
public void SetPageBlobWithInvalidFileSize() { string fileName = Utility.GenNameString("tinypageblob"); string filePath = Path.Combine(uploadDirRoot, fileName); int fileSize = 480; Helper.GenerateTinyFile(filePath, fileSize); string containerName = Utility.GenNameString("container"); StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName); try { List <StorageBlob.IListBlobItem> blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList(); Test.Assert(blobLists.Count == 0, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 0, blobLists.Count)); Test.Assert(!agent.SetAzureStorageBlobContent(filePath, containerName, StorageBlob.BlobType.PageBlob), "upload page blob with invalid file size should be failed."); string expectedErrorMessage = "The page blob size must be a multiple of 512 bytes."; Test.Assert(agent.ErrorMessages[0].StartsWith(expectedErrorMessage), expectedErrorMessage); blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList(); Test.Assert(blobLists.Count == 0, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 0, blobLists.Count)); } finally { blobUtil.RemoveContainer(containerName); FileUtil.RemoveFile(filePath); } }
public BlobManager(){ try { storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString")); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference("supstorage"); container.CreateIfNotExists(); } catch (ArgumentNullException) { Trace.TraceInformation("CloudStorageAccount Exception null ou vide"); // Use Application Local Storage Account String } catch (NullReferenceException) { Trace.TraceInformation("CloudBlobClient Or CloudBlobContainer Exception"); // Create Container } catch (FormatException) { Trace.TraceInformation("CloudStorageAccount Exception Connection String Invalid"); } catch (ArgumentException) { Trace.TraceInformation("CloudStorageAccount Exception connectionString ne peut pas être analysée"); } }
internal void UploadFromString(string accountName, string accountKey, string containerName, string fileName, string sourceFileName, string fileContentType, string content) //, string name, string fileDescription) { { Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse( string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1};BlobEndpoint=https://{0}.blob.core.windows.net/", accountName, accountKey) ); Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference(containerName); container.CreateIfNotExists(); string ext = System.IO.Path.GetExtension(sourceFileName); //string fileName = String.Format( Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(fileName); blockBlob.Properties.ContentType = fileContentType; //blockBlob.Metadata.Add("name", name); blockBlob.Metadata.Add("originalfilename", sourceFileName); //blockBlob.Metadata.Add("userid", userId.ToString()); //blockBlob.Metadata.Add("ownerid", userId.ToString()); DateTime created = DateTime.UtcNow; // https://msdn.microsoft.com/en-us/library/8kb3ddd4(v=vs.110).aspx // http://stackoverflow.com/questions/114983/given-a-datetime-object-how-do-i-get-a-iso-8601-date-in-string-format //blockBlob.Metadata.Add("username", userName); blockBlob.Metadata.Add("created", created.ToString("yyyy-MM-ddTHH:mm:ss")); // "yyyy-MM-ddTHH:mm:ssZ" blockBlob.Metadata.Add("modified", created.ToString("yyyy-MM-ddTHH:mm:ss")); // "yyyy-MM-ddTHH:mm:ssZ" blockBlob.Metadata.Add("fileext", ext); blockBlob.UploadText(content, Encoding.UTF8); // .UploadFromStream(fileInputStream); blockBlob.SetMetadata(); }
private static void InitStorage() { var credentials = new StorageCredentials(resources.AccountName, resources.AccountKey); var storageAccount = new CloudStorageAccount(credentials, true); var blobClient = storageAccount.CreateCloudBlobClient(); imagesContainer = blobClient.GetContainerReference("images"); }
public void ListBlobsWithBlobPermission() { string containerName = Utility.GenNameString(ContainerPrefix); StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName, StorageBlob.BlobContainerPublicAccessType.Blob); try { string pageBlobName = Utility.GenNameString("pageblob"); string blockBlobName = Utility.GenNameString("blockblob"); StorageBlob.ICloudBlob blockBlob = blobUtil.CreateBlockBlob(container, blockBlobName); StorageBlob.ICloudBlob pageBlob = blobUtil.CreatePageBlob(container, pageBlobName); Test.Assert(agent.GetAzureStorageBlob(blockBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true)); agent.OutputValidation(new List <StorageBlob.ICloudBlob> { blockBlob }); Test.Assert(agent.GetAzureStorageBlob(pageBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true)); agent.OutputValidation(new List <StorageBlob.ICloudBlob> { pageBlob }); } finally { blobUtil.RemoveContainer(containerName); } }
internal void GetContainerTest(Agent agent) { string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-"); Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Container, NEW_CONTAINER_NAME); // create container if it does not exist StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME); container.CreateIfNotExists(); Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> > { dic }; try { //--------------Get operation-------------- Test.Assert(agent.GetAzureStorageContainer(NEW_CONTAINER_NAME), Utility.GenComparisonData("GetAzureStorageContainer", true)); // Verification for returned values container.FetchAttributes(); dic.Add("CloudBlobContainer", container); CloudBlobUtil.PackContainerCompareData(container, dic); agent.OutputValidation(comp); } finally { // clean up container.DeleteIfExists(); } }
/// <summary> /// Parameters: /// Block: /// True for BlockBlob, false for PageBlob /// </summary> internal void UploadBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type) { string NEW_CONTAINER_NAME = Utility.GenNameString("upload-"); string blobName = Path.GetFileName(UploadFilePath); Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >(); Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName); dic["BlobType"] = Type; comp.Add(dic); // create the container StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME); container.CreateIfNotExists(); try { //--------------Upload operation-------------- Test.Assert(agent.SetAzureStorageBlobContent(UploadFilePath, NEW_CONTAINER_NAME, Type), Utility.GenComparisonData("SendAzureStorageBlob", true)); StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName); CloudBlobUtil.PackBlobCompareData(blob, dic); // Verification for returned values agent.OutputValidation(comp); Test.Assert(blob != null && blob.Exists(), "blob " + blobName + " should exist!"); } finally { // cleanup container.DeleteIfExists(); } }
internal void NewContainerTest(Agent agent) { string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-"); Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Container, NEW_CONTAINER_NAME); Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> > { dic }; // delete container if it exists StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME); container.DeleteIfExists(); try { //--------------New operation-------------- Test.Assert(agent.NewAzureStorageContainer(NEW_CONTAINER_NAME), Utility.GenComparisonData("NewAzureStorageContainer", true)); // Verification for returned values CloudBlobUtil.PackContainerCompareData(container, dic); agent.OutputValidation(comp); Test.Assert(container.Exists(), "container {0} should exist!", NEW_CONTAINER_NAME); } finally { // clean up container.DeleteIfExists(); } }
public void GetCopyStateFromMultiBlobsTest() { StorageBlob.CloudBlobContainer srcContainer = blobUtil.CreateContainer(); StorageBlob.CloudBlobContainer destContainer = blobUtil.CreateContainer(); List <StorageBlob.ICloudBlob> blobs = blobUtil.CreateRandomBlob(srcContainer); try { ((PowerShellAgent)agent).AddPipelineScript(String.Format("Get-AzureStorageBlob -Container {0}", srcContainer.Name)); ((PowerShellAgent)agent).AddPipelineScript(String.Format("Start-AzureStorageBlobCopy -DestContainer {0}", destContainer.Name)); Test.Assert(agent.GetAzureStorageBlobCopyState(string.Empty, string.Empty, true), "Get copy state for many blobs should be successed."); Test.Assert(agent.Output.Count == blobs.Count, String.Format("Expected get {0} copy state, and actually get {1} copy state", blobs.Count, agent.Output.Count)); List <StorageBlob.IListBlobItem> destBlobs = destContainer.ListBlobs().ToList(); Test.Assert(destBlobs.Count == blobs.Count, String.Format("Expected get {0} copied blobs, and actually get {1} copy state", blobs.Count, destBlobs.Count)); for (int i = 0, count = agent.Output.Count; i < count; i++) { AssertFinishedCopyState(blobs[i].Uri, i); } } finally { blobUtil.RemoveContainer(srcContainer.Name); blobUtil.RemoveContainer(destContainer.Name); } }
public void GetCopyStateFromCrossAccountCopyTest() { CloudStorageAccount secondaryAccount = TestBase.GetCloudStorageAccountFromConfig("Secondary"); object destContext = PowerShellAgent.GetStorageContext(secondaryAccount.ToString(true)); CloudBlobUtil destBlobUtil = new CloudBlobUtil(secondaryAccount); string destContainerName = Utility.GenNameString("secondary"); StorageBlob.CloudBlobContainer destContainer = destBlobUtil.CreateContainer(destContainerName); blobUtil.SetupTestContainerAndBlob(); //remove the same name container in source storage account, so we could avoid some conflicts. blobUtil.RemoveContainer(destContainer.Name); try { Test.Assert(agent.StartAzureStorageBlobCopy(blobUtil.Blob, destContainer.Name, string.Empty, destContext), "Start cross account copy should successed"); int expectedBlobCount = 1; Test.Assert(agent.Output.Count == expectedBlobCount, String.Format("Expected get {0} copy blob, and actually it's {1}", expectedBlobCount, agent.Output.Count)); StorageBlob.ICloudBlob destBlob = (StorageBlob.ICloudBlob)agent.Output[0]["ICloudBlob"]; //make sure this context is different from the PowerShell.Context object context = agent.Output[0]["Context"]; Test.Assert(PowerShellAgent.Context != context, "make sure you are using different context for cross account copy"); Test.Assert(agent.GetAzureStorageBlobCopyState(destBlob, context, true), "Get copy state in dest container should be successed."); AssertFinishedCopyState(blobUtil.Blob.Uri); } finally { blobUtil.CleanupTestContainerAndBlob(); destBlobUtil.RemoveContainer(destContainer.Name); } }
public void AnonymousContextWithEndPoint() { string containerName = Utility.GenNameString(ContainerPrefix); StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName, StorageBlob.BlobContainerPublicAccessType.Blob); try { string pageBlobName = Utility.GenNameString("pageblob"); string blockBlobName = Utility.GenNameString("blockblob"); StorageBlob.ICloudBlob blockBlob = blobUtil.CreateBlockBlob(container, blockBlobName); StorageBlob.ICloudBlob pageBlob = blobUtil.CreatePageBlob(container, pageBlobName); agent.UseContextParam = false; string cmd = string.Format("new-azurestoragecontext -StorageAccountName {0} " + "-Anonymous -EndPoint {1}", StorageAccountName, StorageEndPoint); ((PowerShellAgent)agent).AddPipelineScript(cmd); Test.Assert(agent.GetAzureStorageBlob(blockBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true)); agent.OutputValidation(new List <StorageBlob.ICloudBlob> { blockBlob }); ((PowerShellAgent)agent).AddPipelineScript(cmd); Test.Assert(agent.GetAzureStorageBlob(pageBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true)); agent.OutputValidation(new List <StorageBlob.ICloudBlob> { pageBlob }); } finally { blobUtil.RemoveContainer(containerName); } }
protected void SetContainerPermission(CloudBlobContainer container, BlobContainerPublicAccessType perimssion) { container.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = perimssion }); }
public BlobContainer(string name) { // hämta connectionsträngen från config // RoleEnviroment bestämmer settingvalue runtime //var connectionString = RoleEnvironment.GetConfigurationSettingValue("PhotoAppStorage"); //var connectionString = CloudConfigurationManager.GetSetting("CloudStorageApp"); // hämtar kontot utfrån connectionsträngens värde //var account = CloudStorageAccount.Parse(connectionString); //var account = CloudStorageAccount.DevelopmentStorageAccount; var cred = new StorageCredentials("jholm", "/bVipQ2JxjWwYrZQfHmzhaBx1p1s8BoD/wX6VWOmg4/gpVo/aALrjsDUKqzXsFtc9utepPqe65NposrXt9YsyA=="); var account = new CloudStorageAccount(cred, true); // skapar en blobclient _client = account.CreateCloudBlobClient(); m_BlobContainer = _client.GetContainerReference(name); // Om det inte finns någon container med det namnet if (!m_BlobContainer.Exists()) { // Skapa containern m_BlobContainer.Create(); var permissions = new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }; // Sätter public access till blobs m_BlobContainer.SetPermissions(permissions); } }
public static async Task<List<string>> CreateBlobsAsync(CloudBlobContainer container, int count, BlobType type) { string name; List<string> blobs = new List<string>(); for (int i = 0; i < count; i++) { switch (type) { case BlobType.BlockBlob: name = "bb" + Guid.NewGuid().ToString(); CloudBlockBlob blockBlob = container.GetBlockBlobReference(name); await blockBlob.PutBlockListAsync(new string[] { }); blobs.Add(name); break; case BlobType.PageBlob: name = "pb" + Guid.NewGuid().ToString(); CloudPageBlob pageBlob = container.GetPageBlobReference(name); await pageBlob.CreateAsync(0); blobs.Add(name); break; case BlobType.AppendBlob: name = "ab" + Guid.NewGuid().ToString(); CloudAppendBlob appendBlob = container.GetAppendBlobReference(name); await appendBlob.CreateOrReplaceAsync(); blobs.Add(name); break; } } return blobs; }
/// <summary> /// create a container with random properties and metadata /// </summary> /// <param name="containerName">container name</param> /// <returns>the created container object with properties and metadata</returns> public StorageBlob.CloudBlobContainer CreateContainer(string containerName = "") { if (String.IsNullOrEmpty(containerName)) { containerName = Utility.GenNameString("container"); } StorageBlob.CloudBlobContainer container = client.GetContainerReference(containerName); container.CreateIfNotExists(); //there is no properties to set container.FetchAttributes(); int minMetaCount = 1; int maxMetaCount = 5; int minMetaValueLength = 10; int maxMetaValueLength = 20; int count = random.Next(minMetaCount, maxMetaCount); for (int i = 0; i < count; i++) { string metaKey = Utility.GenNameString("metatest"); int valueLength = random.Next(minMetaValueLength, maxMetaValueLength); string metaValue = Utility.GenNameString("metavalue-", valueLength); container.Metadata.Add(metaKey, metaValue); } container.SetMetadata(); Test.Info(string.Format("create container '{0}'", containerName)); return(container); }
/// <summary> /// Initiates the SolCat Azure blob data sync. /// </summary> public static void CopyBlobData() { // Authentication Credentials for Azure Storage: var credsSrc = new StorageCredentials( ConfigHelper.GetConfigValue("HubContainerName"), ConfigHelper.GetConfigValue("HubContainerKey")); var credsDest = new StorageCredentials( ConfigHelper.GetConfigValue("NodeContainerKey"), ConfigHelper.GetConfigValue("NodeContainerKey")); // Source Container: Hub (Development) _srcContainer = new CloudBlobContainer( new Uri(ConfigHelper.GetConfigValue("HubContainerUri")), credsSrc); // Destination Container: Node (Production) _destContainer = new CloudBlobContainer( new Uri(ConfigHelper.GetConfigValue("NodeContainerUri")), credsDest); // Set permissions on the container: var permissions = new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Blob}; _srcContainer.SetPermissions(permissions); _destContainer.SetPermissions(permissions); // Call the blob copy master method: CopyBlobs(_srcContainer, _destContainer); }
public ContainerElementViewModel(CloudBlobContainer container) { if (container == null) throw new ArgumentNullException(nameof(container)); _container = container; }
public BlobFile2(FileEntity entity) { _username = entity.PartitionKey; _path = new FilePath(entity.Path); _entity = entity; _container = AzureServiceHelper.GetUserContainer(_username); }
/// <summary> Initialization function for this storage provider. </summary> /// <see cref="IProvider.Init"/> public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { Log = providerRuntime.GetLogger("Storage.AzureBlobStorage"); try { this.Name = name; ConfigureJsonSerializerSettings(config); if (!config.Properties.ContainsKey("DataConnectionString")) throw new BadProviderConfigException("The DataConnectionString setting has not been configured in the cloud role. Please add a DataConnectionString setting with a valid Azure Storage connection string."); var account = CloudStorageAccount.Parse(config.Properties["DataConnectionString"]); var blobClient = account.CreateCloudBlobClient(); var containerName = config.Properties.ContainsKey("ContainerName") ? config.Properties["ContainerName"] : "grainstate"; container = blobClient.GetContainerReference(containerName); await container.CreateIfNotExistsAsync().ConfigureAwait(false); Log.Info((int)AzureProviderErrorCode.AzureBlobProvider_InitProvider, "Init: Name={0} ServiceId={1} {2}", name, providerRuntime.ServiceId.ToString(), string.Join(" ", FormatPropertyMessage(config))); Log.Info((int)AzureProviderErrorCode.AzureBlobProvider_ParamConnectionString, "AzureBlobStorage Provider is using DataConnectionString: {0}", ConfigUtilities.PrintDataConnectionInfo(config.Properties["DataConnectionString"])); } catch (Exception ex) { Log.Error((int)AzureProviderErrorCode.AzureBlobProvider_InitProvider, ex.ToString(), ex); throw; } }
public AzureAsyncAppender(CloudStorageAccount storage, string container, AzureBlobAppenderOptions options = null) { this.storage = storage; this.container = container; this.options = options; this.client = this.storage.CreateCloudBlobClient().GetContainerReference(container); }
public void InitializeContainer(string container) { var blobClient = StorageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference(container); blobContainer.CreateIfNotExists(); blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }); }
public BlobStorage(BlobSettings appSettings) { try { if (appSettings.ImageSize != null) ResizeLayer = new ResizeLayer(appSettings.ImageSize, ResizeMode.Min); UploadThumbnail = appSettings.UploadThumbnail; StorageAccountName = appSettings.StorageAccountName; StorageAccountAccessKey = appSettings.StorageAccountAccessKey; // Create a blob client and retrieve reference to images container BlobClient = StorageAccount.CreateCloudBlobClient(); Container = BlobClient.GetContainerReference(appSettings.ContainerName); // Create the "images" container if it doesn't already exist. if (Container.CreateIfNotExists()) { // Enable public access on the newly created "images" container Container.SetPermissions( new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); } } catch (Exception ex) { Debug.WriteLine(ex); } }
private void Init() { var connectionString = ConfigurationManager.ConnectionStrings["BlobStorage"].ConnectionString; var storageAccount = CloudStorageAccount.Parse(connectionString); _blobClient = storageAccount.CreateCloudBlobClient(); _blobContainer = _blobClient.GetContainerReference(ConfigurationManager.AppSettings["PhotoContainer"]); }
public override bool OnStart() { ServicePointManager.DefaultConnectionLimit = 12; var dbConnString = CloudConfigurationManager.GetSetting("PhotoGalleryDbConnectionString"); db = new PhotoGalleryContext(dbConnString); var storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); Trace.TraceInformation("Creating images blob container"); var blobClient = storageAccount.CreateCloudBlobClient(); imagesBlobContainer = blobClient.GetContainerReference("images"); if (imagesBlobContainer.CreateIfNotExists()) { imagesBlobContainer.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); } Trace.TraceInformation("Creating images queue"); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); imagesQueue = queueClient.GetQueueReference("images"); imagesQueue.CreateIfNotExists(); Trace.TraceInformation("Storage initialized"); return base.OnStart(); }
private void GetClientAndReference() { var account = CloudStorageAccount.Parse(_source.ConnectionString); var client = account.CreateCloudBlobClient(); _containerReference = client.GetContainerReference(_source.ContainerName); _containerReference.CreateIfNotExists(); }
private static void InitStorage() { var credentials = new StorageCredentials(AppKeys.Storage_Account_Name, AppKeys.PrimaryAccessKey); var storageAccount = new CloudStorageAccount(credentials, true); var blobClient = storageAccount.CreateCloudBlobClient(); imagesContainer = blobClient.GetContainerReference("images"); }
public static void ParallelUploadFile(CloudBlobContainer blobContainer, string blobName, string filePath, string contentType = null) { var start = DateTime.Now; Console.WriteLine("\nUpload file in parallel."); CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(blobName); // 2M blocks for demo int blockLength = 2 * 1000 * 1024; byte[] dataToUpload = File.ReadAllBytes(filePath); int numberOfBlocks = (dataToUpload.Length / blockLength) + 1; string[] blockIds = new string[numberOfBlocks]; Parallel.For(0, numberOfBlocks, x => { var blockId = Convert.ToBase64String(Guid.NewGuid().ToByteArray()); var currentLength = Math.Min(blockLength, dataToUpload.Length - (x * blockLength)); using (var memStream = new MemoryStream(dataToUpload, x * blockLength, currentLength)) { blockBlob.PutBlock(blockId, memStream, null); } blockIds[x] = blockId; Console.WriteLine("BlockId:{0}", blockId); }); if (!String.IsNullOrEmpty(contentType)) { blockBlob.Properties.ContentType = contentType; } blockBlob.PutBlockList(blockIds); Console.WriteLine("URL:{0}, ETag:{1}", blockBlob.Uri, blockBlob.Properties.ETag); var timespan = DateTime.Now - start; Console.WriteLine("{0} seconds.", timespan.Seconds); }
public static void ListBlobs(CloudBlobContainer blobContainer, BlobListing blobListing, String prefix = null) { if (blobListing == BlobListing.Flat) { foreach (var blockBlob in blobContainer.ListBlobs(prefix: null, useFlatBlobListing: true)) { Console.WriteLine("{0,-10} - {1}", @"Blob", ((CloudBlockBlob)blockBlob).Name); Console.WriteLine("{0,-10} - {1}", String.Empty, blockBlob.Uri); } } else if (blobListing == BlobListing.Hierarchical) { foreach (var blockBlob in blobContainer.ListBlobs(prefix: prefix, useFlatBlobListing: false)) { if (blockBlob is CloudBlockBlob) { Console.WriteLine("{0,-10} - {1}", @"Blob", ((CloudBlockBlob)blockBlob).Name); Console.WriteLine("{0,-10} - {1}", String.Empty, blockBlob.Uri); } else if (blockBlob is CloudBlobDirectory) { Console.WriteLine("{0,-10} - {1}", @"Directory", ((CloudBlobDirectory)blockBlob).Prefix); Console.WriteLine("{0,-10} - {1}", String.Empty, blockBlob.Uri); ListBlobs(blobContainer, BlobListing.Hierarchical, ((CloudBlobDirectory)blockBlob).Prefix); } } } }
public void SetBlobContentWithInvalidBlobType() { string containerName = Utility.GenNameString("container"); StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName); try { string blobName = files[0]; List <StorageBlob.IListBlobItem> blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList(); Test.Assert(blobLists.Count == 0, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 0, blobLists.Count)); Test.Assert(agent.SetAzureStorageBlobContent(Path.Combine(uploadDirRoot, files[0]), containerName, StorageBlob.BlobType.BlockBlob, blobName), "upload blob should be successful."); blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList(); Test.Assert(blobLists.Count == 1, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 1, blobLists.Count)); string convertBlobName = blobUtil.ConvertFileNameToBlobName(blobName); Test.Assert(((StorageBlob.ICloudBlob)blobLists[0]).Name == convertBlobName, string.Format("blob name should be {0}, actually it's {1}", convertBlobName, ((StorageBlob.ICloudBlob)blobLists[0]).Name)); Test.Assert(!agent.SetAzureStorageBlobContent(Path.Combine(uploadDirRoot, files[0]), containerName, StorageBlob.BlobType.PageBlob, blobName), "upload blob should be with invalid blob should be failed."); string expectedErrorMessage = string.Format("Blob type mismatched, the current blob type of '{0}' is BlockBlob.", ((StorageBlob.ICloudBlob)blobLists[0]).Name); Test.Assert(agent.ErrorMessages[0] == expectedErrorMessage, string.Format("Expect error message: {0} != {1}", expectedErrorMessage, agent.ErrorMessages[0])); } finally { blobUtil.RemoveContainer(containerName); } }
public static void UploadFileToBlob(string fileName, string containerSAS) { Console.WriteLine("Uploading {0} to {1}", fileName, containerSAS); CloudBlobContainer container = new CloudBlobContainer(new Uri(containerSAS)); CloudBlockBlob blob = container.GetBlockBlobReference(fileName); blob.UploadFromStream(new FileStream(fileName, FileMode.Open, FileAccess.Read)); }
internal void UploadBlobTestGB(Agent agent, StorageBlob.BlobType blobType) { string uploadFilePath = @".\" + Utility.GenNameString("gbupload"); string containerName = Utility.GenNameString("gbupload-"); string blobName = Path.GetFileName(uploadFilePath); // create the container StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName); // Generate a 512 bytes file which contains GB18030 characters File.WriteAllText(uploadFilePath, GB18030String); try { //--------------Upload operation-------------- Test.Assert(agent.SetAzureStorageBlobContent(uploadFilePath, containerName, blobType), Utility.GenComparisonData("SendAzureStorageBlob", true)); StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(container, blobName, blobType); Test.Assert(blob != null && blob.Exists(), "blob " + blobName + " should exist!"); // Check MD5 string localMd5 = Helper.GetFileContentMD5(uploadFilePath); blob.FetchAttributes(); Test.Assert(localMd5 == blob.Properties.ContentMD5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5)); } finally { // cleanup container.DeleteIfExists(); File.Delete(uploadFilePath); } }
public AzureIndexInput(AzureDirectory azuredirectory, ICloudBlob blob) : base(blob.Name) { _name = blob.Uri.Segments[blob.Uri.Segments.Length - 1]; _fileMutex = BlobMutexManager.GrabMutex(_name); _fileMutex.WaitOne(); try { _azureDirectory = azuredirectory; _blobContainer = azuredirectory.BlobContainer; _blob = blob; string fileName = _name; StreamOutput fileStream = _azureDirectory.CreateCachedOutputAsStream(fileName); // get the blob _blob.DownloadToStream(fileStream); fileStream.Flush(); Debug.WriteLine("GET {0} RETREIVED {1} bytes", _name, fileStream.Length); fileStream.Close(); // and open it as an input _indexInput = CacheDirectory.openInput(fileName, IOContext.DEFAULT); } finally { _fileMutex.ReleaseMutex(); } }
private async Task<bool> CloudBlobDirectorySetupWithDelimiterAsync(CloudBlobContainer container, string delimiter = "/") { try { for (int i = 1; i < 3; i++) { for (int j = 1; j < 3; j++) { for (int k = 1; k < 3; k++) { String directory = "TopDir" + i + delimiter + "MidDir" + j + delimiter + "EndDir" + k + delimiter + "EndBlob" + k; CloudPageBlob blob1 = container.GetPageBlobReference(directory); await blob1.CreateAsync(0); } } CloudPageBlob blob2 = container.GetPageBlobReference("TopDir" + i + delimiter + "Blob" + i); await blob2.CreateAsync(0); } return true; } catch (Exception e) { throw e; } }
public async Task CopyContainer(CloudBlobContainer sourceContainer, string destination) { var uri = new Uri(sourceContainer.Uri.AbsoluteUri.TrimEnd('/') + '/'); destination = Path.Combine(destination, sourceContainer.Name); BlobContinuationToken continuationToken = null; do { var segments = await sourceContainer.ListBlobsSegmentedAsync(prefix: null, useFlatBlobListing: true, blobListingDetails: BlobListingDetails.Metadata, maxResults: MaxParallelDownloads, currentToken: continuationToken, options: null, operationContext: null); var tasks = new BlockingCollection<Task>(MaxParallelDownloads); Parallel.ForEach(segments.Results.Cast<CloudBlockBlob>(), srcFile => { var relativePath = uri.MakeRelativeUri(srcFile.Uri); var destLocation = Path.Combine(destination, relativePath.OriginalString); if (File.Exists(destLocation) && File.GetLastWriteTimeUtc(destLocation) == srcFile.Properties.LastModified) { // If the file looks unchanged, skip it. return; } Directory.CreateDirectory(Path.GetDirectoryName(destLocation)); tasks.Add(srcFile.DownloadToFileAsync(destLocation, FileMode.Create)); }); await Task.WhenAll(tasks); continuationToken = segments.ContinuationToken; } while (continuationToken != null); }
public async Task Init( string name, IProviderRuntime providerRuntime, IProviderConfiguration config ) { Log = providerRuntime.GetLogger( this.GetType().Name ); try { ConfigureJsonSerializerSettings( config ); if( !config.Properties.ContainsKey( "DataConnectionString" ) ) { throw new BadProviderConfigException( "The DataConnectionString setting has not been configured in the cloud role. Please add a DataConnectionString setting with a valid Azure Storage connection string." ); } else { var account = CloudStorageAccount.Parse( config.Properties[ "DataConnectionString" ] ); var blobClient = account.CreateCloudBlobClient(); var containerName = config.Properties.ContainsKey( "ContainerName" ) ? config.Properties[ "ContainerName" ] : "grainstate"; container = blobClient.GetContainerReference( containerName ); await container.CreateIfNotExistsAsync(); } } catch( Exception ex ) { Log.Error( 0, ex.ToString(), ex ); throw; } }
public static void PackContainerCompareData(StorageBlob.CloudBlobContainer container, Dictionary <string, object> dic) { StorageBlob.BlobContainerPermissions permissions = container.GetPermissions(); dic["PublicAccess"] = permissions.PublicAccess; dic["Permission"] = permissions; dic["LastModified"] = container.Properties.LastModified; }
/// <summary> /// Occurs when a storage provider operation has completed. /// </summary> //public event EventHandler<StorageProviderEventArgs> StorageProviderOperationCompleted; #endregion // Initialiser method private void Initialise(string storageAccount, string containerName) { if (String.IsNullOrEmpty(containerName)) throw new ArgumentException("You must provide the base Container Name", "containerName"); ContainerName = containerName; _account = CloudStorageAccount.Parse(storageAccount); _blobClient = _account.CreateCloudBlobClient(); _container = _blobClient.GetContainerReference(ContainerName); try { _container.FetchAttributes(); } catch (StorageException) { Trace.WriteLine(string.Format("Create new container: {0}", ContainerName), "Information"); _container.Create(); // set new container's permissions // Create a permission policy to set the public access setting for the container. BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); // The public access setting explicitly specifies that the container is private, // so that it can't be accessed anonymously. containerPermissions.PublicAccess = BlobContainerPublicAccessType.Off; //Set the permission policy on the container. _container.SetPermissions(containerPermissions); } }
public override bool OnStart() { ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount; // Read storage account configuration settings ConfigureDiagnostics(); Trace.TraceInformation("Initializing storage account in worker role B"); var storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); // Initialize queue storage Trace.TraceInformation("Creating queue client."); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); sendEmailQueue = queueClient.GetQueueReference("azuremailqueue"); subscribeQueue = queueClient.GetQueueReference("azuremailsubscribequeue"); // Initialize blob storage CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference("azuremailblobcontainer"); // Initialize table storage var tableClient = storageAccount.CreateCloudTableClient(); mailingListTable = tableClient.GetTableReference("mailinglist"); messageTable = tableClient.GetTableReference("message"); messagearchiveTable = tableClient.GetTableReference("messagearchive"); Trace.TraceInformation("WorkerB: Creating blob container, queue, tables, if they don't exist."); blobContainer.CreateIfNotExists(); sendEmailQueue.CreateIfNotExists(); subscribeQueue.CreateIfNotExists(); this.messageTable.CreateIfNotExists(); this.mailingListTable.CreateIfNotExists(); this.messagearchiveTable.CreateIfNotExists(); return base.OnStart(); }
public AzureFileSystem(string containerName, string root, bool isPrivate, CloudStorageAccount storageAccount) { // Setup the connection to custom storage accountm, e.g. Development Storage _storageAccount = storageAccount; ContainerName = containerName; _root = String.IsNullOrEmpty(root) ? "": root + "/"; _absoluteRoot = Combine(Combine(_storageAccount.BlobEndpoint.AbsoluteUri, containerName), _root); //using ( new HttpContextWeaver() ) { BlobClient = _storageAccount.CreateCloudBlobClient(); // Get and create the container if it does not exist // The container is named with DNS naming restrictions (i.e. all lower case) Container = BlobClient.GetContainerReference(ContainerName); Container.CreateIfNotExists(); Container.SetPermissions(isPrivate ? new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off} : new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Blob}); // deny listing } }
public static List<string> CreateBlobsTask(CloudBlobContainer container, int count, BlobType type) { string name; List<string> blobs = new List<string>(); for (int i = 0; i < count; i++) { switch (type) { case BlobType.BlockBlob: name = "bb" + Guid.NewGuid().ToString(); CloudBlockBlob blockBlob = container.GetBlockBlobReference(name); blockBlob.PutBlockListAsync(new string[] { }).Wait(); blobs.Add(name); break; case BlobType.PageBlob: name = "pb" + Guid.NewGuid().ToString(); CloudPageBlob pageBlob = container.GetPageBlobReference(name); pageBlob.CreateAsync(0).Wait(); blobs.Add(name); break; } } return blobs; }
public AzureImageUploader() { var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); _blobClient = storageAccount.CreateCloudBlobClient(); _container = FindOrCreateContainer(ContainerName); _filecontainer = FindOrCreateContainer(FileContainerName); }
public List<CloudBlockBlob> GetBlobs(CloudBlobContainer container, string filter = "") { return container.ListBlobs() .OfType<CloudBlockBlob>() .Where(b => String.IsNullOrEmpty(filter) || b.Name.Contains(filter)) .ToList(); }
public static List<string> CreateLogs(CloudBlobContainer container, StorageService service, int count, DateTime start, string granularity) { string name; List<string> blobs = new List<string>(); for (int i = 0; i < count; i++) { CloudBlockBlob blockBlob; switch (granularity) { case "hour": name = string.Concat(service.ToString().ToLowerInvariant(), "/", start.AddHours(i).ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture), "00/000001.log"); break; case "day": name = string.Concat(service.ToString().ToLowerInvariant(), "/", start.AddDays(i).ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture), "00/000001.log"); break; case "month": name = string.Concat(service.ToString().ToLowerInvariant(), "/", start.AddMonths(i).ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture), "00/000001.log"); break; default: throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "CreateLogs granularity of '{0}' is invalid.", granularity)); } blockBlob = container.GetBlockBlobReference(name); blockBlob.PutBlockList(new string[] { }); blobs.Add(name); } return blobs; }
public StorageBlob.CloudBlobContainer CreateContainer(string containerName, StorageBlob.BlobContainerPublicAccessType permission) { StorageBlob.CloudBlobContainer container = CreateContainer(containerName); StorageBlob.BlobContainerPermissions containerPermission = new StorageBlob.BlobContainerPermissions(); containerPermission.PublicAccess = permission; container.SetPermissions(containerPermission); return(container); }
/// <summary> /// Create a random container with a random blob /// </summary> public void SetupTestContainerAndBlob() { ContainerName = Utility.GenNameString("container"); BlobName = Utility.GenNameString("blob"); StorageBlob.CloudBlobContainer container = CreateContainer(ContainerName); Blob = CreateRandomBlob(container, BlobName); Container = container; }
//Delete a blob file public void DeleteBlob(string UserId, string BlobName) { Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId); Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName); if (blockBlob.Exists()) { blockBlob.Delete(); } }
public string DownloadPublicBlob(string UserId, string BlobName, bool PublicAccess = true) { //Retrieve a reference to a container. //Retrieve storage account from connection string. Microsoft.WindowsAzure.Storage.CloudStorageAccount StorageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(Convert.ToString(ConfigurationManager.AppSettings["StorageConnectionString"])); // Create the blob client. Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient(); // Retrieve a reference to a container. Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference(UserId); // Create the container if it doesn't exist. container.CreateIfNotExists(); //Set permission to public if (PublicAccess) { container.SetPermissions( new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions { PublicAccess = Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Blob }); } else { container.SetPermissions( new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions { PublicAccess = Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Off }); } // Retrieve reference to a blob named Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName); //var sasToken = blockBlob.GetSharedAccessSignature(new SharedAccessBlobPolicy() //{ // Permissions = SharedAccessBlobPermissions.Read, // SharedAccessExpiryTime = DateTime.UtcNow.AddMinutes(10),//assuming the blob can be downloaded in 10 miinutes //}, new SharedAccessBlobHeaders() //{ // ContentDisposition = "attachment; filename=file-name" //}); //return string.Format("{0}{1}", blockBlob.Uri, sasToken); return(blockBlob.Uri.ToString()); }
public void SetBlobContentWithSubDirectory() { DirectoryInfo rootDir = new DirectoryInfo(uploadDirRoot); DirectoryInfo[] dirs = rootDir.GetDirectories(); foreach (DirectoryInfo dir in dirs) { string containerName = Utility.GenNameString("container"); StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName); try { List <StorageBlob.IListBlobItem> blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList(); Test.Assert(blobLists.Count == 0, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 0, blobLists.Count)); StorageBlob.BlobType blobType = StorageBlob.BlobType.BlockBlob; if (dir.Name.StartsWith("dirpage")) { blobType = Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob; } ((PowerShellAgent)agent).AddPipelineScript(string.Format("ls -File -Recurse -Path {0}", dir.FullName)); Test.Info("Upload files..."); Test.Assert(agent.SetAzureStorageBlobContent(string.Empty, containerName, blobType), "upload multiple files should be successsed"); Test.Info("Upload finished..."); blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList(); List <string> dirFiles = files.FindAll(item => item.StartsWith(dir.Name)); Test.Assert(blobLists.Count == dirFiles.Count(), string.Format("set-azurestorageblobcontent should upload {0} files, and actually it's {1}", dirFiles.Count(), blobLists.Count)); StorageBlob.ICloudBlob blob = null; for (int i = 0, count = dirFiles.Count(); i < count; i++) { blob = blobLists[i] as StorageBlob.ICloudBlob; if (blob == null) { Test.AssertFail("blob can't be null"); } string convertedName = blobUtil.ConvertBlobNameToFileName(blob.Name, dir.Name); Test.Assert(dirFiles[i] == convertedName, string.Format("blob name should be {0}, and actully it's {1}", dirFiles[i], convertedName)); string localMd5 = Helper.GetFileContentMD5(Path.Combine(uploadDirRoot, dirFiles[i])); Test.Assert(blob.BlobType == blobType, "blob type should be block blob"); Test.Assert(localMd5 == blob.Properties.ContentMD5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5)); } } finally { blobUtil.RemoveContainer(containerName); } } }
//Upload a Blob File public void UploadByteBlob(string UserId, string BlobName, string ContentType, byte[] image) { // Retrieve a reference to a container. Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId); // Retrieve reference to a blob named Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName); blockBlob.Properties.ContentType = ContentType; blockBlob.UploadFromByteArray(image, 0, image.Length); }
// Upload a Blob File public void UploadBlob(string UserId, string BlobName, HttpPostedFileBase image, int timeout = 60) { // Retrieve a reference to a container. Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId); // Retrieve reference to a blob named Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName); blockBlob.Properties.ContentType = image.ContentType; blockBlob.UploadFromStream(image.InputStream); }
/// <summary> /// Create a blob with specified blob type /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">Blob name</param> /// <param name="type">Blob type</param> /// <returns>ICloudBlob object</returns> public StorageBlob.ICloudBlob CreateBlob(StorageBlob.CloudBlobContainer container, string blobName, StorageBlob.BlobType type) { if (type == StorageBlob.BlobType.BlockBlob) { return(CreateBlockBlob(container, blobName)); } else { return(CreatePageBlob(container, blobName)); } }
public List <StorageBlob.ICloudBlob> CreateRandomBlob(StorageBlob.CloudBlobContainer container) { int count = random.Next(1, 5); List <string> blobNames = new List <string>(); for (int i = 0; i < count; i++) { blobNames.Add(Utility.GenNameString("blob")); } return(CreateRandomBlob(container, blobNames)); }
private void LogError(Exception ex, string message) { //ConfigurationManager.ConnectionStrings["CineStorageConStr"].ConnectionString Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("CineStorageConStr")); Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); // Retrieve a reference to a container. Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference("data"); Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob logBlob = container.GetBlockBlobReference(String.Format(this.LogFile, DateTime.UtcNow.ToString("dd MMM yyyy"))); try { using (StreamReader sr = new StreamReader(logBlob.OpenRead())) { using (StreamWriter sw = new StreamWriter(logBlob.OpenWrite())) { sw.Write(sr.ReadToEnd()); if (ex != null) { sw.Write(System.Environment.NewLine); sw.WriteLine(ex.Message); sw.WriteLine(ex.StackTrace); sw.Write(System.Environment.NewLine); if (ex.InnerException != null) { sw.Write(System.Environment.NewLine); sw.WriteLine(ex.InnerException.Message); sw.WriteLine(ex.InnerException.StackTrace); sw.Write(System.Environment.NewLine); } } if (message != null) { sw.Write(System.Environment.NewLine); sw.WriteLine(message); sw.Write(System.Environment.NewLine); } } } } catch { } }
/// <summary> /// clean test container and blob /// </summary> public void CleanupTestContainerAndBlob() { if (String.IsNullOrEmpty(ContainerName)) { return; } RemoveContainer(ContainerName); ContainerName = string.Empty; BlobName = string.Empty; Blob = null; Container = null; }
/// <summary> /// create a list of blobs with random properties/metadata/blob type /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">a list of blob names</param> /// <returns>a list of cloud page blobs</returns> public List <StorageBlob.ICloudBlob> CreateRandomBlob(StorageBlob.CloudBlobContainer container, List <string> blobNames) { List <StorageBlob.ICloudBlob> blobs = new List <StorageBlob.ICloudBlob>(); foreach (string blobName in blobNames) { blobs.Add(CreateRandomBlob(container, blobName)); } blobs = blobs.OrderBy(blob => blob.Name).ToList(); return(blobs); }
public static StorageBlob.ICloudBlob GetBlob(StorageBlob.CloudBlobContainer container, string blobName, StorageType blobType) { StorageBlob.ICloudBlob blob = null; if (blobType == StorageType.BlockBlob) { blob = container.GetBlockBlobReference(blobName); } else { blob = container.GetPageBlobReference(blobName); } return(blob); }
/// <summary> /// create a new page blob with random properties and metadata /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">blob name</param> /// <returns>ICloudBlob object</returns> public StorageBlob.ICloudBlob CreatePageBlob(StorageBlob.CloudBlobContainer container, string blobName) { StorageBlob.CloudPageBlob pageBlob = container.GetPageBlobReference(blobName); int size = random.Next(1, 10) * PageBlobUnitSize; pageBlob.Create(size); byte[] buffer = new byte[size]; string md5sum = Convert.ToBase64String(Helper.GetMD5(buffer)); pageBlob.Properties.ContentMD5 = md5sum; GenerateBlobPropertiesAndMetaData(pageBlob); Test.Info(string.Format("create page blob '{0}' in container '{1}'", blobName, container.Name)); return(pageBlob); }
internal void CopyBlobTestGB(Agent agent, StorageBlob.BlobType blobType) { string uploadFilePath = @".\" + Utility.GenNameString("gbupload"); string srcContainerName = Utility.GenNameString("gbupload-", 15); string destContainerName = Utility.GenNameString("gbupload-", 15); string blobName = Path.GetFileName(uploadFilePath); // create the container StorageBlob.CloudBlobContainer srcContainer = blobUtil.CreateContainer(srcContainerName); StorageBlob.CloudBlobContainer destContainer = blobUtil.CreateContainer(destContainerName); // Generate a 512 bytes file which contains GB18030 characters File.WriteAllText(uploadFilePath, GB18030String); string localMd5 = Helper.GetFileContentMD5(uploadFilePath); try { // create source blob StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(srcContainer, blobName, blobType); // upload file data using (var fileStream = System.IO.File.OpenRead(uploadFilePath)) { blob.UploadFromStream(fileStream); // need to set MD5 as for page blob, it won't set MD5 automatically blob.Properties.ContentMD5 = localMd5; blob.SetProperties(); } //--------------Copy blob operation-------------- Test.Assert(agent.StartAzureStorageBlobCopy(srcContainerName, blobName, destContainerName, blobName), Utility.GenComparisonData("Start copy blob using blob name", true)); // Get destination blob blob = CloudBlobUtil.GetBlob(destContainer, blobName, blobType); // Check MD5 blob.FetchAttributes(); Test.Assert(localMd5 == blob.Properties.ContentMD5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5)); } finally { // cleanup srcContainer.DeleteIfExists(); destContainer.DeleteIfExists(); File.Delete(uploadFilePath); } }
/// <summary> /// Create a list of blobs with random properties/metadata/blob type /// </summary> /// <param name="container">CloudBlobContainer object</param> /// <param name="blobName">Blob name</param> /// <returns>ICloudBlob object</returns> public StorageBlob.ICloudBlob CreateRandomBlob(StorageBlob.CloudBlobContainer container, string blobName) { int switchKey = 0; switchKey = random.Next(0, 2); if (switchKey == 0) { return(CreatePageBlob(container, blobName)); } else { return(CreateBlockBlob(container, blobName)); } }