public CloudBlob UploadText(string blobName, string text, string containerName, bool isPublic) { var container = BlobClient.GetContainerReference(containerName); container.CreateIfNotExist(); if (isPublic) { var permissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container }; container.SetPermissions(permissions); } else { var permissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off }; container.SetPermissions(permissions); } var blob = container.GetBlockBlobReference(blobName); blob.UploadText(text); return blob; }
public string Get(string blobName, string contentType) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse( string.Format("DefaultEndpointsProtocol=http;AccountName={0};AccountKey={1}", storageAccountName, storageAccountKey)); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer blobContainer = blobClient.GetContainerReference(containerName); blobContainer.CreateIfNotExist(); BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; containerPermissions.SharedAccessPolicies.Add("mypolicy", new SharedAccessPolicy() { Permissions = SharedAccessPermissions.Write | SharedAccessPermissions.Read , SharedAccessExpiryTime = DateTime.Now.Add(TimeSpan.FromHours(4)) }); blobContainer.SetPermissions(containerPermissions); string sas = blobContainer.GetSharedAccessSignature(new SharedAccessPolicy(), "mypolicy"); return string.Format("{0}/{1}{2}", blobContainer.Uri, blobName, sas); }
public void CreateIfNotExist(CloudBlobContainer cloudBlobContainer, bool isPublic = true) { cloudBlobContainer.CreateIfNotExist(); var permission = cloudBlobContainer.GetPermissions(); var blobContainerPermissions = new BlobContainerPermissions {PublicAccess = isPublic ? BlobContainerPublicAccessType.Container : BlobContainerPublicAccessType.Off}; cloudBlobContainer.SetPermissions(blobContainerPermissions); }
public List<BlobFileresult> getAllBlobsUnderCourse(Guid courseId) { List<BlobFileresult> blobUris = new List<BlobFileresult>(); CloudBlobContainer container = blobClient.GetContainerReference(courseId.ToString()); if (container.CreateIfNotExist()) { BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(containerPermissions); } // Loop over items within the container and output the length and URI. foreach (IListBlobItem item in container.ListBlobs()) { if (item.GetType() == typeof(CloudBlockBlob)) { CloudBlockBlob blob = (CloudBlockBlob)item; int lastIndexOfSpecialChar = blob.Name.LastIndexOf(specialChar); int lastIndexOfExtensionChar = blob.Name.LastIndexOf(extensionChar); string blobNameWithoutOwner = blob.Name.Substring(0,lastIndexOfSpecialChar); string ownerName = blob.Name.Substring(lastIndexOfSpecialChar + 1, lastIndexOfExtensionChar - lastIndexOfSpecialChar - 1); blobUris.Add(new BlobFileresult(blobNameWithoutOwner, blob.Uri, ownerName, blob.Properties.LastModifiedUtc)); } } return blobUris; }
public void Create(bool publiccontainer) { // Create if it doesn't exist Container.CreateIfNotExist(); var perm = new BlobContainerPermissions(); perm.PublicAccess = publiccontainer ? BlobContainerPublicAccessType.Blob : BlobContainerPublicAccessType.Off; Container.SetPermissions(perm); }
/// <summary> /// Creates the bucket. /// </summary> /// <param name="name">The name.</param> public void CreateBucket(string name) { CloudBlobContainer container = GetProvider(name); BlobContainerPermissions permissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container }; container.CreateIfNotExist(); container.SetPermissions(permissions); }
/// <summary> /// Init the container with the specified name. /// The container is initialized with Blog Public Access permissions /// </summary> /// <param name="containerName">Name of container to INIT</param> public static void InitContainer(string containerName) { var _blobClient = Account.CreateCloudBlobClient(); var _blobContainer = _blobClient.GetContainerReference(containerName); var permissions = new BlobContainerPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Blob; _blobContainer.CreateIfNotExist(); _blobContainer.SetPermissions(permissions); }
/// <summary> /// deletes the contents of a logging blob. /// </summary> /// <param name="blobName"></param> public static void clearLogBlob(string blobName) { string baseUri = ""; CloudBlobContainer blobContainer = initContainer(AccountInfo.LogContainer, ref baseUri); blobContainer.CreateIfNotExist(); var perms = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container // Blob (see files if you know the name) or Container (enumerate like a directory) }; blobContainer.SetPermissions(perms); // This line makes the blob public so it is available from a web browser (no magic needed to read it) CloudBlob blob = blobContainer.GetBlobReference(blobName); blob.DeleteIfExists(); }
public ActionResult Delete(string url) { var blobContainer = this.blobClient.GetContainerReference(ConfigReader.GetConfigValue("TileImagesContainer")); if (blobContainer.CreateIfNotExist()) { var permissions = new BlobContainerPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; blobContainer.SetPermissions(permissions); } var blob = blobContainer.GetBlobReference(url); blob.DeleteIfExists(); return RedirectToAction("Index"); }
static void CreateContainer() { //get blob container account = CloudStorageAccount.FromConfigurationSetting("BlobConnectionString"); client = account.CreateCloudBlobClient(); container = client.GetContainerReference("userphotos"); container.CreateIfNotExist(); BlobContainerPermissions permissions = new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }; container.SetPermissions(permissions); }
/// <summary> /// Creates container with given name and permissions /// </summary> /// <param name="containerName"></param> /// <param name="containerPermissions"></param> /// <returns></returns> public bool CreateContainer(string containerName, BlobContainerPermissions containerPermissions) { CloudBlobContainer container = blobManager.GetContainerReference(containerName); try { container.CreateIfNotExist(); container.SetPermissions(containerPermissions); return true; } catch (Exception) { } return false; }
public static void log(string message = "") { Settings settings = new Settings(); string loggingstring = settings.Get("logging"); bool isLoggingEnabled = (loggingstring.ToLower().Trim() != "true") ? false : true; if (isLoggingEnabled) { DiscountBlobContainer logblobs = new DiscountBlobContainer(); logblobs = BlobManagement.GetContainer("logs"); BlobContainerPermissions perms = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }; logblobs.Container.SetPermissions(perms); CloudBlob blob = logblobs.Container.GetBlobReference("log-" + String.Format("{0:MM-dd-yyyy}", DateTime.Now) + ".txt"); string blobtext = ""; try { blobtext = blob.DownloadText(); } catch { }; blob.UploadText(blobtext + String.Format("{0:M-d-yyyy HH:mm:ss.fff: }", DateTime.Now) + message + Environment.NewLine); } }
public string AddToBucket(string bucketName, string path) { var blobContainer = blobStorage.GetContainerReference(bucketName); blobContainer.CreateIfNotExist(); var containerPermissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }; blobContainer.SetPermissions(containerPermissions); var blobReference = blobContainer.GetBlobReference(Path.GetFileName(path)); blobReference.Properties.ContentType = "image/jpeg"; blobReference.UploadFile(path); return blobReference.Uri.ToString(); //var blob = _cloudBlobContainer.GetBlobReference(blobStorage.GetContainerReference(bucketName)); //blob.UploadByteArray(data); }
public void uploadToBlob(Guid courseId, string fileName,string owner, FileStream fileStream) { // Retrieve a reference to a container. CloudBlobContainer container = blobClient.GetContainerReference(courseId.ToString()); // Create the container if it doesn't already exist. if (container.CreateIfNotExist()) { BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(containerPermissions); } // create name of blob string blobName = new StringBuilder(fileName + specialChar + owner + Path.GetExtension(fileStream.Name)).ToString(); // retrieve reference to the blob CloudBlockBlob blob = container.GetBlockBlobReference(blobName); blob.UploadFromStream(fileStream); }
public static string GenerateSAS(string containerName, string blobUri) { string res = null; if ((string.IsNullOrEmpty(containerName)) || (string.IsNullOrEmpty(blobUri))) throw new ArgumentException("Both container name and blob Uri must containt valid values"); var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); var blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference(containerName); CloudBlob blob = blobClient.GetBlobReference(blobUri); container.CreateIfNotExist(); try { BlobContainerPermissions permissions = new BlobContainerPermissions(); // The container itself doesn't allow public access. permissions.PublicAccess = BlobContainerPublicAccessType.Off; // The container itself doesn't allow SAS access. SharedAccessPolicy containerPolicy = new SharedAccessPolicy() { Permissions = SharedAccessPermissions.None }; permissions.SharedAccessPolicies.Clear(); permissions.SharedAccessPolicies.Add("SASPolicy", containerPolicy); container.SetPermissions(permissions); // Generate an SAS for the blob. SharedAccessPolicy blobPolicy = new SharedAccessPolicy() { Permissions = SharedAccessPermissions.Read, SharedAccessExpiryTime = DateTime.UtcNow.AddDays(1d) }; res = blob.GetSharedAccessSignature(blobPolicy, "SASPolicy"); } catch (Exception ex) { Console.WriteLine(ex.Message); } return res; }
/// <summary> /// Configures Azure account and container /// </summary> /// <param name="bloburl">string with url to the blob</param> /// <param name="connectionString">Azure blob connection string</param> public void ConfigureAzure(string bloburl, string connectionString) { // Azure preparations DestinationBlobUrl = bloburl; // Set storage account cloudStorageAccount = CloudStorageAccount.Parse(connectionString); // Initialize client blobClient = new Microsoft.WindowsAzure.StorageClient.CloudBlobClient(cloudStorageAccount.BlobEndpoint, cloudStorageAccount.Credentials); // Get the container reference. blobContainer = blobClient.GetContainerReference(bloburl); // Create the container if it does not exist. blobContainer.CreateIfNotExist(); // Set permissions on the container. containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); }
public string StoreDeploymentPackageInBlob(string csPkgFileLocation, string blobUrl, string storageAccountName, string storageAccountKey) { string fileName; bool containerCreated = false; StorageCredentials storageCredentails; CloudBlobClient blobClient; CloudBlobContainer packageContainer; CloudBlob deploymentBlob; storageCredentails = new StorageCredentialsAccountAndKey(storageAccountName, storageAccountKey); blobClient = new CloudBlobClient(blobUrl, storageCredentails); packageContainer = blobClient.GetContainerReference(_cspkgBlobContainerName); try { containerCreated = packageContainer.CreateIfNotExist(); } catch { }; if (containerCreated == true) { BlobContainerPermissions permissions = new BlobContainerPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; packageContainer.SetPermissions(permissions); } //Upload a file. Console.WriteLine("Uploading Deployment package - start"); fileName = Path.GetFileName(csPkgFileLocation); deploymentBlob = packageContainer.GetBlobReference(fileName); using (FileStream fs = new FileStream(csPkgFileLocation, FileMode.Open)) { deploymentBlob.UploadFromStream(fs); } Console.WriteLine("Uploading Deployment package - end"); return String.Format(deploymentBlob.Uri.ToString()); }
public string CreateContainer(string containerName, bool createIfNotExists, bool isPublic) { // Authenticate. var userId = this.UserId; this.requestValidator.OnValidateRequest(userId, containerName, true); try { var container = this.cloudBlobClient.GetContainerReference(containerName.ToLowerInvariant()); if (createIfNotExists) { container.CreateIfNotExist(); } else { container.Create(); } var publicBlobContainerPrivilege = string.Format(CultureInfo.InvariantCulture, "{0}{1}", containerName, PrivilegeConstants.PublicBlobContainerPrivilegeSuffix); if (isPublic) { BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(containerPermissions); } var accessBlobContainerPrivilege = string.Format(CultureInfo.InvariantCulture, "{0}{1}", containerName, PrivilegeConstants.BlobContainerPrivilegeSuffix); this.userPrivilegesRepository.AddPrivilegeToUser(userId, accessBlobContainerPrivilege); return "Success"; } catch (Exception exception) { throw new WebFaultException<string>(exception.Message, HttpStatusCode.InternalServerError); } }
public BlobContainer(string connectionString, string containerName) { // Connect, if not already connected CloudBlobClient client; if (!clients.TryGetValue(connectionString, out client)) { // Connect client = CloudStorageAccount.Parse(connectionString).CreateCloudBlobClient(); // Store for next time clients[connectionString] = client; } // Get container Container = client.GetContainerReference(containerName); // Create if it doesn't exist Container.CreateIfNotExist(); // Set access public var perm = new BlobContainerPermissions(); perm.PublicAccess = BlobContainerPublicAccessType.Blob; Container.SetPermissions(perm); }
private static dynamic initAzureConfig() { var _timeout = 45; var account = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=eagleraydev;AccountKey=UFc4ZR15pEDv1wlXJv43j+zLeJ1FMUYfpfQQBTFO5O9hDPWskLxFk16VKIKlSb0mm+jZVgdaHmsGD9Qa4krlEg=="); var _containerName = "test"; _containerName = _containerName.ToLowerInvariant(); // Azure requires container names to be lower case. var _blobs = account.CreateCloudBlobClient(); // Init Container var container = _blobs.GetContainerReference(_containerName); var _containerPermissions = new BlobContainerPermissions(); _containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container; container.CreateIfNotExist(); container.SetPermissions(_containerPermissions); var sas = container.GetSharedAccessSignature(new SharedAccessPolicy() { // Read required to get existing metadata Permissions = SharedAccessPermissions.Read | SharedAccessPermissions.Write, SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromMinutes(_timeout) }); // Generate ServiceUri var service = (new UriBuilder(container.Uri) { Query = sas.TrimStart('?') }).Uri.AbsoluteUri; // Generate ClientConfig var expires = TimeSpan.FromMinutes(_timeout).TotalSeconds.ToString(CultureInfo.CurrentCulture); var chunk = container.ServiceClient.WriteBlockSizeInBytes.ToString(CultureInfo.CurrentCulture); var config = string.Format("timeout={0},maxChunkSize={1}", expires, chunk); return new { ServiceUri = service, ClientConfig = config }; }
static void upload(string UUID, string file) { try { string path = Path.GetFullPath(@""+file); BlobContainerPermissions containerPermissions; blobContainer = blobClient.GetContainerReference(UUID); blobContainer.CreateIfNotExist(); containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); blobContainer = blobClient.GetContainerReference(UUID); CloudBlob blob = blobContainer.GetBlobReference(UUID); Console.WriteLine("Starting file upload"); blob.UploadFile(path); Console.WriteLine("File upload complete\n"); } catch (Exception e) { Console.WriteLine("Error uploading file: " + e); } }
// Setup Runtime Servers private void SetupRuntimeServers() { string containerName = RoleEnvironment.GetConfigurationSettingValue("PHPApplicationsBackupContainerName"); string blobName = RoleEnvironment.GetConfigurationSettingValue("InstallationStatusConfigFileBlob"); // Create blob container CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference(containerName); if (container.CreateIfNotExist()) { BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(containerPermissions); } CloudBlob blob = container.GetBlobReference(blobName); if (!BlobExists(blob)) { // Serialize empty NameValueCollection to blob NameValueCollection values = new NameValueCollection(); SoapFormatter ser = new SoapFormatter(); using (MemoryStream memoryStream = new MemoryStream()) { ser.Serialize(memoryStream, values); byte[] b = memoryStream.GetBuffer(); string serilizedNameValueCollection = Encoding.Default.GetString(b); blob.UploadText(serilizedNameValueCollection); } } else { // Setup Runtime Servers vmManager.SetupRuntimeServers(); } }
static void Main(string[] args) { try { // Variables for the cloud storage objects. var storageAccount = new StorageAccount(); // Use the emulatedstorage account. var cloudStorageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(storageAccount.Account, storageAccount.Key), storageAccount.Https); // If you want to use Windows Azure cloud storage account, use the following // code (after uncommenting) instead of the code above. // cloudStorageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=http;AccountName=your_storage_account_name;AccountKey=your_storage_account_key"); // Create the blob client, which provides // authenticated access to the Blob service. CloudBlobClient blobClient = cloudStorageAccount.CreateCloudBlobClient(); // Get the container reference. Console.Write("input your container:"); storageAccount.Container = Console.ReadLine(); CloudBlobContainer blobContainer = blobClient.GetContainerReference(storageAccount.Container); // Create the container if it does not exist. blobContainer.CreateIfNotExist(); // Set permissions on the container. var containerPermissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }; // This sample sets the container to have public blobs. Your application // needs may be different. See the documentation for BlobContainerPermissions // for more information about blob container permissions. blobContainer.SetPermissions(containerPermissions); var directory = GetDirectory(); var fileInfos = GetAllFiles(directory); foreach (var @fileInfo in fileInfos) { CloudBlob blob = blobContainer.GetBlobReference(@fileInfo.FullName.Replace(directory,"")); // Upload a file from the local system to the blob. Console.WriteLine("Starting file upload"); blob.UploadFile(@fileInfo.FullName); // File from emulated storage. Console.WriteLine("File upload complete to blob: " + blob.Uri); } } catch (StorageClientException e) { Console.WriteLine("Storage client error encountered: " + e.Message); // Exit the application with exit code 1. System.Environment.Exit(1); } catch (Exception e) { Console.WriteLine("Error encountered: " + e.Message); // Exit the application with exit code 1. System.Environment.Exit(1); } finally { // Exit the application. System.Environment.Exit(0); } }
// Primary Key = 60VMAzM8UiGe5NuL5t6IMpXm8mo2qiuKkBJY5CQg8Pz2XtF0Dm57tVDP4oTvmlvc8AV8Gh4HWSFz9fmxeszVDA== // Secondary Key = s+kNBQqwJR+1LPSeG1D5bWOVgWJ/snaxgP2Ar0K5jkrJYz0IOOde4wpXAy0lIb9TpYqtIQS6SVJhRQ1UobtxcQ== public IBucket CreateBucket(string bucketName) { var blobContainer = blobStorage.GetContainerReference("bmaigorcloudmorphstorage"); blobContainer.CreateIfNotExist(); var containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); return new AzureBucket() { Name = bucketName, CloudBlobClient = blobStorage.GetContainerReference(bucketName) }; }
private void PushEventToStore(TableServiceContext context, Guid eventSourceId, IEnumerable<SourcedEvent> events) { var formatter = new BinaryFormatter(); var blobClient = _account.CreateCloudBlobClient(); foreach (var eventToPush in events) { using (var buffer = new MemoryStream()) { var eventEntity = SourcedEventEntity.FromEventSource(eventToPush); var rootContainer = blobClient.GetContainerReference("events"); rootContainer.CreateIfNotExist(); var permissions = new BlobContainerPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; rootContainer.SetPermissions(permissions); var blob = rootContainer.GetBlobReference(eventEntity.RowKey); formatter.Serialize(buffer, eventToPush); buffer.Seek(0, SeekOrigin.Begin); blob.UploadFromStream(buffer); context.AddObject(EVENTS_TABLE_NAME, eventEntity); } } }
static CloudBlobContainer CreateContainer() { var c = client.GetContainerReference("userphotos"); BlobContainerPermissions permissions = new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Container }; c.SetPermissions(permissions); return c; }
public string AddToBucket(string bucketName, string id, Stream stream) { var blobContainer = blobStorage.GetContainerReference(bucketName); blobContainer.CreateIfNotExist(); var containerPermissions = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }; blobContainer.SetPermissions(containerPermissions); var blobReference = blobContainer.GetBlobReference(id); blobReference.Properties.ContentType = "image/jpeg"; blobReference.UploadFromStream(stream); return blobReference.Uri.ToString(); }
public static string writeIterationToBlob(string containerName,Int32 t, ref Int64[] Before,ref Int64[] After, ref bool[] State) { string baseUri = ""; string paddedContainer=""; SimulatorLibrary.generateDirectoryName(containerName, ref paddedContainer); CloudBlobContainer blobContainer = BlobLibrary.initContainer(paddedContainer, ref baseUri); int tries=0; bool success=false; string errors = ""; do { try { blobContainer.CreateIfNotExist(); success = true; } catch (Exception e) { BlobLibrary.logToBlog("error when creating iteration result blob. " + e.Message + " retrying...", AccountInfo.masterLog); Console.WriteLine("error when creating iteration result blob. " + e.Message + " retrying..."); errors = errors + e.Message+"\n"; Thread.Sleep(3000); tries++; } } while (tries < 5 && !success); if (!success) { return errors; } var perms = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container // Blob (see files if you know the name) or Container (enumerate like a directory) }; blobContainer.SetPermissions(perms); // This line makes the blob public so it is available from a web browser (no magic needed to read it) StreamWriter BeforeOutput = new StreamWriter(BlobLibrary.getBlobWriteStream(paddedContainer, paddedContainer + "." + Constants._UBeforeFileName + "." + t)); StreamWriter AfterOutput = new StreamWriter(BlobLibrary.getBlobWriteStream(paddedContainer, paddedContainer + "." + Constants._UAfterFileName + "." + t)); StreamWriter StateOutput = new StreamWriter(BlobLibrary.getBlobWriteStream(paddedContainer, paddedContainer + "." + Constants._SFileName + "." + t)); for (int i = 0; i < Before.Length; i++) BeforeOutput.Write(Before[i] + ","); for (int i = 0; i < After.Length; i++) AfterOutput.Write(After[i] + ","); for (int i = 0; i < State.Length; i++) { if (State[i]) StateOutput.Write("1,"); else StateOutput.Write("0,"); } BeforeOutput.Write("\n"); AfterOutput.Write("\n"); StateOutput.Write("\n"); BeforeOutput.Close(); AfterOutput.Close(); StateOutput.Close(); return ""; }
// Set container access control to container|blob|private. // Return true on success, false if not found, throw exception on error. // Set access level to container|blob|private. public bool SetContainerACL(string containerName, string accessLevel) { try { CloudBlobContainer container = BlobClient.GetContainerReference(containerName); BlobContainerPermissions permissions = new BlobContainerPermissions(); switch(accessLevel) { case "container": permissions.PublicAccess = BlobContainerPublicAccessType.Container; break; case "blob": permissions.PublicAccess = BlobContainerPublicAccessType.Blob; break; case "private": default: permissions.PublicAccess = BlobContainerPublicAccessType.Off; break; } container.SetPermissions(permissions); return true; } catch (StorageClientException ex) { if ((int)ex.StatusCode == 404) { return false; } throw; } }
public static CloudBlobContainer ConfigureBlobStorageContainer(string connString, bool deleteBlobs, string containerName, BlobContainerPublicAccessType containerAccessType) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connString); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); var anonWebContainer = blobClient.GetContainerReference(containerName); anonWebContainer.CreateIfNotExist(); if (deleteBlobs) { BlobRequestOptions blobRequestOptions = new BlobRequestOptions(); blobRequestOptions.UseFlatBlobListing = true; foreach (var blob in anonWebContainer.ListBlobs(blobRequestOptions)) { CloudBlockBlob blockBlob = blob as CloudBlockBlob; if (blockBlob != null) blockBlob.Delete(); CloudPageBlob pageBlob = blob as CloudPageBlob; if (pageBlob != null) pageBlob.Delete(); } } BlobContainerPermissions permissions = new BlobContainerPermissions(); permissions.PublicAccess = containerAccessType; anonWebContainer.SetPermissions(permissions); return anonWebContainer; }