// 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);
}
