public CloudBlobContainer GetBlobContainer(string container)
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(
StorageConnectionString);
ServicePoint tableServicePoint = ServicePointManager.FindServicePoint(storageAccount.TableEndpoint);
tableServicePoint.UseNagleAlgorithm = false;
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
CloudBlobContainer blobContainer = blobClient.GetContainerReference(container);
// Create the container if it doesn't already exist.
blobContainer.CreateIfNotExistsAsync().Wait();
blobContainer.SetPermissionsAsync(
new BlobContainerPermissions
{
PublicAccess =
BlobContainerPublicAccessType.Blob
}).Wait();
return(blobContainer);
}
internal FunctionsController(
CloudStorageAccount account,
CloudBlobClient blobClient,
IFunctionInstanceLookup functionInstanceLookup,
IFunctionLookup functionLookup,
IFunctionIndexReader functionIndexReader,
IHeartbeatValidityMonitor heartbeatMonitor,
IAborter aborter,
IRecentInvocationIndexReader recentInvocationsReader,
IRecentInvocationIndexByFunctionReader recentInvocationsByFunctionReader,
IRecentInvocationIndexByJobRunReader recentInvocationsByJobRunReader,
IRecentInvocationIndexByParentReader recentInvocationsByParentReader,
IFunctionStatisticsReader statisticsReader,
ILogReader reader)
{
_account = account;
_blobClient = blobClient;
_functionInstanceLookup = functionInstanceLookup;
_functionLookup = functionLookup;
_functionIndexReader = functionIndexReader;
_heartbeatMonitor = heartbeatMonitor;
_aborter = aborter;
_recentInvocationsReader = recentInvocationsReader;
_recentInvocationsByFunctionReader = recentInvocationsByFunctionReader;
_recentInvocationsByJobRunReader = recentInvocationsByJobRunReader;
_recentInvocationsByParentReader = recentInvocationsByParentReader;
_statisticsReader = statisticsReader;
_reader = reader;
}
public BlobStorageManager(string blobConnectionEndPointString)
{
this.blobConnectionEndPointString = blobConnectionEndPointString;
CloudStorageAccount VP2ClientBlobStorageAccount = CloudStorageAccount.Parse(blobConnectionEndPointString);
VP2CloudBlobClient = VP2ClientBlobStorageAccount.CreateCloudBlobClient();
VP2CloudTableClient = VP2ClientBlobStorageAccount.CreateCloudTableClient();
}
public virtual Uri UploadFile(
string storageName,
Uri blobEndpointUri,
string storageKey,
string filePath,
BlobRequestOptions blobRequestOptions)
{
StorageCredentials credentials = new StorageCredentials(storageName, storageKey);
CloudBlobClient client = new CloudBlobClient(blobEndpointUri, credentials);
string blobName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}",
DateTime.UtcNow.ToString("yyyyMMdd_HHmmss", CultureInfo.InvariantCulture),
Path.GetFileName(filePath));
CloudBlobContainer container = client.GetContainerReference(ContainerName);
container.CreateIfNotExists();
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobRequestOptions uploadRequestOption = blobRequestOptions ?? new BlobRequestOptions();
if (!uploadRequestOption.ServerTimeout.HasValue)
{
uploadRequestOption.ServerTimeout = TimeSpan.FromMinutes(300);
}
using (FileStream readStream = File.OpenRead(filePath))
{
blob.UploadFromStream(readStream, AccessCondition.GenerateEmptyCondition(), uploadRequestOption);
}
return new Uri(string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}", client.BaseUri, ContainerName, client.DefaultDelimiter, blobName));
}
public Task DownloadBlob(
Uri uri,
string localFile,
FileEncryption fileEncryption,
ulong initializationVector,
CloudBlobClient client,
CancellationToken cancellationToken,
IRetryPolicy retryPolicy,
Func<string> getSharedAccessSignature = null,
long start = 0,
long length = -1,
int parallelTransferThreadCount = 10,
int numberOfConcurrentTransfers = 2)
{
if (client != null && getSharedAccessSignature != null)
{
throw new InvalidOperationException("The arguments client and getSharedAccessSignature cannot both be non-null");
}
SetConnectionLimits(uri, Environment.ProcessorCount * numberOfConcurrentTransfers * parallelTransferThreadCount);
Task task =
Task.Factory.StartNew(
() =>
DownloadFileFromBlob(uri, localFile, fileEncryption, initializationVector, client,
cancellationToken, retryPolicy, getSharedAccessSignature, start: start, length: length,
parallelTransferThreadCount: parallelTransferThreadCount));
return task;
}
public Task UploadBlob(
Uri url,
string localFile,
FileEncryption fileEncryption,
CancellationToken cancellationToken,
CloudBlobClient client,
IRetryPolicy retryPolicy,
string contentType = null,
string subDirectory = "",
Func<string> getSharedAccessSignature = null)
{
SetConnectionLimits(url);
return Task.Factory.StartNew(
() => UploadFileToBlob(
cancellationToken,
url,
localFile,
contentType,
subDirectory,
fileEncryption,
client,
retryPolicy,
getSharedAccessSignature),
cancellationToken);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="blobClient">use BlobConn to get blobClient</param>
/// <param name="clientContainerName">This should be the ID of the User</param>
/// <returns></returns>
public Blob(CloudBlobClient blobClient, string clientContainerName)
{
//Get a reference to a container and create container for first time use user
container = blobClient.GetContainerReference(clientContainerName);
container.CreateIfNotExists();
indicator = "OK";
}
public void TestInitialize()
{
this.blobClient = GenerateCloudBlobClient();
// Create and log a new prefix for this test.
this.prefix = Guid.NewGuid().ToString("N");
}
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>
/// Occurs when a storage provider operation has completed.
/// </summary>
//public event EventHandler<StorageProviderEventArgs> StorageProviderOperationCompleted;
#endregion
// Initialiser method
private void Initialise(string storageAccount, string containerName)
{
if (String.IsNullOrEmpty(containerName))
throw new ArgumentException("You must provide the base Container Name", "containerName");
ContainerName = containerName;
_account = CloudStorageAccount.Parse(storageAccount);
_blobClient = _account.CreateCloudBlobClient();
_container = _blobClient.GetContainerReference(ContainerName);
try
{
_container.FetchAttributes();
}
catch (StorageException)
{
Trace.WriteLine(string.Format("Create new container: {0}", ContainerName), "Information");
_container.Create();
// set new container's permissions
// Create a permission policy to set the public access setting for the container.
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
// The public access setting explicitly specifies that the container is private,
// so that it can't be accessed anonymously.
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Off;
//Set the permission policy on the container.
_container.SetPermissions(containerPermissions);
}
}
public AzureBlobClient()
{
var storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("StorageConnectionString"));
_blobClient = storageAccount.CreateCloudBlobClient();
}
public AzureImageUploader()
{
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
_blobClient = storageAccount.CreateCloudBlobClient();
_container = FindOrCreateContainer(ContainerName);
_filecontainer = FindOrCreateContainer(FileContainerName);
}
public static CloudBlobClient GenerateCloudBlobClient()
{
Uri baseAddressUri = new Uri(TestBase.TargetTenantConfig.BlobServiceEndpoint);
CloudBlobClient client = new CloudBlobClient(baseAddressUri, TestBase.StorageCredentials);
client.AuthenticationScheme = DefaultAuthenticationScheme;
return client;
}
protected EndToEndTestFixture(string rootPath)
{
string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.Storage);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
_queueClient = storageAccount.CreateCloudQueueClient();
_blobClient = storageAccount.CreateCloudBlobClient();
CreateTestStorageEntities();
TraceWriter = new TestTraceWriter(TraceLevel.Verbose);
ScriptHostConfiguration config = new ScriptHostConfiguration()
{
RootScriptPath = rootPath,
TraceWriter = TraceWriter,
FileLoggingEnabled = true
};
HostManager = new ScriptHostManager(config);
Thread t = new Thread(_ =>
{
HostManager.RunAndBlock();
});
t.Start();
TestHelpers.Await(() => HostManager.IsRunning).Wait();
}
/// <summary>
/// Upload the generated receipt Pdf to Blob storage.
/// </summary>
/// <param name="file">Byte array containig the Pdf file contents to be uploaded.</param>
/// <param name="fileName">The desired filename of the uploaded file.</param>
/// <returns></returns>
public string UploadPdfToBlob(byte[] file, string fileName)
{
// Create the blob client.
blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
blobContainer = blobClient.GetContainerReference(receiptBlobName);
// Create the container if it doesn't already exist.
blobContainer.CreateIfNotExists(BlobContainerPublicAccessType.Blob);
string fileUri = string.Empty;
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(fileName);
using (var stream = new MemoryStream(file))
{
// Upload the in-memory Pdf file to blob storage.
blockBlob.UploadFromStream(stream);
}
fileUri = blockBlob.Uri.ToString();
return fileUri;
}
/// <summary>
/// Create an AzureDirectory
/// </summary>
/// <param name="storageAccount">storage account to use</param>
/// <param name="containerName">name of container (folder in blob storage)</param>
/// <param name="cacheDirectory">local Directory object to use for local cache</param>
/// <param name="rootFolder">path of the root folder inside the container</param>
public AzureDirectory(
CloudStorageAccount storageAccount,
string containerName = null,
Lucene.Net.Store.Directory cacheDirectory = null,
bool compressBlobs = false,
string rootFolder = null)
{
if (storageAccount == null)
throw new ArgumentNullException("storageAccount");
if (string.IsNullOrEmpty(containerName))
_containerName = "lucene";
else
_containerName = containerName.ToLower();
if (string.IsNullOrEmpty(rootFolder))
_rootFolder = string.Empty;
else
{
rootFolder = rootFolder.Trim('/');
_rootFolder = rootFolder + "/";
}
_blobClient = storageAccount.CreateCloudBlobClient();
_initCacheDirectory(cacheDirectory);
this.CompressBlobs = compressBlobs;
}
public BlobStorage(string connectionString)
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
this._blobClient = storageAccount.CreateCloudBlobClient();
}
public async Task LocationModeWithMissingUriAsync()
{
AssertSecondaryEndpoint();
CloudBlobClient client = GenerateCloudBlobClient();
CloudBlobClient primaryOnlyClient = new CloudBlobClient(client.BaseUri, client.Credentials);
CloudBlobContainer container = primaryOnlyClient.GetContainerReference("nonexistingcontainer");
BlobRequestOptions options = new BlobRequestOptions()
{
LocationMode = LocationMode.SecondaryOnly,
RetryPolicy = new NoRetry(),
};
Exception e = await TestHelper.ExpectedExceptionAsync<Exception>(
async () => await container.FetchAttributesAsync(null, options, null),
"Request should fail when an URI is not provided for the target location");
Assert.IsInstanceOfType(e.InnerException, typeof(InvalidOperationException));
options.LocationMode = LocationMode.SecondaryThenPrimary;
e = await TestHelper.ExpectedExceptionAsync<Exception>(
async () => await container.FetchAttributesAsync(null, options, null),
"Request should fail when an URI is not provided for the target location");
Assert.IsInstanceOfType(e.InnerException, typeof(InvalidOperationException));
options.LocationMode = LocationMode.PrimaryThenSecondary;
e = await TestHelper.ExpectedExceptionAsync<Exception>(
async () => await container.FetchAttributesAsync(null, options, null),
"Request should fail when an URI is not provided for the target location");
Assert.IsInstanceOfType(e.InnerException, typeof(InvalidOperationException));
}
public BlobFileProvider(IEnumerable<string> locations)
: base()
{
_storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
_blobClient = _storageAccount.CreateCloudBlobClient();
_container = _blobClient.GetContainerReference("data");
_container.CreateIfNotExists();
_strings = new List<string>();
foreach(string location in locations) {
foreach (IListBlobItem item in _container.ListBlobs(location,true))
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
string text;
using (var memoryStream = new MemoryStream())
{
blob.DownloadToStream(memoryStream);
text = Encoding.UTF8.GetString(memoryStream.ToArray());
if (text[0] == _byteOrderMarkUtf8[0])
{
text= text.Remove(0,_byteOrderMarkUtf8.Length);
}
_strings.Add(text);
}
}
}
}
}
public BlobManager(){
try
{
storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"));
blobClient = storageAccount.CreateCloudBlobClient();
container = blobClient.GetContainerReference("supstorage");
container.CreateIfNotExists();
}
catch (ArgumentNullException)
{
Trace.TraceInformation("CloudStorageAccount Exception null ou vide");
// Use Application Local Storage Account String
}
catch (NullReferenceException)
{
Trace.TraceInformation("CloudBlobClient Or CloudBlobContainer Exception");
// Create Container
}
catch (FormatException)
{
Trace.TraceInformation("CloudStorageAccount Exception Connection String Invalid");
}
catch (ArgumentException)
{
Trace.TraceInformation("CloudStorageAccount Exception connectionString ne peut pas être analysée");
}
}
public BlobStorage()
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ReadConfig.CommonCloudCoreApplicationSettings.Storage.StorageConnectionString);
blobClient = storageAccount.CreateCloudBlobClient();
blobClient.DefaultRequestOptions.ServerTimeout = TimeSpan.FromMinutes(10);
// blobClient.ServerTimeout = TimeSpan.FromMinutes(10);
}
public Task UploadBlob(
Uri url,
string localFile,
FileEncryption fileEncryption,
CancellationToken cancellationToken,
CloudBlobClient client,
IRetryPolicy retryPolicy,
string contentType = null,
string subDirectory = "",
Func<string> getSharedAccessSignature = null,
int parallelTransferThreadCount = 10,
int numberOfConcurrentTransfers = default(int))
{
SetConnectionLimits(url, numberOfConcurrentTransfers);
return Task.Factory.StartNew(
() => UploadFileToBlob(
cancellationToken,
url,
localFile,
contentType,
subDirectory,
fileEncryption,
client,
retryPolicy,
getSharedAccessSignature,
parallelTransferThreadCount),
cancellationToken);
}
public AzureService(string account, string azureKey, string blobUri)
{
_account = account;
var storageAccount = new CloudStorageAccount(new StorageCredentials(account, azureKey), new Uri(blobUri),
null, null);
_client = storageAccount.CreateCloudBlobClient();
}
public BlobManager(string conStr)
{
//RoleEnvironment.GetConfigurationSettingValue("UploadCon")
Storage = CloudStorageAccount.Parse(conStr);
BlobClient = Storage.CreateCloudBlobClient();
QueueClient = Storage.CreateCloudQueueClient();
}
private void Init()
{
var connectionString = ConfigurationManager.ConnectionStrings["BlobStorage"].ConnectionString;
var storageAccount = CloudStorageAccount.Parse(connectionString);
_blobClient = storageAccount.CreateCloudBlobClient();
_blobContainer = _blobClient.GetContainerReference(ConfigurationManager.AppSettings["PhotoContainer"]);
}
public static void Run(string connectionString, bool disableLogging)
{
_connectionString = connectionString;
_storageAccount = CloudStorageAccount.Parse(connectionString);
_blobClient = _storageAccount.CreateCloudBlobClient();
Console.WriteLine("Creating the test blob...");
CreateTestBlob();
try
{
TimeSpan azureSDKTime = RunAzureSDKTest();
TimeSpan webJobsSDKTime = RunWebJobsSDKTest(disableLogging);
// Convert to ulong because the measurment block does not support other data type
ulong perfRatio = (ulong)((webJobsSDKTime.TotalMilliseconds / azureSDKTime.TotalMilliseconds) * 100);
Console.WriteLine("--- Results ---");
Console.WriteLine("Azure SDK: {0} ms: ", azureSDKTime.TotalMilliseconds);
Console.WriteLine("WebJobs SDK: {0} ms: ", webJobsSDKTime.TotalMilliseconds);
Console.WriteLine("Perf ratio (x100, long): {0}", perfRatio);
MeasurementBlock.Mark(
perfRatio,
(disableLogging ? BlobNoLoggingOverheadMetric : BlobLoggingOverheadMetric) + ";Ratio;Percent");
}
finally
{
Cleanup();
}
}
internal static BlobRequestOptions ApplyDefaults(BlobRequestOptions options, BlobType blobType, CloudBlobClient serviceClient, bool applyExpiry = true)
{
BlobRequestOptions modifiedOptions = new BlobRequestOptions(options);
modifiedOptions.RetryPolicy = modifiedOptions.RetryPolicy ?? serviceClient.RetryPolicy;
modifiedOptions.ServerTimeout = modifiedOptions.ServerTimeout ?? serviceClient.ServerTimeout;
modifiedOptions.MaximumExecutionTime = modifiedOptions.MaximumExecutionTime ?? serviceClient.MaximumExecutionTime;
if (applyExpiry && !modifiedOptions.OperationExpiryTime.HasValue && modifiedOptions.MaximumExecutionTime.HasValue)
{
modifiedOptions.OperationExpiryTime = DateTime.Now + modifiedOptions.MaximumExecutionTime.Value;
}
#if WINDOWS_PHONE
modifiedOptions.DisableContentMD5Validation = true;
modifiedOptions.StoreBlobContentMD5 = false;
modifiedOptions.UseTransactionalMD5 = false;
#else
modifiedOptions.DisableContentMD5Validation = modifiedOptions.DisableContentMD5Validation ?? false;
modifiedOptions.StoreBlobContentMD5 = modifiedOptions.StoreBlobContentMD5 ?? (blobType == BlobType.BlockBlob);
modifiedOptions.UseTransactionalMD5 = modifiedOptions.UseTransactionalMD5 ?? false;
#endif
return modifiedOptions;
}
public StorageHelper()
{
_adminuser = "******";
_standarduser = "******";
try
{
var connstring = ConfigurationManager.AppSettings["AzureStorage"];
var acct = CloudStorageAccount.Parse(connstring);
client = acct.CreateCloudBlobClient();
var dir = client.GetContainerReference("studentconnect");
var adminpwd = dir.GetBlobReferenceFromServer("_adminpassword");
// If you get a 403 - Forbidden warning here, its because you dont have access to SD's Azure Storage account.
// Get your own FREE here. http://www.windowsazure.com/en-us/pricing/free-trial/
var adminpwdText = adminpwd.DownloadText();
var schoolsRef = dir.GetBlobReferenceFromServer("_schools");
var schoolsText = schoolsRef.DownloadText();
_adminpassword = adminpwdText;
_schools = this.ParseSchoolText(schoolsText);
}
finally
{
}
}
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 UsersForAdminCsvPublishService(CloudBlobClient blobClient,
IAdminUserService adminUserService,
IMapper mapper) : base(blobClient, new UserForAdminCsvFormatter())
{
_adminUserService = adminUserService;
_mapper = mapper;
}
/// <summary>
/// Constructor for a store backed by Azure
/// </summary>
/// <param name="blobStorage">The storage account that backs this store</param>
/// <param name="enableSnapshots">Whether any save on this store should create snapshots</param>
/// <param name="deletedKey">The metadata key to check if a store item is soft deleted</param>
/// <param name="containerPrefix">Use this to namespace your containers if required</param>
public AzureStore(CloudBlobClient blobStorage, bool enableSnapshots, string deletedKey = null, string containerPrefix = null)
{
_blobStorage = blobStorage;
_enableSnapshots = enableSnapshots;
_deletedKey = deletedKey ?? DefaultDeletedKey;
_containerPrefix = containerPrefix;
}
internal void UploadFromString(string accountName, string accountKey, string containerName, string fileName, string sourceFileName, string fileContentType, string content) //, string name, string fileDescription) {
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount =
Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(
string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1};BlobEndpoint=https://{0}.blob.core.windows.net/", accountName, accountKey)
);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference(containerName);
container.CreateIfNotExists();
string ext = System.IO.Path.GetExtension(sourceFileName);
//string fileName = String.Format(
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(fileName);
blockBlob.Properties.ContentType = fileContentType;
//blockBlob.Metadata.Add("name", name);
blockBlob.Metadata.Add("originalfilename", sourceFileName);
//blockBlob.Metadata.Add("userid", userId.ToString());
//blockBlob.Metadata.Add("ownerid", userId.ToString());
DateTime created = DateTime.UtcNow;
// https://msdn.microsoft.com/en-us/library/8kb3ddd4(v=vs.110).aspx
// http://stackoverflow.com/questions/114983/given-a-datetime-object-how-do-i-get-a-iso-8601-date-in-string-format
//blockBlob.Metadata.Add("username", userName);
blockBlob.Metadata.Add("created", created.ToString("yyyy-MM-ddTHH:mm:ss")); // "yyyy-MM-ddTHH:mm:ssZ"
blockBlob.Metadata.Add("modified", created.ToString("yyyy-MM-ddTHH:mm:ss")); // "yyyy-MM-ddTHH:mm:ssZ"
blockBlob.Metadata.Add("fileext", ext);
blockBlob.UploadText(content, Encoding.UTF8); // .UploadFromStream(fileInputStream);
blockBlob.SetMetadata();
}
protected void Page_Load(object sender, EventArgs e)
{
CloudStorageAccount storageAccount = new CloudStorageAccount(new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials("arailproject", "zSU2JysKO4g0NmCmVSu3vsFUGnvcm8d4WsDhkNgQVVtPCyXfQprTQBWfzh72zu89Hq8vKT6v6XUZpotPTL39CQ=="), true);
string projectattachments = ConfigurationManager.AppSettings["StorageConnectionString"];
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("projectattachments");
container.CreateIfNotExists();
}
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());
}
private void LogError(Exception ex, string message)
{
//ConfigurationManager.ConnectionStrings["CineStorageConStr"].ConnectionString
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("CineStorageConStr"));
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference("data");
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob logBlob = container.GetBlockBlobReference(String.Format(this.LogFile, DateTime.UtcNow.ToString("dd MMM yyyy")));
try
{
using (StreamReader sr = new StreamReader(logBlob.OpenRead()))
{
using (StreamWriter sw = new StreamWriter(logBlob.OpenWrite()))
{
sw.Write(sr.ReadToEnd());
if (ex != null)
{
sw.Write(System.Environment.NewLine);
sw.WriteLine(ex.Message);
sw.WriteLine(ex.StackTrace);
sw.Write(System.Environment.NewLine);
if (ex.InnerException != null)
{
sw.Write(System.Environment.NewLine);
sw.WriteLine(ex.InnerException.Message);
sw.WriteLine(ex.InnerException.StackTrace);
sw.Write(System.Environment.NewLine);
}
}
if (message != null)
{
sw.Write(System.Environment.NewLine);
sw.WriteLine(message);
sw.Write(System.Environment.NewLine);
}
}
}
}
catch { }
}
public Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient GetBlobClient()
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(
StorageConnectionString);
ServicePoint tableServicePoint = ServicePointManager.FindServicePoint(storageAccount.TableEndpoint);
tableServicePoint.UseNagleAlgorithm = false;
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
return(blobClient);
}
private CloudBlobContainer GetContainer()
{
var client = new Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient(
new Uri(ConfigurationManager.AppSettings[@"blobUrl"]),
new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(
ConfigurationManager.AppSettings[@"storageAccount"],
ConfigurationManager.AppSettings[@"storageKey"]));
var c = client.GetContainerReference(@"images");
c.CreateIfNotExists(BlobContainerPublicAccessType.Blob);
return(c);
}
public static Tuple <bool, List <string> > listHubs(string account, string accountKey, string orgID, string studyID)
{
try
{
CloudStorageAccount storageAccount = new CloudStorageAccount(new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(account, accountKey), true);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer storageContainer = blobClient.GetContainerReference(AzureConfigContainerName);
List <String> hubList = lsDirectory(storageContainer.ListBlobs(), "/" + orgID + "/" + studyID + "/");
return(new Tuple <bool, List <string> >(true, hubList));
}
catch (Exception e)
{
return(new Tuple <bool, List <string> >(false, new List <string>()
{
e.Message
}));
}
}
public string GetTempUrl(string accountName, string accountKey, string fullPath)
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount =
Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(
string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1};BlobEndpoint=https://{0}.blob.core.windows.net/", accountName, accountKey)
);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
var blob = blobClient.GetBlobReferenceFromServer(new Uri(fullPath));
var readPolicy = new Microsoft.WindowsAzure.Storage.Blob.SharedAccessBlobPolicy()
{
Permissions = Microsoft.WindowsAzure.Storage.Blob.SharedAccessBlobPermissions.Read, // SharedAccessPermissions.Read,
SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromMinutes(10)
};
string resultUrl = new Uri(blob.Uri.AbsoluteUri + blob.GetSharedAccessSignature(readPolicy)).ToString();
return(resultUrl);
}
private DateTime GetLastModified()
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("CineStorageConStr"));
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference("data");
// Retrieve reference to a blob.
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob cinemasUKBlob = container.GetBlockBlobReference(CinemasUKFileName);
if (cinemasUKBlob.Exists())
{
DateTimeOffset?dto = cinemasUKBlob.Properties.LastModified;
if (dto.HasValue)
{
return(dto.Value.DateTime);
}
}
return(DateTime.MinValue);
}
//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);
}
public string DownloadSharedBlob(string UserId, string BlobName)
{
//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);
var blob = container.GetBlockBlobReference(BlobName);
var sasToken = blob.GetSharedAccessSignature(new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(15),
}, new SharedAccessBlobHeaders()
{
ContentDisposition = "attachment; filename=\"somefile.pdf\"",
});
var downloadUrl = string.Format("{0}{1}", blob.Uri.AbsoluteUri, sasToken);
return(downloadUrl);
}
public string GetTempDownloadUrl(string accountName, string accountKey, string fullPath)
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount =
Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(
string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1};BlobEndpoint=https://{0}.blob.core.windows.net/", accountName, accountKey)
);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
var blob = blobClient.GetBlobReferenceFromServer(new Uri(fullPath));
var readPolicy = new Microsoft.WindowsAzure.Storage.Blob.SharedAccessBlobPolicy()
{
Permissions = Microsoft.WindowsAzure.Storage.Blob.SharedAccessBlobPermissions.Read, // SharedAccessPermissions.Read,
SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromMinutes(10)
};
string resultUrl = new Uri(blob.Uri.AbsoluteUri + blob.GetSharedAccessSignature(readPolicy,
new SharedAccessBlobHeaders {
ContentDisposition = blob.Metadata.ContainsKey("originalfilename") ? "attachment; filename=" + blob.Metadata["originalfilename"] : "attachment; filename=FileUnknown",
ContentType = blob.Properties.ContentType
}
)).ToString();
return(resultUrl);
}
public async Task CloudBlobDirectoryFlatListingAsync()
{
foreach (String delimiter in Delimiters)
{
CloudBlobClient client = GenerateCloudBlobClient();
client.DefaultDelimiter = delimiter;
string name = GetRandomContainerName();
CloudBlobContainer container = client.GetContainerReference(name);
try
{
await container.CreateAsync();
if (await CloudBlobDirectorySetupWithDelimiterAsync(container, delimiter))
{
BlobResultSegment segment = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter, false, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList1 = new List <IListBlobItem>();
simpleList1.AddRange(segment.Results);
while (segment.ContinuationToken != null)
{
segment = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter, false, BlobListingDetails.None, null, segment.ContinuationToken, null, null);
simpleList1.AddRange(segment.Results);
}
Assert.IsTrue(simpleList1.Count == 3);
IListBlobItem item11 = simpleList1.ElementAt(0);
Assert.IsTrue(item11.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "Blob1"));
IListBlobItem item12 = simpleList1.ElementAt(1);
Assert.IsTrue(item12.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter));
IListBlobItem item13 = simpleList1.ElementAt(2);
Assert.IsTrue(item13.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter));
CloudBlobDirectory midDir2 = (CloudBlobDirectory)item13;
BlobResultSegment segment2 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1", true, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList2 = new List <IListBlobItem>();
simpleList2.AddRange(segment2.Results);
while (segment2.ContinuationToken != null)
{
segment2 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1", true, BlobListingDetails.None, null, segment2.ContinuationToken, null, null);
simpleList2.AddRange(segment2.Results);
}
Assert.IsTrue(simpleList2.Count == 2);
IListBlobItem item21 = simpleList2.ElementAt(0);
Assert.IsTrue(item21.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter + "EndBlob1"));
IListBlobItem item22 = simpleList2.ElementAt(1);
Assert.IsTrue(item22.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir2" + delimiter + "EndBlob2"));
BlobResultSegment segment3 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1" + delimiter, false, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList3 = new List <IListBlobItem>();
simpleList3.AddRange(segment3.Results);
while (segment3.ContinuationToken != null)
{
segment3 = await container.ListBlobsSegmentedAsync("TopDir1" + delimiter + "MidDir1" + delimiter, false, BlobListingDetails.None, null, segment3.ContinuationToken, null, null);
simpleList3.AddRange(segment3.Results);
}
Assert.IsTrue(simpleList3.Count == 2);
IListBlobItem item31 = simpleList3.ElementAt(0);
Assert.IsTrue(item31.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir1" + delimiter));
IListBlobItem item32 = simpleList3.ElementAt(1);
Assert.IsTrue(item32.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir1" + delimiter + "EndDir2" + delimiter));
BlobResultSegment segment4 = await midDir2.ListBlobsSegmentedAsync(true, BlobListingDetails.None, null, null, null, null);
List <IListBlobItem> simpleList4 = new List <IListBlobItem>();
simpleList4.AddRange(segment4.Results);
while (segment4.ContinuationToken != null)
{
segment4 = await midDir2.ListBlobsSegmentedAsync(true, BlobListingDetails.None, null, segment4.ContinuationToken, null, null);
simpleList4.AddRange(segment4.Results);
}
Assert.IsTrue(simpleList4.Count == 2);
IListBlobItem item41 = simpleList4.ElementAt(0);
Assert.IsTrue(item41.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter + "EndDir1" + delimiter + "EndBlob1"));
IListBlobItem item42 = simpleList4.ElementAt(1);
Assert.IsTrue(item42.Uri.Equals(container.Uri + "/TopDir1" + delimiter + "MidDir2" + delimiter + "EndDir2" + delimiter + "EndBlob2"));
}
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
}
/// <summary>
/// init cloud blob util
/// </summary>
/// <param name="account">storage account</param>
public CloudBlobUtil(CloudStorageAccount account)
{
this.account = account;
client = account.CreateCloudBlobClient();
random = new Random();
}
public async Task CloudBlobContainerGetBlobReferenceFromServerAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
await blockBlob.PutBlockListAsync(new List <string>());
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
await pageBlob.CreateAsync(0);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("ab");
await appendBlob.CreateOrReplaceAsync();
CloudBlobClient client;
ICloudBlob blob;
blob = await container.GetBlobReferenceFromServerAsync("bb");
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
CloudBlockBlob blockBlobSnapshot = await((CloudBlockBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri blockBlobSnapshotUri = new Uri(blockBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + blockBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSnapshotUri);
AssertAreEqual(blockBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.GetBlobReferenceFromServerAsync("pb");
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
CloudPageBlob pageBlobSnapshot = await((CloudPageBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri pageBlobSnapshotUri = new Uri(pageBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + pageBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSnapshotUri);
AssertAreEqual(pageBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.GetBlobReferenceFromServerAsync("ab");
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
CloudAppendBlob appendBlobSnapshot = await((CloudAppendBlob)blob).CreateSnapshotAsync();
await blob.SetPropertiesAsync();
Uri appendBlobSnapshotUri = new Uri(appendBlobSnapshot.Uri.AbsoluteUri + "?snapshot=" + appendBlobSnapshot.SnapshotTime.Value.UtcDateTime.ToString("o"));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSnapshotUri);
AssertAreEqual(appendBlobSnapshot.Properties, blob.Properties);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlobSnapshot.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlob.Uri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlob.StorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string appendBlobToken = appendBlob.GetSharedAccessSignature(policy);
StorageCredentials appendBlobSAS = new StorageCredentials(appendBlobToken);
Uri appendBlobSASUri = appendBlobSAS.TransformUri(appendBlob.Uri);
StorageUri appendBlobSASStorageUri = appendBlobSAS.TransformUri(appendBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(blockBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(pageBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
blob = await container.ServiceClient.GetBlobReferenceFromServerAsync(appendBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.BaseUri, blockBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(blockBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.BaseUri, pageBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(pageBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.BaseUri, appendBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(appendBlobSASUri);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(appendBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
client = new CloudBlobClient(container.ServiceClient.StorageUri, blockBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(blockBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudBlockBlob));
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.StorageUri, pageBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(pageBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudPageBlob));
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
client = new CloudBlobClient(container.ServiceClient.StorageUri, appendBlobSAS);
blob = await client.GetBlobReferenceFromServerAsync(appendBlobSASStorageUri, null, null, null);
Assert.IsInstanceOfType(blob, typeof(CloudAppendBlob));
Assert.IsTrue(blob.StorageUri.Equals(appendBlob.StorageUri));
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudBlobClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync()
{
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N"));
byte[] buffer = BlobTestBase.GetRandomBuffer(1024 * 1024);
try
{
await container.CreateAsync();
blobClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30);
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
blockBlob.StreamWriteSizeInBytes = 1024 * 1024;
blockBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
pageBlob.StreamWriteSizeInBytes = 1024 * 1024;
pageBlob.StreamMinimumReadSizeInBytes = 1024 * 1024;
using (var bos = await blockBlob.OpenWriteAsync())
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await bos.WriteAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await bos.WriteAsync(buffer, 0, buffer.Length);
await bos.CommitAsync();
}
using (Stream bis = (await blockBlob.OpenReadAsync()))
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await bis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await bis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
using (var bos = await pageBlob.OpenWriteAsync(8 * 1024 * 1024))
{
DateTime start = DateTime.Now;
for (int i = 0; i < 7; i++)
{
await bos.WriteAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last write
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
await bos.WriteAsync(buffer, 0, buffer.Length);
await bos.CommitAsync();
}
using (Stream bis = (await pageBlob.OpenReadAsync()))
{
DateTime start = DateTime.Now;
int total = 0;
while (total < 7 * 1024 * 1024)
{
total += await bis.ReadAsync(buffer, 0, buffer.Length);
}
// Sleep to ensure we are over the Max execution time when we do the last read
int msRemaining = (int)(blobClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds;
if (msRemaining > 0)
{
await Task.Delay(msRemaining);
}
while (true)
{
int count = await bis.ReadAsync(buffer, 0, buffer.Length);
total += count;
if (count == 0)
{
break;
}
}
}
}
finally
{
blobClient.DefaultRequestOptions.MaximumExecutionTime = null;
container.DeleteIfExistsAsync().Wait();
}
}
public void CloudBlobClientListBlobsSegmentedWithEmptyPrefix()
{
string name = "bb" + GetRandomContainerName();
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer rootContainer = blobClient.GetRootContainerReference();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
rootContainer.CreateIfNotExists();
container.Create();
List <Uri> preExistingBlobs = rootContainer.ListBlobs().Select(b => b.Uri).ToList();
List <string> blobNames = CreateBlobs(container, 3, BlobType.BlockBlob);
List <string> rootBlobNames = CreateBlobs(rootContainer, 2, BlobType.BlockBlob);
BlobResultSegment results;
BlobContinuationToken token = null;
List <Uri> listedBlobs = new List <Uri>();
do
{
results = blobClient.ListBlobsSegmented("", token);
token = results.ContinuationToken;
foreach (IListBlobItem blob in results.Results)
{
if (preExistingBlobs.Contains(blob.Uri))
{
continue;
}
else
{
if (blob is CloudPageBlob)
{
((CloudPageBlob)blob).Delete();
}
else
{
((CloudBlockBlob)blob).Delete();
}
listedBlobs.Add(blob.Uri);
}
}
}while (token != null);
Assert.AreEqual(2, listedBlobs.Count);
do
{
results = container.ListBlobsSegmented("", false, BlobListingDetails.None, null, token, null, null);
token = results.ContinuationToken;
foreach (IListBlobItem blob in results.Results)
{
if (preExistingBlobs.Contains(blob.Uri))
{
continue;
}
else
{
if (blob is CloudPageBlob)
{
((CloudPageBlob)blob).Delete();
}
else
{
((CloudBlockBlob)blob).Delete();
}
listedBlobs.Add(blob.Uri);
}
}
}while (token != null);
Assert.AreEqual(5, listedBlobs.Count);
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlobClientListBlobsSegmentedWithPrefixAPM()
{
string name = "bb" + GetRandomContainerName();
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer rootContainer = blobClient.GetRootContainerReference();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
rootContainer.CreateIfNotExists();
container.Create();
List <string> blobNames = CreateBlobs(container, 3, BlobType.BlockBlob);
List <string> rootBlobNames = CreateBlobs(rootContainer, 2, BlobType.BlockBlob);
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result;
BlobResultSegment results;
BlobContinuationToken token = null;
do
{
result = blobClient.BeginListBlobsSegmented("bb", token,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
results = blobClient.EndListBlobsSegmented(result);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
blob.Delete();
rootBlobNames.Remove(blob.Name);
}
}while (token != null);
Assert.AreEqual(0, rootBlobNames.Count);
result = blobClient.BeginListBlobsSegmented("bb", token,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
results = blobClient.EndListBlobsSegmented(result);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
result = blobClient.BeginListBlobsSegmented(name, token,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
results = blobClient.EndListBlobsSegmented(result);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
token = null;
do
{
result = blobClient.BeginListBlobsSegmented(name + "/", token,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
results = blobClient.EndListBlobsSegmented(result);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
Assert.IsTrue(blobNames.Remove(blob.Name));
}
}while (token != null);
Assert.AreEqual(0, blobNames.Count);
}
}
finally
{
container.DeleteIfExists();
}
}
internal CloudPageBlob(BlobAttributes attributes, CloudBlobClient serviceClient)
: base(attributes, serviceClient)
{
throw new System.NotImplementedException();
}
private void ProcessData()
{
//return;
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("CineStorageConStr"));
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference("data");
// Retrieve reference to a blob.
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob cinemasUKBlob = container.GetBlockBlobReference(CinemasUKFileName);
using (Stream s = cinemasUKBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(CinemasUK));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob filmsUKBlob = container.GetBlockBlobReference(FilmsUKFileName);
using (Stream s = filmsUKBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(FilmsUK));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob filmCinemasUKBlob = container.GetBlockBlobReference(FilmCinemasUKFileName);
using (Stream s = filmCinemasUKBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(filmCinemasUK));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob cinemaFilmsUKBlob = container.GetBlockBlobReference(CinemaFilmsUKFileName);
using (Stream s = cinemaFilmsUKBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(cinemaFilmsUK));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob cinemasIEBlob = container.GetBlockBlobReference(CinemasIEFileName);
using (Stream s = cinemasIEBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(CinemasIE));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob filmsIEBlob = container.GetBlockBlobReference(FilmsIEFileName);
using (Stream s = filmsIEBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(FilmsIE));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob filmCinemasIEBlob = container.GetBlockBlobReference(FilmCinemasIEFileName);
using (Stream s = filmCinemasIEBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(filmCinemasIE));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob cinemaFilmsIEBlob = container.GetBlockBlobReference(CinemaFilmsIEFileName);
using (Stream s = cinemaFilmsIEBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(cinemaFilmsIE));
}
}
}
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob filmsPostersBlob = container.GetBlockBlobReference(MovieFilmPostersFileName);
using (Stream s = filmsPostersBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
sw.Write(JsonConvert.SerializeObject(MoviePosters));
}
}
}
//Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob mediumfilmsPostersBlob = container.GetBlockBlobReference(MediumFilmPostersFileName);
//using (Stream s = mediumfilmsPostersBlob.OpenWrite())
//{
// using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
// {
// using (StreamWriter sw = new StreamWriter(gzipStream))
// {
// sw.Write(JsonConvert.SerializeObject(mediumposters));
// }
// }
//}
}
private async Task <(bool, string)> UploadToBlob(string filename, byte[] imageBuffer = null, Stream stream = null)
{
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = null;
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer cloudBlobContainer = null;
string storageConnectionString = _configuration["storageconnectionstring"];
// Check whether the connection string can be parsed.
if (Microsoft.WindowsAzure.Storage.CloudStorageAccount.TryParse(storageConnectionString, out storageAccount))
{
try
{
// Create the CloudBlobClient that represents the Blob storage endpoint for the storage account.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
// Create a container called 'uploadblob' and append a GUID value to it to make the name unique.
cloudBlobContainer = cloudBlobClient.GetContainerReference("womeninworkforce");// ("uploadblob" + Guid.NewGuid().ToString());
await cloudBlobContainer.CreateIfNotExistsAsync();
// Set the permissions so the blobs are public.
BlobContainerPermissions permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
await cloudBlobContainer.SetPermissionsAsync(permissions);
// Get a reference to the blob address, then upload the file to the blob.
CloudBlockBlob cloudBlockBlob = cloudBlobContainer.GetBlockBlobReference(filename);
List <Task> tasks = new List <Task>();
int count = 0;
if (imageBuffer != null)
{
// OPTION A: use imageBuffer (converted from memory stream)
await cloudBlockBlob.UploadFromByteArrayAsync(imageBuffer, 0, imageBuffer.Length);
//tasks.Add(cloudBlockBlob.UploadFromByteArrayAsync(imageBuffer, 0, options, null).ContinueWith((t) =>
//{
// sem.Release();
// Interlocked.Increment(ref completed_count);
//}));
//count++;
}
else if (stream != null)
{
// OPTION B: pass in memory stream directly
await cloudBlockBlob.UploadFromStreamAsync(stream);
}
else
{
return(false, null);
}
return(true, cloudBlockBlob.SnapshotQualifiedStorageUri.PrimaryUri.ToString());
}
catch (Microsoft.WindowsAzure.Storage.StorageException ex)
{
return(false, null);
}
finally
{
// OPTIONAL: Clean up resources, e.g. blob container
//if (cloudBlobContainer != null)
//{
// await cloudBlobContainer.DeleteIfExistsAsync();
//}
}
}
else
{
return(false, null);
}
}
// Create a CSV file and save to Blob storage with the Headers required for our Azure Function processing
// A new request telemetry is created
// The request is part of the parent request (since)
public void CreateBlob(string fileName)
{
///////////////////////////////////////////////////
// Grab existing
///////////////////////////////////////////////////
Microsoft.ApplicationInsights.TelemetryClient telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
telemetryClient.Context.User.AuthenticatedUserId = "*****@*****.**";
string traceoperation = null;
string traceparent = null;
System.Console.WriteLine("telemetryClient.Context.Operation.Id: " + telemetryClient.Context.Operation.Id);
System.Console.WriteLine("telemetryClient.Context.Session.Id: " + telemetryClient.Context.Session.Id);
System.Console.WriteLine("telemetryClient.Context.Operation.ParentId: " + telemetryClient.Context.Operation.ParentId);
Microsoft.ApplicationInsights.DataContracts.RequestTelemetry requestTelemetry = new Microsoft.ApplicationInsights.DataContracts.RequestTelemetry();
requestTelemetry.Name = "Create Blob: " + fileName;
//requestTelemetry.Source = requestContext.Replace("appId=",string.Empty);
requestTelemetry.Timestamp = System.DateTimeOffset.Now;
requestTelemetry.Context.Operation.Id = traceoperation;
requestTelemetry.Context.Operation.ParentId = traceparent;
requestTelemetry.Context.User.AuthenticatedUserId = "*****@*****.**";
using (var requestBlock = telemetryClient.StartOperation<Microsoft.ApplicationInsights.DataContracts.RequestTelemetry>(requestTelemetry))
{
///////////////////////////////////////////////////
// Request Telemetry
///////////////////////////////////////////////////
requestBlock.Telemetry.Context.User.AuthenticatedUserId = "*****@*****.**";
if (!string.IsNullOrWhiteSpace(traceoperation))
{
// Use the existing common operation id
requestBlock.Telemetry.Context.Operation.Id = traceoperation;
System.Console.WriteLine("[Use existing] traceoperation: " + traceoperation);
}
else
{
// Set the traceoperation (we did not know it until now)
traceoperation = requestBlock.Telemetry.Context.Operation.Id;
System.Console.WriteLine("[Set the] traceoperation = requestBlock.Telemetry.Context.Operation.Id: " + traceoperation);
}
if (!string.IsNullOrWhiteSpace(traceparent))
{
// Use the existing traceparent
requestBlock.Telemetry.Context.Operation.ParentId = traceparent;
System.Console.WriteLine("[Use existing] traceparent: " + traceparent);
}
else
{
traceparent = requestBlock.Telemetry.Id;
System.Console.WriteLine("[Set the] traceparent = requestBlock.Telemetry.Id: " + traceparent);
}
// Store future parent id
traceparent = requestBlock.Telemetry.Id;
System.Console.WriteLine("traceparent = requestBlock.Telemetry.Id: " + traceparent);
///////////////////////////////////////////////////
// Create Dependency for future Azure Function processing
// NOTE: I trick it by giving a Start Time Offset of Now.AddSeconds(1), so it sorts correctly in the Azure Portal UI
///////////////////////////////////////////////////
string operationName = "Dependency: Blob Event";
// Set the target so it points to the "dependent" app insights account app id
// string target = "03-disttrace-func-blob | cid-v1:676560d0-81fb-4e5b-bfdd-7da1ad11c866"
string target = "03-disttrace-func-blob | cid-v1:" + System.Environment.GetEnvironmentVariable("ai_03_disttrace_web_app_appkey");
string dependencyName = "Dependency Name: Azure Function Blob Trigger";
Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry dependencyTelemetry =
new Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry(
operationName, target, dependencyName,
"02-disttrace-web-app", System.DateTimeOffset.Now.AddSeconds(1), System.TimeSpan.FromSeconds(2), "200", true);
dependencyTelemetry.Context.Operation.Id = traceoperation;
dependencyTelemetry.Context.Operation.ParentId = requestBlock.Telemetry.Id;
// Store future parent id
traceparent = dependencyTelemetry.Id;
System.Console.WriteLine("traceparent = dependencyTelemetry.Id: " + traceparent);
telemetryClient.TrackDependency(dependencyTelemetry);
///////////////////////////////////////////////////
// Blob code
///////////////////////////////////////////////////
string containerName = "appinsightstest";
string storageConnectionString = System.Environment.GetEnvironmentVariable("ai_storage_key");
CloudStorageAccount storageAccount = null;
System.Console.WriteLine("storageConnectionString: " + storageConnectionString);
CloudStorageAccount.TryParse(storageConnectionString, out storageAccount);
System.Collections.Generic.List<string> list = new System.Collections.Generic.List<string>();
list.Add("id,date");
for (int i = 1; i <= 50000; i++)
{
list.Add(i.ToString() + "," + string.Format("{0:MM/dd/yyyy}", System.DateTime.Now));
}
var text = string.Join("\n", list.ToArray());
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient();
blobStorage.DefaultRequestOptions.RetryPolicy = new Microsoft.WindowsAzure.Storage.RetryPolicies.LinearRetry(System.TimeSpan.FromSeconds(1), 10);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobStorage.GetContainerReference(containerName);
container.CreateIfNotExistsAsync().Wait();
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blob = container.GetBlockBlobReference(fileName);
///////////////////////////////////////////////////
// Set the blob's meta data
// We need the values from the dependency
///////////////////////////////////////////////////
// Request-Context: appId=cid-v1:{The App Id of the current App Insights Account}
string requestContext = "appId=cid-v1:" + System.Environment.GetEnvironmentVariable("ai_02_disttrace_web_app_appkey");
System.Console.WriteLine("Blob Metadata -> requestContext: " + requestContext);
blob.Metadata.Add("RequestContext", requestContext);
// Request-Id / traceparent: {parent request/operation id} (e.g. the Track Dependency)
System.Console.WriteLine("Blob Metadata -> RequestId: " + traceparent);
blob.Metadata.Add("RequestId", traceparent);
System.Console.WriteLine("Blob Metadata -> traceparent: " + traceparent);
blob.Metadata.Add("traceparent", traceparent);
// Traceoperation {common operation id} (e.g. same operation id for all requests in this telemetry pipeline)
System.Console.WriteLine("Blob Metadata -> traceoperation: " + traceoperation);
blob.Metadata.Add("traceoperation", traceoperation);
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(text)))
{
blob.UploadFromStreamAsync(memoryStream).Wait();
}
requestTelemetry.ResponseCode = "200";
requestTelemetry.Success = true;
telemetryClient.StopOperation(requestBlock);
} // using
///////////////////////////////////////////////////
// For Debugging
///////////////////////////////////////////////////
telemetryClient.Flush();
} // Create Blob
public static void MyClassCleanup()
{
CloudBlobClient client = GenerateCloudBlobClient();
client.SetServicePropertiesAsync(startProperties).AsTask().Wait();
}
public async Task CloudBlobClientListBlobsSegmentedWithPrefixAsync()
{
string name = "bb" + GetRandomContainerName();
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer rootContainer = blobClient.GetRootContainerReference();
CloudBlobContainer container = blobClient.GetContainerReference(name);
try
{
await rootContainer.CreateIfNotExistsAsync();
await container.CreateAsync();
List <string> blobNames = await CreateBlobsAsync(container, 3, BlobType.BlockBlob);
List <string> rootBlobNames = await CreateBlobsAsync(rootContainer, 2, BlobType.BlockBlob);
BlobResultSegment results;
BlobContinuationToken token = null;
do
{
results = await blobClient.ListBlobsSegmentedAsync("bb", token);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
await blob.DeleteAsync();
rootBlobNames.Remove(blob.Name);
}
}while (token != null);
Assert.AreEqual(0, rootBlobNames.Count);
results = await blobClient.ListBlobsSegmentedAsync("bb", token);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
results = await blobClient.ListBlobsSegmentedAsync(name, token);
Assert.AreEqual(0, results.Results.Count());
Assert.IsNull(results.ContinuationToken);
token = null;
do
{
results = await blobClient.ListBlobsSegmentedAsync(name + "/", token);
token = results.ContinuationToken;
foreach (CloudBlockBlob blob in results.Results)
{
Assert.IsTrue(blobNames.Remove(blob.Name));
}
}while (token != null);
Assert.AreEqual(0, blobNames.Count);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudBlobClientMaximumExecutionTimeoutAsync()
{
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(Guid.NewGuid().ToString("N"));
byte[] buffer = BlobTestBase.GetRandomBuffer(80 * 1024 * 1024);
try
{
await container.CreateAsync();
blobClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(5);
blobClient.DefaultRequestOptions.SingleBlobUploadThresholdInBytes = 2 * 1024 * 1024;
CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1");
blockBlob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await blockBlob.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (AggregateException ex)
{
#if !FACADE_NETCORE
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message);
#else
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message);
#endif
}
catch (TaskCanceledException)
{
}
}
CloudPageBlob pageBlob = container.GetPageBlobReference("blob2");
pageBlob.StreamWriteSizeInBytes = 1 * 1024 * 1024;
using (MemoryStream ms = new MemoryStream(buffer))
{
try
{
await pageBlob.UploadFromStreamAsync(ms);
Assert.Fail();
}
catch (AggregateException ex)
{
#if !FACADE_NETCORE
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).ExceptionInfo.Message);
#else
Assert.AreEqual("The client could not finish the operation within specified timeout.", RequestResult.TranslateFromExceptionMessage(ex.InnerException.Message).Exception.Message);
#endif
}
catch (TaskCanceledException)
{
}
}
}
finally
{
blobClient.DefaultRequestOptions.MaximumExecutionTime = null;
container.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudBlobTestAnalyticsRetentionPoliciesAsync()
{
CloudBlobClient client = GenerateCloudBlobClient();
ServiceProperties props = await client.GetServicePropertiesAsync();
// Set retention policy null with metrics disabled.
props.Metrics.RetentionDays = null;
props.Metrics.MetricsLevel = MetricsLevel.None;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
// Set retention policy not null with metrics disabled.
props.Metrics.RetentionDays = 1;
props.Metrics.MetricsLevel = MetricsLevel.Service;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
// Set retention policy not null with metrics enabled.
props.Metrics.MetricsLevel = MetricsLevel.ServiceAndApi;
props.Metrics.RetentionDays = 2;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
// Set retention policy null with logging disabled.
props.Logging.RetentionDays = null;
props.Logging.LoggingOperations = LoggingOperations.None;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
// Set retention policy not null with logging disabled.
props.Logging.RetentionDays = 3;
props.Logging.LoggingOperations = LoggingOperations.None;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
// Set retention policy null with logging enabled.
props.Logging.RetentionDays = null;
props.Logging.LoggingOperations = LoggingOperations.All;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
// Set retention policy not null with logging enabled.
props.Logging.RetentionDays = 4;
props.Logging.LoggingOperations = LoggingOperations.All;
await client.SetServicePropertiesAsync(props);
// Wait for analytics server to update
await Task.Delay(60 * 1000);
AssertServicePropertiesAreEqual(props, await client.GetServicePropertiesAsync());
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result)
{
var message = await result as Activity;
if (message.Attachments != null)
{
var attachment = message.Attachments[0];
using (HttpClient httpClient = new HttpClient())
{
// Skype & MS Teams attachment URLs are secured by a JwtToken, so we need to pass the token from our bot.
var responseMessage = await httpClient.GetAsync(attachment.ContentUrl);
var contentLenghtBytes = responseMessage.Content.Headers.ContentLength;
string filename = attachment.Name;
string dir = AppDomain.CurrentDomain.BaseDirectory; // System.IO.Directory.GetCurrentDirectory();
string file = dir + "Uploads";
if (!Directory.Exists(file))
{
DirectoryInfo di = Directory.CreateDirectory(file);
//return;
}
// Try to create the directory.
string file1 = dir + "Uploads" + "\\" + filename;
FileStream fs = new FileStream(file1, FileMode.Create, FileAccess.Write, FileShare.None);
// FileStream fs = new FileStream(file1, FileMode.Open);
// SaveAttchments(fs, filename);
await responseMessage.Content.CopyToAsync(fs).ContinueWith(
(copyTask) =>
{
fs.Close();
});
string StorageConnectionString = ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString;
//string SourceFolder = ConfigurationManager.AppSettings["SourceFolder"];
string destContainer = ConfigurationManager.AppSettings["destContainer"];
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(StorageConnectionString);
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer = cloudBlobClient.GetContainerReference(destContainer);
blobContainer.CreateIfNotExists();
string key = Path.GetFileName(file1);
CloudBlockBlob blockBlob = blobContainer.GetBlockBlobReference(key);
using (var fis = System.IO.File.Open(file1, FileMode.Open, FileAccess.Read, FileShare.None))
{
blockBlob.UploadFromStream(fis);
}
await context.PostAsync($"Attachment of {attachment.ContentType} type and size of {contentLenghtBytes} bytes received.");
await context.PostAsync($"Attachment of {attachment.ContentType} type and size of bytes received.");
}
}
else
{
await context.PostAsync("Hi there! I'm a bot created to show you how I can receive message attachments, but no attachment was sent to me. Please, try again sending a new message including an attachment.");
}
context.Wait(this.MessageReceivedAsync);
}
public static void MyClassInitialize(TestContext testContext)
{
CloudBlobClient client = GenerateCloudBlobClient();
startProperties = client.GetServicePropertiesAsync().AsTask().Result;
}
public async Task ProcessCinemaPerformances(RegionDef region, int cinemaID, List <FilmInfo> films)
{
CineworldService cws = new CineworldService();
List <FilmHeader> filmsForCinema = new List <FilmHeader>();
foreach (var film in films)
{
Task <Dates> td = cws.GetDates(region, cinemaID, film.EDI);
td.Wait();
HashSet <DateTime> perfDates = new HashSet <DateTime>();
if (!td.IsFaulted && td.Result != null && td.Result.dates != null)
{
FilmHeader fh = new FilmHeader()
{
EDI = film.EDI
};
filmsForCinema.Add(fh);
fh.Performances = new List <PerformanceInfo>();
foreach (var date in td.Result.dates)
{
DateTime performanceDate = DateTime.ParseExact(date, "yyyyMMdd", CultureInfo.InvariantCulture);
Task <Performances> tp = cws.GetPerformances(region, cinemaID, film.EDI, date);
tp.Wait();
if (!tp.IsFaulted && tp.Result != null && tp.Result.performances != null)
{
foreach (var p in tp.Result.performances)
{
PerformanceInfo pi = new PerformanceInfo();
pi.PerformanceTS = performanceDate.Add(DateTime.ParseExact(p.time, "HH:mm", CultureInfo.InvariantCulture).TimeOfDay);
pi.Available = p.available;
pi.Type = p.Type;
pi.BookUrl = new Uri(p.booking_url);
fh.Performances.Add(pi);
}
}
}
}
}
//return;
Microsoft.WindowsAzure.Storage.CloudStorageAccount storageAccount = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("CineStorageConStr"));
Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobClient.GetContainerReference("data");
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob cinemaFilmsBlob = container.GetBlockBlobReference(String.Format(FilmsPerCinemaFileName, cinemaID));
using (Stream s = cinemaFilmsBlob.OpenWrite())
{
using (var gzipStream = new GZipStream(s, CompressionMode.Compress))
{
using (StreamWriter sw = new StreamWriter(gzipStream))
{
await sw.WriteAsync(JsonConvert.SerializeObject(filmsForCinema));
}
}
}
}