public string DownloadPublicBlob(string UserId, string BlobName, bool PublicAccess = true)
{
//Retrieve a reference to a container.
//Retrieve storage account from connection string.
Microsoft.WindowsAzure.Storage.CloudStorageAccount StorageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(Convert.ToString(ConfigurationManager.AppSettings["StorageConnectionString"]));
// Create the blob client.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference(UserId);
// Create the container if it doesn't exist.
container.CreateIfNotExists();
//Set permission to public
if (PublicAccess)
{
container.SetPermissions(
new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions
{
PublicAccess =
Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Blob
});
}
else
{
container.SetPermissions(
new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions
{
PublicAccess =
Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Off
});
}
// Retrieve reference to a blob named
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName);
//var sasToken = blockBlob.GetSharedAccessSignature(new SharedAccessBlobPolicy()
//{
// Permissions = SharedAccessBlobPermissions.Read,
// SharedAccessExpiryTime = DateTime.UtcNow.AddMinutes(10),//assuming the blob can be downloaded in 10 miinutes
//}, new SharedAccessBlobHeaders()
//{
// ContentDisposition = "attachment; filename=file-name"
//});
//return string.Format("{0}{1}", blockBlob.Uri, sasToken);
return(blockBlob.Uri.ToString());
}
public BlobContainer(string name)
{
// hämta connectionsträngen från config // RoleEnviroment bestämmer settingvalue runtime
//var connectionString = RoleEnvironment.GetConfigurationSettingValue("PhotoAppStorage");
//var connectionString = CloudConfigurationManager.GetSetting("CloudStorageApp");
// hämtar kontot utfrån connectionsträngens värde
//var account = CloudStorageAccount.Parse(connectionString);
//var account = CloudStorageAccount.DevelopmentStorageAccount;
var cred = new StorageCredentials("jholm",
"/bVipQ2JxjWwYrZQfHmzhaBx1p1s8BoD/wX6VWOmg4/gpVo/aALrjsDUKqzXsFtc9utepPqe65NposrXt9YsyA==");
var account = new CloudStorageAccount(cred, true);
// skapar en blobclient
_client = account.CreateCloudBlobClient();
m_BlobContainer = _client.GetContainerReference(name);
// Om det inte finns någon container med det namnet
if (!m_BlobContainer.Exists())
{
// Skapa containern
m_BlobContainer.Create();
var permissions = new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
// Sätter public access till blobs
m_BlobContainer.SetPermissions(permissions);
}
}
/// <summary>
/// Initiates the SolCat Azure blob data sync.
/// </summary>
public static void CopyBlobData()
{
// Authentication Credentials for Azure Storage:
var credsSrc
= new StorageCredentials(
ConfigHelper.GetConfigValue("HubContainerName"),
ConfigHelper.GetConfigValue("HubContainerKey"));
var credsDest
= new StorageCredentials(
ConfigHelper.GetConfigValue("NodeContainerKey"),
ConfigHelper.GetConfigValue("NodeContainerKey"));
// Source Container: Hub (Development)
_srcContainer =
new CloudBlobContainer(
new Uri(ConfigHelper.GetConfigValue("HubContainerUri")),
credsSrc);
// Destination Container: Node (Production)
_destContainer =
new CloudBlobContainer(
new Uri(ConfigHelper.GetConfigValue("NodeContainerUri")),
credsDest);
// Set permissions on the container:
var permissions = new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Blob};
_srcContainer.SetPermissions(permissions);
_destContainer.SetPermissions(permissions);
// Call the blob copy master method:
CopyBlobs(_srcContainer, _destContainer);
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections.
ServicePointManager.DefaultConnectionLimit = 12;
// Read database connection string and open database.
var dbConnString = CloudConfigurationManager.GetSetting("TCWAdminPortalDbConnectionString");
_dbContext = new TCWAdminContext(dbConnString);
// Open storage account using credentials from .cscfg file.
var storageAccount = CloudStorageAccount.Parse
(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString"));
Trace.TraceInformation("Creating images blob container");
var blobClient = storageAccount.CreateCloudBlobClient();
_imagesBlobContainer = blobClient.GetContainerReference("images");
if (_imagesBlobContainer.CreateIfNotExists())
{
// Enable public access on the newly created "images" container.
_imagesBlobContainer.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
Trace.TraceInformation("Creating images queue");
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
_imagesQueue = queueClient.GetQueueReference("images");
_imagesQueue.CreateIfNotExists();
Trace.TraceInformation("Storage initialized");
return base.OnStart();
}
public BlobStorage(BlobSettings appSettings)
{
try
{
if (appSettings.ImageSize != null)
ResizeLayer = new ResizeLayer(appSettings.ImageSize, ResizeMode.Min);
UploadThumbnail = appSettings.UploadThumbnail;
StorageAccountName = appSettings.StorageAccountName;
StorageAccountAccessKey = appSettings.StorageAccountAccessKey;
// Create a blob client and retrieve reference to images container
BlobClient = StorageAccount.CreateCloudBlobClient();
Container = BlobClient.GetContainerReference(appSettings.ContainerName);
// Create the "images" container if it doesn't already exist.
if (Container.CreateIfNotExists())
{
// Enable public access on the newly created "images" container
Container.SetPermissions(
new BlobContainerPermissions
{
PublicAccess =
BlobContainerPublicAccessType.Blob
});
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
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);
//using ( new HttpContextWeaver() )
{
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.CreateIfNotExists();
Container.SetPermissions(isPrivate
? new BlobContainerPermissions
{PublicAccess = BlobContainerPublicAccessType.Off}
: new BlobContainerPermissions
{PublicAccess = BlobContainerPublicAccessType.Blob}); // deny listing
}
}
protected void SetContainerPermission(CloudBlobContainer container, BlobContainerPublicAccessType perimssion)
{
container.SetPermissions(new BlobContainerPermissions
{
PublicAccess = perimssion
});
}
public void InitializeContainer(string container)
{
var blobClient = StorageAccount.CreateCloudBlobClient();
blobContainer = blobClient.GetContainerReference(container);
blobContainer.CreateIfNotExists();
blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob });
}
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);
}
public async Task OpenAsync(PartitionContext context)
{
if (!WebJobsHelper.RunAsWebJobs)
Console.WriteLine(string.Format("EventProcessor initialization. Partition: '{0}', Offset: '{1}'",
context.Lease.PartitionId, context.Lease.Offset));
partitionContext = context;
var retries = 3;
while (retries > 0)
{
var s = string.Empty;
try
{
retries--;
s = "storage";
storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["SigfoxDemoStorage"].ConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
blobContainer = blobClient.GetContainerReference("device");
blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Off });
blobContainer.CreateIfNotExists();
s = "cache";
cacheConnection = await ConnectionMultiplexer.ConnectAsync(ConfigurationManager.ConnectionStrings["SigfoxDemoCache"].ConnectionString);
cacheDatabase = cacheConnection.GetDatabase();
s = "database";
sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["SigfoxDemoDatabase"].ConnectionString);
sqlConnection.Open();
sqlCommand = new SqlCommand("InsertMessage", sqlConnection) { CommandType = CommandType.StoredProcedure };
sqlCommand.Parameters.Add(new SqlParameter("@Device", SqlDbType.VarChar));
sqlCommand.Parameters.Add(new SqlParameter("@Data", SqlDbType.VarChar));
sqlCommand.Parameters.Add(new SqlParameter("@Mode", SqlDbType.TinyInt));
sqlCommand.Parameters.Add(new SqlParameter("@Periode", SqlDbType.TinyInt));
sqlCommand.Parameters.Add(new SqlParameter("@FrameType", SqlDbType.TinyInt));
sqlCommand.Parameters.Add(new SqlParameter("@Battery", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Temperature", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Humidity", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@ILS", SqlDbType.Bit));
sqlCommand.Parameters.Add(new SqlParameter("@Light", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Version", SqlDbType.VarChar));
sqlCommand.Parameters.Add(new SqlParameter("@AlertCount", SqlDbType.Int));
sqlCommand.Parameters.Add(new SqlParameter("@TimeStamp", SqlDbType.DateTime));
sqlCommand.Parameters.Add(new SqlParameter("@Duplicate", SqlDbType.Bit));
sqlCommand.Parameters.Add(new SqlParameter("@Signal", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Station", SqlDbType.VarChar));
sqlCommand.Parameters.Add(new SqlParameter("@AvgSignal", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Latitude", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Longitude", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@Rssi", SqlDbType.Float));
sqlCommand.Parameters.Add(new SqlParameter("@SeqNumber", SqlDbType.Int));
retries = 0;
}
catch (Exception e)
{
Console.Error.WriteLine("Error opening destination Event Hub: " + e.Message + "(" + s + ")");
if (retries == 0)
throw;
}
}
checkpointStopWatch = new Stopwatch();
checkpointStopWatch.Start();
}
public StorageBlob.CloudBlobContainer CreateContainer(string containerName, StorageBlob.BlobContainerPublicAccessType permission)
{
StorageBlob.CloudBlobContainer container = CreateContainer(containerName);
StorageBlob.BlobContainerPermissions containerPermission = new StorageBlob.BlobContainerPermissions();
containerPermission.PublicAccess = permission;
container.SetPermissions(containerPermission);
return(container);
}
public BlobHelper(String container)
{
// get or create blobContainer to communicate with Azure storage service
var blobClient = StorageAccount.CreateCloudBlobClient();
blobContainer = blobClient.GetContainerReference(container);
blobContainer.CreateIfNotExists();
blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob });
}
public void setPublicPermissions(CloudBlobContainer container, BlobContainerPublicAccessType Level)
{
container.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = Level
});
}
public void createContainer()
{
container = blobClient.GetContainerReference(Constants.blobContainerName);
if (container.CreateIfNotExists())
{
container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
}
}
public PhotoInBlob()
{
storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnection"].ConnectionString);
blobClinet = storageAccount.CreateCloudBlobClient();
blobContainer = blobClinet.GetContainerReference(ConfigurationManager.AppSettings["blobContainer"].ToString());
if(blobContainer.CreateIfNotExists())
{
blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob });
}
}
public AzureFileSystem(CloudBlobContainer container)
{
// this is not the constructor you're looking for
this.container = container;
container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container });
container.CreateIfNotExists();
CreateDirectory("");
}
public AzureFileSystem(ISessionProvider sessionProvider, DatabaseSection config)
{
var storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
this.container = storageAccount.CreateCloudBlobClient().GetContainerReference("le-upload");
container.CreateIfNotExists();
container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container });
CreateDirectory("/upload/");
}
/// <summary>
/// Assign permissions for a download to occur for our readonly permission policy
/// </summary>
static void AssignDownloadPolicyContainerPermissions(CloudBlobContainer container)
{
// Secure storage. We will provide read tokens for access to blob data on a per-blob basis.
var containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Off;
containerPermissions.SharedAccessPolicies.Add(DownloadPolicyName, new SharedAccessBlobPolicy
{
Permissions = SharedAccessBlobPermissions.Read
});
container.SetPermissions(containerPermissions);
}
/// <summary>
/// Returns the Url of the given File object
/// </summary>
public static string GetImageUrl(Models.File file)
{
_container = _blobClient.GetContainerReference(file.Container);
_container.CreateIfNotExists();
_container.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
return _container.GetBlockBlobReference(file.Key).Uri.ToString();
}
//Retrieve Blob Container
public Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer GetCloudBlobContainer(string ContainerName, Boolean PublicAccess = false)
{
// Retrieve storage account from connection string.
Microsoft.WindowsAzure.Storage.CloudStorageAccount StorageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(Convert.ToString(ConfigurationManager.AppSettings["StorageConnectionString"]));
// Create the blob client.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference(ContainerName);
// Create the container if it doesn't exist.
container.CreateIfNotExists();
//Set permission to public
if (PublicAccess)
{
container.SetPermissions(
new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions
{
PublicAccess =
Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Blob
});
}
else
{
container.SetPermissions(
new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions
{
PublicAccess =
Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Off
});
}
return(container);
}
/// <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 FileService()
{
var storageAccount =
CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
var blobClient = storageAccount.CreateCloudBlobClient();
_container = blobClient.GetContainerReference(CloudConfigurationManager.GetSetting("FileContainer"));
_container.CreateIfNotExists();
_container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off });
_publicContainer = blobClient.GetContainerReference(CloudConfigurationManager.GetSetting("PublicImageContainer"));
_publicContainer.CreateIfNotExists();
_publicContainer.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container });
}
public BlobStoargeService()
{
var storageConnectionString =
string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
CloudConfigurationManager.GetSetting("AzureStorageAccountName"),
CloudConfigurationManager.GetSetting("AzureStorageKey"));
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
_container = blobClient.GetContainerReference(CloudConfigurationManager.GetSetting("AzureContainerName"));
_container.CreateIfNotExists();
_container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off });
}
// Overriding OnStartup to be able to store azure-specific data outside the logic.
// Data is reachable in code through (App.Current as App).[variable]
protected override async void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
csa = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("stacConnectionString"));
cbc = csa.CreateCloudBlobClient();
blobcontainer = cbc.GetContainerReference("lexiconblobs");
bro.RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(2), 3);
// If connection is established
if (await checkConnection())
{
blobcontainer.CreateIfNotExists();
blobcontainer.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
ping = getPing();//await checkConnection();
}
}
public FileService(IRepositoryWithTypedId<Attachment, Guid> attachmentRepository)
{
_attachmentRepository = attachmentRepository;
var storageConnectionString =
string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
CloudConfigurationManager.GetSetting("AzureStorageAccountName"),
CloudConfigurationManager.GetSetting("AzureStorageKey"));
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
_container = blobClient.GetContainerReference("oppattachments");
_container.CreateIfNotExists();
_container.SetPermissions(new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off});
}
public static void Create(string account, string key, string containerName, bool publicAccess)
{
if (string.IsNullOrEmpty(containerName))
return;
CloudBlobClient blobClient = Client.GetBlobClient(account, key);
Uri uri = new Uri(string.Format(blobClient.BaseUri + "{0}", containerName));
CloudBlobContainer cont = new CloudBlobContainer(uri, blobClient.Credentials);
cont.Create();
if (publicAccess)
{
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
cont.SetPermissions(permissions);
}
}
static void CreateSharedAccessPolicy(CloudBlobClient blobClient, CloudBlobContainer container, string policyName)
{
//Create a new stored access policy and define its constraints.
SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
{
SharedAccessExpiryTime = DateTime.UtcNow.AddHours(10),
Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.List
};
//Get the container's existing permissions.
BlobContainerPermissions permissions = new BlobContainerPermissions();
//Add the new policy to the container's permissions.
permissions.SharedAccessPolicies.Clear();
permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
container.SetPermissions(permissions);
}
public void Initialize()
{
string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
CloudStorageAccount account = CloudStorageAccount.Parse(connectionString);
CloudBlobClient client = account.CreateCloudBlobClient();
Container = client.GetContainerReference("images");
Container.CreateIfNotExists();
Container.SetPermissions(
new BlobContainerPermissions
{
PublicAccess =
BlobContainerPublicAccessType.Blob
});
}
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>
/// Receives the users Id for where the pictures are and creates
/// a blob storage with that name if it does not exist.
/// </summary>
/// <param name="DirecoryUrl"></param>
public BlobRepo(string DirecoryUrl)
{
this._direcoryUrl = DirecoryUrl;
// Create the blob client.
_blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
_container = _blobClient.GetContainerReference(DirecoryUrl);
// Create the container if it doesn't already exist.
_container.CreateIfNotExists();
//Make available to everyone
_container.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
/// <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);
}
public AzurePictureService(IRepository<Picture> pictureRepository,
IRepository<ProductPicture> productPictureRepository,
IRepository<Product> productRepository,
ISettingService settingService,
IWebHelper webHelper,
ILogger logger,
IDbContext dbContext,
IEventPublisher eventPublisher,
MediaSettings mediaSettings,
NopConfig config)
: base(pictureRepository,
productPictureRepository,
productRepository,
settingService,
webHelper,
logger,
dbContext,
eventPublisher,
mediaSettings)
{
this._config = config;
if (String.IsNullOrEmpty(_config.AzureBlobStorageConnectionString))
throw new Exception("Azure connection string for BLOB is not specified");
if (String.IsNullOrEmpty(_config.AzureBlobStorageContainerName))
throw new Exception("Azure container name for BLOB is not specified");
if (String.IsNullOrEmpty(_config.AzureBlobStorageEndPoint))
throw new Exception("Azure end point for BLOB is not specified");
_storageAccount = CloudStorageAccount.Parse(_config.AzureBlobStorageConnectionString);
if (_storageAccount == null)
throw new Exception("Azure connection string for BLOB is not wrong");
//should we do it for each HTTP request?
blobClient = _storageAccount.CreateCloudBlobClient();
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
//container.SetPermissions(containerPermissions);
container_thumb = blobClient.GetContainerReference(_config.AzureBlobStorageContainerName);
container_thumb.CreateIfNotExists();
container_thumb.SetPermissions(containerPermissions);
}
/// <summary>
/// Create the container if it doesn't already exist
/// and changes its permissions to public.
/// </summary>
/// <param name="name">Name of the container.
/// Must be a valid DNS name</param>
private static void CreatePublicContainer(string name)
{
container = blobClient.GetContainerReference(name);
// Create the container if it doesn't already exist.
container.CreateIfNotExists();
// By default, the new container is private and you must
// specify your storage access key to download blobs
container.SetPermissions(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
Console.WriteLine("{0} created!", name);
Console.WriteLine("Press any key to continue ...");
Console.ReadKey();
Console.Clear();
}
public ImageService()
{
CloudStorageAccount storageAccount;
// Retrieve storage account from connection string.
if (CloudStorageAccount.TryParse(RoleEnvironment.GetConfigurationSettingValue("ImageStorageAccountConnection"), out storageAccount))
{
// Create the blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
_container = blobClient.GetContainerReference("blobContainer");
if (_container.CreateIfNotExists())
{
_container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
}
}
else
{
throw new ApplicationException("Could not find ImageStorageAccountConnection setting");
}
}
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"]}");
}
}
private static void CloudBlockBlobCopy(bool sourceIsSas, bool destinationIsSas)
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
// Create Source on server
CloudBlockBlob source = container.GetBlockBlobReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
// Create Destination on server
CloudBlockBlob destination = container.GetBlockBlobReference("destination");
destination.PutBlockList(new string[] { });
CloudBlockBlob copySource = source;
CloudBlockBlob copyDestination = destination;
if (sourceIsSas)
{
// Source SAS must have read permissions
SharedAccessBlobPermissions permissions = SharedAccessBlobPermissions.Read;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = source.GetSharedAccessSignature(policy);
// Get source
StorageCredentials credentials = new StorageCredentials(sasToken);
copySource = new CloudBlockBlob(credentials.TransformUri(source.Uri));
}
if (destinationIsSas)
{
if (!sourceIsSas)
{
// Source container must be public if source is not SAS
BlobContainerPermissions containerPermissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
container.SetPermissions(containerPermissions);
}
// Destination SAS must have write permissions
SharedAccessBlobPermissions permissions = SharedAccessBlobPermissions.Write;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = permissions,
};
string sasToken = destination.GetSharedAccessSignature(policy);
// Get destination
StorageCredentials credentials = new StorageCredentials(sasToken);
copyDestination = new CloudBlockBlob(credentials.TransformUri(destination.Uri));
}
// Start copy and wait for completion
string copyId = copyDestination.StartCopyFromBlob(TestHelper.Defiddler(copySource));
WaitForCopy(destination);
// Check original blob references for equality
Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, destination.CopyState.TotalBytes);
Assert.AreEqual(data.Length, destination.CopyState.BytesCopied);
Assert.AreEqual(copyId, destination.CopyState.CopyId);
Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
if (!destinationIsSas)
{
// Abort Copy is not supported for SAS destination
TestHelper.ExpectedException(
() => copyDestination.AbortCopy(copyId),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
Assert.IsNotNull(destination.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag);
Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(destination, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of blob not equal.");
destination.FetchAttributes();
BlobProperties prop1 = destination.Properties;
BlobProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", destination.Metadata["Test"], false, "Copied metadata not same");
destination.Delete();
source.Delete();
}
finally
{
container.DeleteIfExists();
}
}
