// Placed object message payload into a segment from a buffer pool. When this get's too big, older blocks will be purged private ArraySegment <byte> SerializeMessageIntoPooledSegment(MemoryMessageData queueMessage) { // serialize payload int size = SegmentBuilder.CalculateAppendSize(queueMessage.Payload); // get segment from current block ArraySegment <byte> segment; if (currentBuffer == null || !currentBuffer.TryGetSegment(size, out segment)) { // no block or block full, get new block and try again currentBuffer = bufferPool.Allocate(); //call EvictionStrategy's OnBlockAllocated method this.evictionStrategy.OnBlockAllocated(currentBuffer); // if this fails with clean block, then requested size is too big if (!currentBuffer.TryGetSegment(size, out segment)) { string errmsg = String.Format(CultureInfo.InvariantCulture, "Message size is too big. MessageSize: {0}", size); throw new ArgumentOutOfRangeException(nameof(queueMessage), errmsg); } } // encode namespace, offset, partitionkey, properties and payload into segment int writeOffset = 0; SegmentBuilder.Append(segment, ref writeOffset, queueMessage.Payload); return(segment); }
public IBatchContainer GetBatchContainer(ref CachedMessage cachedMessage) { //Deserialize payload int readOffset = 0; ArraySegment <byte> payload = SegmentBuilder.ReadNextBytes(cachedMessage.Segment, ref readOffset); MemoryMessageData message = MemoryMessageData.Create(cachedMessage.StreamGuid, cachedMessage.StreamNamespace, new ArraySegment <byte>(payload.ToArray())); return(new MemoryBatchContainer <TSerializer>(message, this.serializer)); }
/// <summary> /// Enqueues an event data. If the current total count reaches the max limit. throws an exception. /// </summary> /// <param name="data"></param> /// <returns></returns> public Task Enqueue(MemoryMessageData data) { if (eventQueue.Count >= maxEventCount) { throw new InvalidOperationException($"Can not enqueue since the count has reached its maximum of {maxEventCount}"); } data.SequenceNumber = sequenceNumber++; eventQueue.Enqueue(data); return(Task.CompletedTask); }
/// <summary> /// Enqueues an event data. If the current total count reaches the max limit. throws an exception. /// </summary> /// <param name="data"></param> /// <returns></returns> public Task Enqueue(MemoryMessageData data) { if (eventQueue.Count >= maxEventCount) { throw new InvalidOperationException($"Can not enqueue since the count has reached its maximum of {maxEventCount}"); } data.SequenceNumber = sequenceNumber++; eventQueue.Enqueue(data); return TaskDone.Done; }
private CachedMessage QueueMessageToCachedMessage(MemoryMessageData queueMessage, DateTime dequeueTimeUtc) { StreamPosition streamPosition = GetStreamPosition(queueMessage); return(new CachedMessage() { StreamId = streamPosition.StreamId, SequenceNumber = queueMessage.SequenceNumber, EnqueueTimeUtc = queueMessage.EnqueueTimeUtc, DequeueTimeUtc = dequeueTimeUtc, Segment = SerializeMessageIntoPooledSegment(queueMessage) }); }
private CachedMessage QueueMessageToCachedMessage(MemoryMessageData queueMessage, DateTime dequeueTimeUtc) { StreamPosition streamPosition = GetStreamPosition(queueMessage); return(new CachedMessage() { StreamGuid = streamPosition.StreamIdentity.Guid, StreamNamespace = streamPosition.StreamIdentity.Namespace != null?string.Intern(streamPosition.StreamIdentity.Namespace) : null, SequenceNumber = queueMessage.SequenceNumber, EnqueueTimeUtc = queueMessage.EnqueueTimeUtc, DequeueTimeUtc = dequeueTimeUtc, Segment = SerializeMessageIntoPooledSegment(queueMessage) }); }
/// <summary> /// Writes a set of events to the queue as a single batch associated with the provided streamId. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="streamGuid"></param> /// <param name="streamNamespace"></param> /// <param name="events"></param> /// <param name="token"></param> /// <param name="requestContext"></param> /// <returns></returns> public async Task QueueMessageBatchAsync <T>(Guid streamGuid, string streamNamespace, IEnumerable <T> events, StreamSequenceToken token, Dictionary <string, object> requestContext) { try { var queueId = streamQueueMapper.GetQueueForStream(streamGuid, streamNamespace); ArraySegment <byte> bodyBytes = serializer.Serialize(new MemoryMessageBody(events.Cast <object>(), requestContext)); var messageData = MemoryMessageData.Create(streamGuid, streamNamespace, bodyBytes); IMemoryStreamQueueGrain queueGrain = GetQueueGrain(queueId); await queueGrain.Enqueue(messageData); } catch (Exception exc) { logger.Error((int)ProviderErrorCode.MemoryStreamProviderBase_QueueMessageBatchAsync, "Exception thrown in MemoryAdapterFactory.QueueMessageBatchAsync.", exc); throw; } }
private StreamPosition GetStreamPosition(MemoryMessageData queueMessage) { return(new StreamPosition(queueMessage.StreamId, new EventSequenceTokenV2(queueMessage.SequenceNumber))); }
private StreamPosition GetStreamPosition(MemoryMessageData queueMessage) { return(new StreamPosition(new StreamIdentity(queueMessage.StreamGuid, queueMessage.StreamNamespace), new EventSequenceTokenV2(queueMessage.SequenceNumber))); }
public MemoryBatchContainer(MemoryMessageData messageData, TSerializer serializer) { this.serializer = serializer; MessageData = messageData; realToken = new EventSequenceToken(messageData.SequenceNumber); }
public MemoryBatchContainer(MemoryMessageData messageData) { serializer = new TSerializer(); MessageData = messageData; realToken = new EventSequenceToken(messageData.SequenceNumber); }