| public SetPermissions ( Microsoft.WindowsAzure.StorageClient.BlobContainerPermissions permissions ) : void | ||
| permissions | Microsoft.WindowsAzure.StorageClient.BlobContainerPermissions | The permissions to apply to the container. |
| 리턴 | 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);
}
