/// <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) { }