public NameHandler(State s)
{
logger = Log.ForContext <NameHandler>();
variables = s.Variables;
functions = s.Functions;
namespaces = s.Namespaces;
}
public static UriBuilder GetRedirectUriBuilder(string method,
string scheme,
CloudStorageAccount account,
string containerName,
string blobName,
bool useSas,
string queryString,
bool decodeQueryParams = true)
{
CloudBlobContainer container = NamespaceHandler.GetContainerByName(account, containerName);
// Strip any existing SAS query params as we'll replace them with our own SAS calculation
var queryParams = RequestQueryParameters.Create(queryString, decodeQueryParams);
SharedAccessSignature.RemoveSasQueryParameters(queryParams);
if (useSas)
{
// Be careful to preserve the URL encoding in the signature
queryParams.Append(CalculateSASStringForContainer(method, container), false);
}
return(new UriBuilder
{
Scheme = scheme,
Host = account.BlobEndpoint.Host,
Path = PathUtils.CombineContainerAndBlob(containerName, PathUtils.PathEncode(blobName)),
Query = queryParams.ToString(),
});
}
/// <summary>
/// Generic function to redirect a put request for properties of a blob
/// </summary>
public static async Task <HandlerResult> BasicBlobAsync(IHttpRequestWrapper requestWrapper, string container, string blob, bool servePrimaryOnly, bool operationCanReplicateBlob)
{
return(await WebOperationRunner.DoHandlerAsync("BlobHandler.BasicBlobAsync", async() =>
{
var namespaceBlob = await NamespaceHandler.FetchNamespaceBlobAsync(container, blob);
if (!await namespaceBlob.ExistsAsync())
{
return new HandlerResult
{
StatusCode = HttpStatusCode.NotFound,
};
}
string accountName = namespaceBlob.SelectDataAccount(servePrimaryOnly);
if (operationCanReplicateBlob)
{
if (namespaceBlob.IsReplicated ||
BlobReplicationHandler.ShouldReplicateBlob(requestWrapper.Headers, container, blob))
{
accountName = namespaceBlob.PrimaryAccountName;
await BlobReplicationHandler.EnqueueBlobReplicationAsync(namespaceBlob, false);
}
}
Uri redirect = ControllerOperations.GetRedirectUri(HttpContextFactory.Current.Request,
DashConfiguration.GetDataAccountByAccountName(accountName),
namespaceBlob.Container,
namespaceBlob.BlobName,
false);
return HandlerResult.Redirect(requestWrapper, redirect);
}));
}
public async Task <HttpResponseMessage> DeleteBlob(string container, string blob, string snapshot = null)
{
var requestWrapper = DashHttpRequestWrapper.Create(this.Request);
var headers = requestWrapper.Headers;
var queryParams = requestWrapper.QueryParameters;
bool dataBlobDeleted = false;
return(await DoHandlerAsync(String.Format("BlobController.DeleteBlob: {0}/{1}", container, blob),
async() => await NamespaceHandler.PerformNamespaceOperation(container, blob, async(namespaceBlob) =>
{
// We only need to delete the actual blob. We are leaving the namespace entry alone as a sort of cache.
if (!(await namespaceBlob.ExistsAsync()) || namespaceBlob.IsMarkedForDeletion)
{
return this.CreateResponse(HttpStatusCode.NotFound, headers);
}
// Delete the real data blob by forwarding the request onto the data account
if (!dataBlobDeleted)
{
var forwardedResponse = await ForwardRequestHandler(namespaceBlob, StorageOperationTypes.DeleteBlob);
if (!forwardedResponse.IsSuccessStatusCode)
{
return forwardedResponse;
}
dataBlobDeleted = true;
}
// See if we need to delete any replicas
if (namespaceBlob.IsReplicated)
{
await BlobReplicationHandler.EnqueueBlobReplicationAsync(namespaceBlob, true, false);
}
// Mark the namespace blob for deletion
await namespaceBlob.MarkForDeletionAsync();
return this.CreateResponse(HttpStatusCode.Accepted, headers);
})));
}
public async Task <HttpResponseMessage> PutContainerComp(string container, string comp)
{
return(await DoHandlerAsync(String.Format("ContainerController.PutContainerComp: {0}", comp), async() =>
{
CloudBlobContainer containerObj = NamespaceHandler.GetContainerByName(DashConfiguration.NamespaceAccount, container);
HttpResponseMessage errorResponse = await ValidatePreconditions(containerObj);
if (errorResponse != null)
{
return errorResponse;
}
switch (comp.ToLower())
{
case "lease":
return await SetContainerLease(containerObj);
case "metadata":
return await SetContainerMetadata(containerObj);
case "acl":
return await SetContainerAcl(containerObj);
default:
return new HttpResponseMessage(HttpStatusCode.BadRequest);
}
}));
}
static async Task <BlobContainerPublicAccessType> GetContainerPublicAccessAsync(string container)
{
// TODO: Plug this potential DoS vector - spurious anonymous requests could drown us here...
var containerObject = NamespaceHandler.GetContainerByName(DashConfiguration.NamespaceAccount, container);
var permissions = await containerObject.GetPermissionsAsync();
return(permissions.PublicAccess);
}
private async Task <HttpResponseMessage> PutBlobHandler(string container, string blob, IHttpRequestWrapper requestWrapper, StorageOperationTypes operation)
{
return(await DoHandlerAsync(String.Format("BlobController.PutBlobHandler: {0} {1}/{2}", operation, container, blob),
async() =>
{
var namespaceBlob = await NamespaceHandler.CreateNamespaceBlobAsync(container, blob);
if (BlobReplicationOperations.DoesOperationTriggerReplication(operation) &&
BlobReplicationHandler.ShouldReplicateBlob(requestWrapper.Headers, namespaceBlob))
{
await BlobReplicationHandler.EnqueueBlobReplicationAsync(namespaceBlob, false);
}
return await ForwardRequestHandler(namespaceBlob, operation);
}));
}
static void CleanupAbortedBlobReplication(ICloudBlob destBlob)
{
if (destBlob == null)
{
return;
}
NamespaceHandler.PerformNamespaceOperation(destBlob.Container.Name, destBlob.Name, async(namespaceBlob) =>
{
if (CleanupAbortedBlobReplication(namespaceBlob, destBlob))
{
await namespaceBlob.SaveAsync();
return(true);
}
return(false);
}).Wait();
}
void AssertReplicationWorker(string container, string blobName, string primaryAccount, bool isDeleteReplica)
{
// Wait for the messages to be fully enqueued
Task.Delay(1000).Wait();
int processed = 0, errors = 0;
MessageProcessor.ProcessMessageLoop(ref processed, ref errors, 0);
Assert.AreEqual(0, errors);
Assert.IsTrue(DashConfiguration.DataAccounts.Count - 1 <= processed);
foreach (var account in DashConfiguration.DataAccounts
.Where(dataAccount => !String.Equals(dataAccount.Credentials.AccountName, primaryAccount, StringComparison.OrdinalIgnoreCase)))
{
var dataBlob = NamespaceHandler.GetBlobByName(account, container, blobName);
Assert.AreEqual(!isDeleteReplica, dataBlob.Exists());
}
}
public static async Task <HandlerResult> AbortCopyBlobAsync(IHttpRequestWrapper requestWrapper, string destContainer, string destBlob, string copyId)
{
return(await WebOperationRunner.DoHandlerAsync("BlobHandler.AbortCopyBlobAsync", async() =>
{
var destNamespaceBlob = await NamespaceHandler.FetchNamespaceBlobAsync(destContainer, destBlob);
var destCloudBlob = NamespaceHandler.GetBlobByName(
DashConfiguration.GetDataAccountByAccountName(destNamespaceBlob.PrimaryAccountName),
destContainer,
destBlob);
await destCloudBlob.AbortCopyAsync(copyId);
return new HandlerResult
{
StatusCode = HttpStatusCode.NoContent,
};
}));
}
private static async Task <IEnumerable <IListBlobItem> > ChildBlobListAsync(CloudStorageAccount dataAccount,
string container, string prefix, string delimiter, string includeFlags)
{
CloudBlobContainer containerObj = NamespaceHandler.GetContainerByName(dataAccount, container);
if (!String.IsNullOrWhiteSpace(delimiter))
{
containerObj.ServiceClient.DefaultDelimiter = delimiter;
}
var results = new List <IEnumerable <IListBlobItem> >();
BlobListingDetails listDetails;
Enum.TryParse(includeFlags, true, out listDetails);
string nextMarker = null;
try
{
do
{
var continuationToken = new BlobContinuationToken
{
NextMarker = nextMarker,
};
var blobResults = await containerObj.ListBlobsSegmentedAsync(prefix, String.IsNullOrWhiteSpace(delimiter), listDetails, null, continuationToken, null, null);
results.Add(blobResults.Results);
if (blobResults.ContinuationToken != null)
{
nextMarker = blobResults.ContinuationToken.NextMarker;
}
else
{
nextMarker = null;
}
} while (!String.IsNullOrWhiteSpace(nextMarker));
}
catch (StorageException)
{
// Silently swallow the exception if we're missing the container for this account
}
return(results
.SelectMany(segmentResults => segmentResults));
}
static bool FinalizeBlobReplication(string dataAccount, string container, string blobName, bool deleteReplica, ICloudBlob destBlob = null)
{
return(NamespaceHandler.PerformNamespaceOperation(container, blobName, async(namespaceBlob) =>
{
bool exists = await namespaceBlob.ExistsAsync();
if (!exists || namespaceBlob.IsMarkedForDeletion)
{
// It's ok for a deleted replica not to have a corresponding namespace blob
if (!deleteReplica)
{
DashTrace.TraceWarning("Replication of blob [{0}] to account [{1}] cannot be completed because the namespace blob either does not exist or is marked for deletion.",
PathUtils.CombineContainerAndBlob(container, blobName),
dataAccount);
// Attempt to not leave the replica orphaned
if (CleanupAbortedBlobReplication(namespaceBlob, destBlob))
{
await namespaceBlob.SaveAsync();
}
}
// Do not attempt retry in this state
return true;
}
string message = "replicated to";
bool nsDirty = false;
if (deleteReplica)
{
nsDirty = namespaceBlob.RemoveDataAccount(dataAccount);
message = "dereplicated from";
}
else
{
nsDirty = namespaceBlob.AddDataAccount(dataAccount);
}
if (nsDirty)
{
await namespaceBlob.SaveAsync();
DashTrace.TraceInformation("Blob [{0}] has been successfully {1} account [{2}].",
PathUtils.CombineContainerAndBlob(container, blobName),
message,
dataAccount);
}
return true;
}).Result);
}
/// <summary>
/// Generic function to forward blob request. Target blob must already exist.
/// </summary>
private async Task <HttpResponseMessage> BasicBlobHandler(string container, string blob, IHttpRequestWrapper requestWrapper, StorageOperationTypes operation)
{
return(await DoHandlerAsync(String.Format("BlobController.BasicBlobHandler: {0} {1}/{2}", operation, container, blob),
async() =>
{
var namespaceBlob = await NamespaceHandler.FetchNamespaceBlobAsync(container, blob);
if (!await namespaceBlob.ExistsAsync())
{
return this.CreateResponse(HttpStatusCode.NotFound, (RequestHeaders)null);
}
if (BlobReplicationOperations.DoesOperationTriggerReplication(operation) &&
(namespaceBlob.IsReplicated ||
BlobReplicationHandler.ShouldReplicateBlob(requestWrapper.Headers, namespaceBlob)))
{
await BlobReplicationHandler.EnqueueBlobReplicationAsync(namespaceBlob, false);
}
return await ForwardRequestHandler(namespaceBlob, operation);
}));
}
static async Task <SharedAccessBlobPolicy> GetStoredPolicyForContainer(string container, string storedPolicyId)
{
try
{
// TODO: Move this information to cache to mitigate DoS vector
var containerObject = NamespaceHandler.GetContainerByName(DashConfiguration.NamespaceAccount, container);
var permissions = await containerObject.GetPermissionsAsync();
SharedAccessBlobPolicy retval;
if (permissions.SharedAccessPolicies.TryGetValue(storedPolicyId, out retval))
{
return(retval);
}
}
catch (StorageException)
{
}
return(null);
}
public State()
{
logger = Log.ForContext <State>();
var origin = new Context <Shell.Types.IShellData>("ORIGIN");
var functions = new Context <Shell.Types.Function>("ORIGIN");
contexts = new List <Tuple <Context <Shell.Types.IShellData>, Context <Shell.Types.Function> > >
{
new Tuple <Context <Types.IShellData>, Context <Types.Function> >(origin, functions)
};
all_namespaces = new Dictionary <string, Shell.Types.Namespace>();
this.Variables = new VariableHandler(this);
this.Functions = new FunctionHandler(this);
this.Namespaces = new NamespaceHandler(this);
this.Names = new NameHandler(this);
}
public static async Task <HandlerResult> PutBlobAsync(IHttpRequestWrapper requestWrapper, string container, string blob, bool operationCanReplicateBlob)
{
return(await WebOperationRunner.DoHandlerAsync("BlobHandler.PutBlobAsync", async() =>
{
var namespaceBlob = await NamespaceHandler.CreateNamespaceBlobAsync(container, blob);
if (operationCanReplicateBlob)
{
if (BlobReplicationHandler.ShouldReplicateBlob(requestWrapper.Headers, container, blob))
{
await BlobReplicationHandler.EnqueueBlobReplicationAsync(namespaceBlob, false);
}
}
Uri redirect = ControllerOperations.GetRedirectUri(HttpContextFactory.Current.Request,
DashConfiguration.GetDataAccountByAccountName(namespaceBlob.PrimaryAccountName),
container,
blob,
false);
return HandlerResult.Redirect(requestWrapper, redirect);
}));
}
public async Task <HttpResponseMessage> GetContainerProperties(string container)
{
return(await DoHandlerAsync("ContainerController.GetContainerProperties", async() =>
{
CloudBlobContainer containerObj = NamespaceHandler.GetContainerByName(DashConfiguration.NamespaceAccount, container);
HttpResponseMessage errorResponse = await ValidatePreconditions(containerObj);
if (errorResponse != null)
{
return errorResponse;
}
HttpResponseMessage response = await FormContainerMetadataResponse(containerObj);
response.Headers.Add("x-ms-lease-status", containerObj.Properties.LeaseStatus.ToString().ToLower());
response.Headers.Add("x-ms-lease-state", containerObj.Properties.LeaseState.ToString().ToLower());
//Only add Lease Duration information if the container is leased
if (containerObj.Properties.LeaseState == LeaseState.Leased)
{
response.Headers.Add("x-ms-lease-duration", containerObj.Properties.LeaseDuration.ToString().ToLower());
}
return response;
}));
}
public AzureMessageQueue(string queueName)
{
this.Queue = NamespaceHandler.GetQueueByName(DashConfiguration.NamespaceAccount, queueName);
this.Queue.CreateIfNotExists();
this.CurrentMessage = null;
}
public static async Task ImportAccountAsync(string accountName)
{
await OperationRunner.DoActionAsync(String.Format("Importing data account: {0}", accountName), async() =>
{
// This method will only import the blobs into the namespace. A future task may be
// to redistribute the blobs to balance the entire virtual account.
var account = DashConfiguration.GetDataAccountByAccountName(accountName);
if (account == null)
{
DashTrace.TraceWarning("Failure importing storage account: {0}. The storage account has not been configured as part of this virtual account",
accountName);
return;
}
// Check if we've already imported this account
var accountClient = account.CreateCloudBlobClient();
var namespaceClient = DashConfiguration.NamespaceAccount.CreateCloudBlobClient();
var accountContainers = await ListContainersAsync(accountClient);
var status = await AccountStatus.GetAccountStatus(accountName);
await status.UpdateStatusInformation(AccountStatus.States.Healthy, "Importing storage account: {0} into virtual account", accountName);
bool alreadyImported = false;
await GetAccountBlobs(accountClient, async(blobItem) =>
{
var blob = (ICloudBlob)blobItem;
var namespaceBlob = await NamespaceBlob.FetchForBlobAsync(
(CloudBlockBlob)NamespaceHandler.GetBlobByName(DashConfiguration.NamespaceAccount, blob.Container.Name, blob.Name, blob.IsSnapshot ? blob.SnapshotTime.ToString() : String.Empty));
alreadyImported = await namespaceBlob.ExistsAsync(true) &&
namespaceBlob.DataAccounts.Contains(accountName, StringComparer.OrdinalIgnoreCase);
return(false);
});
if (alreadyImported)
{
await status.UpdateStatusWarning("Importing storage account: {0} has already been imported. This account cannot be imported again.", accountName);
return;
}
// Sync the container structure first - add containers in the imported account to the virtual account
await status.UpdateStatusInformation("Importing storage account: {0}. Synchronizing container structure", accountName);
int containersAddedCount = 0, containersWarningCount = 0;
var namespaceContainers = await ListContainersAsync(namespaceClient);
await ProcessContainerDifferencesAsync(accountContainers, namespaceContainers, async(newContainerName, accountContainer) =>
{
var createContainerResult = await ContainerHandler.DoForAllContainersAsync(newContainerName,
HttpStatusCode.Created,
async newContainer => await CopyContainer(accountContainer, newContainer),
true,
new[] { account });
if (createContainerResult.StatusCode < HttpStatusCode.OK || createContainerResult.StatusCode >= HttpStatusCode.Ambiguous)
{
await status.UpdateStatusWarning("Importing storage account: {0}. Failed to create container: {1} in virtual account. Details: {2}, {3}",
accountName,
newContainerName,
createContainerResult.StatusCode.ToString(),
createContainerResult.ReasonPhrase);
containersWarningCount++;
}
else
{
containersAddedCount++;
}
},
(newContainerName, ex) =>
{
status.UpdateStatusWarning("Importing storage account: {0}. Error processing container {1}. Details: {2}",
accountName,
newContainerName,
ex.ToString()).Wait();
containersWarningCount++;
});
// Sync the other way
await ProcessContainerDifferencesAsync(namespaceContainers, accountContainers, async(newContainerName, namespaceContainer) =>
{
await CopyContainer(namespaceContainer, accountClient.GetContainerReference(newContainerName));
},
(newContainerName, ex) =>
{
status.UpdateStatusWarning("Importing storage account: {0}. Error replicating container {1} to imported account. Details: {2}",
accountName,
newContainerName,
ex.ToString()).Wait();
containersWarningCount++;
});
DashTrace.TraceInformation("Importing storage account: {0}. Synchronized containers structure. {1} containers added to virtual account. {2} failures/warnings.",
accountName,
containersAddedCount,
containersWarningCount);
// Start importing namespace entries
await status.UpdateStatusInformation("Importing storage account: {0}. Adding blob entries to namespace", accountName);
int blobsAddedCount = 0, warningCount = 0, duplicateCount = 0;
await GetAccountBlobs(accountClient, async(blobItem) =>
{
var blob = (ICloudBlob)blobItem;
try
{
var namespaceBlob = await NamespaceBlob.FetchForBlobAsync(
(CloudBlockBlob)NamespaceHandler.GetBlobByName(DashConfiguration.NamespaceAccount, blob.Container.Name, blob.Name, blob.IsSnapshot ? blob.SnapshotTime.ToString() : String.Empty));
if (await namespaceBlob.ExistsAsync())
{
if (!String.Equals(namespaceBlob.PrimaryAccountName, accountName, StringComparison.OrdinalIgnoreCase))
{
await status.UpdateStatusWarning("Importing storage account: {0}. Adding blob: {1}/{2} would result in a duplicate blob entry. This blob will NOT be imported into the virtual account. Manually add the contents of this blob to the virtual account.",
accountName,
blob.Container.Name,
blob.Name);
duplicateCount++;
}
}
else
{
namespaceBlob.PrimaryAccountName = accountName;
namespaceBlob.Container = blob.Container.Name;
namespaceBlob.BlobName = blob.Name;
namespaceBlob.IsMarkedForDeletion = false;
await namespaceBlob.SaveAsync();
blobsAddedCount++;
}
}
catch (StorageException ex)
{
status.UpdateStatusWarning("Importing storage account: {0}. Error importing blob: {0}/{1} into virtual namespace. Details: {3}",
accountName,
blob.Container.Name,
blob.Name,
ex.ToString()).Wait();
warningCount++;
}
return(true);
});
if (status.State < AccountStatus.States.Warning)
{
await status.UpdateStatus(String.Empty, AccountStatus.States.Unknown, TraceLevel.Off);
}
DashTrace.TraceInformation("Successfully imported the contents of storage account: '{0}' into the virtual namespace. Blobs added: {1}, duplicates detected: {2}, errors encountered: {3}",
accountName, blobsAddedCount, duplicateCount, warningCount);
},
ex =>
{
var status = AccountStatus.GetAccountStatus(accountName).Result;
status.UpdateStatusWarning("Error importing storage account: {0} into virtual account. Details: {1}", accountName, ex.ToString()).Wait();
}, false, true);
}
public static async Task <HandlerResult> CopyBlobAsync(IHttpRequestWrapper requestWrapper, string destContainer, string destBlob, string source)
{
return(await WebOperationRunner.DoHandlerAsync(String.Format("BlobHandler.CopyBlobAsync: {0}/{1} from {2}", destContainer, destBlob, source), async() =>
{
// source is a naked URI supplied by client
Uri sourceUri;
if (Uri.TryCreate(source, UriKind.RelativeOrAbsolute, out sourceUri))
{
string sourceContainer = String.Empty;
string sourceBlobName = String.Empty;
string sourceQuery = String.Empty;
BlobType sourceBlobType = BlobType.BlockBlob;
var requestVersion = requestWrapper.Headers.Value("x-ms-version", StorageServiceVersions.Version_2009_09_19);
bool processRelativeSource = false;
if (!sourceUri.IsAbsoluteUri)
{
if (requestVersion >= StorageServiceVersions.Version_2012_02_12)
{
// 2012-02-12 onwards doesn't accept relative URIs
return new HandlerResult
{
StatusCode = HttpStatusCode.BadRequest,
};
}
// Make sourceUri absolute here because a bunch of Uri functionality fails for relative URIs
sourceUri = new Uri(new Uri("http://dummyhost"), sourceUri);
processRelativeSource = true;
}
if (processRelativeSource ||
(String.Equals(sourceUri.Host, requestWrapper.Url.Host, StringComparison.OrdinalIgnoreCase) &&
((sourceUri.IsDefaultPort && requestWrapper.Url.IsDefaultPort) || (sourceUri.Port == requestWrapper.Url.Port))))
{
var segments = PathUtils.GetPathSegments(sourceUri.AbsolutePath);
if (processRelativeSource)
{
// Blob in named container: /accountName/containerName/blobName
// Snapshot in named container: /accountName/containerName/blobName?snapshot=<DateTime>
// Blob in root container: /accountName/blobName
// Snapshot in root container: /accountName/blobName?snapshot=<DateTime>
if (!String.Equals(segments.FirstOrDefault(), DashConfiguration.AccountName))
{
return new HandlerResult
{
StatusCode = HttpStatusCode.BadRequest,
ErrorInformation = new DashErrorInformation
{
ErrorCode = "CopyAcrossAccountsNotSupported",
ErrorMessage = "The copy source account and destination account must be the same.",
},
};
}
if (segments.Count() == 2)
{
sourceContainer = "root";
sourceBlobName = segments[1];
}
else if (segments.Count() > 2)
{
sourceContainer = segments[1];
sourceBlobName = PathUtils.CombinePathSegments(segments.Skip(2));
}
}
else
{
sourceContainer = segments.FirstOrDefault();
sourceBlobName = PathUtils.CombinePathSegments(segments.Skip(1));
}
}
var destNamespaceBlob = await NamespaceHandler.FetchNamespaceBlobAsync(destContainer, destBlob);
string destAccount = String.Empty;
if (!String.IsNullOrEmpty(sourceContainer) && !String.IsNullOrEmpty(sourceBlobName))
{
var sourceQueryParams = HttpUtility.ParseQueryString(sourceUri.Query);
var sourceNamespaceBlob = await NamespaceHandler.FetchNamespaceBlobAsync(sourceContainer, sourceBlobName, sourceQueryParams["snapshot"]);
if (!await sourceNamespaceBlob.ExistsAsync())
{
// This isn't actually documented (what happens when the source doesn't exist), but by obervation the service emits 404
return new HandlerResult
{
StatusCode = HttpStatusCode.NotFound,
};
}
var sourceCloudContainer = NamespaceHandler.GetContainerByName(
DashConfiguration.GetDataAccountByAccountName(sourceNamespaceBlob.PrimaryAccountName), sourceContainer);
sourceBlobType = sourceCloudContainer.GetBlobReferenceFromServer(sourceBlobName).BlobType;
// This is effectively an intra-account copy which is expected to be atomic. Therefore, even if the destination already
// exists, we need to place the destination in the same data account as the source.
// If the destination blob already exists, we delete it below to prevent an orphaned data blob
destAccount = sourceNamespaceBlob.PrimaryAccountName;
var sourceUriBuilder = ControllerOperations.GetRedirectUriBuilder("GET",
requestWrapper.Url.Scheme,
DashConfiguration.GetDataAccountByAccountName(destAccount),
sourceContainer,
sourceBlobName,
false,
String.Empty);
sourceUri = sourceUriBuilder.Uri;
}
else if (await destNamespaceBlob.ExistsAsync())
{
destAccount = destNamespaceBlob.PrimaryAccountName;
}
else
{
destAccount = NamespaceHandler.GetDataStorageAccountForBlob(destBlob).Credentials.AccountName;
}
bool replicateDestination = false;
if (await destNamespaceBlob.ExistsAsync() && destNamespaceBlob.PrimaryAccountName != destAccount)
{
// Delete the existing blob to prevent orphaning it
replicateDestination = destNamespaceBlob.IsReplicated;
var dataBlob = NamespaceHandler.GetBlobByName(
DashConfiguration.GetDataAccountByAccountName(destNamespaceBlob.PrimaryAccountName), destContainer, destBlob);
await dataBlob.DeleteIfExistsAsync();
}
destNamespaceBlob.PrimaryAccountName = destAccount;
destNamespaceBlob.Container = destContainer;
destNamespaceBlob.BlobName = destBlob;
destNamespaceBlob.IsMarkedForDeletion = false;
await destNamespaceBlob.SaveAsync();
// Now that we've got the metadata tucked away - do the actual copy
var destCloudContainer = NamespaceHandler.GetContainerByName(DashConfiguration.GetDataAccountByAccountName(destAccount), destContainer);
ICloudBlob destCloudBlob = null;
if (sourceBlobType == BlobType.PageBlob)
{
destCloudBlob = destCloudContainer.GetPageBlobReference(destBlob);
}
else
{
destCloudBlob = destCloudContainer.GetBlockBlobReference(destBlob);
}
// Storage client will retry failed copy. Let our clients decide that.
var copyId = await destCloudBlob.StartCopyFromBlobAsync(sourceUri,
AccessCondition.GenerateEmptyCondition(),
AccessCondition.GenerateEmptyCondition(),
new BlobRequestOptions
{
RetryPolicy = new NoRetry(),
},
new OperationContext());
// Check if we should replicate the copied destination blob
if (replicateDestination || BlobReplicationHandler.ShouldReplicateBlob(requestWrapper.Headers, destContainer, destBlob))
{
await BlobReplicationHandler.EnqueueBlobReplicationAsync(destNamespaceBlob, false);
}
return new HandlerResult
{
StatusCode = requestVersion >= StorageServiceVersions.Version_2012_02_12 ? HttpStatusCode.Accepted : HttpStatusCode.Created,
Headers = new ResponseHeaders(new[]
{
new KeyValuePair <string, string>("x-ms-copy-id", copyId),
new KeyValuePair <string, string>("x-ms-copy-status", destCloudBlob.CopyState.Status == CopyStatus.Success ? "success" : "pending"),
})
};
}
return new HandlerResult
{
StatusCode = HttpStatusCode.BadRequest,
};
}));
}
public abstract object Resolve(NestedArgument argument, SourceHandler source,
NamespaceHandler scope, ExtensionResolver resolver, Type targettype);