/// <summary>
/// Registers an expected exception to be thrown.
/// </summary>
/// <param name="secretName">The name of the secret the exception is associated with.</param>
/// <param name="ex">The exception to throw.</param>
/// <returns>True if expected exception was registered successfully, false if it failed.</returns>
public bool RegisterExpectedException(string secretName, StorageClientException ex)
{
if (_expectedExceptions.ContainsKey(secretName))
{
throw new InvalidOperationException($"An exception for the secret with the identifier {secretName} was already registered!");
}
return(_expectedExceptions.TryAdd(secretName, ex));
}
public AzureEnvironmentDistributedMutex()
{
_log = ClassLogger.Create(GetType());
_dblog = DebugOnlyLogger.Create(_log);
var config = Catalog.Factory.Resolve <IConfig>(SpecialFactoryContexts.Routed);
_name = config[DistributedMutexLocalConfig.Name].ToLowerInvariant();
_expireUnused = TimeSpan.FromSeconds(config.Get <int>(DistributedMutexLocalConfig.UnusedExpirationSeconds));
var account = Client.FromConfig().ForBlobs();
_container = account.GetContainerReference(AzureConstants.LeaseContainer);
_container.CreateIfNotExist();
_leaseBlob = _container.GetBlobReference(_name);
_cts = new CancellationTokenSource();
_cancelGrooming = new CancellationTokenSource();
try
{
if (!_leaseBlob.Exists())
{
_leaseBlob.UploadText("1");
_leaseBlob.SetExpiration(_expireUnused);
_log.InfoFormat("Creating distributed mutex for {0}, auto expires in {1}", _name, _expireUnused);
}
}
catch (StorageClientException storageClientException1)
{
StorageClientException storageClientException = storageClientException1;
if (storageClientException.ErrorCode == StorageErrorCode.BlobAlreadyExists ||
storageClientException.StatusCode == HttpStatusCode.PreconditionFailed)
{
}
else
{
throw;
}
}
_groomingTask =
Task.Factory.StartNew(
() =>
AzureStorageAssistant.CleanExpiredBlobsFrom(AzureConstants.LeaseContainer, _cancelGrooming.Token,
false));
}
private bool _handleStorageClientException(CloudBlob blob, StorageClientException err)
{
switch (err.ErrorCode)
{
case StorageErrorCode.ResourceNotFound:
blob.UploadText(_lockFile);
return(true);
case StorageErrorCode.ContainerNotFound:
// container is missing, we should create it.
_azureDirectory.BlobContainer.Delete();
_azureDirectory.CreateContainer();
return(true);
default:
return(false);
}
}
public static void ExecuteSubscription(Subscription subscription)
{
if (String.IsNullOrEmpty(subscription.SubscriptionType))
{
return;
}
if (subscription.TargetRelativeLocation == subscription.SubscriberRelativeLocation)
{
throw new InvalidDataException("Self-circular subscription for target: " + subscription.TargetRelativeLocation);
}
if (subscription.SubscriptionType == SubscribeSupport.SubscribeType_WebPageToSource)
{
try
{
CloudBlob cloudBlob =
StorageSupport.CurrActiveContainer.GetBlockBlobReference(subscription.SubscriberRelativeLocation);
RenderWebSupport.RefreshPHTMLContent(cloudBlob, true);
} catch (Exception ex)
{
StorageClientException storageClientException = ex as StorageClientException;
if (storageClientException != null)
{
if (storageClientException.ErrorCode == StorageErrorCode.BlobNotFound)
{
return;
}
}
// TODO: Detect and remove the missing subscribers
ErrorSupport.ReportException(ex);
}
}
else if (subscription.SubscriptionType == SubscribeSupport.SubscribeType_MasterToReferenceUpdate)
{
try
{
string containerLocation = subscription.SubscriberRelativeLocation;
string containerType = subscription.SubscriberInformationObjectType;
string masterLocation = subscription.TargetRelativeLocation;
string masterType = subscription.TargetInformationObjectType;
UpdateContainerFromMaster(containerLocation, containerType, masterLocation, masterType);
} catch (Exception ex)
{
StorageClientException storageClientException = ex as StorageClientException;
if (storageClientException != null)
{
if (storageClientException.ErrorCode == StorageErrorCode.BlobNotFound)
{
return;
}
}
ErrorSupport.ReportException(ex);
}
}
else if (subscription.SubscriptionType == SubscribeSupport.SubscribeType_DirectoryToCollection)
{
string directoryLocation = subscription.TargetRelativeLocation;
string collectionType = subscription.SubscriberInformationObjectType;
string collectionLocation = subscription.SubscriberRelativeLocation;
UpdateCollectionFromDirectory(collectionType, collectionLocation, directoryLocation);
}
else if (subscription.SubscriptionType == SubscribeSupport.SubscribeType_CollectionToCollectionUpdate)
{
string masterCollectionLocation = subscription.TargetRelativeLocation;
string masterCollectionType = subscription.TargetInformationObjectType;
string referenceCollectionLocation = subscription.SubscriberRelativeLocation;
string referenceCollectionType = subscription.SubscriberInformationObjectType;
UpdateCollectionFromMasterCollection(referenceCollectionType, referenceCollectionLocation,
masterCollectionType, masterCollectionLocation);
}
else if (subscription.SubscriptionType == SubscribeSupport.SubscribeType_MasterCollectionToContainerUpdate)
{
string masterCollectionLocation = subscription.TargetRelativeLocation;
string masterCollectionType = subscription.TargetInformationObjectType;
string containerLocation = subscription.SubscriberRelativeLocation;
string containerType = subscription.SubscriberInformationObjectType;
UpdateContainerFromMasterCollection(containerType, containerLocation,
masterCollectionType, masterCollectionLocation);
}
else
{
throw new InvalidDataException(String.Format(
"Unsupported subscription type {0} for object: {1} by {2}", subscription.SubscriptionType,
subscription.TargetRelativeLocation, subscription.SubscriberRelativeLocation));
}
}
public TestableStorageClientException(StorageClientException ex)
{
ErrorCode = ex.ErrorCode;
}
