public void GetBlobCopyStateTest()
{
CloudBlobUtil blobUtil = new CloudBlobUtil(CommonStorageAccount);
blobUtil.SetupTestContainerAndBlob();
StorageBlob.ICloudBlob destBlob = CopyBlobAndWaitForComplete(blobUtil);
try
{
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));
PowerShellAgent agent = new PowerShellAgent();
Test.Assert(agent.GetAzureStorageBlobCopyState(blobUtil.ContainerName, destBlob.Name, false), "Get copy state should be success");
int expectedStateCount = 1;
Test.Assert(agent.Output.Count == expectedStateCount, String.Format("Expected to get {0} copy state, actually it's {1}", expectedStateCount, agent.Output.Count));
StorageBlob.CopyStatus copyStatus = (StorageBlob.CopyStatus)agent.Output[0]["Status"];
Test.Assert(copyStatus == StorageBlob.CopyStatus.Success, String.Format("The blob copy should be success, actually it's {0}", copyStatus));
Uri sourceUri = (Uri)agent.Output[0]["Source"];
string expectedUri = CloudBlobUtil.ConvertCopySourceUri(blobUtil.Blob.Uri.ToString());
Test.Assert(sourceUri.ToString() == expectedUri, String.Format("Expected source uri is {0}, actully it's {1}", expectedUri, sourceUri.ToString()));
Test.Assert(!agent.GetAzureStorageBlobCopyState(blobUtil.ContainerName, blobUtil.BlobName, false), "Get copy state should be fail since the specified blob don't have any copy operation");
Test.Assert(agent.ErrorMessages.Count > 0, "Should return error message");
string errorMessage = "Can not find copy task on specified blob";
Test.Assert(agent.ErrorMessages[0].StartsWith(errorMessage), String.Format("Error message should start with {0}, and actually it's {1}", errorMessage, agent.ErrorMessages[0]));
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
}
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void UploadBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
//--------------Upload operation--------------
Test.Assert(agent.SetAzureStorageBlobContent(UploadFilePath, NEW_CONTAINER_NAME, Type), Utility.GenComparisonData("SendAzureStorageBlob", true));
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
CloudBlobUtil.PackBlobCompareData(blob, dic);
// Verification for returned values
agent.OutputValidation(comp);
Test.Assert(blob != null && blob.Exists(), "blob " + blobName + " should exist!");
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
public void GetCopyStateFromCrossAccountCopyTest()
{
CloudStorageAccount secondaryAccount = TestBase.GetCloudStorageAccountFromConfig("Secondary");
object destContext = PowerShellAgent.GetStorageContext(secondaryAccount.ToString(true));
CloudBlobUtil destBlobUtil = new CloudBlobUtil(secondaryAccount);
string destContainerName = Utility.GenNameString("secondary");
StorageBlob.CloudBlobContainer destContainer = destBlobUtil.CreateContainer(destContainerName);
blobUtil.SetupTestContainerAndBlob();
//remove the same name container in source storage account, so we could avoid some conflicts.
blobUtil.RemoveContainer(destContainer.Name);
try
{
Test.Assert(agent.StartAzureStorageBlobCopy(blobUtil.Blob, destContainer.Name, string.Empty, destContext), "Start cross account copy should successed");
int expectedBlobCount = 1;
Test.Assert(agent.Output.Count == expectedBlobCount, String.Format("Expected get {0} copy blob, and actually it's {1}", expectedBlobCount, agent.Output.Count));
StorageBlob.ICloudBlob destBlob = (StorageBlob.ICloudBlob)agent.Output[0]["ICloudBlob"];
//make sure this context is different from the PowerShell.Context
object context = agent.Output[0]["Context"];
Test.Assert(PowerShellAgent.Context != context, "make sure you are using different context for cross account copy");
Test.Assert(agent.GetAzureStorageBlobCopyState(destBlob, context, true), "Get copy state in dest container should be successed.");
AssertFinishedCopyState(blobUtil.Blob.Uri);
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
destBlobUtil.RemoveContainer(destContainer.Name);
}
}
internal void UploadBlobTestGB(Agent agent, StorageBlob.BlobType blobType)
{
string uploadFilePath = @".\" + Utility.GenNameString("gbupload");
string containerName = Utility.GenNameString("gbupload-");
string blobName = Path.GetFileName(uploadFilePath);
// create the container
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName);
// Generate a 512 bytes file which contains GB18030 characters
File.WriteAllText(uploadFilePath, GB18030String);
try
{
//--------------Upload operation--------------
Test.Assert(agent.SetAzureStorageBlobContent(uploadFilePath, containerName, blobType),
Utility.GenComparisonData("SendAzureStorageBlob", true));
StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(container, blobName, blobType);
Test.Assert(blob != null && blob.Exists(), "blob " + blobName + " should exist!");
// Check MD5
string localMd5 = Helper.GetFileContentMD5(uploadFilePath);
blob.FetchAttributes();
Test.Assert(localMd5 == blob.Properties.ContentMD5,
string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5));
}
finally
{
// cleanup
container.DeleteIfExists();
File.Delete(uploadFilePath);
}
}
public void AnonymousContextWithEndPoint()
{
string containerName = Utility.GenNameString(ContainerPrefix);
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName, StorageBlob.BlobContainerPublicAccessType.Blob);
try
{
string pageBlobName = Utility.GenNameString("pageblob");
string blockBlobName = Utility.GenNameString("blockblob");
StorageBlob.ICloudBlob blockBlob = blobUtil.CreateBlockBlob(container, blockBlobName);
StorageBlob.ICloudBlob pageBlob = blobUtil.CreatePageBlob(container, pageBlobName);
agent.UseContextParam = false;
string cmd = string.Format("new-azurestoragecontext -StorageAccountName {0} " +
"-Anonymous -EndPoint {1}", StorageAccountName, StorageEndPoint);
((PowerShellAgent)agent).AddPipelineScript(cmd);
Test.Assert(agent.GetAzureStorageBlob(blockBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true));
agent.OutputValidation(new List <StorageBlob.ICloudBlob> {
blockBlob
});
((PowerShellAgent)agent).AddPipelineScript(cmd);
Test.Assert(agent.GetAzureStorageBlob(pageBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true));
agent.OutputValidation(new List <StorageBlob.ICloudBlob> {
pageBlob
});
}
finally
{
blobUtil.RemoveContainer(containerName);
}
}
public void ListBlobsWithBlobPermission()
{
string containerName = Utility.GenNameString(ContainerPrefix);
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName, StorageBlob.BlobContainerPublicAccessType.Blob);
try
{
string pageBlobName = Utility.GenNameString("pageblob");
string blockBlobName = Utility.GenNameString("blockblob");
StorageBlob.ICloudBlob blockBlob = blobUtil.CreateBlockBlob(container, blockBlobName);
StorageBlob.ICloudBlob pageBlob = blobUtil.CreatePageBlob(container, pageBlobName);
Test.Assert(agent.GetAzureStorageBlob(blockBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true));
agent.OutputValidation(new List <StorageBlob.ICloudBlob> {
blockBlob
});
Test.Assert(agent.GetAzureStorageBlob(pageBlobName, containerName), Utility.GenComparisonData("Get-AzureStorageBlob", true));
agent.OutputValidation(new List <StorageBlob.ICloudBlob> {
pageBlob
});
}
finally
{
blobUtil.RemoveContainer(containerName);
}
}
public static void PackBlobCompareData(StorageBlob.ICloudBlob blob, Dictionary <string, object> dic)
{
dic["Length"] = blob.Properties.Length;
dic["ContentType"] = blob.Properties.ContentType;
dic["LastModified"] = blob.Properties.LastModified;
dic["SnapshotTime"] = blob.SnapshotTime;
}
public void SetBlobContentWithProperties(StorageBlob.BlobType blobType)
{
string filePath = FileUtil.GenerateOneTempTestFile();
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer();
Hashtable properties = new Hashtable();
properties.Add("CacheControl", Utility.GenNameString(string.Empty));
properties.Add("ContentEncoding", Utility.GenNameString(string.Empty));
properties.Add("ContentLanguage", Utility.GenNameString(string.Empty));
properties.Add("ContentMD5", Utility.GenNameString(string.Empty));
properties.Add("ContentType", Utility.GenNameString(string.Empty));
try
{
Test.Assert(agent.SetAzureStorageBlobContent(filePath, container.Name, blobType, string.Empty, true, -1, properties), "set blob content with property should succeed");
StorageBlob.ICloudBlob blob = container.GetBlobReferenceFromServer(Path.GetFileName(filePath));
blob.FetchAttributes();
ExpectEqual(properties["CacheControl"].ToString(), blob.Properties.CacheControl, "Cache control");
ExpectEqual(properties["ContentEncoding"].ToString(), blob.Properties.ContentEncoding, "Content Encoding");
ExpectEqual(properties["ContentLanguage"].ToString(), blob.Properties.ContentLanguage, "Content Language");
ExpectEqual(properties["ContentMD5"].ToString(), blob.Properties.ContentMD5, "Content MD5");
ExpectEqual(properties["ContentType"].ToString(), blob.Properties.ContentType, "Content Type");
}
finally
{
blobUtil.RemoveContainer(container.Name);
FileUtil.RemoveFile(filePath);
}
}
public static bool WaitForCopyOperationComplete(StorageBlob.ICloudBlob destBlob, int maxRetry = 100)
{
int retryCount = 0;
int sleepInterval = 1000; //ms
if (destBlob == null)
{
return(false);
}
do
{
if (retryCount > 0)
{
Test.Info(String.Format("{0}th check current copy state and it's {1}. Wait for copy completion", retryCount, destBlob.CopyState.Status));
}
Thread.Sleep(sleepInterval);
destBlob.FetchAttributes();
retryCount++;
}while (destBlob.CopyState.Status == StorageBlob.CopyStatus.Pending && retryCount < maxRetry);
Test.Info(String.Format("Final Copy status is {0}", destBlob.CopyState.Status));
return(destBlob.CopyState.Status != StorageBlob.CopyStatus.Pending);
}
public void StopCopyBlobTest()
{
CloudBlobUtil blobUtil = new CloudBlobUtil(CommonStorageAccount);
blobUtil.SetupTestContainerAndBlob();
StorageBlob.ICloudBlob destBlob = CopyBlobAndWaitForComplete(blobUtil);
try
{
PowerShellAgent agent = new PowerShellAgent();
string copyId = Guid.NewGuid().ToString();
Test.Assert(!agent.StopAzureStorageBlobCopy(blobUtil.ContainerName, blobUtil.BlobName, copyId, true), "Stop copy operation should be fail since the specified blob don't have any copy operation");
Test.Assert(agent.ErrorMessages.Count > 0, "Should return error message");
string errorMessage = String.Format("Can not find copy task on specified blob '{0}' in container '{1}'", blobUtil.BlobName, blobUtil.ContainerName);
Test.Assert(agent.ErrorMessages[0].IndexOf(errorMessage) != -1, String.Format("Error message should contain {0}, and actually it's {1}", errorMessage, agent.ErrorMessages[0]));
errorMessage = "There is currently no pending copy operation.";
Test.Assert(!agent.StopAzureStorageBlobCopy(blobUtil.ContainerName, destBlob.Name, copyId, true), "Stop copy operation should be fail since the specified copy operation has finished");
Test.Assert(agent.ErrorMessages.Count > 0, "Should return error message");
Test.Assert(agent.ErrorMessages[0].IndexOf(errorMessage) != -1, String.Format("Error message should contain {0}, and actually it's {1}", errorMessage, agent.ErrorMessages[0]));
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
}
}
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);
}
public void SetBlobContentWithSubDirectory()
{
DirectoryInfo rootDir = new DirectoryInfo(uploadDirRoot);
DirectoryInfo[] dirs = rootDir.GetDirectories();
foreach (DirectoryInfo dir in dirs)
{
string containerName = Utility.GenNameString("container");
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName);
try
{
List <StorageBlob.IListBlobItem> blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList();
Test.Assert(blobLists.Count == 0, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 0, blobLists.Count));
StorageBlob.BlobType blobType = StorageBlob.BlobType.BlockBlob;
if (dir.Name.StartsWith("dirpage"))
{
blobType = Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob;
}
((PowerShellAgent)agent).AddPipelineScript(string.Format("ls -File -Recurse -Path {0}", dir.FullName));
Test.Info("Upload files...");
Test.Assert(agent.SetAzureStorageBlobContent(string.Empty, containerName, blobType), "upload multiple files should be successsed");
Test.Info("Upload finished...");
blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList();
List <string> dirFiles = files.FindAll(item => item.StartsWith(dir.Name));
Test.Assert(blobLists.Count == dirFiles.Count(), string.Format("set-azurestorageblobcontent should upload {0} files, and actually it's {1}", dirFiles.Count(), blobLists.Count));
StorageBlob.ICloudBlob blob = null;
for (int i = 0, count = dirFiles.Count(); i < count; i++)
{
blob = blobLists[i] as StorageBlob.ICloudBlob;
if (blob == null)
{
Test.AssertFail("blob can't be null");
}
string convertedName = blobUtil.ConvertBlobNameToFileName(blob.Name, dir.Name);
Test.Assert(dirFiles[i] == convertedName, string.Format("blob name should be {0}, and actully it's {1}", dirFiles[i], convertedName));
string localMd5 = Helper.GetFileContentMD5(Path.Combine(uploadDirRoot, dirFiles[i]));
Test.Assert(blob.BlobType == blobType, "blob type should be block blob");
Test.Assert(localMd5 == blob.Properties.ContentMD5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5));
}
}
finally
{
blobUtil.RemoveContainer(containerName);
}
}
}
public static StorageBlob.ICloudBlob GetBlob(StorageBlob.CloudBlobContainer container, string blobName, StorageType blobType)
{
StorageBlob.ICloudBlob blob = null;
if (blobType == StorageType.BlockBlob)
{
blob = container.GetBlockBlobReference(blobName);
}
else
{
blob = container.GetPageBlobReference(blobName);
}
return(blob);
}
internal void CopyBlobTestGB(Agent agent, StorageBlob.BlobType blobType)
{
string uploadFilePath = @".\" + Utility.GenNameString("gbupload");
string srcContainerName = Utility.GenNameString("gbupload-", 15);
string destContainerName = Utility.GenNameString("gbupload-", 15);
string blobName = Path.GetFileName(uploadFilePath);
// create the container
StorageBlob.CloudBlobContainer srcContainer = blobUtil.CreateContainer(srcContainerName);
StorageBlob.CloudBlobContainer destContainer = blobUtil.CreateContainer(destContainerName);
// Generate a 512 bytes file which contains GB18030 characters
File.WriteAllText(uploadFilePath, GB18030String);
string localMd5 = Helper.GetFileContentMD5(uploadFilePath);
try
{
// create source blob
StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(srcContainer, blobName, blobType);
// upload file data
using (var fileStream = System.IO.File.OpenRead(uploadFilePath))
{
blob.UploadFromStream(fileStream);
// need to set MD5 as for page blob, it won't set MD5 automatically
blob.Properties.ContentMD5 = localMd5;
blob.SetProperties();
}
//--------------Copy blob operation--------------
Test.Assert(agent.StartAzureStorageBlobCopy(srcContainerName, blobName, destContainerName, blobName), Utility.GenComparisonData("Start copy blob using blob name", true));
// Get destination blob
blob = CloudBlobUtil.GetBlob(destContainer, blobName, blobType);
// Check MD5
blob.FetchAttributes();
Test.Assert(localMd5 == blob.Properties.ContentMD5,
string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5));
}
finally
{
// cleanup
srcContainer.DeleteIfExists();
destContainer.DeleteIfExists();
File.Delete(uploadFilePath);
}
}
/// <summary>
/// download specified blob
/// </summary>
/// <param name="container"></param>
/// <param name="blob"></param>
private void DownloadBlobFromContainer(StorageBlob.CloudBlobContainer container, StorageBlob.BlobType type)
{
string blobName = Utility.GenNameString("blob");
StorageBlob.ICloudBlob blob = blobUtil.CreateBlob(container, blobName, type);
string filePath = Path.Combine(downloadDirRoot, blob.Name);
Test.Assert(agent.GetAzureStorageBlobContent(blob.Name, filePath, container.Name, true), "download blob should be successful");
string localMd5 = Helper.GetFileContentMD5(filePath);
Test.Assert(localMd5 == blob.Properties.ContentMD5, string.Format("local content md5 should be {0}, and actualy it's {1}", blob.Properties.ContentMD5, localMd5));
agent.OutputValidation(new List <StorageBlob.ICloudBlob> {
blob
});
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void DownloadBlobTest(Agent agent, string UploadFilePath, string DownloadDirPath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
bool bSuccess = false;
// upload the blob file
if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob)
{
bSuccess = CommonBlobHelper.UploadFileToBlockBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
else if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob)
{
bSuccess = CommonBlobHelper.UploadFileToPageBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
Test.Assert(bSuccess, "upload file {0} to container {1} should succeed", UploadFilePath, NEW_CONTAINER_NAME);
//--------------Download operation--------------
string downloadFilePath = Path.Combine(DownloadDirPath, blobName);
Test.Assert(agent.GetAzureStorageBlobContent(blobName, downloadFilePath, NEW_CONTAINER_NAME),
Utility.GenComparisonData("GetAzureStorageBlobContent", true));
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
CloudBlobUtil.PackBlobCompareData(blob, dic);
// Verification for returned values
agent.OutputValidation(comp);
Test.Assert(Helper.CompareTwoFiles(downloadFilePath, UploadFilePath),
String.Format("File '{0}' should be bit-wise identicial to '{1}'", downloadFilePath, UploadFilePath));
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void GetBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
bool bSuccess = false;
// upload the blob file
if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob)
{
bSuccess = CommonBlobHelper.UploadFileToBlockBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
else if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob)
{
bSuccess = CommonBlobHelper.UploadFileToPageBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
Test.Assert(bSuccess, "upload file {0} to container {1} should succeed", UploadFilePath, NEW_CONTAINER_NAME);
//--------------Get operation--------------
Test.Assert(agent.GetAzureStorageBlob(blobName, NEW_CONTAINER_NAME), Utility.GenComparisonData("GetAzureStorageBlob", true));
// Verification for returned values
// get blob object using XSCL
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
blob.FetchAttributes();
CloudBlobUtil.PackBlobCompareData(blob, dic);
dic.Add("ICloudBlob", blob);
agent.OutputValidation(comp);
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
public void SetBlobContentByMultipleFiles()
{
string containerName = Utility.GenNameString("container");
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName);
try
{
List <StorageBlob.IListBlobItem> blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList();
Test.Assert(blobLists.Count == 0, string.Format("container {0} should contain {1} blobs, and actually it contain {2} blobs", containerName, 0, blobLists.Count));
DirectoryInfo rootDir = new DirectoryInfo(uploadDirRoot);
FileInfo[] rootFiles = rootDir.GetFiles();
((PowerShellAgent)agent).AddPipelineScript(string.Format("ls -File -Path {0}", uploadDirRoot));
Test.Info("Upload files...");
Test.Assert(agent.SetAzureStorageBlobContent(string.Empty, containerName, StorageBlob.BlobType.BlockBlob), "upload multiple files should be successsed");
Test.Info("Upload finished...");
blobLists = container.ListBlobs(string.Empty, true, StorageBlob.BlobListingDetails.All).ToList();
Test.Assert(blobLists.Count == rootFiles.Count(), string.Format("set-azurestorageblobcontent should upload {0} files, and actually it's {1}", rootFiles.Count(), blobLists.Count));
StorageBlob.ICloudBlob blob = null;
for (int i = 0, count = rootFiles.Count(); i < count; i++)
{
blob = blobLists[i] as StorageBlob.ICloudBlob;
if (blob == null)
{
Test.AssertFail("blob can't be null");
}
Test.Assert(rootFiles[i].Name == blob.Name, string.Format("blob name should be {0}, and actully it's {1}", rootFiles[i].Name, blob.Name));
string localMd5 = Helper.GetFileContentMD5(Path.Combine(uploadDirRoot, rootFiles[i].Name));
Test.Assert(blob.BlobType == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob, "blob type should be block blob");
Test.Assert(localMd5 == blob.Properties.ContentMD5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, blob.Properties.ContentMD5));
}
}
finally
{
blobUtil.RemoveContainer(containerName);
}
}
internal void DownloadBlobTestGB(Agent agent, StorageBlob.BlobType blobType)
{
string uploadFilePath = @".\" + Utility.GenNameString("gbupload");
string downloadFilePath = @".\" + Utility.GenNameString("gbdownload");
string containerName = Utility.GenNameString("gbupload-");
string blobName = Path.GetFileName(uploadFilePath);
// create the container
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer(containerName);
// Generate a 512 bytes file which contains GB18030 characters
File.WriteAllText(uploadFilePath, GB18030String);
try
{
// create source blob
StorageBlob.ICloudBlob blob = CloudBlobUtil.GetBlob(container, blobName, blobType);
// upload file data
using (var fileStream = System.IO.File.OpenRead(uploadFilePath))
{
blob.UploadFromStream(fileStream);
}
//--------------Download operation--------------
Test.Assert(agent.GetAzureStorageBlobContent(blobName, downloadFilePath, containerName, true), "download blob should be successful");
// Check MD5
string localMd5 = Helper.GetFileContentMD5(downloadFilePath);
string uploadMd5 = Helper.GetFileContentMD5(uploadFilePath);
blob.FetchAttributes();
Test.Assert(localMd5 == uploadMd5, string.Format("blob content md5 should be {0}, and actualy it's {1}", localMd5, uploadMd5));
}
finally
{
// cleanup
container.DeleteIfExists();
File.Delete(uploadFilePath);
File.Delete(downloadFilePath);
}
}
internal void StartCopyBlobTest(Agent agent, bool useUri)
{
CloudBlobUtil blobUtil = new CloudBlobUtil(CommonStorageAccount);
blobUtil.SetupTestContainerAndBlob();
string copiedName = Utility.GenNameString("copied");
if (useUri)
{
//Set the blob permission, so the copy task could directly copy by uri
StorageBlob.BlobContainerPermissions permission = new StorageBlob.BlobContainerPermissions();
permission.PublicAccess = StorageBlob.BlobContainerPublicAccessType.Blob;
blobUtil.Container.SetPermissions(permission);
}
try
{
if (useUri)
{
Test.Assert(agent.StartAzureStorageBlobCopy(blobUtil.Blob.Uri.ToString(), blobUtil.ContainerName, copiedName, PowerShellAgent.Context), Utility.GenComparisonData("Start copy blob using source uri", true));
}
else
{
Test.Assert(agent.StartAzureStorageBlobCopy(blobUtil.ContainerName, blobUtil.BlobName, blobUtil.ContainerName, copiedName), Utility.GenComparisonData("Start copy blob using blob name", true));
}
Test.Info("Get destination blob in copy task");
StorageBlob.ICloudBlob blob = blobUtil.Container.GetBlobReferenceFromServer(copiedName);
Test.Assert(blob != null, "Destination blob should exist after start copy. If not, please check it's a test issue or dev issue.");
string sourceUri = CloudBlobUtil.ConvertCopySourceUri(blobUtil.Blob.Uri.ToString());
Test.Assert(blob.BlobType == blobUtil.Blob.BlobType, String.Format("The destination blob type should be {0}, actually {1}.", blobUtil.Blob.BlobType, blob.BlobType));
Test.Assert(blob.CopyState.Source.ToString().StartsWith(sourceUri), String.Format("The source of destination blob should start with {0}, and actually it's {1}", sourceUri, blob.CopyState.Source.ToString()));
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
}
}
public void GetCopyStateFromRootContainerTest()
{
StorageBlob.CloudBlobContainer rootContainer = blobUtil.CreateContainer("$root");
string srcBlobName = Utility.GenNameString("src");
StorageBlob.ICloudBlob srcBlob = blobUtil.CreateRandomBlob(rootContainer, srcBlobName);
StorageBlob.ICloudBlob destBlob = blobUtil.CreateBlob(rootContainer, Utility.GenNameString("dest"), srcBlob.BlobType);
if (destBlob.BlobType == StorageBlob.BlobType.BlockBlob)
{
((StorageBlob.CloudBlockBlob)destBlob).StartCopy((StorageBlob.CloudBlockBlob)srcBlob);
}
else
{
((StorageBlob.CloudPageBlob)destBlob).StartCopy((StorageBlob.CloudPageBlob)srcBlob);
}
Test.Assert(agent.GetAzureStorageBlobCopyState("$root", destBlob.Name, true), "Get copy state in $root container should be successed.");
AssertFinishedCopyState(srcBlob.Uri);
}
/// <summary>
/// Parameters:
/// Block:
/// True for BlockBlob, false for PageBlob
/// </summary>
internal void RemoveBlobTest(Agent agent, string UploadFilePath, Microsoft.WindowsAzure.Storage.Blob.BlobType Type)
{
string NEW_CONTAINER_NAME = Utility.GenNameString("upload-");
string blobName = Path.GetFileName(UploadFilePath);
Collection <Dictionary <string, object> > comp = new Collection <Dictionary <string, object> >();
Dictionary <string, object> dic = Utility.GenComparisonData(StorageObjectType.Blob, blobName);
dic["BlobType"] = Type;
comp.Add(dic);
// create the container
StorageBlob.CloudBlobContainer container = CommonStorageAccount.CreateCloudBlobClient().GetContainerReference(NEW_CONTAINER_NAME);
container.CreateIfNotExists();
try
{
bool bSuccess = false;
// upload the blob file
if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.BlockBlob)
{
bSuccess = CommonBlobHelper.UploadFileToBlockBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
else if (Type == Microsoft.WindowsAzure.Storage.Blob.BlobType.PageBlob)
{
bSuccess = CommonBlobHelper.UploadFileToPageBlob(NEW_CONTAINER_NAME, blobName, UploadFilePath);
}
Test.Assert(bSuccess, "upload file {0} to container {1} should succeed", UploadFilePath, NEW_CONTAINER_NAME);
//--------------Remove operation--------------
Test.Assert(agent.RemoveAzureStorageBlob(blobName, NEW_CONTAINER_NAME), Utility.GenComparisonData("RemoveAzureStorageBlob", true));
StorageBlob.ICloudBlob blob = CommonBlobHelper.QueryBlob(NEW_CONTAINER_NAME, blobName);
Test.Assert(blob == null, "blob {0} should not exist!", blobName);
}
finally
{
// cleanup
container.DeleteIfExists();
}
}
/// <summary>
/// Create a snapshot for the specified ICloudBlob object
/// </summary>
/// <param name="blob">ICloudBlob object</param>
public StorageBlob.ICloudBlob SnapShot(StorageBlob.ICloudBlob blob)
{
StorageBlob.ICloudBlob snapshot = default(StorageBlob.ICloudBlob);
switch (blob.BlobType)
{
case StorageBlob.BlobType.BlockBlob:
snapshot = ((StorageBlob.CloudBlockBlob)blob).CreateSnapshot();
break;
case StorageBlob.BlobType.PageBlob:
snapshot = ((StorageBlob.CloudPageBlob)blob).CreateSnapshot();
break;
default:
throw new ArgumentException(string.Format("Unsupport blob type {0} when create snapshot", blob.BlobType));
}
Test.Info(string.Format("Create snapshot for '{0}' at {1}", blob.Name, snapshot.SnapshotTime));
return(snapshot);
}
public void SetBlobContentWithMetadata(StorageBlob.BlobType blobType)
{
string filePath = FileUtil.GenerateOneTempTestFile();
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer();
Hashtable metadata = new Hashtable();
int metaCount = GetRandomTestCount();
for (int i = 0; i < metaCount; i++)
{
string key = Utility.GenRandomAlphabetString();
string value = Utility.GenNameString(string.Empty);
if (!metadata.ContainsKey(key))
{
Test.Info(string.Format("Add meta key: {0} value : {1}", key, value));
metadata.Add(key, value);
}
}
try
{
Test.Assert(agent.SetAzureStorageBlobContent(filePath, container.Name, blobType, string.Empty, true, -1, null, metadata), "set blob content with meta should succeed");
StorageBlob.ICloudBlob blob = container.GetBlobReferenceFromServer(Path.GetFileName(filePath));
blob.FetchAttributes();
ExpectEqual(metadata.Count, blob.Metadata.Count, "meta data count");
foreach (string key in metadata.Keys)
{
ExpectEqual(metadata[key].ToString(), blob.Metadata[key], "Meta data key " + key);
}
}
finally
{
blobUtil.RemoveContainer(container.Name);
FileUtil.RemoveFile(filePath);
}
}
public void SetBlobContentForEixstsBlobWithoutForce()
{
string filePath = FileUtil.GenerateOneTempTestFile();
StorageBlob.CloudBlobContainer container = blobUtil.CreateContainer();
string blobName = Utility.GenNameString("blob");
StorageBlob.ICloudBlob blob = blobUtil.CreateRandomBlob(container, blobName);
try
{
string previousMd5 = blob.Properties.ContentMD5;
Test.Assert(!agent.SetAzureStorageBlobContent(filePath, container.Name, blob.BlobType, blob.Name, false), "set blob content without force parameter should fail");
ExpectedContainErrorMessage(ConfirmExceptionMessage);
blob.FetchAttributes();
ExpectEqual(previousMd5, blob.Properties.ContentMD5, "content md5");
}
finally
{
blobUtil.RemoveContainer(container.Name);
FileUtil.RemoveFile(filePath);
}
}
/// <summary>
/// generate random blob properties and metadata
/// </summary>
/// <param name="blob">ICloudBlob object</param>
private void GenerateBlobPropertiesAndMetaData(StorageBlob.ICloudBlob blob)
{
blob.Properties.ContentEncoding = Utility.GenNameString("encoding");
blob.Properties.ContentLanguage = Utility.GenNameString("lang");
int minMetaCount = 1;
int maxMetaCount = 5;
int minMetaValueLength = 10;
int maxMetaValueLength = 20;
int count = random.Next(minMetaCount, maxMetaCount);
for (int i = 0; i < count; i++)
{
string metaKey = Utility.GenNameString("metatest");
int valueLength = random.Next(minMetaValueLength, maxMetaValueLength);
string metaValue = Utility.GenNameString("metavalue-", valueLength);
blob.Metadata.Add(metaKey, metaValue);
}
blob.SetProperties();
blob.SetMetadata();
blob.FetchAttributes();
}
public void GetCopyStateWhenCopyingTest()
{
StorageBlob.CloudBlobContainer Container = blobUtil.CreateContainer();
string ContainerName = Container.Name;
string BlobName = Utility.GenNameString("blockblob");
StorageBlob.ICloudBlob Blob = blobUtil.CreateBlockBlob(Container, BlobName);
string uri = Test.Data.Get("BigFileUri");
Test.Assert(!String.IsNullOrEmpty(uri), string.Format("Big file uri should be not empty, actually it's {0}", uri));
if (String.IsNullOrEmpty(uri))
{
return;
}
Blob.StartCopyFromBlob(new Uri(uri));
int maxMonitorTime = 30; //seconds
int checkCount = 0;
int sleepInterval = 1000; //ms
StorageBlob.CopyStatus status = StorageBlob.CopyStatus.Pending;
try
{
int expectedCopyStateCount = 1;
do
{
Test.Info(String.Format("{0}th check current copy state", checkCount));
Test.Assert(agent.GetAzureStorageBlobCopyState(ContainerName, BlobName, false), "Get copy state in dest container should be successed.");
Test.Assert(agent.Output.Count == expectedCopyStateCount, String.Format("Should contain {0} copy state, and actually it's {1}", expectedCopyStateCount, agent.Output.Count));
status = (StorageBlob.CopyStatus)agent.Output[0]["Status"];
Test.Assert(status == StorageBlob.CopyStatus.Pending, String.Format("Copy status should be Pending, actually it's {0}", status));
checkCount++;
Thread.Sleep(sleepInterval);
}while (status == StorageBlob.CopyStatus.Pending && checkCount < maxMonitorTime);
Test.Info("Finish the monitor loop and try to abort copy");
try
{
Blob.AbortCopy(Blob.CopyState.CopyId);
}
catch (StorageException e)
{
//TODO use extension method
if (e.RequestInformation != null && e.RequestInformation.HttpStatusCode == 409)
{
Test.Info("Skip 409 abort conflict exception. Error:{0}", e.Message);
Test.Info("Detail Error Message: {0}", e.RequestInformation.HttpStatusMessage);
}
else
{
Test.AssertFail(String.Format("Can't abort copy. Error: {0}", e.Message));
}
}
Test.Assert(agent.GetAzureStorageBlobCopyState(ContainerName, BlobName, false), "Get copy state in dest container should be successed.");
Test.Assert(agent.Output.Count == expectedCopyStateCount, String.Format("Should contain {0} copy state, and actually it's {1}", expectedCopyStateCount, agent.Output.Count));
status = (StorageBlob.CopyStatus)agent.Output[0]["Status"];
Test.Assert(status == StorageBlob.CopyStatus.Aborted, String.Format("Copy status should be Aborted, actually it's {0}", status));
}
finally
{
blobUtil.RemoveContainer(Container.Name);
}
}