/// <summary> /// Deserializes an event sequence token /// </summary> /// <param name="expected">The expected type.</param> /// <param name="reader">The binary stream to read from.</param> /// <returns></returns> public static object Deserialize(Type expected, BinaryTokenStreamReader reader) { var result = new EventSequenceTokenV2(reader.ReadLong(), reader.ReadInt()); DeserializationContext.Current.RecordObject(result); return(result); }
/// <summary> /// Deserializes an event sequence token /// </summary> /// <param name="expected">The expected type.</param> /// <param name="context">The deserialization context.</param> /// <returns></returns> public static object Deserialize(Type expected, IDeserializationContext context) { var reader = context.StreamReader; var result = new EventSequenceTokenV2(reader.ReadLong(), reader.ReadInt()); context.RecordObject(result); return(result); }
public void EventSequenceTokenV2_Serialize_IfNotNull() { var writer = new BinaryTokenStreamWriter(); var token = new EventSequenceTokenV2(long.MaxValue, int.MaxValue); EventSequenceTokenV2.Serialize(token, writer, null); var reader = new BinaryTokenStreamReader(writer.ToByteArray()); var deserialized = EventSequenceTokenV2.Deserialize(typeof(EventSequenceTokenV2), reader) as EventSequenceTokenV2; Assert.NotNull(deserialized); Assert.NotSame(token, deserialized); Assert.Equal(token.EventIndex, deserialized.EventIndex); Assert.Equal(token.SequenceNumber, deserialized.SequenceNumber); }
/// <summary> /// Create a deep copy of the token. /// </summary> /// <param name="original">The token to copy</param> /// <returns>A copy</returns> public static object DeepCopy(object original) { var source = original as EventSequenceTokenV2; if (source == null) { return null; } var copy = new EventSequenceTokenV2(source.SequenceNumber, source.EventIndex); SerializationContext.Current.RecordObject(original, copy); return copy; }
/// <summary> /// Create a deep copy of the token. /// </summary> /// <param name="original">The token to copy</param> /// <returns>A copy</returns> public static object DeepCopy(object original) { var source = original as EventSequenceTokenV2; if (source == null) { return(null); } var copy = new EventSequenceTokenV2(source.SequenceNumber, source.EventIndex); SerializationContext.Current.RecordObject(original, copy); return(copy); }
/// <summary> /// Create a deep copy of the token. /// </summary> /// <param name="original">The token to copy</param> /// <param name="context">The serialization context.</param> /// <returns>A copy</returns> public static object DeepCopy(object original, ICopyContext context) { var source = original as EventSequenceTokenV2; if (source == null) { return(null); } var copy = new EventSequenceTokenV2(source.SequenceNumber, source.EventIndex); context.RecordCopy(original, copy); return(copy); }
public void EventSequenceTokenV2_DeepCopy_IfNotNull() { var token = new EventSequenceTokenV2(long.MaxValue, int.MaxValue); var copy = EventSequenceTokenV2.DeepCopy(token) as EventSequenceToken; Assert.NotNull(copy); Assert.NotSame(token, copy); Assert.Equal(token.EventIndex, copy.EventIndex); Assert.Equal(token.SequenceNumber, copy.SequenceNumber); var writer = new BinaryTokenStreamWriter(); SerializationManager.Serialize(token, writer); var bytes = writer.ToByteArray(); var reader = new BinaryTokenStreamReader(bytes); copy = SerializationManager.Deserialize(reader) as EventSequenceToken; Assert.NotNull(copy); Assert.NotSame(token, copy); Assert.Equal(token.EventIndex, copy.EventIndex); Assert.Equal(token.SequenceNumber, copy.SequenceNumber); }
private async Task SendAndReceiveFromQueueAdapter(IQueueAdapterFactory adapterFactory, IProviderConfiguration config) { IQueueAdapter adapter = await adapterFactory.CreateAdapter(); IQueueAdapterCache cache = adapterFactory.GetQueueAdapterCache(); // Create receiver per queue IStreamQueueMapper mapper = adapterFactory.GetStreamQueueMapper(); Dictionary<QueueId, IQueueAdapterReceiver> receivers = mapper.GetAllQueues().ToDictionary(queueId => queueId, adapter.CreateReceiver); Dictionary<QueueId, IQueueCache> caches = mapper.GetAllQueues().ToDictionary(queueId => queueId, cache.CreateQueueCache); await Task.WhenAll(receivers.Values.Select(receiver => receiver.Initialize(TimeSpan.FromSeconds(5)))); // test using 2 streams Guid streamId1 = Guid.NewGuid(); Guid streamId2 = Guid.NewGuid(); int receivedBatches = 0; var streamsPerQueue = new ConcurrentDictionary<QueueId, HashSet<IStreamIdentity>>(); // reader threads (at most 2 active queues because only two streams) var work = new List<Task>(); foreach( KeyValuePair<QueueId, IQueueAdapterReceiver> receiverKvp in receivers) { QueueId queueId = receiverKvp.Key; var receiver = receiverKvp.Value; var qCache = caches[queueId]; Task task = Task.Factory.StartNew(() => { while (receivedBatches < NumBatches) { var messages = receiver.GetQueueMessagesAsync(CloudQueueMessage.MaxNumberOfMessagesToPeek).Result.ToArray(); if (!messages.Any()) { continue; } foreach (AzureQueueBatchContainer message in messages.Cast<AzureQueueBatchContainer>()) { streamsPerQueue.AddOrUpdate(queueId, id => new HashSet<IStreamIdentity> { new StreamIdentity(message.StreamGuid, message.StreamGuid.ToString()) }, (id, set) => { set.Add(new StreamIdentity(message.StreamGuid, message.StreamGuid.ToString())); return set; }); output.WriteLine("Queue {0} received message on stream {1}", queueId, message.StreamGuid); Assert.Equal(NumMessagesPerBatch / 2, message.GetEvents<int>().Count()); // "Half the events were ints" Assert.Equal(NumMessagesPerBatch / 2, message.GetEvents<string>().Count()); // "Half the events were strings" } Interlocked.Add(ref receivedBatches, messages.Length); qCache.AddToCache(messages); } }); work.Add(task); } // send events List<object> events = CreateEvents(NumMessagesPerBatch); work.Add(Task.Factory.StartNew(() => Enumerable.Range(0, NumBatches) .Select(i => i % 2 == 0 ? streamId1 : streamId2) .ToList() .ForEach(streamId => adapter.QueueMessageBatchAsync(streamId, streamId.ToString(), events.Take(NumMessagesPerBatch).ToArray(), null, RequestContext.Export()).Wait()))); await Task.WhenAll(work); // Make sure we got back everything we sent Assert.Equal(NumBatches, receivedBatches); // check to see if all the events are in the cache and we can enumerate through them StreamSequenceToken firstInCache = new EventSequenceTokenV2(0); foreach (KeyValuePair<QueueId, HashSet<IStreamIdentity>> kvp in streamsPerQueue) { var receiver = receivers[kvp.Key]; var qCache = caches[kvp.Key]; foreach (IStreamIdentity streamGuid in kvp.Value) { // read all messages in cache for stream IQueueCacheCursor cursor = qCache.GetCacheCursor(streamGuid, firstInCache); int messageCount = 0; StreamSequenceToken tenthInCache = null; StreamSequenceToken lastToken = firstInCache; while (cursor.MoveNext()) { Exception ex; messageCount++; IBatchContainer batch = cursor.GetCurrent(out ex); output.WriteLine("Token: {0}", batch.SequenceToken); Assert.True(batch.SequenceToken.CompareTo(lastToken) >= 0, $"order check for event {messageCount}"); lastToken = batch.SequenceToken; if (messageCount == 10) { tenthInCache = batch.SequenceToken; } } output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid); Assert.Equal(NumBatches / 2, messageCount); Assert.NotNull(tenthInCache); // read all messages from the 10th cursor = qCache.GetCacheCursor(streamGuid, tenthInCache); messageCount = 0; while (cursor.MoveNext()) { messageCount++; } output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid); const int expected = NumBatches / 2 - 10 + 1; // all except the first 10, including the 10th (10 + 1) Assert.Equal(expected, messageCount); } } }
/// <summary> /// Deserializes an event sequence token /// </summary> /// <param name="expected">The expected type.</param> /// <param name="reader">The binary stream to read from.</param> /// <returns></returns> public static object Deserialize(Type expected, BinaryTokenStreamReader reader) { var result = new EventSequenceTokenV2(reader.ReadLong(), reader.ReadInt()); DeserializationContext.Current.RecordObject(result); return result; }