public static void TaskMain(string[] args)
{
if (args == null || args.Length != 5)
{
throw new Exception("Usage: TopNWordsSample.exe --Task <blobpath> <numtopwords> <storageAccountName> <storageAccountKey>");
}
string blobName = args[1];
int numTopN = int.Parse(args[2]);
string storageAccountName = args[3];
string storageAccountKey = args[4];
// open the cloud blob that contains the book
var storageCred = new StorageCredentials(storageAccountName, storageAccountKey);
CloudBlockBlob blob = new CloudBlockBlob(new Uri(blobName), storageCred);
using (Stream memoryStream = new MemoryStream())
{
blob.DownloadToStream(memoryStream);
memoryStream.Position = 0; //Reset the stream
var sr = new StreamReader(memoryStream);
var myStr = sr.ReadToEnd();
string[] words = myStr.Split(' ');
var topNWords =
words.
Where(word => word.Length > 0).
GroupBy(word => word, (key, group) => new KeyValuePair<String, long>(key, group.LongCount())).
OrderByDescending(x => x.Value).
Take(numTopN).
ToList();
foreach (var pair in topNWords)
{
Console.WriteLine("{0} {1}", pair.Key, pair.Value);
}
}
}
public static async Task WaitForBlobAsync(CloudBlockBlob blob)
{
await TestHelpers.Await(() =>
{
return blob.Exists();
});
}
public BlobFileSinkStreamProvider(CloudBlockBlob blob, bool overwrite)
{
Guard.NotNull("blob", blob);
this.blob = blob;
this.overwrite = overwrite;
}
public void revertFromSnapshot(CloudBlockBlob blobRef, CloudBlockBlob snapshot)
{
try
{
blobRef.StartCopyFromBlob(snapshot);
DateTime timestamp = DateTime.Now;
blobRef.FetchAttributes();
snapshot.FetchAttributes();
string time = snapshot.Metadata["timestamp"];
blobRef.Metadata["timestamp"] = timestamp.ToUniversalTime().ToString("MM/dd/yyyy HH:mm:ss");
blobRef.SetMetadata();
blobRef.CreateSnapshot();
//System.Windows.Forms.MessageBox.Show("revert success");
Program.ClientForm.addtoConsole("Successfully Reverted with time: " + time);
Program.ClientForm.ballon("Successfully Reverted! ");
}
catch (Exception e)
{
Program.ClientForm.addtoConsole("Exception:" + e.Message);
//System.Windows.Forms.MessageBox.Show(e.ToString());
}
}
public void deleteSnapshot(CloudBlockBlob blobRef)
{
string blobPrefix = null;
bool useFlatBlobListing = true;
var snapshots = container.ListBlobs(blobPrefix, useFlatBlobListing,
BlobListingDetails.Snapshots).Where(item => ((CloudBlockBlob)item).SnapshotTime.HasValue && item.Uri.Equals(blobRef.Uri)).ToList<IListBlobItem>();
if (snapshots.Count < 1)
{
Console.WriteLine("snapshot was not created");
}
else
{
foreach (IListBlobItem item in snapshots)
{
CloudBlockBlob blob = (CloudBlockBlob)item;
blob.DeleteIfExists();
Console.WriteLine("Delete Name: {0}, Timestamp: {1}", blob.Name, blob.SnapshotTime);
Console.WriteLine("success");
}
//snapshots.ForEach(item => Console.WriteLine(String.Format("{0} {1} ", ((CloudBlockBlob)item).Name, ((CloudBlockBlob)item).Metadata["timestamp"])));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BlobFile" /> class.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="address">The address.</param>
/// <exception cref="ArgumentOutOfRangeException"/>
/// <exception cref="ArgumentNullException"/>
public BlobFile(BlobFileSystem fileSystem, INodeAddress address)
: base(address, fileSystem)
{
_blobContainer = fileSystem.BlobClient.GetContainerReference(address.PathToDepth(1).Substring(1));
_path = string.Join("/", Address.AbsolutePath.Split('/').Where((item, index) => index > 1));
_blockBlob = _blobContainer.GetBlockBlobReference(_path);
}
/// <summary>
/// Runs the mapper task.
/// </summary>
public async Task RunAsync()
{
CloudBlockBlob blob = new CloudBlockBlob(new Uri(this.blobSas));
Console.WriteLine("Matches in blob: {0}/{1}", blob.Container.Name, blob.Name);
using (Stream memoryStream = new MemoryStream())
{
//Download the blob.
await blob.DownloadToStreamAsync(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using (StreamReader streamReader = new StreamReader(memoryStream))
{
Regex regex = new Regex(this.configurationSettings.RegularExpression);
int lineCount = 0;
//Read the file content.
while (!streamReader.EndOfStream)
{
++lineCount;
string textLine = await streamReader.ReadLineAsync();
//If the line matches the search parameters, then print it out.
if (textLine.Length > 0)
{
if (regex.Match(textLine).Success)
{
Console.WriteLine("Match: \"{0}\" -- line: {1}", textLine, lineCount);
}
}
}
}
}
}
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();
}
public JobLogBlob(CloudBlockBlob blob)
{
Blob = blob;
// Parse the name
var parsed = BlobNameParser.Match(blob.Name);
if (!parsed.Success)
{
throw new ArgumentException(string.Format(NuGetGallery.Strings.JobLogBlobNameInvalid, blob.Name), nameof(blob));
}
// Grab the chunks we care about
JobName = parsed.Groups["job"].Value;
string format = DayTimeStamp;
if (parsed.Groups[1].Success)
{
// Has an hour portion!
format = HourTimeStamp;
}
ArchiveTimestamp = DateTime.ParseExact(
parsed.Groups["timestamp"].Value,
format,
CultureInfo.InvariantCulture);
}
public JobLogBlob(CloudBlockBlob blob)
{
Blob = blob;
// Parse the name
var parsed = BlobNameParser.Match(blob.Name);
if (!parsed.Success)
{
throw new ArgumentException("Job Log Blob name is invalid Bob! Expected [jobname].[yyyy-MM-dd].json or [jobname].json. Got: " + blob.Name, "blob");
}
// Grab the chunks we care about
JobName = parsed.Groups["job"].Value;
string format = DayTimeStamp;
if (parsed.Groups[1].Success)
{
// Has an hour portion!
format = HourTimeStamp;
}
ArchiveTimestamp = DateTime.ParseExact(
parsed.Groups["timestamp"].Value,
format,
CultureInfo.InvariantCulture);
}
protected String GetTitle(Uri blobURI)
{
//returns the title of the file from the Blob metadata
CloudBlockBlob blob = new CloudBlockBlob(blobURI);
blob.FetchAttributes();
return blob.Metadata["Title"];
}
public EndpointToHost(CloudBlockBlob blob)
{
this.blob = blob;
this.blob.FetchAttributes();
EndpointName = Path.GetFileNameWithoutExtension(blob.Uri.AbsolutePath);
LastUpdated = blob.Properties.LastModified.HasValue ? blob.Properties.LastModified.Value.DateTime : default(DateTime);
}
internal StorageBlob.ICloudBlob CopyBlobAndWaitForComplete(CloudBlobUtil blobUtil)
{
string destBlobName = Utility.GenNameString("copystate");
StorageBlob.ICloudBlob destBlob = default(StorageBlob.ICloudBlob);
Test.Info("Copy Blob using storage client");
if (blobUtil.Blob.BlobType == StorageBlob.BlobType.BlockBlob)
{
StorageBlob.CloudBlockBlob blockBlob = blobUtil.Container.GetBlockBlobReference(destBlobName);
blockBlob.StartCopyFromBlob((StorageBlob.CloudBlockBlob)blobUtil.Blob);
destBlob = blockBlob;
}
else
{
StorageBlob.CloudPageBlob pageBlob = blobUtil.Container.GetPageBlobReference(destBlobName);
pageBlob.StartCopyFromBlob((StorageBlob.CloudPageBlob)blobUtil.Blob);
destBlob = pageBlob;
}
CloudBlobUtil.WaitForCopyOperationComplete(destBlob);
Test.Assert(destBlob.CopyState.Status == StorageBlob.CopyStatus.Success, String.Format("The blob copy using storage client should be success, actually it's {0}", destBlob.CopyState.Status));
return(destBlob);
}
// Helper function to allow Storage Client 1.7 (Microsoft.WindowsAzure.StorageClient) to utilize this class.
// Remove this function if only using Storage Client 2.0 (Microsoft.WindowsAzure.Storage).
public void DownloadBlobAsync(Microsoft.WindowsAzure.StorageClient.CloudBlob blob, string LocalFile)
{
Microsoft.WindowsAzure.StorageCredentialsAccountAndKey account = blob.ServiceClient.Credentials as Microsoft.WindowsAzure.StorageCredentialsAccountAndKey;
ICloudBlob blob2 = new Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob(blob.Attributes.Uri, new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(blob.ServiceClient.Credentials.AccountName, account.Credentials.ExportBase64EncodedKey()));
DownloadBlobAsync(blob2, LocalFile);
}
private static void UploadDocument(CloudBlockBlob blob, String path)
{
using (var fileStream = File.OpenRead(path))
{
blob.UploadFromStream(fileStream);
}
}
private static string DownloadBlob(CloudBlockBlob blob)
{
using (var stream = new MemoryStream())
{
StreamReader reader;
try
{
blob.DownloadToStream(stream, options: new BlobRequestOptions()
{
RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(5), 3)
});
}
catch (StorageException se)
{
return "";
}
try
{
stream.Seek(0, 0);
reader = new StreamReader(new GZipStream(stream, CompressionMode.Decompress));
return reader.ReadToEnd();
}
catch
{
stream.Seek(0, 0);
reader = new StreamReader(stream);
return reader.ReadToEnd();
}
}
}
public virtual void Init()
{
_store = new AzureStore(CloudStorageAccount.DevelopmentStorageAccount.CreateCloudBlobClient(), true);
_blob = AzureTestsHelper.GetBlockBlob("kalix-leo-tests", "AzureStoreTests.testdata", true);
_location = new StoreLocation("kalix-leo-tests", "AzureStoreTests.testdata");
}
public void uploadfromFilesystem(CloudBlockBlob blob, string localFilePath, string eventType)
{
if (eventType.Equals("create") || eventType.Equals("signUpStart"))
{
Program.ClientForm.addtoConsole("Upload started[create || signUpStart]:" + localFilePath);
blob.UploadFromFile(localFilePath, FileMode.Open);
Program.ClientForm.addtoConsole("Uploaded");
Program.ClientForm.ballon("Uploaded:"+ localFilePath);
}
else
{
try
{
Program.ClientForm.addtoConsole("Upload started[change,etc]:" + localFilePath);
string leaseId = Guid.NewGuid().ToString();
blob.AcquireLease(TimeSpan.FromMilliseconds(16000), leaseId);
blob.UploadFromFile(localFilePath, FileMode.Open, AccessCondition.GenerateLeaseCondition(leaseId));
blob.ReleaseLease(AccessCondition.GenerateLeaseCondition(leaseId));
Program.ClientForm.addtoConsole("Uploaded");
Program.ClientForm.ballon("Uploaded:" + localFilePath);
}
catch (Exception ex)
{
Program.ClientForm.addtoConsole("Upload: second attempt");
Thread.Sleep(5000);
string leaseId = Guid.NewGuid().ToString();
blob.AcquireLease(TimeSpan.FromMilliseconds(16000), leaseId);
blob.UploadFromFile(localFilePath, FileMode.Open, AccessCondition.GenerateLeaseCondition(leaseId));
blob.ReleaseLease(AccessCondition.GenerateLeaseCondition(leaseId));
Program.ClientForm.addtoConsole("Uploaded");
Program.ClientForm.ballon("Uploaded:" + localFilePath);
}
}
}
protected String GetInstanceIndex(Uri blobURI)
{
//returns the Worker role's index from the Blob metadata
CloudBlockBlob blob = new CloudBlockBlob(blobURI);
blob.FetchAttributes();
return blob.Metadata["InstanceNo"];
}
public static void AddContainerMetadata(CloudBlockBlob blob, object fileUploadObj)
{
var obj = ((BlobStorage.Models.UploadDataModel)fileUploadObj);
//Add some metadata to the container.
if (IsNotNull(obj.Category))
blob.Metadata["category"] = obj.Category;
else
blob.Metadata["category"] = "Other";
if (IsNotNull(obj.Name))
blob.Metadata["name"] = obj.Name;
else
blob.Metadata["name"] = "Null";
if (IsNotNull(obj.Number))
blob.Metadata["number"] = obj.Number;
else
blob.Metadata["number"] = "Null";
if (IsNotNull(obj.Email))
blob.Metadata["email"] = obj.Email;
else
blob.Metadata["email"] = "Null";
if (IsNotNull(obj.Comments))
blob.Metadata["comments"] = obj.Comments;
else
blob.Metadata["comments"] = "Null";
//Set the container's metadata.
blob.SetMetadata();
}
public static void Main(string[] args)
{
Console.WriteLine("Press any key to run sample...");
Console.ReadKey();
// Make sure the endpoint matches with the web role's endpoint.
var tokenServiceEndpoint = ConfigurationManager.AppSettings["serviceEndpointUrl"];
try
{
var blobSas = GetBlobSas(new Uri(tokenServiceEndpoint)).Result;
// Create storage credentials object based on SAS
var credentials = new StorageCredentials(blobSas.Credentials);
// Using the returned SAS credentials and BLOB Uri create a block blob instance to upload
var blob = new CloudBlockBlob(blobSas.BlobUri, credentials);
using (var stream = GetFileToUpload(10))
{
blob.UploadFromStream(stream);
}
Console.WriteLine("Blob uplodad successful: {0}", blobSas.Name);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine();
Console.WriteLine("Done. Press any key to exit...");
Console.ReadKey();
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// Create the queue if it does not exist already
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.QueueExists(QueueName))
{
namespaceManager.CreateQueue(QueueName);
}
// Initialize the connection to Service Bus Queue
_client = QueueClient.CreateFromConnectionString(connectionString, QueueName);
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
// Create the blob client.
var blobClient = storageAccount.CreateCloudBlobClient();
// Retrieve a reference to a container.
var container = blobClient.GetContainerReference("mycontainer");
// Create the container if it doesn't already exist.
container.CreateIfNotExists();
_blob = container.GetBlockBlobReference("myblob");
return base.OnStart();
}
/// <summary>
/// Creates an archived copy of the original package blob if it doesn't already exist.
/// </summary>
private void ArchiveOriginalPackageBlob(CloudBlockBlob originalPackageBlob, CloudBlockBlob latestPackageBlob)
{
// Copy the blob to backup only if it isn't already successfully copied
if ((!originalPackageBlob.Exists()) || (originalPackageBlob.CopyState != null && originalPackageBlob.CopyState.Status != CopyStatus.Success))
{
if (!WhatIf)
{
Log.Info("Backing up blob: {0} to {1}", latestPackageBlob.Name, originalPackageBlob.Name);
originalPackageBlob.StartCopyFromBlob(latestPackageBlob);
CopyState state = originalPackageBlob.CopyState;
for (int i = 0; (state == null || state.Status == CopyStatus.Pending) && i < SleepTimes.Length; i++)
{
Log.Info("(sleeping for a copy completion)");
Thread.Sleep(SleepTimes[i]);
originalPackageBlob.FetchAttributes(); // To get a refreshed CopyState
//refresh state
state = originalPackageBlob.CopyState;
}
if (state.Status != CopyStatus.Success)
{
string msg = string.Format("Blob copy failed: CopyState={0}", state.StatusDescription);
Log.Error("(error) " + msg);
throw new BlobBackupFailedException(msg);
}
}
}
}
public object GetBlobMetadata(CloudBlockBlob blob, string metadataKey) {
if(blob.Metadata.ContainsKey(metadataKey)) {
return blob.Metadata[metadataKey];
} else {
return null;
}
}
public void ValidatePipelineICloudBlobSuccessfullyTest()
{
AddTestBlobs();
CloudBlockBlob blob = new CloudBlockBlob(new Uri("http://127.0.0.1/account/container1/blob0"));
command.ValidatePipelineICloudBlob(blob);
}
public ValueWatcherCommand(IReadOnlyDictionary<string, IWatcher> watches, CloudBlockBlob blobResults,
TextWriter consoleOutput)
{
_blobResults = blobResults;
_consoleOutput = consoleOutput;
_watches = watches;
}
private static XmlLoggingConfiguration ReadLoggingConfiguration(CloudBlockBlob blob)
{
Logger.Debug("Opening blob for reading.");
Stream stream = blob.OpenRead();
Logger.Debug("Reading logging configuration from blob.");
return new XmlLoggingConfiguration(new XmlTextReader(stream), null);
}
private static void ConfigureLoggingWithBlob(CloudBlockBlob blob)
{
XmlLoggingConfiguration configuration = ReadLoggingConfiguration(blob);
Logger.Debug("Applying new configuration to NLog.");
LogManager.Configuration = configuration;
Logger.Info("NLog is now using the configuration loaded from {0}.", blob.Uri);
}
public BlockBlob(CloudBlockBlob blockBlob, string name, IAzureAssemblyLogger logger)
{
if (blockBlob == null) throw new ArgumentNullException(nameof(blockBlob));
_blockBlob = blockBlob;
_name = name;
_logger = logger;
}
// Begin watchers.
public ValueWatcher(IReadOnlyDictionary<string, IWatcher> watches, CloudBlockBlob blobResults,
TextWriter consoleOutput, IBackgroundExceptionDispatcher backgroundExceptionDispatcher)
{
ValueWatcherCommand command = new ValueWatcherCommand(watches, blobResults, consoleOutput);
_command = command;
_timer = ValueWatcherCommand.CreateTimer(command, backgroundExceptionDispatcher);
_timer.Start();
}
private async Task Delete(CloudBlobContainer container, Uri blobUri)
{
CloudBlockBlob blob = new CloudBlockBlob(blobUri);
if (blob.Container == container)
{
await blob.DeleteAsync();
}
}
/// <summary>
/// Initializes a new instance of the BlobWriteStreamBase class for a block blob.
/// </summary>
/// <param name="blockBlob">Blob reference to write to.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
protected BlobWriteStreamBase(CloudBlockBlob blockBlob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: this(blockBlob.ServiceClient, accessCondition, options, operationContext)
{
this.blockBlob = blockBlob;
this.blockList = new List<string>();
this.blockIdPrefix = new Random().Next().ToString("X8") + "-";
this.buffer = new MemoryStream(this.Blob.StreamWriteSizeInBytes);
}
private void DeleteBackup(CloudBlockBlob blob)
{
Log.Info("Deleting Blob: {0}", blob.Uri.AbsoluteUri);
if (!WhatIf)
{
blob.DeleteIfExists(DeleteSnapshotsOption.IncludeSnapshots, accessCondition: AccessCondition.GenerateIfMatchCondition(blob.Properties.ETag));
}
}
//Delete a blob file
public void DeleteBlob(string UserId, string BlobName)
{
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId);
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName);
if (blockBlob.Exists())
{
blockBlob.Delete();
}
}
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());
}
string GetBlobSasUri(Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob)
{
SharedAccessBlobPolicy sasConstraints = new SharedAccessBlobPolicy();
sasConstraints.SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5);
sasConstraints.SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddHours(24);
sasConstraints.Permissions = SharedAccessBlobPermissions.Read;
string sasBlobToken = blockBlob.GetSharedAccessSignature(sasConstraints);
return(blockBlob.Uri + sasBlobToken);
}
// Upload a Blob File
public void UploadBlob(string UserId, string BlobName, HttpPostedFileBase image, int timeout = 60)
{
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId);
// Retrieve reference to a blob named
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName);
blockBlob.Properties.ContentType = image.ContentType;
blockBlob.UploadFromStream(image.InputStream);
}
//Upload a Blob File
public void UploadByteBlob(string UserId, string BlobName, string ContentType, byte[] image)
{
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId);
// Retrieve reference to a blob named
Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName);
blockBlob.Properties.ContentType = ContentType;
blockBlob.UploadFromByteArray(image, 0, image.Length);
}
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 { }
}
/// <summary>
/// Copies the file.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="blob">The BLOB.</param>
/// <param name="newFileName">New name of the file.</param>
/// <returns></returns>
public async Task <bool> CopyFile(CloudBlobContainer container, Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blob, string newFileName)
{
await blob.FetchAttributesAsync();
Uri uri = new Uri(blob.Name);
string filename = System.IO.Path.GetFileName(uri.LocalPath);
var newFile = uri.OriginalString.Replace(filename, newFileName);
var newBlob = blob.Container.GetBlockBlobReference(newFile);
var exists = BlobExistsOnCloud(container, newFile);
if (exists)
{
//Inform the user that the blob exists
return(false);
}
await newBlob.StartCopyFromBlobAsync(blob);
return(true);
}
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);
}
// Get url of blob
public string DownloadBlob(string UserId, string BlobName)
{
// Retrieve a reference to a container.
Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = GetCloudBlobContainer(UserId);
// 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());
}
/// <summary>
/// create a block blob with random properties and metadata
/// </summary>
/// <param name="container">CloudBlobContainer object</param>
/// <param name="blobName">Block blob name</param>
/// <returns>ICloudBlob object</returns>
public StorageBlob.ICloudBlob CreateBlockBlob(StorageBlob.CloudBlobContainer container, string blobName)
{
StorageBlob.CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobName);
int maxBlobSize = 1024 * 1024;
string md5sum = string.Empty;
int blobSize = random.Next(maxBlobSize);
byte[] buffer = new byte[blobSize];
using (MemoryStream ms = new MemoryStream(buffer))
{
random.NextBytes(buffer);
//ms.Read(buffer, 0, buffer.Length);
blockBlob.UploadFromStream(ms);
md5sum = Convert.ToBase64String(Helper.GetMD5(buffer));
}
blockBlob.Properties.ContentMD5 = md5sum;
GenerateBlobPropertiesAndMetaData(blockBlob);
Test.Info(string.Format("create block blob '{0}' in container '{1}'", blobName, container.Name));
return(blockBlob);
}
public AvroBlobAppenderWriter(CloudBlockBlob blockBlob, bool leaveOpen, IAvroSerializer <T> serializer, Codec codec)
{
if (blockBlob == null)
{
throw new ArgumentNullException("blockBlob");
}
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
if (codec == null)
{
throw new ArgumentNullException("codec");
}
this.codec = codec;
this.serializer = serializer;
this.isHeaderWritten = false;
this.locker = new object();
this.blockBlob = blockBlob;
this.SetupObjectContainerHeader();
}
public async Task CloudBlockBlobCopyTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob source = container.GetBlockBlobReference("source");
string data = "String data";
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
string copyId = await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(source));
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
OperationContext opContext = new OperationContext();
await TestHelper.ExpectedExceptionAsync(
async() => await copy.AbortCopyAsync(copyId, null, null, opContext),
opContext,
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
await source.FetchAttributesAsync();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = await DownloadTextAsync(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of blob not similar");
await copy.FetchAttributesAsync();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = source.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
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", copy.Metadata["Test"], false, "Copied metadata not same");
await copy.DeleteAsync();
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
/// <summary>
/// Initializes a new instance of the BlobWriteStream class for a block blob.
/// </summary>
/// <param name="blockBlob">Blob reference to write to.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
internal BlobWriteStream(CloudBlockBlob blockBlob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base(blockBlob, accessCondition, options, operationContext)
{
}
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().AsTask().Wait();
}
}
public async Task CloudBlobSnapshotAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024));
CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName);
await blockBlob.UploadFromStreamAsync(originalData);
CloudBlob blob = container.GetBlobReference(BlobName);
await blob.FetchAttributesAsync();
Assert.IsFalse(blob.IsSnapshot);
Assert.IsNull(blob.SnapshotTime, "Root blob has SnapshotTime set");
Assert.IsFalse(blob.SnapshotQualifiedUri.Query.Contains("snapshot"));
Assert.AreEqual(blob.Uri, blob.SnapshotQualifiedUri);
CloudBlob snapshot1 = await blob.SnapshotAsync();
Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag);
Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified);
Assert.IsTrue(snapshot1.IsSnapshot);
Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set");
Assert.AreEqual(blob.Uri, snapshot1.Uri);
Assert.AreNotEqual(blob.SnapshotQualifiedUri, snapshot1.SnapshotQualifiedUri);
Assert.AreNotEqual(snapshot1.Uri, snapshot1.SnapshotQualifiedUri);
Assert.IsTrue(snapshot1.SnapshotQualifiedUri.Query.Contains("snapshot"));
CloudBlob snapshot2 = await blob.SnapshotAsync();
Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value);
await snapshot1.FetchAttributesAsync();
await snapshot2.FetchAttributesAsync();
await blob.FetchAttributesAsync();
AssertAreEqual(snapshot1.Properties, blob.Properties);
CloudBlob snapshot1Clone = new CloudBlob(new Uri(blob.Uri + "?snapshot=" + snapshot1.SnapshotTime.Value.ToString("O")), blob.ServiceClient.Credentials);
Assert.IsNotNull(snapshot1Clone.SnapshotTime, "Snapshot clone does not have SnapshotTime set");
Assert.AreEqual(snapshot1.SnapshotTime.Value, snapshot1Clone.SnapshotTime.Value);
await snapshot1Clone.FetchAttributesAsync();
AssertAreEqual(snapshot1.Properties, snapshot1Clone.Properties);
CloudBlob snapshotCopy = container.GetBlobReference("blob2");
await snapshotCopy.StartCopyAsync(TestHelper.Defiddler(snapshot1.Uri));
await WaitForCopyAsync(snapshotCopy);
Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status);
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()))
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
await blockBlob.PutBlockListAsync(new List <string>());
await blob.FetchAttributesAsync();
using (Stream snapshotStream = (await snapshot1.OpenReadAsync()))
{
snapshotStream.Seek(0, SeekOrigin.End);
TestHelper.AssertStreamsAreEqual(originalData, snapshotStream);
}
BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null);
List <IListBlobItem> blobs = resultSegment.Results.ToList();
Assert.AreEqual(4, blobs.Count);
AssertAreEqual(snapshot1, (CloudBlob)blobs[0]);
AssertAreEqual(snapshot2, (CloudBlob)blobs[1]);
AssertAreEqual(blob, (CloudBlob)blobs[2]);
AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]);
}
finally
{
container.DeleteIfExistsAsync().Wait();
}
}
public async Task CloudBlockBlobDownloadRangeToByteArrayNegativeTestsAsync()
{
CloudBlockBlob blob = this.testContainer.GetBlockBlobReference("blob1");
await this.DoDownloadRangeToByteArrayNegativeTestsAsync(blob);
}
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.AsBuffer());
}
// 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.AsBuffer());
await bos.CommitAsync();
}
using (Stream bis = (await blockBlob.OpenReadAsync()).AsStreamForRead())
{
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.AsBuffer());
}
// 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.AsBuffer());
await bos.CommitAsync();
}
using (Stream bis = (await pageBlob.OpenReadAsync()).AsStreamForRead())
{
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().AsTask().Wait();
}
}
public async Task BlockBlobWriteStreamOpenWithAccessConditionAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
await container.CreateAsync();
try
{
OperationContext context = new OperationContext();
CloudBlockBlob existingBlob = container.GetBlockBlobReference("blob");
await existingBlob.PutBlockListAsync(new List <string>());
CloudBlockBlob blob = container.GetBlockBlobReference("blob2");
AccessCondition accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await blob.OpenWriteAsync(accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.NotFound);
blob = container.GetBlockBlobReference("blob3");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag);
IOutputStream blobStream = await blob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
blob = container.GetBlockBlobReference("blob4");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
blobStream = await blob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
blob = container.GetBlockBlobReference("blob5");
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
blobStream = await blob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
blob = container.GetBlockBlobReference("blob6");
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
blobStream = await blob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfMatchCondition(blob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(blob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfNoneMatchCondition(existingBlob.Properties.ETag);
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.NotModified);
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
await TestHelper.ExpectedExceptionAsync(
() =>
{
blobStream.Dispose();
return(Task.FromResult(true));
},
context,
"BlobWriteStream.Dispose with a non-met condition should fail",
HttpStatusCode.Conflict);
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.NotModified);
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(1));
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
blobStream.Dispose();
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value.AddMinutes(-1));
await TestHelper.ExpectedExceptionAsync(
async() => await existingBlob.OpenWriteAsync(accessCondition, null, context),
context,
"OpenWriteAsync with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
accessCondition = AccessCondition.GenerateIfMatchCondition(existingBlob.Properties.ETag);
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
await existingBlob.SetPropertiesAsync();
await TestHelper.ExpectedExceptionAsync(
() =>
{
blobStream.Dispose();
return(Task.FromResult(true));
},
context,
"BlobWriteStream.Dispose with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
blob = container.GetBlockBlobReference("blob7");
accessCondition = AccessCondition.GenerateIfNoneMatchCondition("*");
blobStream = await blob.OpenWriteAsync(accessCondition, null, context);
await blob.PutBlockListAsync(new List <string>());
await TestHelper.ExpectedExceptionAsync(
() =>
{
blobStream.Dispose();
return(Task.FromResult(true));
},
context,
"BlobWriteStream.Dispose with a non-met condition should fail",
HttpStatusCode.Conflict);
blob = container.GetBlockBlobReference("blob8");
accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(existingBlob.Properties.LastModified.Value);
blobStream = await existingBlob.OpenWriteAsync(accessCondition, null, context);
await existingBlob.SetPropertiesAsync();
await TestHelper.ExpectedExceptionAsync(
() =>
{
blobStream.Dispose();
return(Task.FromResult(true));
},
context,
"BlobWriteStream.Dispose with a non-met condition should fail",
HttpStatusCode.PreconditionFailed);
}
finally
{
container.DeleteAsync().AsTask().Wait();
}
}
public void CloudBlobSASSharedProtocolsQueryParam()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlob blob;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
blockBlob.PutBlockList(new string[] { });
foreach (SharedAccessProtocol?protocol in new SharedAccessProtocol?[] { null, SharedAccessProtocol.HttpsOrHttp, SharedAccessProtocol.HttpsOnly })
{
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy, null, null, protocol, null);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = new Uri(blockBlob.Uri + blockBlobSAS.SASToken);
StorageUri blockBlobSASStorageUri = new StorageUri(new Uri(blockBlob.StorageUri.PrimaryUri + blockBlobSAS.SASToken), new Uri(blockBlob.StorageUri.SecondaryUri + blockBlobSAS.SASToken));
int httpPort = blockBlobSASUri.Port;
int securePort = 443;
if (!string.IsNullOrEmpty(TestBase.TargetTenantConfig.BlobSecurePortOverride))
{
securePort = Int32.Parse(TestBase.TargetTenantConfig.BlobSecurePortOverride);
}
var schemesAndPorts = new[] {
new { scheme = Uri.UriSchemeHttp, port = httpPort },
new { scheme = Uri.UriSchemeHttps, port = securePort }
};
foreach (var item in schemesAndPorts)
{
blockBlobSASUri = TransformSchemeAndPort(blockBlobSASUri, item.scheme, item.port);
blockBlobSASStorageUri = new StorageUri(TransformSchemeAndPort(blockBlobSASStorageUri.PrimaryUri, item.scheme, item.port), TransformSchemeAndPort(blockBlobSASStorageUri.SecondaryUri, item.scheme, item.port));
if (protocol.HasValue && protocol.Value == SharedAccessProtocol.HttpsOnly && string.CompareOrdinal(item.scheme, Uri.UriSchemeHttp) == 0)
{
blob = new CloudBlob(blockBlobSASUri);
TestHelper.ExpectedException(() => blob.FetchAttributes(), "Access a blob using SAS with a shared protocols that does not match", HttpStatusCode.Unused);
blob = new CloudBlob(blockBlobSASStorageUri, null, null);
TestHelper.ExpectedException(() => blob.FetchAttributes(), "Access a blob using SAS with a shared protocols that does not match", HttpStatusCode.Unused);
}
else
{
blob = new CloudBlob(blockBlobSASUri);
blob.FetchAttributes();
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
blob = new CloudBlob(blockBlobSASStorageUri, null, null);
blob.FetchAttributes();
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
}
}
}
}
finally
{
container.DeleteIfExists();
}
}
public void CloudBlockBlobCopyTestAPM()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlockBlob source = container.GetBlockBlobReference("source");
string data = "String data";
UploadText(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
source.SetMetadata();
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = copy.BeginStartCopyFromBlob(TestHelper.Defiddler(source),
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
string copyId = copy.EndStartCopyFromBlob(result);
WaitForCopy(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath);
Assert.AreEqual(data.Length, copy.CopyState.TotalBytes);
Assert.AreEqual(data.Length, copy.CopyState.BytesCopied);
Assert.AreEqual(copyId, copy.CopyState.CopyId);
Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
result = copy.BeginAbortCopy(copyId,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
TestHelper.ExpectedException(
() => copy.EndAbortCopy(result),
"Aborting a copy operation after completion should fail",
HttpStatusCode.Conflict,
"NoPendingCopyOperation");
}
source.FetchAttributes();
Assert.IsNotNull(copy.Properties.ETag);
Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag);
Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1)));
string copyData = DownloadText(copy, Encoding.UTF8);
Assert.AreEqual(data, copyData, "Data inside copy of blob not similar");
copy.FetchAttributes();
BlobProperties prop1 = copy.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", copy.Metadata["Test"], false, "Copied metadata not same");
copy.Delete();
}
finally
{
container.DeleteIfExists();
}
}
/// <summary>
/// Helper function for testing the IPAddressOrRange funcitonality for blobs
/// </summary>
/// <param name="generateInitialIPAddressOrRange">Function that generates an initial IPAddressOrRange object to use. This is expected to fail on the service.</param>
/// <param name="generateFinalIPAddressOrRange">Function that takes in the correct IP address (according to the service) and returns the IPAddressOrRange object
/// that should be accepted by the service</param>
public void CloudBlobSASIPAddressHelper(Func <IPAddressOrRange> generateInitialIPAddressOrRange, Func <IPAddress, IPAddressOrRange> generateFinalIPAddressOrRange)
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlob blob;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
byte[] data = new byte[] { 0x1, 0x2, 0x3, 0x4 };
blockBlob.UploadFromByteArray(data, 0, 4);
// The plan then is to use an incorrect IP address to make a call to the service
// ensure that we get an error message
// parse the error message to get my actual IP (as far as the service sees)
// then finally test the success case to ensure we can actually make requests
IPAddressOrRange ipAddressOrRange = generateInitialIPAddressOrRange();
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy, null, null, null, ipAddressOrRange);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
blob = new CloudBlob(blockBlobSASUri);
byte[] target = new byte[4];
OperationContext opContext = new OperationContext();
IPAddress actualIP = null;
opContext.ResponseReceived += (sender, e) =>
{
Stream stream = e.Response.GetResponseStream();
stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(stream))
{
string text = reader.ReadToEnd();
XDocument xdocument = XDocument.Parse(text);
actualIP = IPAddress.Parse(xdocument.Descendants("SourceIP").First().Value);
}
};
bool exceptionThrown = false;
try
{
blob.DownloadRangeToByteArray(target, 0, 0, 4, null, null, opContext);
}
catch (StorageException)
{
exceptionThrown = true;
Assert.IsNotNull(actualIP);
}
Assert.IsTrue(exceptionThrown);
ipAddressOrRange = generateFinalIPAddressOrRange(actualIP);
blockBlobToken = blockBlob.GetSharedAccessSignature(policy, null, null, null, ipAddressOrRange);
blockBlobSAS = new StorageCredentials(blockBlobToken);
blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
blob = new CloudBlob(blockBlobSASUri);
blob.DownloadRangeToByteArray(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(blockBlobSASStorageUri, null, null);
blob.DownloadRangeToByteArray(target, 0, 0, 4, null, null, null);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(data[i], target[i]);
}
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
}
finally
{
container.DeleteIfExists();
}
}
public async Task CloudBlockBlobBlockReorderingAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
List <string> originalBlockIds = GetBlockIdList(10);
List <string> blockIds = new List <string>(originalBlockIds);
List <byte[]> blocks = new List <byte[]>();
for (int i = 0; i < blockIds.Count; i++)
{
byte[] buffer = Encoding.UTF8.GetBytes(i.ToString());
using (MemoryStream stream = new MemoryStream(buffer))
{
await blob.PutBlockAsync(blockIds[i], stream.AsInputStream(), null);
}
blocks.Add(buffer);
}
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("0123456789", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.RemoveAt(0);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("123456789", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.RemoveAt(8);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("12345678", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.RemoveAt(3);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("1235678", await DownloadTextAsync(blob, Encoding.UTF8));
using (MemoryStream stream = new MemoryStream(blocks[9]))
{
await blob.PutBlockAsync(originalBlockIds[9], stream.AsInputStream(), null);
}
blockIds.Insert(0, originalBlockIds[9]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("91235678", await DownloadTextAsync(blob, Encoding.UTF8));
using (MemoryStream stream = new MemoryStream(blocks[0]))
{
await blob.PutBlockAsync(originalBlockIds[0], stream.AsInputStream(), null);
}
blockIds.Add(originalBlockIds[0]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("912356780", await DownloadTextAsync(blob, Encoding.UTF8));
using (MemoryStream stream = new MemoryStream(blocks[4]))
{
await blob.PutBlockAsync(originalBlockIds[4], stream.AsInputStream(), null);
}
blockIds.Insert(2, originalBlockIds[4]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("9142356780", await DownloadTextAsync(blob, Encoding.UTF8));
blockIds.Insert(0, originalBlockIds[0]);
await blob.PutBlockListAsync(blockIds);
Assert.AreEqual("09142356780", await DownloadTextAsync(blob, Encoding.UTF8));
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public void CloudBlobSASApiVersionQueryParam()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
container.Create();
CloudBlob blob;
SharedAccessBlobPolicy policy = new SharedAccessBlobPolicy()
{
Permissions = SharedAccessBlobPermissions.Read,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
CloudBlockBlob blockBlob = container.GetBlockBlobReference("bb");
blockBlob.PutBlockList(new string[] { });
CloudPageBlob pageBlob = container.GetPageBlobReference("pb");
pageBlob.Create(0);
CloudAppendBlob appendBlob = container.GetAppendBlobReference("ab");
appendBlob.CreateOrReplace();
string blockBlobToken = blockBlob.GetSharedAccessSignature(policy);
StorageCredentials blockBlobSAS = new StorageCredentials(blockBlobToken);
Uri blockBlobSASUri = blockBlobSAS.TransformUri(blockBlob.Uri);
StorageUri blockBlobSASStorageUri = blockBlobSAS.TransformUri(blockBlob.StorageUri);
string pageBlobToken = pageBlob.GetSharedAccessSignature(policy);
StorageCredentials pageBlobSAS = new StorageCredentials(pageBlobToken);
Uri pageBlobSASUri = pageBlobSAS.TransformUri(pageBlob.Uri);
StorageUri pageBlobSASStorageUri = pageBlobSAS.TransformUri(pageBlob.StorageUri);
string appendBlobToken = appendBlob.GetSharedAccessSignature(policy);
StorageCredentials appendBlobSAS = new StorageCredentials(appendBlobToken);
Uri appendBlobSASUri = appendBlobSAS.TransformUri(appendBlob.Uri);
StorageUri appendBlobSASStorageUri = appendBlobSAS.TransformUri(appendBlob.StorageUri);
OperationContext apiVersionCheckContext = new OperationContext();
apiVersionCheckContext.SendingRequest += (sender, e) =>
{
Assert.IsTrue(e.Request.RequestUri.Query.Contains("api-version"));
};
blob = new CloudBlob(blockBlobSASUri);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(blockBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(pageBlobSASUri);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.PageBlob);
Assert.IsTrue(blob.StorageUri.PrimaryUri.Equals(pageBlob.Uri));
Assert.IsNull(blob.StorageUri.SecondaryUri);
blob = new CloudBlob(blockBlobSASStorageUri, null, null);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.BlockBlob);
Assert.IsTrue(blob.StorageUri.Equals(blockBlob.StorageUri));
blob = new CloudBlob(pageBlobSASStorageUri, null, null);
blob.FetchAttributes(operationContext: apiVersionCheckContext);
Assert.AreEqual(blob.BlobType, BlobType.PageBlob);
Assert.IsTrue(blob.StorageUri.Equals(pageBlob.StorageUri));
}
finally
{
container.DeleteIfExists();
}
}
public async Task CloudBlockBlobCopyFromSnapshotTestAsync()
{
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob source = container.GetBlockBlobReference("source");
string data = "String data";
await UploadTextAsync(source, data, Encoding.UTF8);
source.Metadata["Test"] = "value";
await source.SetMetadataAsync();
CloudBlockBlob snapshot = await source.CreateSnapshotAsync();
//Modify source
string newData = "Hello";
source.Metadata["Test"] = "newvalue";
await source.SetMetadataAsync();
source.Properties.ContentMD5 = null;
await UploadTextAsync(source, newData, Encoding.UTF8);
Assert.AreEqual(newData, await DownloadTextAsync(source, Encoding.UTF8), "Source is modified correctly");
Assert.AreEqual(data, await DownloadTextAsync(snapshot, Encoding.UTF8), "Modifying source blob should not modify snapshot");
await source.FetchAttributesAsync();
await snapshot.FetchAttributesAsync();
Assert.AreNotEqual(source.Metadata["Test"], snapshot.Metadata["Test"], "Source and snapshot metadata should be independent");
CloudBlockBlob copy = container.GetBlockBlobReference("copy");
await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot));
await WaitForCopyAsync(copy);
Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status);
Assert.AreEqual(data, await DownloadTextAsync(copy, Encoding.UTF8), "Data inside copy of blob not similar");
await copy.FetchAttributesAsync();
BlobProperties prop1 = copy.Properties;
BlobProperties prop2 = snapshot.Properties;
Assert.AreEqual(prop1.CacheControl, prop2.CacheControl);
Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding);
Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition);
Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage);
Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5);
Assert.AreEqual(prop1.ContentType, prop2.ContentType);
Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same");
await copy.DeleteAsync();
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task CloudBlockBlobConditionalAccessAsync()
{
OperationContext operationContext = new OperationContext();
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
CloudBlockBlob blob = container.GetBlockBlobReference("blob1");
await CreateForTestAsync(blob, 2, 1024);
await blob.FetchAttributesAsync();
string currentETag = blob.Properties.ETag;
DateTimeOffset currentModifiedTime = blob.Properties.LastModified.Value;
// ETag conditional tests
blob.Metadata["ETagConditionalName"] = "ETagConditionalValue";
await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(currentETag), null, null);
await blob.FetchAttributesAsync();
string newETag = blob.Properties.ETag;
Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata");
blob.Metadata["ETagConditionalName"] = "ETagConditionalValue2";
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(newETag), null, operationContext),
operationContext,
"If none match on conditional test should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
string invalidETag = "\"0x10101010\"";
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(invalidETag), null, operationContext),
operationContext,
"Invalid ETag on conditional test should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
currentETag = blob.Properties.ETag;
await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(invalidETag), null, null);
await blob.FetchAttributesAsync();
newETag = blob.Properties.ETag;
// LastModifiedTime tests
currentModifiedTime = blob.Properties.LastModified.Value;
blob.Metadata["DateConditionalName"] = "DateConditionalValue";
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(currentModifiedTime), null, operationContext),
operationContext,
"IfModifiedSince conditional on current modified time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
DateTimeOffset pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5));
await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null);
pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5));
await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null);
pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5));
await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null);
currentModifiedTime = blob.Properties.LastModified.Value;
pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5));
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext),
operationContext,
"IfNotModifiedSince conditional on past time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5));
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext),
operationContext,
"IfNotModifiedSince conditional on past time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5));
await TestHelper.ExpectedExceptionAsync(
async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext),
operationContext,
"IfNotModifiedSince conditional on past time should throw",
HttpStatusCode.PreconditionFailed,
"ConditionNotMet");
blob.Metadata["DateConditionalName"] = "DateConditionalValue2";
currentETag = blob.Properties.ETag;
await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(currentModifiedTime), null, null);
await blob.FetchAttributesAsync();
newETag = blob.Properties.ETag;
Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata");
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
private static void TestAccess(string sasToken, SharedAccessBlobPermissions permissions, SharedAccessBlobHeaders headers, CloudBlobContainer container, CloudBlob blob)
{
CloudBlob SASblob;
StorageCredentials credentials = string.IsNullOrEmpty(sasToken) ?
new StorageCredentials() :
new StorageCredentials(sasToken);
if (container != null)
{
container = new CloudBlobContainer(credentials.TransformUri(container.Uri));
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = container.GetBlockBlobReference(blob.Name);
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = container.GetPageBlobReference(blob.Name);
}
else
{
SASblob = container.GetAppendBlobReference(blob.Name);
}
}
else
{
if (blob.BlobType == BlobType.BlockBlob)
{
SASblob = new CloudBlockBlob(credentials.TransformUri(blob.Uri));
}
else if (blob.BlobType == BlobType.PageBlob)
{
SASblob = new CloudPageBlob(credentials.TransformUri(blob.Uri));
}
else
{
SASblob = new CloudAppendBlob(credentials.TransformUri(blob.Uri));
}
}
HttpStatusCode failureCode = sasToken == null ? HttpStatusCode.NotFound : HttpStatusCode.Forbidden;
// We want to ensure that 'create', 'add', and 'write' permissions all allow for correct writing of blobs, as is reasonable.
if (((permissions & SharedAccessBlobPermissions.Create) == SharedAccessBlobPermissions.Create) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
if (blob.BlobType == BlobType.PageBlob)
{
CloudPageBlob SASpageBlob = (CloudPageBlob)SASblob;
SASpageBlob.Create(512);
CloudPageBlob pageBlob = (CloudPageBlob)blob;
byte[] buffer = new byte[512];
buffer[0] = 2; // random data
if (((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASpageBlob.UploadFromByteArray(buffer, 0, 512);
}
else
{
TestHelper.ExpectedException(
() => SASpageBlob.UploadFromByteArray(buffer, 0, 512),
"pageBlob SAS token without Write perms should not allow for writing/adding",
failureCode);
pageBlob.UploadFromByteArray(buffer, 0, 512);
}
}
else if (blob.BlobType == BlobType.BlockBlob)
{
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
UploadText(SASblob, "blob", Encoding.UTF8);
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"Block blob SAS token without Write or perms should not allow for writing",
failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
}
else // append blob
{
// If the sas token contains Feb 2012, append won't be accepted
if (sasToken.Contains(Constants.VersionConstants.February2012))
{
UploadText(blob, "blob", Encoding.UTF8);
}
else
{
CloudAppendBlob SASAppendBlob = SASblob as CloudAppendBlob;
SASAppendBlob.CreateOrReplace();
byte[] textAsBytes = Encoding.UTF8.GetBytes("blob");
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
if (((permissions & SharedAccessBlobPermissions.Add) == SharedAccessBlobPermissions.Add) || ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write))
{
SASAppendBlob.AppendBlock(stream, null);
}
else
{
TestHelper.ExpectedException(
() => SASAppendBlob.AppendBlock(stream, null),
"Append blob SAS token without Write or Add perms should not allow for writing/adding",
failureCode);
stream.Seek(0, SeekOrigin.Begin);
((CloudAppendBlob)blob).AppendBlock(stream, null);
}
}
}
}
}
else
{
TestHelper.ExpectedException(
() => UploadText(SASblob, "blob", Encoding.UTF8),
"UploadText SAS does not allow for writing/adding",
((blob.BlobType == BlobType.AppendBlob) && (sasToken != null) && (sasToken.Contains(Constants.VersionConstants.February2012))) ? HttpStatusCode.BadRequest : failureCode);
UploadText(blob, "blob", Encoding.UTF8);
}
if (container != null)
{
if ((permissions & SharedAccessBlobPermissions.List) == SharedAccessBlobPermissions.List)
{
container.ListBlobs().ToArray();
}
else
{
TestHelper.ExpectedException(
() => container.ListBlobs().ToArray(),
"List blobs while SAS does not allow for listing",
failureCode);
}
}
// need to have written to the blob to read from it.
if (((permissions & SharedAccessBlobPermissions.Read) == SharedAccessBlobPermissions.Read))
{
SASblob.FetchAttributes();
// Test headers
if (headers != null)
{
if (headers.CacheControl != null)
{
Assert.AreEqual(headers.CacheControl, SASblob.Properties.CacheControl);
}
if (headers.ContentDisposition != null)
{
Assert.AreEqual(headers.ContentDisposition, SASblob.Properties.ContentDisposition);
}
if (headers.ContentEncoding != null)
{
Assert.AreEqual(headers.ContentEncoding, SASblob.Properties.ContentEncoding);
}
if (headers.ContentLanguage != null)
{
Assert.AreEqual(headers.ContentLanguage, SASblob.Properties.ContentLanguage);
}
if (headers.ContentType != null)
{
Assert.AreEqual(headers.ContentType, SASblob.Properties.ContentType);
}
}
}
else
{
TestHelper.ExpectedException(
() => SASblob.FetchAttributes(),
"Fetch blob attributes while SAS does not allow for reading",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Write) == SharedAccessBlobPermissions.Write)
{
SASblob.SetMetadata();
}
else
{
TestHelper.ExpectedException(
() => SASblob.SetMetadata(),
"Set blob metadata while SAS does not allow for writing",
failureCode);
}
if ((permissions & SharedAccessBlobPermissions.Delete) == SharedAccessBlobPermissions.Delete)
{
SASblob.Delete();
}
else
{
TestHelper.ExpectedException(
() => SASblob.Delete(),
"Delete blob while SAS does not allow for deleting",
failureCode);
}
}
/// <summary>
/// Initializes a new instance of the BlobWriteStreamHelper class for a block blob.
/// </summary>
/// <param name="blockBlob">Blob reference to write to.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
internal BlobWriteStreamHelper(CloudBlockBlob blockBlob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
this.originalStream = new BlobWriteStream(blockBlob, accessCondition, options, operationContext);
this.originalStreamAsOutputStream = this.originalStream.AsOutputStream();
}
