public void GetBlobCopyStateTest()
{
CloudBlobUtil blobUtil = new CloudBlobUtil(CommonStorageAccount);
blobUtil.SetupTestContainerAndBlob();
ICloudBlob destBlob = CopyBlobAndWaitForComplete(blobUtil);
try
{
Test.Assert(destBlob.CopyState.Status == 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));
CopyStatus copyStatus = (CopyStatus)agent.Output[0]["Status"];
Test.Assert(copyStatus == 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>
/// Creates a new PathProperties instance for mocking.
/// </summary>
public static PathProperties PathProperties(
DateTimeOffset lastModified,
DateTimeOffset creationTime,
IDictionary <string, string> metadata,
DateTimeOffset copyCompletionTime,
string copyStatusDescription,
string copyId,
string copyProgress,
Uri copySource,
CopyStatus copyStatus,
bool isIncrementalCopy,
DataLakeLeaseDuration leaseDuration,
DataLakeLeaseState leaseState,
DataLakeLeaseStatus leaseStatus,
long contentLength,
string contentType,
ETag eTag,
byte[] contentHash,
string contentEncoding,
string contentDisposition,
string contentLanguage,
string cacheControl,
string acceptRanges,
bool isServerEncrypted,
string encryptionKeySha256,
string accessTier,
string archiveStatus,
DateTimeOffset accessTierChangeTime,
bool isDirectory)
=> new PathProperties()
{
LastModified = lastModified,
CreatedOn = creationTime,
Metadata = metadata,
CopyCompletedOn = copyCompletionTime,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
IsIncrementalCopy = isIncrementalCopy,
LeaseDuration = leaseDuration,
LeaseState = leaseState,
LeaseStatus = leaseStatus,
ContentLength = contentLength,
ContentType = contentType,
ETag = eTag,
ContentHash = contentHash,
ContentEncoding = contentEncoding,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
CacheControl = cacheControl,
AcceptRanges = acceptRanges,
IsServerEncrypted = isServerEncrypted,
EncryptionKeySha256 = encryptionKeySha256,
AccessTier = accessTier,
ArchiveStatus = archiveStatus,
AccessTierChangedOn = accessTierChangeTime,
IsDirectory = isDirectory
};
private void Button_Click(object sender, RoutedEventArgs e)
{
CopyData s = new CopyData(this, false);
CopyStatus status = s.SendMessage("Test message 1234567890 1234567890 1234567890 1234567890", "Test Receiver");
status = s.SendMessage("Test message A", "SpeechCristi");
}
/// <summary>
/// Creates a new BlobDownloadDetails instance for mocking.
/// </summary>
public static BlobDownloadDetails BlobDownloadDetails(
DateTimeOffset lastModified,
IDictionary <string, string> metadata,
string contentRange,
string contentEncoding,
string cacheControl,
string contentDisposition,
string contentLanguage,
long blobSequenceNumber,
DateTimeOffset copyCompletedOn,
string copyStatusDescription,
string copyId,
string copyProgress,
Uri copySource,
CopyStatus copyStatus,
LeaseDurationType leaseDuration,
LeaseState leaseState,
LeaseStatus leaseStatus,
string acceptRanges,
int blobCommittedBlockCount,
bool isServerEncrypted,
string encryptionKeySha256,
string encryptionScope,
byte[] blobContentHash,
long tagCount,
string versionId,
bool isSealed,
IList <ObjectReplicationPolicy> objectReplicationSourceProperties,
string objectReplicationDestinationPolicy)
=> new BlobDownloadDetails
{
LastModified = lastModified,
Metadata = metadata,
ContentRange = contentRange,
ContentEncoding = contentEncoding,
CacheControl = cacheControl,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
BlobSequenceNumber = blobSequenceNumber,
CopyCompletedOn = copyCompletedOn,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
LeaseDuration = leaseDuration,
LeaseState = leaseState,
LeaseStatus = leaseStatus,
AcceptRanges = acceptRanges,
BlobCommittedBlockCount = blobCommittedBlockCount,
IsServerEncrypted = isServerEncrypted,
EncryptionKeySha256 = encryptionKeySha256,
EncryptionScope = encryptionScope,
BlobContentHash = blobContentHash,
TagCount = tagCount,
VersionId = versionId,
IsSealed = isSealed,
ObjectReplicationSourceProperties = objectReplicationSourceProperties,
ObjectReplicationDestinationPolicyId = objectReplicationDestinationPolicy
};
static public CopyStatus MonitorBlobContainer(CloudBlobContainer destinationBlobContainer)
{
string blobPrefix = null;
bool useFlatBlobListing = true;
var destBlobList = destinationBlobContainer.ListBlobs(blobPrefix, useFlatBlobListing, BlobListingDetails.Copy);
CopyStatus copyStatus = CopyStatus.Success;
foreach (var dest in destBlobList)
{
var destBlob = dest as CloudBlob;
if (destBlob.CopyState.Status == CopyStatus.Aborted || destBlob.CopyState.Status == CopyStatus.Failed)
{
// Log the copy status description for diagnostics and restart copy
destBlob.StartCopyAsync(destBlob.CopyState.Source);
copyStatus = CopyStatus.Pending;
}
else if (destBlob.CopyState.Status == CopyStatus.Pending)
{
// We need to continue waiting for this pending copy
// However, let us log copy state for diagnostics
copyStatus = CopyStatus.Pending;
}
// else we completed this pending copy
}
return(copyStatus);
}
protected override bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus)
{
bool flag = false;
string text = null;
CopyStatus copyStatus2 = CopyStatus.Unknown;
if (copyStatus.CopyStatus == CopyStatusEnum.Suspended)
{
copyStatus2 = CopyStatus.Suspended;
text = copyStatus.SuspendComment;
flag = true;
}
else if (copyStatus.CopyStatus == CopyStatusEnum.FailedAndSuspended)
{
copyStatus2 = CopyStatus.FailedAndSuspended;
text = copyStatus.ErrorMessage;
flag = true;
}
if (flag)
{
text = ((!string.IsNullOrEmpty(text)) ? text : Strings.ReplicationCheckBlankMessage);
base.FailContinue(Strings.DatabaseCopySuspendedCheck(new LocalizedReplayConfigType(configToCheck.Type).ToString(), configToCheck.DisplayName, copyStatus2.ToString(), base.ServerName, text));
return(false);
}
return(true);
}
private void SetDestCopyStatus(CopyStatus copyStatus)
{
// We have to use reflection because the setter is not public.
typeof(CopyState)
.GetProperty(nameof(CopyState.Status))
.SetValue(_destCopyState, copyStatus, null);
}
private static void clc_bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
CopyStatus cp = (CopyStatus)e.UserState;
String leftstr = friendlyBytes(cp.BytesThisFile) + "/" + friendlyBytes(cp.SizeThisFile);
ProgressUpdate(cp.FileName, leftstr);
}
/*
* // incomplete function
* static bool createXISO(string infolder, string outfile)
* {
* XBoxISO.ISOWriter xiso = new ISOWriter();
* xiso.IsXbox360Iso = false;
* xiso.SetFileSource();
* return true;
* }
*/
static void convertISO(string infile, string outfile)
{
XboxISOFileSource xisosrc = new XboxISOFileSource(infile);
if (xisosrc.GetISOType() != Format.Xbox1)
{
Console.Write("This utility only supports ORIGINAL XBox ISOs");
return;
}
ISOWriter xiso = new ISOWriter();
FileSystemEntry xfs = xisosrc.GetFileSystem();
List <FileSystemEntry> fslist = xfs.GetFileList();
FSManipulator xfsm = new FSManipulator();
FSFileOptimiseComparer xiso_sort = new FSFileOptimiseComparer();
XBoxISO.CrossLinkChecker clc = new CrossLinkChecker();
CopyStatus cs = new CopyStatus();
bool result = false;
ISOPartitionDetails isop = xisosrc.GetPartitionDetails();
Console.Write("Optimizing XISO Filesystem Layout...");
if ((long)isop.GamePartitionSize > XBoxDVDReader.DVD5MaxSize)
{
result = xfsm.OptimiseDVD9(xfs, false, true, true, isop);
}
else
{
result = xfsm.OptimiseDVD5(xfs, false, false, true, true, false, 0, false, isop);
}
if (result)
{
Console.WriteLine(" Success.");
}
else
{
Console.WriteLine(" Failed... but thats okay, continuing.");
}
Console.WriteLine("Checking for crosslinkable files...");
BackgroundWorker clc_bw = new BackgroundWorker();
clc_bw.WorkerReportsProgress = true;
clc_bw.WorkerSupportsCancellation = true;
clc_bw.ProgressChanged += clc_bw_ProgressChanged;
clc.CrossLinkCheck(xfs, cs, clc_bw);
Console.WriteLine();
Console.WriteLine("Writing ISO to " + outfile + "...");
BackgroundWorker main_bw = new BackgroundWorker();
main_bw.WorkerReportsProgress = true;
main_bw.WorkerSupportsCancellation = true;
main_bw.ProgressChanged += main_bw_ProgressChanged;
xiso.writeISO(outfile, xfs, main_bw, false);
Console.WriteLine();
Console.WriteLine("Done!");
}
public static List <string> ListBlobsInContainer(string containerUrl, CopyStatus copyStatusFilter)
{
var blobList = ListBlobsInContainer(containerUrl);
var filteredBlobList = (from b in blobList where (((ICloudBlob)b).CopyState != null) && (((ICloudBlob)b).CopyState.Status == copyStatusFilter) select b.Uri.AbsolutePath).ToList <string>();
return(filteredBlobList);
}
private static void main_bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
CopyStatus cp = (CopyStatus)e.UserState;
String leftstr = friendlyBytes(cp.BytesThisFile) + "/" + friendlyBytes(cp.SizeThisFile);
String rightstr = "Total: " + friendlyBytes(cp.TotalBytesWritten) + "/" + friendlyBytes(cp.TotalSizeToWrite);
ProgressUpdate("Writing " + cp.FileName, leftstr, rightstr);
}
/// <summary>
/// Creates a new StorageFileProperties instance for mocking.
/// </summary>
public static ShareFileProperties StorageFileProperties(
DateTimeOffset lastModified,
IDictionary <string, string> metadata,
long contentLength,
string contentType,
ETag eTag,
byte[] contentHash,
IEnumerable <string> contentEncoding,
string cacheControl,
string contentDisposition,
IEnumerable <string> contentLanguage,
DateTimeOffset copyCompletedOn,
string copyStatusDescription,
string copyId,
string copyProgress,
string copySource,
CopyStatus copyStatus,
bool isServerEncrypted,
#pragma warning disable CA1801 // Review unused parameters
string fileAttributes,
DateTimeOffset fileCreationTime,
DateTimeOffset fileLastWriteTime,
DateTimeOffset fileChangeTime,
string filePermissionKey,
string fileId,
string fileParentId
#pragma warning restore CA1801 // Review unused parameters
) => new ShareFileProperties
{
LastModified = lastModified,
Metadata = metadata,
ContentLength = contentLength,
ContentType = contentType,
ETag = eTag,
ContentHash = contentHash,
ContentEncoding = contentEncoding,
CacheControl = cacheControl,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
CopyCompletedOn = copyCompletedOn,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
IsServerEncrypted = isServerEncrypted,
SmbProperties = new FileSmbProperties
{
FileAttributes = ShareExtensions.ToFileAttributes(fileAttributes),
FilePermissionKey = filePermissionKey,
FileCreatedOn = fileCreationTime,
FileLastWrittenOn = fileLastWriteTime,
FileChangedOn = fileChangeTime,
FileId = fileId,
ParentId = fileParentId
}
};
//TODO: Move to utilities
/// <summary>
/// Synchronous rename of the specified blob to a new name, within the same container.
/// </summary>
/// <remarks>
/// Note that Azure blobs do not really have a rename operation so the
/// implemenation has to be to copy the blob and then delete the original.
/// </remarks>
/// <param name="container">The container of the target and destination</param>
/// <param name="sourcePath">The portion of the blob name within the container.
/// e.g. /Incoming/fred.mp4</param>
/// <param name="targetPath">The path portion of the target blob within the container.
/// e.g., /Processing/fred.mp4</param>
/// <returns>true if the operation succeeds.</returns>
public static bool RenameBlobWithinContainer(CloudBlobContainer container, string sourcePath, string targetPath)
{
// Handle the simple version of delete as just a one-element list.
var srcList = new List <string>(1)
{
sourcePath
};
var targetList = new List <string>(1)
{
targetPath
};
return(RenameBlobsWithinContainer(container, srcList, targetList));
#if NO
// CloudBlobContainer container = blobClient.GetContainerReference(blobContainer);
//TODO: block is okay since WAMS only supports block
CloudBlockBlob newBlob = container.GetBlockBlobReference(targetPath);
CloudBlockBlob sourceBlob = container.GetBlockBlobReference(sourcePath);
string monitorStr = null;
try
{
monitorStr = newBlob.StartCopyFromBlob(sourceBlob);
}
catch (Exception ex)
{
var e = ex; // to avoid compiler warning
throw;
}
CopyStatus cs = CopyStatus.Pending;
while (cs == CopyStatus.Pending)
{
Thread.Sleep(2000); // sleep for 2 seconds
cs = newBlob.CopyState.Status;
}
if (cs == CopyStatus.Success)
{
try
{
Trace.TraceInformation("Deleting source blob: {0}", sourceBlob.Name);
sourceBlob.DeleteIfExists();
}
catch (Exception e)
{
Trace.TraceInformation("Delete failed for {1}, msg = '{0}'", e.Message, sourceBlob.Name);
// and continue.
}
//TODO: actually delete the source
// sourceBlob.DeleteIfExists();
}
return(true);
#endif
}
public void ParseHeaders(System.Net.HttpWebResponse response)
{
//TODO: determine what we want to do about potential missing headers and date parsing errors
ETag = response.Headers[ProtocolConstants.Headers.ETag].Trim('"');
Date = Parsers.ParseDateHeader(response.Headers[ProtocolConstants.Headers.OperationDate]);
LastModified = Parsers.ParseDateHeader(response.Headers[ProtocolConstants.Headers.LastModified]);
CopyId = response.Headers[ProtocolConstants.Headers.CopyId];
CopyStatus = Parsers.ParseCopyStatus(response.Headers[ProtocolConstants.Headers.CopyStatus]);
}
/// <summary>
/// Creates a new StorageFileProperties instance for mocking.
/// </summary>
public static StorageFileProperties StorageFileProperties(
DateTimeOffset lastModified,
IDictionary <string, string> metadata,
Header fileType,
long contentLength,
string contentType,
ETag eTag,
byte[] contentHash,
IEnumerable <string> contentEncoding,
string cacheControl,
string contentDisposition,
IEnumerable <string> contentLanguage,
DateTimeOffset copyCompletionTime,
string copyStatusDescription,
string copyId,
string copyProgress,
string copySource,
CopyStatus copyStatus,
bool isServerEncrypted,
string fileAttributes,
DateTimeOffset fileCreationTime,
DateTimeOffset fileLastWriteTime,
DateTimeOffset fileChangeTime,
string filePermissionKey,
string fileId,
string fileParentId
) => new StorageFileProperties(new RawStorageFileProperties()
{
LastModified = lastModified,
Metadata = metadata,
FileType = fileType,
ContentLength = contentLength,
ContentType = contentType,
ETag = eTag,
ContentHash = contentHash,
ContentEncoding = contentEncoding,
CacheControl = cacheControl,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
CopyCompletionTime = copyCompletionTime,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
IsServerEncrypted = isServerEncrypted,
FileAttributes = fileAttributes,
FilePermissionKey = filePermissionKey,
FileCreationTime = fileCreationTime,
FileLastWriteTime = fileLastWriteTime,
FileChangeTime = fileChangeTime,
FileId = fileId,
FileParentId = fileParentId
});
public void CopyFile()
{
try
{
File.Copy(sourceFilePath, destinationFilePath, true);
Status = CopyStatus.Success;
}
catch
{
Status = CopyStatus.Failed;
}
}
/// <summary>
/// Copy all account members of one or more statuses into a group.
/// </summary>
/// <param name="groupId">Group identifier.</param>
/// <param name="status">Class representing a list of Member statuses: ‘a’ (active), ‘o’ (optout), and/or ‘e’ (error).</param>
/// <returns>True</returns>
/// <remarks>Http404 if the group does not exist.</remarks>
public bool CopyMembersIntoStatusGroup(string groupId, CopyStatus status)
{
var request = new RestRequest(Method.PUT);
request.Resource = "/{accountId}/members/{groupId}/copy";
request.AddUrlSegment("groupId", groupId);
request.RequestFormat = DataFormat.Json;
request.JsonSerializer = new EmmaJsonSerializer();
request.AddBody(status);
return Execute<bool>(request);
}
public static BlobCopyInfo BlobCopyInfo(
ETag eTag,
DateTimeOffset lastModified,
string copyId,
CopyStatus copyStatus)
=> new BlobCopyInfo()
{
ETag = eTag,
LastModified = lastModified,
CopyId = copyId,
CopyStatus = copyStatus,
};
public void Perform()
{
try
{
File.Copy(Source, Destination, true);
Console.WriteLine($"Скопировано из {Source} в {Destination}");
Status = CopyStatus.Successful;
}
catch (Exception exception)
{
Status = CopyStatus.Error;
Console.WriteLine(exception.Message);
}
}
public void Perform()
{
try
{
File.Copy(Src, Dest, true);
Console.WriteLine("- Copied file from " + Src + " to " + Dest);
Status = CopyStatus.Successful;
}
catch (Exception exception)
{
Console.WriteLine("- " + exception.Message);
Status = CopyStatus.Error;
}
}
/// <summary>
/// Creates a new ShareFileCopyInfo instance for mocking.
/// </summary>
public static ShareFileCopyInfo ShareFileCopyInfo(
ETag eTag,
DateTimeOffset lastModified,
string copyId,
CopyStatus copyStatus)
{
return(new ShareFileCopyInfo()
{
ETag = eTag,
LastModified = lastModified,
CopyId = copyId,
CopyStatus = copyStatus,
});
}
private void AssertFinishedCopyState(Uri SourceUri, int startIndex = 0)
{
string expectedSourceUri = CloudBlobUtil.ConvertCopySourceUri(SourceUri.ToString());
Test.Assert(agent.Output.Count > startIndex, String.Format("Should contain the great than {0} copy state, and actually it's {1}", startIndex, agent.Output.Count));
string sourceUri = ((Uri)agent.Output[startIndex]["Source"]).ToString();
Test.Assert(sourceUri.StartsWith(expectedSourceUri), String.Format("source uri should start with {0}, and actualy it's {1}", expectedSourceUri, sourceUri));
CopyStatus status = (CopyStatus)agent.Output[startIndex]["Status"];
Test.Assert(status != CopyStatus.Pending, String.Format("Copy status should not be Pending, actually it's {0}", status));
string copyId = (string)agent.Output[startIndex]["CopyId"];
Test.Assert(!String.IsNullOrEmpty(copyId), "Copy ID should be not empty");
}
/// <summary>
/// Creates a new FileDownloadDetails instance for mocking.
/// </summary>
public static FileDownloadDetails FileDownloadDetails(
DateTimeOffset lastModified,
IDictionary <string, string> metadata,
string contentRange,
ETag eTag,
string contentEncoding,
string cacheControl,
string contentDisposition,
string contentLanguage,
DateTimeOffset copyCompletionTime,
string copyStatusDescription,
string copyId,
string copyProgress,
Uri copySource,
CopyStatus copyStatus,
LeaseDurationType leaseDuration,
LeaseState leaseState,
LeaseStatus leaseStatus,
string acceptRanges,
bool isServerEncrypted,
string encryptionKeySha256,
byte[] contentHash)
=> new FileDownloadDetails()
{
LastModified = lastModified,
Metadata = metadata,
ContentRange = contentRange,
ETag = eTag,
ContentEncoding = contentEncoding,
CacheControl = cacheControl,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
CopyCompletedOn = copyCompletionTime,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
LeaseDuration = leaseDuration,
LeaseState = leaseState,
LeaseStatus = leaseStatus,
AcceptRanges = acceptRanges,
IsServerEncrypted = isServerEncrypted,
EncryptionKeySha256 = encryptionKeySha256,
ContentHash = contentHash
};
public async Task ReturnsErrorIfNotAllowedForLoan(CopyStatus status, string errorMessage)
{
// Arrange
_context.Setup(x => x.CreateUnitOfWork()).Returns(_uow.Object);
_loanHelper.Setup(x => x.IsLoanerCardActive(It.IsAny <int>())).Returns(true);
_fakeCopy.Status = status;
_copyRepo.Setup(x => x.GetByBarcode(It.IsAny <int>())).Returns(_fakeCopy);
var sut = new CreateLoanHandler(_context.Object, _loanRepo.Object, _loanHelper.Object, _copyRepo.Object);
// Act
var response = await sut.Handle(_command, default);
// Assert
Assert.Equal(errorMessage, response.ErrorMessage);
}
/// <summary>
/// Creates a new StorageFileDownloadProperties instance for mocking.
/// </summary>
public static StorageFileDownloadDetails StorageFileDownloadProperties(
DateTimeOffset lastModified,
IDictionary <string, string> metadata,
string contentType,
string contentRange,
ETag eTag,
IEnumerable <string> contentEncoding,
string cacheControl,
string contentDisposition,
IEnumerable <string> contentLanguage,
string acceptRanges,
DateTimeOffset copyCompletedOn,
string copyStatusDescription,
string copyId,
string copyProgress,
Uri copySource,
CopyStatus copyStatus,
byte[] fileContentHash,
bool isServiceEncrypted)
{
var flattened = new FlattenedStorageFileProperties()
{
LastModified = lastModified,
Metadata = metadata,
ContentType = contentType,
ContentRange = contentRange,
ETag = eTag,
ContentEncoding = contentEncoding,
CacheControl = cacheControl,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
AcceptRanges = acceptRanges,
CopyCompletionTime = copyCompletedOn,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
FileContentHash = fileContentHash,
IsServerEncrypted = isServiceEncrypted
};
return(new StorageFileDownloadDetails(flattened));
}
/// <summary>
/// Update failed/finished task count
/// </summary>
/// <param name="status">Copy status</param>
private void UpdateTaskCount(CopyStatus status)
{
switch (status)
{
case CopyStatus.Invalid:
case CopyStatus.Failed:
case CopyStatus.Aborted:
failed++;
break;
case CopyStatus.Pending:
break;
case CopyStatus.Success:
default:
finished++;
break;
}
}
/// <summary>
/// Creates a new StorageFileDownloadProperties instance for mocking.
/// </summary>
public static ShareFileDownloadDetails StorageFileDownloadProperties(
DateTimeOffset lastModified,
IDictionary <string, string> metadata,
#pragma warning disable CA1801 // Review unused parameters
string contentType,
#pragma warning restore CA1801 // Review unused parameters
string contentRange,
ETag eTag,
IEnumerable <string> contentEncoding,
string cacheControl,
string contentDisposition,
IEnumerable <string> contentLanguage,
string acceptRanges,
DateTimeOffset copyCompletedOn,
string copyStatusDescription,
string copyId,
string copyProgress,
Uri copySource,
CopyStatus copyStatus,
byte[] fileContentHash,
bool isServiceEncrypted)
{
return(new ShareFileDownloadDetails
{
LastModified = lastModified,
Metadata = metadata,
ContentRange = contentRange,
ETag = eTag,
ContentEncoding = contentEncoding,
CacheControl = cacheControl,
ContentDisposition = contentDisposition,
ContentLanguage = contentLanguage,
AcceptRanges = acceptRanges,
CopyCompletedOn = copyCompletedOn,
CopyStatusDescription = copyStatusDescription,
CopyId = copyId,
CopyProgress = copyProgress,
CopySource = copySource,
CopyStatus = copyStatus,
FileContentHash = fileContentHash,
IsServerEncrypted = isServiceEncrypted
});
}
/// <summary>
/// Update failed/finished task count
/// </summary>
/// <param name="status">Copy status</param>
private void UpdateTaskCount(CopyStatus status)
{
switch (status)
{
case CopyStatus.Invalid:
case CopyStatus.Failed:
case CopyStatus.Aborted:
Interlocked.Increment(ref InternalFailedCount);
break;
case CopyStatus.Pending:
break;
case CopyStatus.Success:
default:
Interlocked.Increment(ref InternalFinishedCount);
break;
}
}
//TODO: Move to utilities
/// <summary>
/// Synchronous rename of the specified blob to a new name, within the same container.
/// </summary>
/// <remarks>
/// Note that Azure blobs do not really have a rename operation so the
/// implemenation has to be to copy the blob and then delete the original.
/// </remarks>
/// <param name="container">The container of the target and destination</param>
/// <param name="sourcePath">The portion of the blob name within the container.
/// e.g. /Incoming/fred.mp4</param>
/// <param name="targetPath">The path portion of the target blob within the container.
/// e.g., /Processing/fred.mp4</param>
/// <returns>true if the operation succeeds.</returns>
public static bool RenameBlobWithinContainer(CloudBlobContainer container, string sourcePath, string targetPath)
{
CloudBlockBlob newBlob = container.GetBlockBlobReference(targetPath);
CloudBlockBlob sourceBlob = container.GetBlockBlobReference(sourcePath);
var monitorStr = newBlob.StartCopy(sourceBlob);
CopyStatus cs = CopyStatus.Pending;
while (cs == CopyStatus.Pending)
{
Thread.Sleep(2000); // sleep for 2 seconds
cs = newBlob.CopyState.Status;
}
if (cs == CopyStatus.Success)
{
sourceBlob.DeleteIfExists();
}
return(true);
}
//TODO: Move to utilities
/// <summary>
/// Synchronous rename of the specified blob to a new name, within the same container.
/// </summary>
/// <remarks>
/// Note that Azure blobs do not really have a rename operation so the
/// implemenation has to be to copy the blob and then delete the original.
/// </remarks>
/// <param name="container">The container of the target and destination</param>
/// <param name="sourcePath">The portion of the blob name within the container.
/// e.g. /Incoming/fred.mp4</param>
/// <param name="targetPath">The path portion of the target blob within the container.
/// e.g., /Processing/fred.mp4</param>
/// <returns>true if the operation succeeds.</returns>
public static bool RenameBlobWithinContainer(CloudBlobContainer container, string sourcePath, string targetPath)
{
// CloudBlobContainer container = blobClient.GetContainerReference(blobContainer);
//TODO: block is okay since WAMS only supports block
CloudBlockBlob newBlob = container.GetBlockBlobReference(targetPath);
CloudBlockBlob sourceBlob = container.GetBlockBlobReference(sourcePath);
var monitorStr = newBlob.StartCopyFromBlob(sourceBlob);
CopyStatus cs = CopyStatus.Pending;
while (cs == CopyStatus.Pending)
{
Thread.Sleep(2000); // sleep for 2 seconds
cs = newBlob.CopyState.Status;
}
if (cs == CopyStatus.Success)
{
sourceBlob.DeleteIfExists();
}
return(true);
}
/// <summary>
/// Update failed/finished task count
/// </summary>
/// <param name="status">Copy status</param>
private void UpdateTaskCount(CopyStatus status)
{
switch (status)
{
case CopyStatus.Invalid:
case CopyStatus.Failed:
case CopyStatus.Aborted:
failed++;
break;
case CopyStatus.Pending:
break;
case CopyStatus.Success:
default:
finished++;
break;
}
}
//TODO: Move to utilities
/// <summary>
/// Synchronous rename of the specified blobs, each to a new name, within the same container.
/// </summary>
/// <remarks>
/// Note that Azure blobs do not really have a rename operation so the
/// implemenation has to be to copy the blob and then delete the original.
/// </remarks>
/// <param name="container">The container of the target and destination</param>
/// <param name="sourcePath">A list containing the portion of the blob name within the container.
/// e.g. /Incoming/fred.mp4</param>
/// <param name="targetPath">A list containing the path portion of the target blob within the container.
/// e.g., /Processing/fred.mp4</param>
/// <returns>true if the operation succeeds</returns>
public static bool RenameBlobsWithinContainer(CloudBlobContainer container, IList<string> sourcePath, IList<string> targetPath)
{
// CloudBlobContainer container = blobClient.GetContainerReference(blobContainer);
//TODO: block is okay since WAMS only supports block
System.Diagnostics.Debug.Assert(sourcePath.Count == targetPath.Count);
int count = sourcePath.Count;
var sourceList = new List<CloudBlockBlob>(count);
var monitorList = new List<CloudBlockBlob>(count);
var doneList = new CopyStatus[count];
// Start the list of blobs copying
for (int i = 0; i < sourcePath.Count; i++)
{
CloudBlockBlob newBlob = container.GetBlockBlobReference(targetPath[i]);
CloudBlockBlob sourceBlob = container.GetBlockBlobReference(sourcePath[i]);
string monitorStr = null;
try
{
monitorStr = newBlob.StartCopyFromBlob(sourceBlob);
monitorList.Add(newBlob);
sourceList.Add(sourceBlob);
doneList[i] = CopyStatus.Pending;
}
catch (Exception ex)
{
var e = ex; // to avoid compiler warning
throw;
}
}
// now monitor for completion
//JPGG: change becouse is not deleting the original File
//bool CopiesCompleted = true;
bool CopiesCompleted = false;
while (!CopiesCompleted)
{
Thread.Sleep(2000); // sleep for 2 seconds
CopiesCompleted = true;
// recheck latest status for any not previously complete
for (int i = 0; i < doneList.Length; i++)
{
if (doneList[i] == CopyStatus.Pending)
{ // check latest status
doneList[i] = monitorList[i].CopyState.Status;
if (doneList[i] == CopyStatus.Pending)
{
CopiesCompleted = false;
}
}
}
}
// so no copying operation remains in Pending state
// if all were successful, return true, else false
bool AllSuccessful = true;
foreach(var cs in doneList) {
if (cs != CopyStatus.Success) {
AllSuccessful = false;
break;
}
}
// Delete all of the source blobs if the copies worked.
if (AllSuccessful) {
foreach(var blob in sourceList) {
try
{
Trace.TraceInformation("Deleting source blob: {0}", blob.Name);
blob.DeleteIfExists();
}
catch (Exception e)
{
Trace.TraceInformation("Delete failed for {1}, msg = '{0}'", e.Message, blob.Name);
// and continue.
}
}
}
return AllSuccessful;
}
public static List<string> ListBlobsInContainer(string containerUrl, CopyStatus copyStatusFilter)
{
var blobList = ListBlobsInContainer(containerUrl);
var filteredBlobList = (from b in blobList where (((ICloudBlob)b).CopyState != null) && (((ICloudBlob)b).CopyState.Status == copyStatusFilter) select b.Uri.AbsolutePath).ToList<string>();
return filteredBlobList;
}
public StandaloneAzureCopyState(CopyStatus copyStatus)
{
_copyStatus = copyStatus;
}
public void ParseCopyStatus_GivenCorrectStatus_ParsesCorrectly(string rawStatus, CopyStatus expectedParsedStatus)
{
var parsed = Parsers.ParseCopyStatus(rawStatus);
Assert.AreEqual(parsed, expectedParsedStatus);
}
/// <summary>
/// Update failed/finished task count
/// </summary>
/// <param name="status">Copy status</param>
private void UpdateTaskCount(CopyStatus status)
{
switch (status)
{
case CopyStatus.Invalid:
case CopyStatus.Failed:
case CopyStatus.Aborted:
Interlocked.Increment(ref InternalFailedCount);
break;
case CopyStatus.Pending:
break;
case CopyStatus.Success:
default:
Interlocked.Increment(ref InternalFinishedCount);
break;
}
}
public StandaloneAzureCopyState(CopyStatus copyStatus, string statusDescription)
{
_copyStatus = copyStatus;
_statusDescription = statusDescription;
}
