// Constructor - get settings from a hosted service configuration or .NET configuration file. public BlobHelper(string configurationSettingName, bool hostedService) { if (hostedService) { CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSettingPublisher) => { var connectionString = RoleEnvironment.GetConfigurationSettingValue(configName); configSettingPublisher(connectionString); } ); } else { CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSettingPublisher) => { var connectionString = ConfigurationManager.ConnectionStrings[configName].ConnectionString; configSettingPublisher(connectionString); } ); } Account = CloudStorageAccount.FromConfigurationSetting(configurationSettingName); BlobClient = Account.CreateCloudBlobClient(); BlobClient.RetryPolicy = RetryPolicies.Retry(4, TimeSpan.Zero); }
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 AzureStorageProvider(CloudStorageAccount storageAccount) { cloudStorageAccount = storageAccount; // Create the blob client blobStorage = cloudStorageAccount.CreateCloudBlobClient(); }
public SharedAccessSignatureController(CloudStorageAccount storageAccount) { if (storageAccount == null) throw new ArgumentNullException("storageAccount", Constants.CloudStorageAccountNullArgumentErrorMessage); this.cloudBlobClient = storageAccount.CreateCloudBlobClient(); }
public WorkerRoleLoader() { this.LastModified = DateTime.MinValue; this.storageAccount = CloudStorageAccount.FromConfigurationSetting(DataConfigurationKey); this.blobStorage = storageAccount.CreateCloudBlobClient(); }
private void OnInitialize() { var selfInstance = InstanceEnumerator.GetSelf(); cloudStorageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(ConfigurationSettingsKeys.StorageConnectionString)); log.Info("Storage account selected: {0}",cloudStorageAccount.BlobEndpoint); cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient(); log.Info("Storage client created"); var containerName = ConfigurationProvider.GetSetting(ConfigurationSettingsKeys.StorageContainerName,"ravendb"); // In order to force a connection we just enumerate all available containers: var availableContainers = cloudBlobClient.ListContainers().ToArray(); foreach (var container in availableContainers) { log.Info("Available container: {0}",container.Name); } if (!availableContainers.Any(c => c.Name.Equals(containerName))) { log.Info("Container {0} does not exist, creating",containerName); // Container does not exist: cloudBlobClient.GetContainerReference(containerName).Create(); } cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName); log.Info("Container {0} selected",cloudBlobContainer.Name); localCache = RoleEnvironment.GetLocalResource(ConfigurationSettingsKeys.StorageCacheResource); log.Info("Cache resource retrieved: {0}, path: {1}",localCache.Name,localCache.RootPath); CloudDrive.InitializeCache(localCache.RootPath, localCache.MaximumSizeInMegabytes); log.Info("Cache initialized: {0} mb",localCache.MaximumSizeInMegabytes); var driveName = string.Format("{0}{1}.vhd", selfInstance.RoleName, selfInstance.RoleInstanceIndex).ToLowerInvariant(); log.Info("Virtual drive name: {0}",driveName); var pageBlob = cloudBlobContainer.GetPageBlobReference(driveName); log.Info("Virtual drive blob: {0}",pageBlob.Uri); cloudDrive = cloudStorageAccount.CreateCloudDrive(pageBlob.Uri.ToString()); log.Info("Virtual drive created: {0}",cloudDrive.Uri); var storageSize = ConfigurationProvider.GetSetting(ConfigurationSettingsKeys.StorageSizeInMb, 50000); log.Info("Storage size: {0} mb",storageSize); cloudDrive.CreateIfNotExist(storageSize); log.Info("Virtual drive initialized: {0}",cloudDrive.Uri); var mountedDirectoryPath = cloudDrive.Mount(storageSize, DriveMountOptions.None); log.Info("Virtual drive mounted at: {0}",mountedDirectoryPath); mountedDirectory = new DirectoryInfo(mountedDirectoryPath); log.Info("Executing drive benchmark for: {0}",mountedDirectoryPath); ExecuteBenchmarks(mountedDirectory,storageSize); log.Info("Storage initialization succeeded"); }
/// <summary> /// Copies a blob from one account and container to another. /// </summary> /// <param name="copyBlockBlobSettings">A <see cref="CopyBlockBlobSettings"/>.</param> public static void CopyBlockBlob(CopyBlockBlobSettings copyBlockBlobSettings) { Contract.Requires(copyBlockBlobSettings != null, "The copy block blob settings cannot be null."); var sourceStorageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(copyBlockBlobSettings.BlobStorageSource, copyBlockBlobSettings.BlobStorageSourceKey), copyBlockBlobSettings.UseHttps); var sourceClient = sourceStorageAccount.CreateCloudBlobClient(); var destinationStorageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(copyBlockBlobSettings.BlobStorageDestination, copyBlockBlobSettings.BlobStorageDestinationKey), copyBlockBlobSettings.UseHttps); var destinationClient = destinationStorageAccount.CreateCloudBlobClient(); var destinationContainer = destinationClient.GetContainerReference(copyBlockBlobSettings.DestinationContainerName); try { destinationContainer.CreateIfNotExist(); } catch { // do nothing, create if not exists blows up if it already exists... nice. } var sourceBlob = sourceClient.GetBlockBlobReference(copyBlockBlobSettings.BlobSourcePath); sourceBlob.FetchAttributes(); CloudBlob destinationBlob = destinationClient.GetBlockBlobReference(copyBlockBlobSettings.BlobDestinationPath); destinationBlob.StartCopyFromBlob(sourceBlob.Uri); MonitorCopy(destinationBlob.Container); }
// Constructor - pass in a storage connection string. public BlobHelper(string connectionString) { Account = CloudStorageAccount.Parse(connectionString); BlobClient = Account.CreateCloudBlobClient(); BlobClient.RetryPolicy = RetryPolicies.Retry(4, TimeSpan.Zero); }
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 NeoServer(NeoServerConfiguration configuration, CloudStorageAccount storageAccount) : this(configuration, new RoleEnvironmentWrapper(), new CloudBlobClientWrapper(storageAccount.CreateCloudBlobClient()), new FileSystem(), new ZipHandler()) {}
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; #if DEBUG account = CloudStorageAccount.DevelopmentStorageAccount; #else account = new CloudStorageAccount(accountAndKey, true); #endif tableContext = new TableServiceContext(account.TableEndpoint.ToString(), account.Credentials); //client = new CloudQueueClient(account.BlobEndpoint.ToString(), account.Credentials); qclient = account.CreateCloudQueueClient(); q = qclient.GetQueueReference("icd9mapplotrequests"); rows = new List<ICD9MapPlotResultEntry>(); bclient = account.CreateCloudBlobClient(); container = bclient.GetContainerReference("results"); container.CreateIfNotExist(); client = account.CreateCloudTableClient(); client.CreateTableIfNotExist("ICD9MapPlotResult"); client.CreateTableIfNotExist("DoctorDetails"); client.CreateTableIfNotExist("PatientDetails"); // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. return base.OnStart(); }
// Constructor - pass in a storage connection string. public BlobHelper(string connectionString) { string storageConnectionString = ConfigurationManager.ConnectionStrings[connectionString].ConnectionString; Account = CloudStorageAccount.Parse(storageConnectionString); BlobClient = Account.CreateCloudBlobClient(); BlobClient.RetryPolicy = RetryPolicies.Retry(4, TimeSpan.Zero); }
public BlobOptimisticDataStore(CloudStorageAccount account, string containerName) { var blobClient = account.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference(containerName.ToLower()); blobContainer.CreateIfNotExist(); blobReferences = new Dictionary<string, CloudBlob>(); }
public AzureStorageClient(CloudStorageAccount account) { client = account.CreateCloudBlobClient(); client.DefaultDelimiter = "/"; container = client.GetContainerReference("documents"); container.CreateIfNotExist(); }
internal AzureBlobStore(string accountName, string targetContainer, string accountKey) { _storageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(accountName, accountKey), true); _blobStorage = _storageAccount.CreateCloudBlobClient(); _targetContainer = targetContainer; CreateContainer(); }
/// <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 Azure_Stream_Factory(CloudStorageAccount account, string container_Name) { _container_Name = container_Name; _blobClient = account.CreateCloudBlobClient(); container = _blobClient.GetContainerReference(container_Name); container.CreateIfNotExist(); }
public static void Initialize() { //First get a reference to the local file structure. localStorage = RoleEnvironment.GetLocalResource("scratchpad"); var acc = string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", RoleEnvironment.GetConfigurationSettingValue("StorageName"), RoleEnvironment.GetConfigurationSettingValue("StorageKey")); storageAccount = CloudStorageAccount.Parse(acc); blobClient = storageAccount.CreateCloudBlobClient(); }
internal AzureBlobStore( string targetContainer, CloudStorageAccount storageAccount ) { _blobStorage = storageAccount.CreateCloudBlobClient(); _targetContainer = targetContainer; CreateContainer(); }
public AzureStorageProvider() { // Retrieve storage account from connection-string //cloudStorageAccount = CloudStorageAccount.DevelopmentStorageAccount; //cloudStorageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); cloudStorageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=http;AccountName=bmaigorcloudmorphstorage;AccountKey=60VMAzM8UiGe5NuL5t6IMpXm8mo2qiuKkBJY5CQg8Pz2XtF0Dm57tVDP4oTvmlvc8AV8Gh4HWSFz9fmxeszVDA=="); //storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); // Create the blob client blobStorage = cloudStorageAccount.CreateCloudBlobClient(); }
public AzureBlobRepository() { var container = CloudConfigurationManager.GetSetting("StorageContainer"); //"queuephotos"; var connection = CloudConfigurationManager.GetSetting("StorageConnectionString"); this._storageAccount = CloudStorageAccount.Parse(connection); this._blobClient = _storageAccount.CreateCloudBlobClient(); this._blobContainer = _blobClient.GetContainerReference(container); this._blobContainer.SetPermissions(this.GetPermissions()); }
public void Connect(string accountName, string accountKey = null ) { if( _account != null ) { return; } if( string.IsNullOrEmpty(accountKey)) { accountKey = _accountSettings[accountName, "key"].EncryptedStringValue; } _account = new CloudStorageAccount(new StorageCredentialsAccountAndKey(accountName, accountKey), true); _blobStore = _account.CreateCloudBlobClient(); }
public static void Initialize(string account, string key) { Uri blobUri = new Uri(string.Format("http://{0}.blob.core.windows.net", account)); Uri queueUri = new Uri(string.Format("http://{0}.queue.core.windows.net", account)); Uri tableUri = new Uri(string.Format("http://{0}.table.core.windows.net", account)); s_credentials = new StorageCredentialsAccountAndKey(account, key); s_storageAccount = new CloudStorageAccount(s_credentials, blobUri, queueUri, tableUri); s_blobClient = s_storageAccount.CreateCloudBlobClient(); s_tableClient = s_storageAccount.CreateCloudTableClient(); s_queueClient = s_storageAccount.CreateCloudQueueClient(); }
// ReSharper restore FunctionNeverReturns public override bool OnStart() { ServicePointManager.DefaultConnectionLimit = 12; _connectionString = CloudConfigurationManager.GetSetting("StorageConnectionString"); _storageAccount = CloudStorageAccount.Parse(_connectionString); _blobClient = _storageAccount.CreateCloudBlobClient(); _container = _blobClient.GetContainerReference(BlobContainer); RunMeme(); return base.OnStart(); }
public BlobFactory(string azureAccountName, string azureKey) { // initialize Azure Account StorageCredentialsAccountAndKey storageKey = new StorageCredentialsAccountAndKey(azureAccountName, azureKey); CloudStorageAccount azureAccount = new CloudStorageAccount(storageKey, true); // Create blob containers CloudBlobClient blobClient = azureAccount.CreateCloudBlobClient(); userContainer = blobClient.GetContainerReference("user"); accountContainer = blobClient.GetContainerReference("account"); listContainer = blobClient.GetContainerReference("list"); msgContainer = blobClient.GetContainerReference("msg"); }
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 CloudFileSystem(RegistryView settingsRoot, string accountName, string accountKey) { _accountSettings = settingsRoot["azure-storage"]; if (string.IsNullOrEmpty(accountKey)) { // load it if not given accountKey = _accountSettings[accountName, "key"].EncryptedStringValue; } else { // store it if given _accountSettings[accountName, "key"].EncryptedStringValue = accountKey; } _account = new CloudStorageAccount(new StorageCredentialsAccountAndKey(accountName, accountKey), true); _blobStore = _account.CreateCloudBlobClient(); }
protected void DeleteAllBlobs(string containerName, CloudStorageAccount account) { var blobClient = account.CreateCloudBlobClient(); var container = blobClient.GetContainerReference(containerName); foreach ( var blob in container.ListBlobs() ) { if ( blob is CloudBlob ) { ( (CloudBlob)blob ).DeleteIfExists(); } if ( blob is CloudBlobDirectory ) { DeleteAllBlobs((CloudBlobDirectory)blob); } } }
public static void CleanAccount(String accountName, String accountKey) { CloudStorageAccount storageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(accountName, accountKey), true); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); foreach (CloudBlobContainer blobcontainer in blobClient.ListContainers()) { if (blobcontainer.Name.Contains(ConfigurationManager.AppSettings.Get("Prefix"))) { blobcontainer.Delete(); Console.WriteLine("Deleting container: "+blobcontainer.Name); } } }
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); }