public static void PackContainerCompareData(StorageBlob.CloudBlobContainer container, Dictionary <string, object> dic)
{
StorageBlob.BlobContainerPermissions permissions = container.GetPermissions();
dic["PublicAccess"] = permissions.PublicAccess;
dic["Permission"] = permissions;
dic["LastModified"] = container.Properties.LastModified;
}
public HomeController()
{
storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.AppSettings["StorageConnectionString"]);
tableClient = storageAccount.CreateCloudTableClient();
table = tableClient.GetTableReference("fouramigos");
table.CreateIfNotExists();
blobClient = storageAccount.CreateCloudBlobClient();
container = blobClient.GetContainerReference("fouramigos");
container.CreateIfNotExists();
BlobContainerPermissions permissions = container.GetPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(permissions);
//lägga till nya
//var tablemodels = new TableModel("Brutus", "Uggla") { Location = "T4", Description="Uggla i träd", Type="Foto" };
//var tablemodels1 = new TableModel("brutus", "Örn") { Location = "T4", Description="Örn som flyger", Type = "Foto" };
//var opreation = TableOperation.Insert(tablemodels);
//var operation2 = TableOperation.Insert(tablemodels1);
//table.Execute(opreation);
//table.Execute(operation2);
}
internal void SetContainerACLTest(Agent agent)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("astoria-");
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Container, NEW_CONTAINER_NAME);
comp.Add(dic);
// create container if it does not exist
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
StorageBlob.BlobContainerPublicAccessType[] accessTypes = new StorageBlob.BlobContainerPublicAccessType[] {
StorageBlob.BlobContainerPublicAccessType.Blob,
StorageBlob.BlobContainerPublicAccessType.Container,
StorageBlob.BlobContainerPublicAccessType.Off
};
// set PublicAccess as one value respetively
foreach (var accessType in accessTypes)
{
//--------------Set operation--------------
Test.Assert(agent.SetAzureStorageContainerACL(NEW_CONTAINER_NAME, accessType),
"SetAzureStorageContainerACL operation should succeed");
// Verification for returned values
dic["PublicAccess"] = accessType;
CloudBlobUtil.PackContainerCompareData(container, dic);
agent.OutputValidation(comp);
Test.Assert(container.GetPermissions().PublicAccess == accessType,
"PublicAccess should be equal: {0} = {1}", container.GetPermissions().PublicAccess, accessType);
}
}
finally
{
// clean up
container.DeleteIfExists();
}
}
/// <summary>
/// Creates a new BlobStorage object
/// </summary>
/// <param name="blobContainerName">The name of the blob to be managed</param>
/// <param name="storageConnectionString">The connection string pointing to the storage account (this can be local or hosted in Windows Azure</param>
public BlobStorageAsync(string blobContainerName, string storageConnectionString)
{
Validate.BlobContainerName(blobContainerName, "blobContainerName");
Validate.String(storageConnectionString, "storageConnectionString");
var cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString);
var cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
cloudBlobContainer = cloudBlobClient.GetContainerReference(blobContainerName);
cloudBlobContainer.CreateIfNotExists();
var permissions = cloudBlobContainer.GetPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
cloudBlobContainer.SetPermissions(permissions);
}
public void CloudBlobContainerSetPermissions()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
BlobContainerPermissions permissions = container.GetPermissions();
Assert.AreEqual(BlobContainerPublicAccessType.Off, permissions.PublicAccess);
Assert.AreEqual(0, permissions.SharedAccessPolicies.Count);
// We do not have precision at milliseconds level. Hence, we need
// to recreate the start DateTime to be able to compare it later.
DateTime start = DateTime.UtcNow;
start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second, DateTimeKind.Utc);
DateTime expiry = start.AddMinutes(30);
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
permissions.SharedAccessPolicies.Add("key1", new SharedAccessBlobPolicy()
{
SharedAccessStartTime = start,
SharedAccessExpiryTime = expiry,
Permissions = SharedAccessBlobPermissions.List,
});
container.SetPermissions(permissions);
Thread.Sleep(30 * 1000);
CloudBlobContainer container2 = container.ServiceClient.GetContainerReference(container.Name);
permissions = container2.GetPermissions();
Assert.AreEqual(BlobContainerPublicAccessType.Container, permissions.PublicAccess);
Assert.AreEqual(1, permissions.SharedAccessPolicies.Count);
Assert.IsTrue(permissions.SharedAccessPolicies["key1"].SharedAccessStartTime.HasValue);
Assert.AreEqual(start, permissions.SharedAccessPolicies["key1"].SharedAccessStartTime.Value.UtcDateTime);
Assert.IsTrue(permissions.SharedAccessPolicies["key1"].SharedAccessExpiryTime.HasValue);
Assert.AreEqual(expiry, permissions.SharedAccessPolicies["key1"].SharedAccessExpiryTime.Value.UtcDateTime);
Assert.AreEqual(SharedAccessBlobPermissions.List, permissions.SharedAccessPolicies["key1"].Permissions);
}
finally
{
container.DeleteIfExists();
}
}
/// <summary>
/// Creates a new Shared Access Policy for the container
/// </summary>
/// <param name="blobClient">The blob client to use for this operation</param>
/// <param name="container">The container to create the policy for</param>
/// <param name="policyName">The name of the policy</param>
static void CreateSharedAccessPolicy(CloudBlobClient blobClient, CloudBlobContainer container,
string policyName)
{
//Create a new shared access policy and define its constraints.
SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
{
// What is the expiration date of this policy?
SharedAccessExpiryTime = DateTime.UtcNow.AddYears(1),
// What permissions does this policy grant?
Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List
};
//Get the container's existing permissions.
BlobContainerPermissions permissions = container.GetPermissions();
//Add the new policy to the container's permissions, and set the container's permissions.
permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
container.SetPermissions(permissions);
}
//Initializing constructor...
public AzureContext(string appSettingsKey)
{
if ( null == _cloudStorageAccount ) //ASSUMPTION: This member is ALWAYS allocated first...
{
lock (lockObject)
{
if ( null == _cloudStorageAccount )
{
string connectionString = ConfigurationManager.AppSettings[appSettingsKey];
_cloudStorageAccount = CloudStorageAccount.Parse(connectionString);
_cloudBlobClient = _cloudStorageAccount.CreateCloudBlobClient();
_cloudBlobContainer = _cloudBlobClient.GetContainerReference(ConfigurationManager.AppSettings["blobContainer"]);
//ASSUMPTION: container access settings: public read access blobs only...
BlobContainerPermissions bcp = _cloudBlobContainer.GetPermissions();
Debug.Assert(BlobContainerPublicAccessType.Blob == bcp.PublicAccess);
}
}
}
}
public void ProcessMedia()
{
// Run the thumbnail job.
var asset = RunVideoThumbnailJob((string)_mediaObject["mediaName"], "config.json");
if (asset != null)
{
Uri blobUri = new Uri(asset.Uri.ToString());
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = new Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer(blobUri, _blobCredentials);
BlobContainerPermissions permissions = container.GetPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(permissions);
var summaryVideoUrl = container.Uri.OriginalString + "/" + asset.AssetFiles.FirstOrDefault().Name;
_log.Info($"Granted public access to {summaryVideoUrl}");
_dbContext.UpdateSummaryUrl((int)_mediaObject["mediaId"], summaryVideoUrl);
}
else
{
_log.Info($"No assets found for media name: {_mediaObject["mediaName"]}");
}
}
/// <summary>
/// Get container presssions
/// </summary>
/// <param name="container">A cloudblobcontainer object</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="options">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <returns>The container's permission</returns>
public BlobContainerPermissions GetContainerPermissions(CloudBlobContainer container, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return container.GetPermissions(accessCondition, options, operationContext);
}
private SharedAccessBlobPolicy GetNonExpiredContainerPolicy(CloudBlobContainer container)
{
SharedAccessBlobPolicy policy;
bool policyExpired = false;
var permissions = container.GetPermissions();
var policyExists = permissions.SharedAccessPolicies.TryGetValue(PolicyName, out policy);
if (policyExists)
{
policyExpired = policy.SharedAccessExpiryTime < DateTime.UtcNow;
}
if (policyExpired || !policyExists)
{
policy = CreateSharedAccessPolicy();
permissions.SharedAccessPolicies.Remove(PolicyName);
permissions.SharedAccessPolicies.Add(PolicyName, policy);
container.SetPermissions(permissions);
}
return policy;
}
public static void PackContainerCompareData(CloudBlobContainer container, Dictionary<string, object> dic)
{
BlobContainerPermissions permissions = container.GetPermissions();
dic["PublicAccess"] = permissions.PublicAccess;
dic["Permission"] = permissions;
dic["LastModified"] = container.Properties.LastModified;
}
/// <summary>
/// Test container reads and writes, expecting success.
/// </summary>
/// <param name="testContainer">The container.</param>
/// <param name="testAccessCondition">The access condition to use.</param>
private void ContainerReadWriteExpectLeaseSuccess(CloudBlobContainer testContainer, AccessCondition testAccessCondition)
{
testContainer.FetchAttributes(testAccessCondition, null /* options */);
testContainer.GetPermissions(testAccessCondition, null /* options */);
testContainer.SetMetadata(testAccessCondition, null /* options */);
testContainer.SetPermissions(new BlobContainerPermissions(), testAccessCondition, null /* options */);
}
/// <summary>
/// Test container reads and writes, expecting lease failure.
/// </summary>
/// <param name="testContainer">The container.</param>
/// <param name="testAccessCondition">The failing access condition to use.</param>
/// <param name="expectedErrorCode">The expected error code.</param>
/// <param name="description">The reason why these calls should fail.</param>
private void ContainerReadWriteExpectLeaseFailure(CloudBlobContainer testContainer, AccessCondition testAccessCondition, HttpStatusCode expectedStatusCode, string expectedErrorCode, string description)
{
// FetchAttributes is a HEAD request with no extended error info, so it returns with the generic ConditionFailed error code.
TestHelper.ExpectedException(
() => testContainer.FetchAttributes(testAccessCondition, null /* options */),
description + "(Fetch Attributes)",
HttpStatusCode.PreconditionFailed);
TestHelper.ExpectedException(
() => testContainer.GetPermissions(testAccessCondition, null /* options */),
description + " (Get Permissions)",
expectedStatusCode,
expectedErrorCode);
TestHelper.ExpectedException(
() => testContainer.SetMetadata(testAccessCondition, null /* options */),
description + " (Set Metadata)",
expectedStatusCode,
expectedErrorCode);
TestHelper.ExpectedException(
() => testContainer.SetPermissions(new BlobContainerPermissions(), testAccessCondition, null /* options */),
description + " (Set Permissions)",
expectedStatusCode,
expectedErrorCode);
}
static void CreateSharedAccessPolicy(CloudBlobClient blobClient, CloudBlobContainer container, string policyName)
{
SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
{
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
Permissions = SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.List | SharedAccessBlobPermissions.Read
};
BlobContainerPermissions permissions = container.GetPermissions();
permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
container.SetPermissions(permissions);
}
public CloudBlobContainer GetContainer(string containerName)
{
container = blobClient.GetContainerReference(containerName);
if (container.CreateIfNotExists())
{
// configure container for public access
var permissions = container.GetPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(permissions);
}
return container;
}