protected override IEnumerator <IAsyncResult> PeekMessagesImpl(IAccountIdentifier identity, string account, string queue, int numMessages, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IEnumerable <PeekedMessage> > context)
{
this.ValidateNumMessages(numMessages, this.config.MaxMessagesToReturn);
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Read
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Read, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.PeekMessagesImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginPeekMessage(numMessages, context.GetResumeCallback(), context.GetResumeState("QueueManager.PeekMessagesImpl"));
yield return(asyncResult);
IEnumerable <IMessageData> messageDatas = operationStatus.EndPeekMessage(asyncResult);
context.ResultData = this.WrapPeekedMessageResults(messageDatas);
}
protected override IEnumerator <IAsyncResult> ClearQueueImpl(IAccountIdentifier identity, string account, string queue, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Delete
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Delete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.ClearQueueImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginClearQueue(context.GetResumeCallback(), context.GetResumeState("QueueManager.ClearQueueImpl"));
yield return(asyncResult);
operationStatus.EndClearQueue(asyncResult);
}
protected override IEnumerator <IAsyncResult> SetQueueMetadataImpl(IAccountIdentifier identity, string account, string queue, NameValueCollection metadata, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.AccountSas,
SignedResourceType = SasResourceType.Container,
SignedPermission = SASPermission.Write
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueMetadataImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
operationStatus.ApplicationMetadata = QueueHelpers.SerializeMetadata(metadata);
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginSetProperties(ContainerPropertyNames.ApplicationMetadata, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueMetadataImpl"));
yield return(asyncResult);
operationStatus.EndSetProperties(asyncResult);
}
protected override IEnumerator <IAsyncResult> GetQueuePropertiesImpl(IAccountIdentifier identity, string account, string queue, bool getMessageCount, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <QueueProperties> context)
{
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Container,
SignedPermission = SASPermission.Read
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
return(this.GetQueuePropertiesImpl(identity, account, queue, getMessageCount, sASAuthorizationParameter1, timeout, requestContext, context));
}
protected override IEnumerator <IAsyncResult> GetMessagesImpl(IAccountIdentifier identity, string account, string queue, int numMessages, long?visibilityTimeout, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IEnumerable <PoppedMessage> > context)
{
object obj;
this.ValidateNumMessages(numMessages, this.config.MaxMessagesToReturn);
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Process
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.ReadDelete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetMessagesImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
long?nullable = visibilityTimeout;
obj = (nullable.HasValue ? nullable.GetValueOrDefault() : this.config.DefaultVisibilityTimeoutSeconds);
TimeSpan timeSpan = TimeSpan.FromSeconds((double)obj);
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginGetMessage(numMessages, timeSpan, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetMessagesImpl"));
yield return(asyncResult);
IEnumerable <IMessageData> messageDatas = operationStatus.EndGetMessage(asyncResult);
StringBuilder stringBuilder = new StringBuilder();
context.ResultData = this.WrapGetMessageResults(messageDatas);
int num = 0;
foreach (PoppedMessage resultDatum in context.ResultData)
{
stringBuilder.Append(string.Format("[{0}],", resultDatum.ToString()));
num++;
}
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] str = new object[] { num, stringBuilder.ToString() };
verboseDebug.Log("GetMessages response: Count={0} Messages={1}", str);
}
protected override IEnumerator <IAsyncResult> DeleteMessageImpl(IAccountIdentifier identity, string account, string queue, string messageId, byte[] popReceipt, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Process
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
NephosAssertionException.Assert(popReceipt != null);
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Delete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteMessageImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
try
{
Guid guid = new Guid(messageId);
}
catch (Exception exception)
{
throw new MessageNotFoundException("Invalid message name", exception);
}
IQueueMessageReceipt queueMessageReceipt = this.DecodeReceipt(popReceipt, new Guid(messageId));
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginDeleteMessage(queueMessageReceipt, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteMessageImpl"));
yield return(asyncResult);
bool flag = operationStatus.EndDeleteMessage(asyncResult);
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] str = new object[] { flag, queueMessageReceipt.ToString() };
verboseDebug.Log("DeleteMessage response: status={0} message={1}", str);
if (!flag)
{
throw new MessageNotFoundException("The message could not be deleted or pop receipt invalid.");
}
}
private IEnumerator <IAsyncResult> SetTableServicePropertiesImpl(IAccountIdentifier identifier, string ownerAccountName, AnalyticsSettings settings, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
Duration startingNow = Duration.StartingNow;
if (identifier == null)
{
throw new ArgumentNullException("identifier");
}
if (string.IsNullOrEmpty(ownerAccountName))
{
throw new ArgumentException("ownerAccountName", "Cannot be null");
}
if (timeout <= TimeSpan.Zero)
{
throw new TimeoutException("Timed out in SetTableServiceProperties");
}
if (identifier is TableSignedAccessAccountIdentifier)
{
throw new NephosUnauthorizedAccessException("Signed access not supported for this request", AuthorizationFailureReason.InvalidOperationSAS);
}
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.AccountSas,
SignedResourceType = SasResourceType.Service,
SignedPermission = SASPermission.Write
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identifier, ownerAccountName, null, null, PermissionLevel.Write | PermissionLevel.Owner, sASAuthorizationParameter1, timeout, context.GetResumeCallback(), context.GetResumeState("TableManager.SetTableServicePropertiesImpl"));
yield return(asyncResult);
this.authorizationManager.EndCheckAccess(asyncResult);
IStorageAccount accountServiceMetadatum = null;
AccountCondition accountCondition = new AccountCondition(false, false, null, null);
accountServiceMetadatum = this.storageManager.CreateAccountInstance(ownerAccountName);
accountServiceMetadatum.ServiceMetadata = new AccountServiceMetadata()
{
TableAnalyticsSettings = settings
};
accountServiceMetadatum.Timeout = timeout;
asyncResult = accountServiceMetadatum.BeginSetProperties(new AccountPropertyNames(AccountLevelPropertyNames.None, (AccountServiceMetadataPropertyNames)((long)131072)), accountCondition, context.GetResumeCallback(), context.GetResumeState("TableManager.SetTableServicePropertiesImpl"));
yield return(asyncResult);
accountServiceMetadatum.EndSetProperties(asyncResult);
}
protected override IEnumerator <IAsyncResult> PutMessageImpl(IAccountIdentifier identity, string account, string queue, List <PushedMessage> messagesList, TimeSpan?timeout, RequestContext requestContext, bool usePutMessageRowCommand, AsyncIteratorContext <IEnumerable <PoppedMessage> > context)
{
TimeSpan timeSpan;
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Add
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.PutMessageImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
object obj = messagesList;
if (obj == null)
{
obj = Enumerable.Empty <PushedMessage>();
}
foreach (PushedMessage pushedMessage in (IEnumerable <PushedMessage>)obj)
{
PushedMessage nullable = pushedMessage;
TimeSpan? messageTTL = pushedMessage.MessageTTL;
timeSpan = (messageTTL.HasValue ? messageTTL.GetValueOrDefault() : TimeSpan.FromSeconds((double)this.config.MaxTtlSeconds));
nullable.MessageTTL = new TimeSpan?(timeSpan);
}
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginPutMessage(messagesList, usePutMessageRowCommand, context.GetResumeCallback(), context.GetResumeState("QueueManager.PutMessageImpl"));
yield return(asyncResult);
List <IMessageData> messageDatas = operationStatus.EndPutMessage(asyncResult);
context.ResultData = this.WrapGetMessageResults(messageDatas);
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
verboseDebug.Log("PutMessage response: MessageId={0}", new object[] { context.ResultData });
}
protected override IEnumerator <IAsyncResult> UpdateMessageImpl(IAccountIdentifier identity, string account, string queue, string messageId, byte[] popReceipt, byte[] body, TimeSpan visibilityTimeout, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <PoppedMessage> context)
{
Guid guid;
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Update
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.UpdateMessageImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
operationStatus.Timeout = remainingTime;
try
{
guid = new Guid(messageId);
}
catch (Exception exception)
{
throw new MessageNotFoundException("Invalid message name", exception);
}
IQueueMessageReceipt queueMessageReceipt = this.DecodeReceipt(popReceipt, guid);
TimeSpan? nullable = null;
asyncResult = operationStatus.BeginUpdateMessage(queueMessageReceipt, body, visibilityTimeout, nullable, context.GetResumeCallback(), context.GetResumeState("QueueManager.UpdateMessageImpl"));
yield return(asyncResult);
IQueueMessageReceipt queueMessageReceipt1 = operationStatus.EndUpdateMessage(asyncResult);
context.ResultData = this.GetPoppedMessageInfoFromReceipt(queueMessageReceipt1);
}
protected override IEnumerator <IAsyncResult> GetQueueServiceStatsImpl(IAccountIdentifier identifier, string ownerAccountName, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <GeoReplicationStats> context)
{
Duration startingNow = Duration.StartingNow;
if (identifier == null)
{
throw new ArgumentNullException("identifier");
}
if (string.IsNullOrEmpty(ownerAccountName))
{
throw new ArgumentException("ownerAccountName", "Cannot be null");
}
if (timeout <= TimeSpan.Zero)
{
throw new TimeoutException("Timed out in GetQueueServiceStats");
}
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.AccountSas,
SignedResourceType = SasResourceType.Service,
SignedPermission = SASPermission.Read
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identifier, ownerAccountName, null, null, PermissionLevel.Read | PermissionLevel.Owner, sASAuthorizationParameter1, timeout, context.GetResumeCallback(), context.GetResumeState("RealQueueManager.GetQueueServiceStatsImpl"));
yield return(asyncResult);
this.authorizationManager.EndCheckAccess(asyncResult);
IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(ownerAccountName);
storageAccount.Timeout = timeout;
AccountCondition accountCondition = new AccountCondition(false, false, storageAccount.LastModificationTime, null);
asyncResult = storageAccount.BeginGetProperties(new AccountPropertyNames(AccountLevelPropertyNames.None, (AccountServiceMetadataPropertyNames)((long)1073741824)), accountCondition, context.GetResumeCallback(), context.GetResumeState("RealQueueManager.GetQueueServiceStatsImpl"));
yield return(asyncResult);
storageAccount.EndGetProperties(asyncResult);
context.ResultData = storageAccount.ServiceMetadata.QueueGeoReplicationStats;
}
protected override IEnumerator <IAsyncResult> DeleteQueueImpl(IAccountIdentifier identity, string account, string queue, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.AccountSas,
SignedResourceType = SasResourceType.Container,
SignedPermission = SASPermission.Delete
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identity, account, null, null, PermissionLevel.Delete, sASAuthorizationParameter1, remainingTime, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteQueueImpl"));
yield return(asyncResult);
this.authorizationManager.EndCheckAccess(asyncResult);
IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account);
storageAccount.Timeout = remainingTime;
asyncResult = storageAccount.BeginDeleteQueueContainer(queue, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteQueueImpl"));
yield return(asyncResult);
storageAccount.EndDeleteQueueContainer(asyncResult);
}
protected override IEnumerator <IAsyncResult> ListQueuesImpl(IAccountIdentifier identity, string account, string queuePrefix, string delimiter, string marker, int maxResults, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IListQueuesResultCollection> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.AccountSas,
SignedResourceType = SasResourceType.Service,
SignedPermission = SASPermission.List
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identity, account, null, null, PermissionLevel.Read, sASAuthorizationParameter1, remainingTime, context.GetResumeCallback(), context.GetResumeState("QueueManager.ListQueuesImpl"));
yield return(asyncResult);
this.authorizationManager.EndCheckAccess(asyncResult);
IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account);
storageAccount.Timeout = remainingTime;
asyncResult = storageAccount.BeginListQueueContainers(queuePrefix, ContainerPropertyNames.ApplicationMetadata, delimiter, marker, null, maxResults, context.GetResumeCallback(), context.GetResumeState("QueueManager.ListQueuesImpl"));
yield return(asyncResult);
context.ResultData = new ListQueuesResult(storageAccount.EndListQueueContainers(asyncResult));
}
private IEnumerator <IAsyncResult> GetQueueImpl(IAccountIdentifier identity, string account, string queue, PermissionLevel permission, SASAuthorizationParameters sasParams, ContainerPropertyNames propertyNames, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <IQueueContainer> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
IAsyncResult asyncResult = this.authorizationManager.BeginCheckAccess(identity, account, null, null, permission, sasParams, remainingTime, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueueImpl"));
yield return(asyncResult);
this.authorizationManager.EndCheckAccess(asyncResult);
IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account);
IQueueContainer queueContainer = storageAccount.CreateQueueContainerInstance(queue);
queueContainer.Timeout = remainingTime;
asyncResult = queueContainer.BeginGetProperties(propertyNames, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueueImpl"));
yield return(asyncResult);
queueContainer.EndGetProperties(asyncResult);
context.ResultData = queueContainer;
}
private IAsyncResult BeginGetQueue(IAccountIdentifier identity, string account, string queue, PermissionLevel permission, SASAuthorizationParameters sasParams, ContainerPropertyNames propertyNames, TimeSpan timeout, RequestContext requestContext, AsyncCallback callback, object state)
{
AsyncIteratorContext <IQueueContainer> asyncIteratorContext = new AsyncIteratorContext <IQueueContainer>("QueueManager.GetQueue", callback, state);
asyncIteratorContext.Begin(this.GetQueueImpl(identity, account, queue, permission, sasParams, propertyNames, timeout, requestContext, asyncIteratorContext));
return(asyncIteratorContext);
}
public IAsyncResult BeginGetQueueProperties(IAccountIdentifier identity, string account, string queue, bool getMessageCount, SASAuthorizationParameters sasParams, TimeSpan?timeout, RequestContext requestContext, AsyncCallback callback, object state)
{
AsyncIteratorContext <QueueProperties> asyncIteratorContext = new AsyncIteratorContext <QueueProperties>("QueueManager.GetQueueProperties", callback, state);
asyncIteratorContext.Begin(this.GetQueuePropertiesImpl(identity, account, queue, getMessageCount, sasParams, timeout, requestContext, asyncIteratorContext));
return(asyncIteratorContext);
}
internal void CheckPermission(string userTableName, bool isUtilityTableCommand, bool shouldCheckGet, UpdateKind commandKind)
{
PermissionLevel permissionLevel;
if (this.SignedAccountIdentifier != null)
{
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] tableName = new object[] { this.SignedAccountIdentifier.TableName, this.SignedAccountIdentifier.StartingPartitionKey, this.SignedAccountIdentifier.StartingRowKey, this.SignedAccountIdentifier.EndingPartitionKey, this.SignedAccountIdentifier.EndingRowKey };
verboseDebug.Log("Sas tn={0} spk={1} srk={2} epk={3} erk={4}", tableName);
}
List <SASPermission> sASPermissions = new List <SASPermission>();
if (!shouldCheckGet)
{
switch (commandKind)
{
case UpdateKind.Insert:
{
if (!isUtilityTableCommand)
{
sASPermissions.Add(SASPermission.Add);
}
else
{
sASPermissions.Add(SASPermission.Create);
sASPermissions.Add(SASPermission.Write);
}
permissionLevel = PermissionLevel.Write;
this.CheckAnalyticsPermissions(userTableName, null);
goto Label0;
}
case UpdateKind.Delete:
{
sASPermissions.Add(SASPermission.Delete);
permissionLevel = PermissionLevel.Delete;
this.CheckAnalyticsPermissions(userTableName, new bool?(isUtilityTableCommand));
goto Label0;
}
case UpdateKind.Replace:
case UpdateKind.Merge:
{
sASPermissions.Add(SASPermission.Update);
permissionLevel = PermissionLevel.Write;
this.CheckAnalyticsPermissions(userTableName, null);
goto Label0;
}
case UpdateKind.InsertOrMerge:
case UpdateKind.InsertOrReplace:
{
sASPermissions.Add(SASPermission.Add | SASPermission.Update);
permissionLevel = PermissionLevel.Write;
this.CheckAnalyticsPermissions(userTableName, null);
goto Label0;
}
}
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] accountName = new object[] { this.AccountName, commandKind, this.m_currentResourceContainer.Name };
throw new NephosUnauthorizedAccessException(string.Format(invariantCulture, "Account {0} is not authorized to perform operation {1} on table {2}.", accountName));
}
else
{
if (!isUtilityTableCommand)
{
sASPermissions.Add(SASPermission.Read);
}
else
{
sASPermissions.Add(SASPermission.List);
}
permissionLevel = PermissionLevel.Read;
}
Label0:
this.CheckPermissionCallback(permissionLevel);
if (this.SignedAccountIdentifier != null)
{
SASPermission item = SASPermission.None;
if (sASPermissions.Count > 0)
{
item = sASPermissions[0];
}
XfeTableSASAuthorizationManager.AuthorizeSASRequest(this.SignedAccountIdentifier, PermissionLevel.Write, item, userTableName, isUtilityTableCommand);
return;
}
if (this.AccountIdentifier is AccountSasAccessIdentifier)
{
string lower = userTableName.ToLower();
if (isUtilityTableCommand)
{
lower = "Tables";
}
if (!string.Equals(this.m_currentResourceContainer.Name, lower, StringComparison.OrdinalIgnoreCase))
{
throw new NephosUnauthorizedAccessException("Signed access not supported for this request as table name did not match", AuthorizationFailureReason.InvalidOperationSAS);
}
AccountSasAccessIdentifier accountIdentifier = this.AccountIdentifier as AccountSasAccessIdentifier;
AuthorizationResult authorizationResult = new AuthorizationResult(false, AuthorizationFailureReason.UnauthorizedAccountSasRequest);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SignedResourceType = (isUtilityTableCommand ? SasResourceType.Container : SasResourceType.Object),
SupportedSasTypes = SasType.AccountSas
};
SASAuthorizationParameters item1 = sASAuthorizationParameter;
for (int i = 0; !authorizationResult.Authorized && i < sASPermissions.Count; i++)
{
item1.SignedPermission = sASPermissions[i];
authorizationResult = AuthorizationManager.AuthorizeAccountSignedAccessRequest(accountIdentifier, this.AccountName, item1);
}
if (!authorizationResult.Authorized)
{
throw new NephosUnauthorizedAccessException("Signed access insufficient permission", authorizationResult.FailureReason);
}
}
}
protected override IEnumerator <IAsyncResult> GetQueuePropertiesImpl(IAccountIdentifier identity, string account, string queue, bool getMessageCount, SASAuthorizationParameters sasParams, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <QueueProperties> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Read, sasParams, ContainerPropertyNames.ApplicationMetadata, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueuePropertiesImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
NameValueCollection nameValueCollection = QueueHelpers.DeserializeMetadata(operationStatus.ApplicationMetadata);
long?nullable = null;
if (getMessageCount)
{
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginGetQueueStatistics(true, true, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueuePropertiesImpl"));
yield return(asyncResult);
nullable = new long?(operationStatus.EndGetQueueStatistics(asyncResult).TotalMessages);
}
context.ResultData = new QueueProperties(account, queue, nullable, nameValueCollection);
}
protected override IEnumerator <IAsyncResult> CreateQueueImpl(IAccountIdentifier identity, string account, string queue, long defaultMessageTtl, long defaultMessageVisibilityTimeout, NameValueCollection metadata, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <CreateQueueResult> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
List <SASPermission> sASPermissions = new List <SASPermission>()
{
SASPermission.Write,
SASPermission.Create
};
SASAuthorizationParameters sASAuthorizationParameter = this.authorizationManager.CheckAccessWithMultiplePermissions(identity, account, null, null, PermissionLevel.Write, SasType.AccountSas, SasResourceType.Container, sASPermissions, remainingTime);
if (metadata == null)
{
metadata = new NameValueCollection();
}
IStorageAccount storageAccount = this.storageManager.CreateAccountInstance(account);
IAsyncResult asyncResult = base.BeginGetQueueProperties(identity, account, queue, false, sASAuthorizationParameter, new TimeSpan?(remainingTime), requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.CreateQueueImpl"));
yield return(asyncResult);
QueueProperties queueProperty = null;
bool flag = true;
try
{
queueProperty = base.EndGetQueueProperties(asyncResult);
}
catch (ContainerNotFoundException containerNotFoundException)
{
flag = false;
}
if (!flag)
{
Logger <IRestProtocolHeadLogger> .Instance.Info.Log("Contacting XAC Server in order to create the queue");
storageAccount.Timeout = remainingTime;
DateTime?nullable = null;
asyncResult = storageAccount.BeginCreateQueueContainer(queue, nullable, null, QueueHelpers.SerializeMetadata(metadata), context.GetResumeCallback(), context.GetResumeState("QueueManager.CreateQueueImpl"));
yield return(asyncResult);
bool flag1 = false;
try
{
storageAccount.EndCreateQueueContainer(asyncResult);
}
catch (ContainerAlreadyExistsException containerAlreadyExistsException)
{
flag1 = true;
}
if (flag1)
{
flag = true;
asyncResult = base.BeginGetQueueProperties(identity, account, queue, false, new TimeSpan?(remainingTime), requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.CreateQueueImpl"));
try
{
queueProperty = base.EndGetQueueProperties(asyncResult);
}
catch (ContainerNotFoundException containerNotFoundException1)
{
flag = false;
}
if (flag)
{
if (!QueueHelpers.IsMetadataSame(queueProperty.Metadata, metadata))
{
throw new ContainerAlreadyExistsException(string.Concat("Queue '", queue, "' already exists, and the metadata is different."));
}
context.ResultData = CreateQueueResult.AlreadyExists;
}
}
}
else
{
Logger <IRestProtocolHeadLogger> .Instance.Info.Log("Queue already exists no need to contact XAC Server.");
if (!QueueHelpers.IsMetadataSame(queueProperty.Metadata, metadata))
{
throw new ContainerAlreadyExistsException(string.Concat("Queue '", queue, "' already exists, and the metadata is different."));
}
context.ResultData = CreateQueueResult.AlreadyExists;
}
}
protected override IEnumerator <IAsyncResult> ListMessagesImpl(IAccountIdentifier identity, string account, string queue, string messageMarker, bool includeInvisibleMessages, bool incldueMessageTextProperty, int maxMessages, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <ListMessagesResult> context)
{
string nextQueueStart;
DateTime?nextVisibilityStart;
Guid guid;
int? subQueueId;
object obj;
this.ValidateNumMessages(maxMessages, this.config.MaxMessagesToReturnForListMessages);
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Read
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Read, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.PeekMessagesImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
operationStatus.Timeout = remainingTime;
ListMessagesMarker listMessagesMarker = SummaryResult.DecodeMarker <ListMessagesMarker>(messageMarker);
if (listMessagesMarker == null)
{
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("ListMessageImpl marker is null");
}
else
{
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
verboseDebug.Log("ListMessageImpl marker.NextQueueStart: {0}", new object[] { listMessagesMarker.NextQueueStart });
IStringDataEventStream stringDataEventStream = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { listMessagesMarker.SubQueueId };
stringDataEventStream.Log("ListMessageImpl marker.SubQueueId: {0}", objArray);
IStringDataEventStream verboseDebug1 = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] nextMessageIdStart = new object[] { listMessagesMarker.NextMessageIdStart };
verboseDebug1.Log("ListMessageImpl marker.NextMessageIdStart: {0}", nextMessageIdStart);
IStringDataEventStream stringDataEventStream1 = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray1 = new object[1];
object[] objArray2 = objArray1;
obj = (listMessagesMarker.NextVisibilityStart.HasValue ? listMessagesMarker.NextVisibilityStart.Value.ToString("mm/dd/yy hh:mm:ss.fff") : "null");
objArray2[0] = obj;
stringDataEventStream1.Log("ListMessageImpl marker.NextVisibilityStart: {0}", objArray1);
}
IQueueContainer queueContainer = operationStatus;
if (listMessagesMarker == null)
{
nextQueueStart = null;
}
else
{
nextQueueStart = listMessagesMarker.NextQueueStart;
}
if (listMessagesMarker == null)
{
nextVisibilityStart = null;
}
else
{
nextVisibilityStart = listMessagesMarker.NextVisibilityStart;
}
guid = (listMessagesMarker == null ? Guid.Empty : listMessagesMarker.NextMessageIdStart);
if (listMessagesMarker == null)
{
subQueueId = null;
}
else
{
subQueueId = listMessagesMarker.SubQueueId;
}
asyncResult = queueContainer.BeginListMessages(nextQueueStart, nextVisibilityStart, guid, subQueueId, includeInvisibleMessages, maxMessages, context.GetResumeCallback(), context.GetResumeState("QueueManager.PeekMessagesImpl"));
yield return(asyncResult);
ListMessagesResult listMessagesResults = operationStatus.EndListMessages(asyncResult);
listMessagesResults.PoppedMessages = this.WrapGetMessageResults(listMessagesResults.Messages);
context.ResultData = listMessagesResults;
StringBuilder stringBuilder = new StringBuilder();
int num = 0;
foreach (PoppedMessage poppedMessage in context.ResultData.PoppedMessages)
{
stringBuilder.Append(string.Format("[{0}],", poppedMessage.ToString()));
num++;
}
IStringDataEventStream verboseDebug2 = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] str = new object[] { num, stringBuilder.ToString() };
verboseDebug2.Log("ListMessages response: Count={0} Messages={1}", str);
}
private IAsyncResult BeginGetQueue(IAccountIdentifier identity, string account, string queue, PermissionLevel permission, SASAuthorizationParameters sasParams, TimeSpan timeout, RequestContext requestContext, AsyncCallback callback, object state)
{
return(this.BeginGetQueue(identity, account, queue, permission, sasParams, ContainerPropertyNames.None, timeout, requestContext, callback, state));
}
protected abstract IEnumerator <IAsyncResult> GetQueuePropertiesImpl(IAccountIdentifier identity, string account, string queue, bool getMessageCount, SASAuthorizationParameters sasParams, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <QueueProperties> context);
