/// <summary>
/// Initializes a new instance of the <see cref="MessageProcessor"/> class.
/// </summary>
/// <param name="service">The parent message service.</param>
/// <param name="container">The queue container to process.</param>
public MessageProcessor(IMessageService service, IQueueContainer container)
{
_workers = new Lazy<IList<IMessageWorker>>(CreateWorkers);
_service = service;
_container = container;
_configuration = container.Configuration;
}
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);
}
private IEnumerator <IAsyncResult> CreateQueueContainerImpl(string queueName, DateTime?expiryTime, byte[] serviceMetadata, byte[] applicationMetadata, AsyncIteratorContext <IQueueContainer> context)
{
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { queueName, expiryTime, serviceMetadata, applicationMetadata, this.Timeout };
verboseDebug.Log("CreateQueueContainerImpl({0},{1},{2},{3},{4})", objArray);
try
{
asyncResult = this.internalAccount.BeginCreateQueueContainer(queueName, StorageStampHelpers.AdjustNullableDatetimeRange(expiryTime), serviceMetadata, applicationMetadata, context.GetResumeCallback(), context.GetResumeState("StorageAccount.CreateQueueContainerImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
IQueueContainer queueContainer = this.internalAccount.EndCreateQueueContainer(asyncResult);
context.ResultData = new QueueContainer(queueContainer);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
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> 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> GetQueueAclImpl(IAccountIdentifier identifier, string account, string queue, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <ContainerAclSettings> context)
{
Duration startingNow = Duration.StartingNow;
if (identifier == null)
{
throw new ArgumentNullException("identifier");
}
if (string.IsNullOrEmpty(account))
{
throw new ArgumentException("account", "Cannot be null or empty");
}
if (string.IsNullOrEmpty(queue))
{
throw new ArgumentException("queue", "Cannot be null or empty");
}
if (timeout <= TimeSpan.Zero)
{
throw new TimeoutException("Timed out in GetQueueAcl");
}
RemainingTime remainingTime = new RemainingTime(timeout);
IAsyncResult asyncResult = this.BeginGetQueue(identifier, account, queue, PermissionLevel.ReadAcl, ContainerPropertyNames.ServiceMetadata, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetQueueAclImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
context.ResultData = new ContainerAclSettings(operationStatus.ServiceMetadata);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageProcessor"/> class.
/// </summary>
/// <param name="service">The parent message service.</param>
/// <param name="container">The queue container to process.</param>
public MessageProcessor(IMessageService service, IQueueContainer container)
{
_workers = new Lazy <IList <IMessageWorker> >(CreateWorkers);
_service = service;
_container = container;
_configuration = container.Configuration;
}
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);
}
public IQueueContainer CreateQueueContainerInstance(string accountName, string queueName)
{
IQueueContainer operationStatus = this.sharedStorageManager.CreateQueueContainerInstance(accountName, queueName);
operationStatus.OperationStatus = this.OperationStatus;
return(operationStatus);
}
/// <summary>
/// Start building a message to a queue with the specified name.
/// </summary>
/// <param name="name">The name of the queue.</param>
/// <returns>A fluent interface to build the queue message.</returns>
public MessageBuilder Queue(string name)
{
// load queue, apply defaults to message
_queueContainer = Manager.Load(name);
_queueContainer.ApplyDefaults(_message);
return new MessageBuilder(_message); ;
}
/// <summary>
/// Start building a message to a queue with the specified name.
/// </summary>
/// <param name="name">The name of the queue.</param>
/// <returns>A fluent interface to build the queue message.</returns>
public MessageBuilder Queue(string name)
{
// load queue, apply defaults to message
_queueContainer = Manager.Load(name);
_queueContainer.ApplyDefaults(_message);
return(new MessageBuilder(_message));;
}
private int queueSwitchCount = 0; // for debug, check the number of switch happened
#endregion
/// <summary>
/// Constructor
/// </summary>
public SwitchContainer(IQueueContainer <TData> first, IQueueContainer <TData> second)
{
firstContainer = first;
secondContainer = second;
// set in/out container
inContainer = firstContainer;
outContainer = secondContainer;
}
public ListQueuesResultQueueProperties(IQueueContainer queue)
{
if (queue == null)
{
throw new ArgumentNullException("queue");
}
this.queueName = queue.ContainerName;
if (queue.ApplicationMetadata != null)
{
this.metadata = QueueHelpers.DeserializeMetadata(queue.ApplicationMetadata);
}
}
public EventSender(IQueueContainer queueContainer, EventReceiver storeReceiver, Checkpoint checkpoint, StoreConfig storeConfig)
{
_storeReceiver = storeReceiver;
_queueContainer = queueContainer;
_checkpoint = checkpoint;
_storeConfig = storeConfig;
if (_storeConfig.ReplicationIsActive)
{
_eventHubClient = EventHubClient.CreateFromConnectionString(_storeConfig.EventHubConnectionString);
_ = StartListeners();
_active = true;
}
}
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> SetQueueAclImpl(IAccountIdentifier identifier, string account, string queue, ContainerAclSettings acl, TimeSpan timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
byte[] numArray;
Duration startingNow = Duration.StartingNow;
if (identifier == null)
{
throw new ArgumentNullException("identifier");
}
if (string.IsNullOrEmpty(account))
{
throw new ArgumentException("account", "Cannot be null or empty");
}
if (string.IsNullOrEmpty(queue))
{
throw new ArgumentException("queue", "Cannot be null or empty");
}
if (acl == null)
{
throw new ArgumentNullException("acl");
}
if (acl.SASIdentifiers == null)
{
throw new ArgumentNullException("sasidentifiers");
}
if (timeout <= TimeSpan.Zero)
{
throw new TimeoutException("Timed out in SetQueueAcl");
}
RemainingTime remainingTime = new RemainingTime(timeout);
IAsyncResult asyncResult = this.BeginGetQueue(identifier, account, queue, PermissionLevel.WriteAcl, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueAclImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
acl.EncodeToServiceMetadata(out numArray);
operationStatus.ServiceMetadata = numArray;
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginSetProperties(ContainerPropertyNames.ServiceMetadata, null, context.GetResumeCallback(), context.GetResumeState("QueueManager.SetQueueAclImpl"));
yield return(asyncResult);
operationStatus.EndSetProperties(asyncResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageProcessor"/> class.
/// </summary>
/// <param name="service">The parent message service.</param>
/// <param name="container">The queue container to process.</param>
public MessageProcessor(IMessageService service, IQueueContainer container)
{
_workers = new Lazy <IList <IMessageWorker> >(CreateWorkers);
_service = service;
_container = container;
_configuration = container.Configuration;
if (!container.Configuration.Trigger)
{
return;
}
// subscribe to notifications
var filter = container.Repository.Collection.CollectionNamespace.FullName;
service.Notifier.Subscribe(this, filter);
}
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.");
}
}
public IQueueContainer CreateQueueContainerInstance(string queueName)
{
IQueueContainer queueContainer;
try
{
IQueueContainer operationStatus = this.internalAccount.CreateQueueContainerInstance(queueName);
operationStatus.OperationStatus = this.OperationStatus;
queueContainer = new QueueContainer(operationStatus);
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
return(queueContainer);
}
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 });
}
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;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageWorkerBase"/> class.
/// </summary>
/// <param name="processor">The parent processor.</param>
/// <param name="name">The name of the worker.</param>
/// <exception cref="ArgumentNullException"><paramref name="processor"/> is <see langword="null" />.</exception>
protected MessageWorkerBase(IMessageProcessor processor, string name)
{
if (processor == null)
throw new ArgumentNullException("processor");
if (name == null)
throw new ArgumentNullException("name");
_name = name;
_processor = processor;
_container = _processor.Container;
_configuration = _container.Configuration;
_repository = _container.Repository;
_random = new Random();
_pollTimer = new Timer(PollQueue);
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageMethodHandling" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="queueContainer">The queue container.</param>
/// <param name="log">The log.</param>
/// <param name="linqCompiler">The method compiler.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public MessageMethodHandling(IExpressionSerializer serializer,
IQueueContainer queueContainer,
ILogFactory log,
ILinqCompiler linqCompiler,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => queueContainer, queueContainer);
Guard.NotNull(() => log, log);
Guard.NotNull(() => linqCompiler, linqCompiler);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_serializer = serializer;
_queueContainer = queueContainer;
_linqCompiler = linqCompiler;
_compositeSerialization = compositeSerialization;
_log = log.Create();
_rpcQueues = new Dictionary<IConnectionInformation, IProducerQueueRpc<object>>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageMethodHandling" /> class.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="queueContainer">The queue container.</param>
/// <param name="log">The log.</param>
/// <param name="linqCompiler">The method compiler.</param>
/// <param name="compositeSerialization">The composite serialization.</param>
public MessageMethodHandling(IExpressionSerializer serializer,
IQueueContainer queueContainer,
ILogFactory log,
ILinqCompiler linqCompiler,
ICompositeSerialization compositeSerialization)
{
Guard.NotNull(() => serializer, serializer);
Guard.NotNull(() => queueContainer, queueContainer);
Guard.NotNull(() => log, log);
Guard.NotNull(() => linqCompiler, linqCompiler);
Guard.NotNull(() => compositeSerialization, compositeSerialization);
_serializer = serializer;
_queueContainer = queueContainer;
_linqCompiler = linqCompiler;
_compositeSerialization = compositeSerialization;
_log = log.Create();
_rpcQueues = new Dictionary <IConnectionInformation, IProducerQueueRpc <object> >();
}
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);
}
/// <summary>
/// 交換輸入及輸出的容器
/// </summary>
private void SwitchQueue()
{
try
{
rwLock.EnterWriteLock();
try
{
IQueueContainer <TData> tmp = inContainer;
inContainer = outContainer;
outContainer = tmp;
}
finally
{
rwLock.ExitWriteLock();
}
System.Diagnostics.Trace.WriteLine("[SwitchContainer] queue switched ");
}
catch (Exception exp)
{
throw(new TimeoutException("SwitchContainer::SwitchQueue() timeout", exp));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageWorkerBase"/> class.
/// </summary>
/// <param name="processor">The parent processor.</param>
/// <param name="name">The name of the worker.</param>
/// <exception cref="ArgumentNullException"><paramref name="processor"/> is <see langword="null" />.</exception>
protected MessageWorkerBase(IMessageProcessor processor, string name)
{
if (processor == null)
{
throw new ArgumentNullException("processor");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
_name = name;
_processor = processor;
_container = _processor.Container;
_configuration = _container.Configuration;
_repository = _container.Repository;
_random = new Random();
_pollTimer = new Timer(PollQueue, null, Timeout.Infinite, Timeout.Infinite);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProcessContext"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="container">The collection.</param>
public ProcessContext(Message message, IQueueContainer container)
{
_message = message;
_container = container;
}
private IEnumerator <IAsyncResult> AuthenticateImpl(IStorageAccount storageAccount, RequestContext requestContext, NephosUriComponents uriComponents, AuthenticationManager.GetStringToSignCallback getStringToSignCallback, TimeSpan timeout, AsyncIteratorContext <IAuthenticationResult> context)
{
bool flag;
bool flag1;
SignedAccessHelper queueSignedAccessHelper;
IStorageAccount operationStatus;
ContainerAclSettings containerAclSetting;
string signedVersion = null;
Duration startingNow = Duration.StartingNow;
NameValueCollection queryParameters = requestContext.QueryParameters;
if (AuthenticationManager.IsInvalidAccess(requestContext))
{
throw new InvalidAuthenticationInfoException("Ambiguous authentication scheme credentials providedRequest contains authentication credentials for signed access and authenticated access");
}
bool flag2 = AuthenticationManager.IsAuthenticatedAccess(requestContext);
bool flag3 = AuthenticationManager.IsSignatureAccess(requestContext);
flag = (!flag2 ? false : AuthenticationManager.IsAuthenticatedAccess(requestContext, "SignedKey"));
bool flag4 = flag;
flag1 = (flag2 ? false : !flag3);
if ((!flag2 || flag4) && !flag1)
{
NephosAssertionException.Assert((flag3 ? true : flag4));
bool flag5 = (flag3 ? false : flag4);
if (!AuthenticationManager.IsAccountSasAccess(requestContext.QueryParameters))
{
queueSignedAccessHelper = new QueueSignedAccessHelper(requestContext, uriComponents, flag5);
}
else
{
if (flag5)
{
throw new AuthenticationFailureException("SignedKey is not supported with account-level SAS.");
}
queueSignedAccessHelper = new AccountSasHelper(requestContext, uriComponents);
}
queueSignedAccessHelper.ParseAccessPolicyFields(flag5);
queueSignedAccessHelper.PerformSignedAccessAuthenticationFirstPhaseValidations();
AccountIdentifier signedAccessAccountIdentifier = null;
if (!flag5)
{
byte[] sign = queueSignedAccessHelper.ComputeUrlDecodedUtf8EncodedStringToSign();
if (storageAccount == null || !string.Equals(storageAccount.Name, uriComponents.AccountName))
{
try
{
operationStatus = this.storageManager.CreateAccountInstance(uriComponents.AccountName);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
}
catch (ArgumentOutOfRangeException argumentOutOfRangeException)
{
throw new AuthenticationFailureException(string.Format(CultureInfo.InvariantCulture, "The account name is invalid.", new object[0]));
}
operationStatus.Timeout = startingNow.Remaining(timeout);
IAsyncResult asyncResult = operationStatus.BeginGetProperties(AccountPropertyNames.All, null, context.GetResumeCallback(), context.GetResumeState("XFEQueueAuthenticationManager.AuthenticateImpl"));
yield return(asyncResult);
try
{
operationStatus.EndGetProperties(asyncResult);
}
catch (AccountNotFoundException accountNotFoundException1)
{
AccountNotFoundException accountNotFoundException = accountNotFoundException1;
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] name = new object[] { operationStatus.Name };
throw new AuthenticationFailureException(string.Format(invariantCulture, "Cannot find the claimed account when trying to GetProperties for the account {0}.", name), accountNotFoundException);
}
catch (Exception exception1)
{
Exception exception = exception1;
IStringDataEventStream warning = Logger <IRestProtocolHeadLogger> .Instance.Warning;
object[] objArray = new object[] { operationStatus.Name, exception };
warning.Log("Rethrow exception when trying to GetProperties for the account {0}: {1}", objArray);
throw;
}
}
else
{
operationStatus = storageAccount;
}
if (!queueSignedAccessHelper.ComputeSignatureAndCompare(sign, operationStatus.SecretKeysV3))
{
throw new AuthenticationFailureException(string.Concat("Signature did not match. String to sign used was ", (new UTF8Encoding()).GetString(sign)));
}
NephosAssertionException.Assert(queueSignedAccessHelper.KeyUsedForSigning != null, "Key used for signing cannot be null");
signedAccessAccountIdentifier = queueSignedAccessHelper.CreateAccountIdentifier(operationStatus);
if (storageAccount != operationStatus)
{
operationStatus.Dispose();
}
}
else
{
IAsyncResult asyncResult1 = this.nephosAuthenticationManager.BeginAuthenticate(storageAccount, requestContext, uriComponents, getStringToSignCallback, startingNow.Remaining(timeout), context.GetResumeCallback(), context.GetResumeState("XFEQueueAuthenticationManager.AuthenticateImpl"));
yield return(asyncResult1);
IAuthenticationResult authenticationResult = this.nephosAuthenticationManager.EndAuthenticate(asyncResult1);
signedAccessAccountIdentifier = new SignedAccessAccountIdentifier(authenticationResult.AccountIdentifier);
}
signedVersion = queueSignedAccessHelper.SignedVersion;
if (queueSignedAccessHelper.IsRevocableAccess)
{
using (IQueueContainer queueContainer = this.storageManager.CreateQueueContainerInstance(uriComponents.AccountName, uriComponents.ContainerName))
{
if (requestContext != null)
{
queueContainer.OperationStatus = requestContext.OperationStatus;
}
ContainerPropertyNames containerPropertyName = ContainerPropertyNames.ServiceMetadata;
queueContainer.Timeout = startingNow.Remaining(timeout);
IAsyncResult asyncResult2 = queueContainer.BeginGetProperties(containerPropertyName, null, context.GetResumeCallback(), context.GetResumeState("XFEQueueAuthenticationManager.AuthenticateImpl"));
yield return(asyncResult2);
try
{
queueContainer.EndGetProperties(asyncResult2);
}
catch (Exception exception3)
{
Exception exception2 = exception3;
if (exception2 is ContainerNotFoundException)
{
throw new AuthenticationFailureException("Error locating SAS identifier", exception2);
}
IStringDataEventStream stringDataEventStream = Logger <IRestProtocolHeadLogger> .Instance.Warning;
object[] accountName = new object[] { uriComponents.AccountName, uriComponents.ContainerName, exception2 };
stringDataEventStream.Log("Rethrow exception when trying to fetch SAS identifier account {0} container {1} : {2}", accountName);
throw;
}
try
{
containerAclSetting = new ContainerAclSettings(queueContainer.ServiceMetadata);
}
catch (MetadataFormatException metadataFormatException1)
{
MetadataFormatException metadataFormatException = metadataFormatException1;
throw new NephosStorageDataCorruptionException(string.Format("Error decoding Acl setting for container {0}", uriComponents.ContainerName), metadataFormatException);
}
}
try
{
queueSignedAccessHelper.ValidateAndDeriveEffectiveAccessPolicy(queueSignedAccessHelper.LocateSasIdentifier(containerAclSetting.SASIdentifiers));
queueSignedAccessHelper.PerformSignedAccessAuthenticationSecondPhaseValidations();
signedAccessAccountIdentifier.Initialize(queueSignedAccessHelper);
context.ResultData = new AuthenticationResult(signedAccessAccountIdentifier, signedVersion, true);
}
catch (FormatException formatException)
{
throw new AuthenticationFailureException("Signature fields not well formed.", formatException);
}
}
else
{
signedAccessAccountIdentifier.Initialize(queueSignedAccessHelper);
context.ResultData = new AuthenticationResult(signedAccessAccountIdentifier, signedVersion, true);
}
}
else
{
IAsyncResult asyncResult3 = this.nephosAuthenticationManager.BeginAuthenticate(storageAccount, requestContext, uriComponents, getStringToSignCallback, startingNow.Remaining(timeout), context.GetResumeCallback(), context.GetResumeState("XFEQueueAuthenticationManager.AuthenticateImpl"));
yield return(asyncResult3);
context.ResultData = this.nephosAuthenticationManager.EndAuthenticate(asyncResult3);
}
}
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 object lock_DataWorker = new object(); // Start(),Stop()時的同步物件
#endregion
#region Constructor
/// <summary>
/// 建構子
/// </summary>
/// <param name="workerCount">設定可使用的執行緒數目</param>
public ThreadDataDispatcher(int workerCount, IQueueContainer <TData> queueData)
{
WorkerCount = workerCount;
this.queueData = queueData;
}
internal QueueContainer(IQueueContainer queueContainer) : base(queueContainer)
{
}
