public SetPermissions ( Microsoft.WindowsAzure.StorageClient.BlobContainerPermissions permissions ) : void | ||
permissions | Microsoft.WindowsAzure.StorageClient.BlobContainerPermissions | The permissions to apply to the container. |
return | void |
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; DiagnosticMonitor.Start("DiagnosticsConnectionString"); // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. RoleEnvironment.Changing += RoleEnvironmentChanging; // read storage account configuration settings CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName))); var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // initialize blob storage CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient(); container = blobStorage.GetContainerReference("converteddata"); // initialize queue storage CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient(); queue = queueStorage.GetQueueReference("workercommands"); Trace.TraceInformation("Creating container and queue..."); bool storageInitialized = false; while (!storageInitialized) { try { // create the blob container and allow public access container.CreateIfNotExist(); var permissions = container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(permissions); // create the message queue queue.CreateIfNotExist(); storageInitialized = true; } catch (StorageClientException e) { if (e.ErrorCode == StorageErrorCode.TransportError) { Trace.TraceError("Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running. Message: '{0}'", e.Message); Thread.Sleep(5000); } else { throw; } } } return base.OnStart(); }
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 override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 100; //Initialize Indexer storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("CrawlerStorage")); //Initialize URL Queue urlQueueClient = storageAccount.CreateCloudQueueClient(); urlQueue = urlQueueClient.GetQueueReference("urlqueue"); if (urlQueue.CreateIfNotExist()) { //Add first URL to the queue CloudQueueMessage firstURL = new CloudQueueMessage(startURL); urlQueue.AddMessage(firstURL); } //Initialize Index Queue indexQueueClient = storageAccount.CreateCloudQueueClient(); indexQueue = indexQueueClient.GetQueueReference("indexqueue"); indexQueue.CreateIfNotExist(); //Initialize Database Blob databaseClient = storageAccount.CreateCloudBlobClient(); databaseContainer = databaseClient.GetContainerReference("wordfrequencies"); databaseContainer.CreateIfNotExist(); var permission = databaseContainer.GetPermissions(); permission.PublicAccess = BlobContainerPublicAccessType.Container; databaseContainer.SetPermissions(permission); return base.OnStart(); }
public Storage(CloudStorageAccount account) { this.account = account; fileStorage = account.CreateCloudBlobClient(); /* Initialize file container */ container = fileStorage.GetContainerReference(filesContainer); container.CreateIfNotExist(); var permissions = container.GetPermissions(); /* Full permissions. From MSDN, Container-level public access. Anonymous clients can * read blob content and metadata and container metadata, and can list the blobs within the container. * * Other alternatives are Blob (can read content but not metadata) and Off (no * anonymous access). */ // permissions.PublicAccess = BlobContainerPublicAccessType.Container; permissions.PublicAccess = BlobContainerPublicAccessType.Off; permissions.SharedAccessPolicies.Remove("basic"); permissions.SharedAccessPolicies.Add("basic", new SharedAccessPolicy() { }); container.SetPermissions(permissions); /* Initialize table (for file metadata) */ CloudTableClient.CreateTablesFromModel( typeof(FileDataContext), account.TableEndpoint.AbsoluteUri, account.Credentials); }
//This function is using storage client ddl of blob public byte[] DownloadBlobClient(string UserId, string BlobName) { // Retrieve storage account from connection string. Microsoft.WindowsAzure.CloudStorageAccount StorageAccount = Microsoft.WindowsAzure.CloudStorageAccount.Parse(Convert.ToString(ConfigurationManager.AppSettings["StorageConnectionString"])); // Create the blob client. Microsoft.WindowsAzure.StorageClient.CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient(); // Retrieve a reference to a container. Microsoft.WindowsAzure.StorageClient.CloudBlobContainer container = blobClient.GetContainerReference(UserId); // Create the container if it doesn't exist. container.CreateIfNotExist(); //Set permission to public container.SetPermissions( new Microsoft.WindowsAzure.StorageClient.BlobContainerPermissions { PublicAccess = Microsoft.WindowsAzure.StorageClient.BlobContainerPublicAccessType.Off }); // Retrieve reference to a blob named Microsoft.WindowsAzure.StorageClient.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName); return(blockBlob.DownloadByteArray()); }
public AzureBlobRepository(CloudStorageAccount storageAccount, CloudBlobClient blobClient, CloudBlobContainer blobContainer) { this._storageAccount = storageAccount; this._blobClient = blobClient; this._blobContainer = blobContainer; _blobContainer.SetPermissions(GetPermissions()); }
static AzureHelper() { var cloudStorageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=http;AccountName=mintchipmarket;AccountKey=6wtpT0uW75m2LsThfROjp+cMA5zWx8VllZhJ5tM7kPAZZlIbPZ0t7pIXkO0s0AnzZ4sWMnl+rc5+1KjlNWKlfA=="); var blobClient = new CloudBlobClient(cloudStorageAccount.BlobEndpoint, cloudStorageAccount.Credentials); _container = blobClient.GetContainerReference("files"); _container.CreateIfNotExist(); _container.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Off }); }
/// <summary> /// Connects to the storage account and creates the default container /// </summary> private void ConnectToBlobStorage() { storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference("testcontainer"); blobContainer.CreateIfNotExist(); blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }); }
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 == "/" ? String.Empty : root + "/"; 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.CreateIfNotExist(); if ( isPrivate ) { Container.SetPermissions(new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off}); } else { Container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container }); } }
public AzureBlobFileRepository(IConfigSettings configSettings) { var setting = configSettings.Get("StorageConnectionString"); containerName = configSettings.Get("BlobContainerName"); storageAccount = CloudStorageAccount.Parse(setting); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(containerName.ToLower()); container.CreateIfNotExist(); container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); }
public override bool OnStart() { //Initialize Indexer storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("CrawlerStorage")); //Initialize Database Blob databaseClient = storageAccount.CreateCloudBlobClient(); databaseContainer = databaseClient.GetContainerReference("wordfrequencies"); databaseContainer.CreateIfNotExist(); var permission = databaseContainer.GetPermissions(); permission.PublicAccess = BlobContainerPublicAccessType.Container; databaseContainer.SetPermissions(permission); return base.OnStart(); }
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); }
public AzureShellSettingsManager(CloudStorageAccount storageAccount, IShellSettingsManagerEventHandler events) { // Setup the connection to custom storage accountm, e.g. Development Storage _storageAccount = storageAccount; _events = events; 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 = new CloudBlobContainer(ContainerName, BlobClient); Container.CreateIfNotExist(); // Tenant settings are protected by default Container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off }); }
public FriendLikesService(string id) { this.UserId = id; account = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("DataConnectionString")); // Table Client tableClient = new CloudTableClient(account.TableEndpoint.ToString(), account.Credentials); tableClient.CreateTableIfNotExist(FRIEND_LIKES_TABLE); // Blob Client blobClient = new CloudBlobClient(account.BlobEndpoint.ToString(), account.Credentials); blobContainer = blobClient.GetContainerReference(FRIEND_LIKES_BLOB_CONTAINER); blobContainer.CreateIfNotExist(); blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }); }
/// <summary> /// Init Azure Storage if needed /// </summary> private static void InitAzureStorage() { if (storageAccount == null) { storageAccount = CloudStorageAccount.FromConfigurationSetting(connectionString); if (blobClient == null) { blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference(FilesFolder); blobContainer.CreateIfNotExist(); var permissions = blobContainer.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; blobContainer.SetPermissions(permissions); } } }
private void CreateStorageContainer() { Log("Attaching to or creating the blob container"); _container = CloudStorageAccount .Parse(RoleEnvironment.GetConfigurationSettingValue(WorkerRole.StorageConnectionString)) .CreateCloudBlobClient() .GetContainerReference(WorkerRole.KinectonitorImageContainer); _container.CreateIfNotExist(); _container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); Log("Attached to the blob container"); }
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); 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.CreateIfNotExist(); Container.SetPermissions(isPrivate ? new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off } : new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container }); }
public GenericBlobSource(string connectionStringName) { var connectionString = RoleEnvironment.IsAvailable ? RoleEnvironment.GetConfigurationSettingValue(connectionStringName) : ConfigurationManager.AppSettings[connectionStringName]; _container = CloudStorageAccount .Parse(connectionString) .CreateCloudBlobClient() .GetContainerReference("uploadedfiles"); _container.CreateIfNotExist(); _container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); }
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); }
public static string MountDrive(string containerName, string vhdName, int driveSize, int driveLocalReadCacheSize) { var client = GetCloudClientInstance(); // Create the container for the drive if it does not already exist. var container = new CloudBlobContainer(containerName, client); if (container.CreateIfNotExist()) { container.SetPermissions(new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off}); } var cloudDrive = new CloudDrive(container.GetPageBlobReference(vhdName).Uri, client.Credentials); try { cloudDrive.Create(driveSize); } catch (CloudDriveException ex) { Logger.Info(string.Format("Cloud drive already exists. Uri: {0}", cloudDrive.Uri), ex); } string pathToDrive = cloudDrive.Mount(driveLocalReadCacheSize, DriveMountOptions.Force); return pathToDrive; }
// Constructor for the service public WindowsAzureVMManager() { // Create HTTPS storage endpoint CloudStorageAccount storageAccount = WindowsAzureVMManager.GetStorageAccount(true); // Get backup contain reference blobClient = storageAccount.CreateCloudBlobClient(); string containerName = RoleEnvironment.GetConfigurationSettingValue("PHPApplicationsBackupContainerName"); container = blobClient.GetContainerReference(containerName); if (container.CreateIfNotExist()) { // TODO: Finally do not provide public access BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(containerPermissions); } // Initialize installation status information and corresponding blob InitializeInstallationStatus(); // Initialize progress information and corresponding blob InitializeProgressInformation(); }
private static string UploadProfileImage(int id = 0, string username = "", HttpPostedFileBase file = null) { try { DeleteProfileImage("", id); #region Old way /*string directory = "/Admin/Content/img/profile_pics"; string ext = Path.GetExtension(file.FileName).ToLower(); UDF.OpenPermissions(directory); string file_path = Path.Combine(HttpContext.Current.Server.MapPath(directory), Path.GetFileName(username + ext)); if (!allowed_profiletypes.Contains(ext)) { throw new Exception(); } Image img = Image.FromStream(file.InputStream); Size size = new Size(72,72); img = ResizeImage(img, size); img.Save(file_path, System.Drawing.Imaging.ImageFormat.Png);*/ #endregion #region Azure Blob // Set up connection to Windows Azure Storage CloudStorageAccount storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); _BlobClient = storageAccount.CreateCloudBlobClient(); // For large file copies you need to set up a custom timeout period // and using parallel settings appears to spread the copy across multiple threads // if you have big bandwidth you can increase the thread number below // because Azure accepts blobs broken into blocks in any order of arrival. F*****g awesome! _BlobClient.Timeout = new System.TimeSpan(1, 0, 0); _BlobClient.ParallelOperationThreadCount = 2; // Get and create the container _BlobContainer = _BlobClient.GetContainerReference("profile-pictures"); _BlobContainer.CreateIfNotExist(); // Set the permissions on the container to be public _BlobContainer.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); // Make a unique blob name string extension = System.IO.Path.GetExtension(file.FileName); string filename = username; // Create the Blob and upload the file CloudBlob blob = _BlobContainer.GetBlobReference(filename + extension); // Create an image object and resize the image to 72x72 Image img = Image.FromStream(file.InputStream); Size size = new Size(72, 72); img = ResizeImage(img, size); // Push the image into a MemoryStream and upload the stream to our blob, f**k this is too much work // why can't we just say here's the image, now put it in a blob! Damn you!!!! MemoryStream stream = new MemoryStream(); img.Save(stream,System.Drawing.Imaging.ImageFormat.Png); byte[] imgBytes = stream.GetBuffer(); stream.Seek(0,SeekOrigin.Begin); blob.UploadFromStream(stream); // Oh yeah, dispose the stream so we don't eat up memory stream.Dispose(); /// Set the metadata into the blob blob.Metadata["FileName"] = filename; blob.Metadata["Submitter"] = "Automated Encoder"; blob.SetMetadata(); // Set the properties blob.Properties.ContentType = file.ContentType; blob.SetProperties(); #endregion return blob.Uri.ToString(); } catch (Exception) { return ""; } }
private void InitializeStorage() { if (storageInitialized) { return; } lock (gate) { if (storageInitialized) { return; } try { // read account configuration settings CloudStorageAccount storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient(); blobContainer = blobStorage.GetContainerReference(blobContainerAddress); blobContainer.CreateIfNotExist(); // configure container for public access BlobContainerPermissions permissions = blobContainer.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; blobContainer.SetPermissions(permissions); // create queue to communicate with worker role queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue requestQueue = queueClient.GetQueueReference(requestQueueAddress); requestQueue.CreateIfNotExist(); CloudQueue responseQueue = queueClient.GetQueueReference(responseQueueAddress); responseQueue.CreateIfNotExist(); } catch (WebException) { throw new WebException("Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running."); } storageInitialized = true; } }
public static void UploadBlobFile(byte[] fileBytes, string fileName) { try { string storageAccountConnection = string.Empty; storageAccountConnection = ConfigurationManager.AppSettings["StorageAccount.ConnectionString"].ToString(); // If you want to use Windows Azure cloud storage account, use the following // code (after uncommenting) instead of the code above. cloudStorageAccount = CloudStorageAccount.Parse(storageAccountConnection); // Create the blob client, which provides // authenticated access to the Blob service. blobClient = cloudStorageAccount.CreateCloudBlobClient(); string deploymentPackageFolderString = string.Empty; deploymentPackageFolderString = ConfigurationManager.AppSettings["DeploymentPackageFolder"].ToString(); // Get the container reference. blobContainer = blobClient.GetContainerReference(deploymentPackageFolderString); // Create the container if it does not exist. blobContainer.CreateIfNotExist(); // Set permissions on the container. containerPermissions = new BlobContainerPermissions(); // 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. containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); blob = blobContainer.GetBlobReference(fileName); // Open a stream using the cloud object using (BlobStream blobStream = blob.OpenWrite()) { blobStream.Write(fileBytes, 0, fileBytes.Count()); blobStream.Flush(); blobStream.Close(); } } catch (System.Exception ex) { Logger.Write(string.Format("Error in UploadBlobFile() Error: {0}", ex.Message)); } }
private static void SetReadOnlySharedAccessPolicy(CloudBlobContainer container) { var blobSASExperiationTime = int.Parse(ConfigReader.GetConfigValue("BlobSASExperiationTime"), NumberStyles.Integer, CultureInfo.InvariantCulture); var permissions = container.GetPermissions(); var options = new BlobRequestOptions { // Fail if someone else has already changed the container before we do. AccessCondition = AccessCondition.IfMatch(container.Properties.ETag) }; var sharedAccessPolicy = new SharedAccessPolicy { Permissions = SharedAccessPermissions.Read, SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromDays(blobSASExperiationTime) }; permissions.SharedAccessPolicies.Remove("readonly"); permissions.SharedAccessPolicies.Add("readonly", sharedAccessPolicy); container.SetPermissions(permissions, options); }
public static string ReadBlobFile(string fileName) { // byte[] fileBytes = null; string fileBytes = string.Empty; try { string storageAccountConnection = string.Empty; storageAccountConnection = ConfigurationManager.AppSettings["StorageAccount.ConnectionString"].ToString(); // If you want to use Windows Azure cloud storage account, use the following // code (after uncommenting) instead of the code above. cloudStorageAccount = CloudStorageAccount.Parse(storageAccountConnection); // Create the blob client, which provides // authenticated access to the Blob service. blobClient = cloudStorageAccount.CreateCloudBlobClient(); string deploymentPackageFolderString = string.Empty; deploymentPackageFolderString = ConfigurationManager.AppSettings["DeploymentPackageFolder"].ToString(); // Get the container reference. blobContainer = blobClient.GetContainerReference(deploymentPackageFolderString); // Create the container if it does not exist. blobContainer.CreateIfNotExist(); // Set permissions on the container. containerPermissions = new BlobContainerPermissions(); // 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. containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); blob = blobContainer.GetBlobReference(fileName); BlobRequestOptions blobReqOptions = new BlobRequestOptions(); blobReqOptions.Timeout = new TimeSpan(0, 5, 0); fileBytes = blob.DownloadText(blobReqOptions); } catch (System.Exception ex) { Logger.Write(string.Format("Error in ReadBlobFile() Error: {0}", ex.Message)); fileBytes = null; } return fileBytes; }
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); } }
public override bool OnStart( ) { DiagnosticMonitor.Start( "DiagnosticsConnectionString" ); RoleEnvironment.Changing += new EventHandler<RoleEnvironmentChangingEventArgs>( RoleEnvironmentChanging ); CloudStorageAccount.SetConfigurationSettingPublisher( ( configName, configSetter ) => configSetter( RoleEnvironment.GetConfigurationSettingValue( configName ) ) ); CloudStorageAccount storageAccount = CloudStorageAccount.FromConfigurationSetting( "DataConnectionString" ); container = storageAccount.CreateCloudBlobClient( ).GetContainerReference( "fotogolpics" ); queue = storageAccount.CreateCloudQueueClient( ).GetQueueReference( "fotogolthumbs" ); Trace.TraceInformation( "Creating container and queue..." ); bool storageInitialized = false; while ( !storageInitialized ) { try { container.CreateIfNotExist( ); BlobContainerPermissions permissions = container.GetPermissions( ); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions( permissions ); queue.CreateIfNotExist( ); storageInitialized = true; } catch ( StorageClientException e ) { if ( e.ErrorCode != StorageErrorCode.TransportError ) throw; Trace.TraceError( "Storage services initialization failure. Check your storage account configuration settings. If running locally, ensure that the Development Storage service is running. Message: '{0}'", new object[] { e.Message } ); Thread.Sleep( 5000 ); } } return base.OnStart( ); }
public static List<CloudBlob> ListBlobs() { List<IListBlobItem> blobItemList = null; List<CloudBlob> blobList = null; try { string storageAccountConnection = string.Empty; storageAccountConnection = ConfigurationManager.AppSettings["StorageAccount.ConnectionString"].ToString(); Logger.Write("Storage Connection: " + storageAccountConnection); // If you want to use Windows Azure cloud storage account, use the following // code (after uncommenting) instead of the code above. cloudStorageAccount = CloudStorageAccount.Parse(storageAccountConnection); Logger.Write("Blob Uri: " + cloudStorageAccount.BlobEndpoint.AbsoluteUri); // Create the blob client, which provides // authenticated access to the Blob service. blobClient = cloudStorageAccount.CreateCloudBlobClient(); string deploymentPackageFolderString = string.Empty; deploymentPackageFolderString = ConfigurationManager.AppSettings["DeploymentPackageFolder"].ToString(); Logger.Write("Deployment Package Folder: " + deploymentPackageFolderString); // Get the container reference. blobContainer = blobClient.GetContainerReference(deploymentPackageFolderString); // Create the container if it does not exist. blobContainer.CreateIfNotExist(); // Set permissions on the container. containerPermissions = new BlobContainerPermissions(); // 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. containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); BlobRequestOptions blobReqOptions = new BlobRequestOptions(); blobReqOptions.BlobListingDetails = BlobListingDetails.All; blobReqOptions.Timeout = new TimeSpan(0, 5, 0); blobReqOptions.UseFlatBlobListing = true; blobItemList = blobContainer.ListBlobs(blobReqOptions).ToList(); if (blobList == null) { blobList = new List<CloudBlob>(); } foreach (IListBlobItem blobItem in blobItemList) { Logger.Write("Blob Uri: " + blobItem.Uri.ToString()); CloudBlob blobEntry = new CloudBlob(blobItem.Uri.ToString()); blobEntry.FetchAttributes(); blobList.Add(blobEntry); } } catch (System.Exception ex) { Logger.Write(string.Format("Error in List<IListBlobItem> ListBlobs() Error: {0}", ex.Message)); blobList = null; } return blobList; }
private static void SetReadOnlySharedAccessPolicy(CloudBlobContainer container) { var permissions = container.GetPermissions(); var options = new BlobRequestOptions { // Fail if someone else has already changed the container before we do. AccessCondition = AccessCondition.IfMatch(container.Properties.ETag) }; var sharedAccessPolicy = new SharedAccessPolicy { Permissions = SharedAccessPermissions.Read, SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromDays(StorageServicesContext.Current.Configuration.BlobsSasExpirationTime) }; permissions.SharedAccessPolicies.Remove("readonly"); permissions.SharedAccessPolicies.Add("readonly", sharedAccessPolicy); container.SetPermissions(permissions, options); }
private void CheckContainer(string containerConfigName) { // Get a handle on account, create a blob service client and get container proxy storageAccount = CloudStorageAccount.FromConfigurationSetting("BlobConnectionString"); blobStorageClient = storageAccount.CreateCloudBlobClient(); containerName = RoleEnvironment.GetConfigurationSettingValue(containerConfigName); blobExcelContainer = blobStorageClient.GetContainerReference(containerName); blobExcelContainer.CreateIfNotExist(); var permissions = blobExcelContainer.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; blobExcelContainer.SetPermissions(permissions); }