public void OnReceived(int streamIndex, ulong id, ScaleoutMessage message)
{
_receive(streamIndex, id, message);
// We assume if a message has come in then the stream is open
Open(streamIndex);
}
// Send messages from the server to the backplane
protected override Task Send(int streamIndex, IList<Message> messages) {
return Task.Factory.StartNew(() => {
var bytes = new ScaleoutMessage(messages).ToBytes();
var filePath = BasePath + "\\" + DateTime.Now.Ticks + ".txt";
File.WriteAllBytes(filePath, bytes);
});
}
public RabbitMqMessageWrapper( IList<Message> messages)
{
if (messages == null)
{
throw new ArgumentNullException("messages");
}
ScaleoutMessage = new ScaleoutMessage(messages);
}
protected override Task Send(int streamIndex, IList<Message> messages)
{
return Task.Factory.StartNew(() =>
{
ScaleoutMessage msg = new ScaleoutMessage(messages);
Bus.Send<DistributeMessages>(m => { m.Payload = msg.ToBytes(); m.StreamIndex = streamIndex; });
});
}
public RabbitMqMessageWrapper(ulong messageIdentifier, IList<Message> messages)
{
if(messages == null)
{
throw new ArgumentNullException("messages");
}
Id = messageIdentifier;
ScaleoutMessage = new ScaleoutMessage(messages);
}
public static string ToScaleoutString(this IList<Message> messages)
{
if (messages == null)
{
throw new ArgumentNullException("messages");
}
var message = new ScaleoutMessage(messages);
return Convert.ToBase64String(message.ToBytes());
}
protected override Task Send(int streamIndex, IList<Message> messages)
{
var message = new ScaleoutMessage(messages);
OnReceived(streamIndex, _id, message);
_id++;
return TaskAsyncHelper.Empty;
}
public static Stream ToStream(IList<Message> messages)
{
if (messages == null)
{
throw new ArgumentNullException("messages");
}
var scaleoutMessage = new ScaleoutMessage(messages);
return new MemoryStream(scaleoutMessage.ToBytes());
}
public static byte[] ToBytes(IList<Message> messages)
{
if (messages == null)
{
throw new ArgumentNullException("messages");
}
var message = new ScaleoutMessage(messages);
return message.ToBytes();
}
private void TraceScaleoutMessages(ulong id, ScaleoutMessage scaleoutMessage)
{
if (!_trace.Switch.ShouldTrace(TraceEventType.Verbose))
{
return;
}
foreach (var message in scaleoutMessage.Messages)
{
_trace.TraceVerbose("Received message {0}: '{1}' over ScaleoutMessageBus", id, message.GetString());
}
}
public static byte[] ToBytes(IList<Message> messages)
{
using (var ms = new MemoryStream())
{
var binaryWriter = new BinaryWriter(ms);
var scaleoutMessage = new ScaleoutMessage(messages);
var buffer = scaleoutMessage.ToBytes();
binaryWriter.Write(buffer.Length);
binaryWriter.Write(buffer);
return ms.ToArray();
}
}
void FromBytesToBytesProducesCorrectValues()
{
var message = new Message("source", "key", "value");
var message2 = new Message("string", "more", "str");
var message3 = new Message("s", "l", "n");
var scaleoutMessage = new ScaleoutMessage(new List<Message>() { message, message2, message3 });
var bytes = scaleoutMessage.ToBytes();
var msg = ScaleoutMessage.FromBytes(bytes);
Assert.True(scaleoutMessage.Messages.Count == 3);
Assert.True(scaleoutMessage.Messages[0].Source == msg.Messages[0].Source, "Source is not the same");
Assert.True(scaleoutMessage.Messages[0].Key == msg.Messages[0].Key, "Key is not the same");
Assert.True(scaleoutMessage.Messages[0].GetString() == msg.Messages[0].GetString(), "Value is not the same");
}
public ScaleoutMapping(ulong id, ScaleoutMessage message, IList<LocalEventKeyInfo> localKeyInfo)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (localKeyInfo == null)
{
throw new ArgumentNullException("localKeyInfo");
}
Id = id;
LocalKeyInfo = localKeyInfo;
ServerCreationTime = message.ServerCreationTime;
}
public ScaleoutMapping(ulong id, ScaleoutMessage message, IList <LocalEventKeyInfo> localKeyInfo)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (localKeyInfo == null)
{
throw new ArgumentNullException("localKeyInfo");
}
Id = id;
LocalKeyInfo = localKeyInfo;
ServerCreationTime = message.ServerCreationTime;
}
private void OnReceivedCore(int streamIndex, ulong id, ScaleoutMessage scaleoutMessage)
{
Counters.ScaleoutMessageBusMessagesReceivedPerSec.IncrementBy(scaleoutMessage.Messages.Count);
_trace.TraceInformation("OnReceived({0}, {1}, {2})", streamIndex, id, scaleoutMessage.Messages.Count);
TraceScaleoutMessages(id, scaleoutMessage);
var localMapping = new LocalEventKeyInfo[scaleoutMessage.Messages.Count];
var keys = new HashSet <string>();
for (var i = 0; i < scaleoutMessage.Messages.Count; ++i)
{
Message message = scaleoutMessage.Messages[i];
// Remember where this message came from
message.MappingId = id;
message.StreamIndex = streamIndex;
keys.Add(message.Key);
ulong localId = Save(message);
_trace.TraceVerbose("Message id: {0}, stream : {1}, eventKey: '{2}' saved with local id: {3}",
id, streamIndex, message.Key, localId);
MessageStore <Message> messageStore = Topics[message.Key].Store;
localMapping[i] = new LocalEventKeyInfo(message.Key, localId, messageStore);
}
// Get the stream for this payload
ScaleoutMappingStore store = StreamManager.Streams[streamIndex];
// Publish only after we've setup the mapping fully
store.Add(id, scaleoutMessage, localMapping);
if (_trace.Switch.ShouldTrace(TraceEventType.Verbose))
{
_trace.TraceVerbose("Scheduling eventkeys: {0}", string.Join(",", keys));
}
// Schedule after we're done
foreach (var eventKey in keys)
{
ScheduleEvent(eventKey);
}
}
protected override Task Send(int streamIndex, IList<Message> messages)
{
return Task.Run(() =>
{
var scaleoutMsg = new ScaleoutMessage(messages);
var msg = new RmqMessage
{
StreamIndex = streamIndex,
Id = 0,
Body = scaleoutMsg.ToBytes()
};
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(msg));
model.BasicPublish("messages", "", true, new BasicProperties(), body);
});
}
public static byte[] ToBytes(IList<Message> messages)
{
if (messages == null)
{
throw new ArgumentNullException("messages");
}
using (var ms = new MemoryStream())
{
var binaryWriter = new BinaryWriter(ms);
var scaleoutMessage = new ScaleoutMessage(messages);
var buffer = scaleoutMessage.ToBytes();
binaryWriter.Write(buffer.Length);
binaryWriter.Write(buffer);
return ms.ToArray();
}
}
private void OnReceivedCore(int streamIndex, ulong id, ScaleoutMessage scaleoutMessage)
{
Counters.ScaleoutMessageBusMessagesReceivedPerSec.IncrementBy(scaleoutMessage.Messages.Count);
_trace.TraceInformation("OnReceived({0}, {1}, {2})", streamIndex, id, scaleoutMessage.Messages.Count);
var localMapping = new Dictionary <string, IList <LocalEventKeyInfo> >(StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < scaleoutMessage.Messages.Count; ++i)
{
Message message = scaleoutMessage.Messages[i];
// Remember where this message came from
message.MappingId = id;
message.StreamIndex = streamIndex;
IList <LocalEventKeyInfo> keyInfo;
if (!localMapping.TryGetValue(message.Key, out keyInfo))
{
keyInfo = new List <LocalEventKeyInfo>();
localMapping.Add(message.Key, keyInfo);
}
ulong localId = Save(message);
MessageStore <Message> messageStore = Topics[message.Key].Store;
keyInfo.Add(new LocalEventKeyInfo(localId, messageStore));
}
// Get the stream for this payload
ScaleoutMappingStore store = StreamManager.Streams[streamIndex];
// Publish only after we've setup the mapping fully
store.Add(id, scaleoutMessage, localMapping);
// Schedule after we're done
foreach (var eventKey in localMapping.Keys)
{
ScheduleEvent(eventKey);
}
}
public static ScaleoutMessage FromBytes(byte[] data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
using (var stream = new MemoryStream(data))
{
var binaryReader = new BinaryReader(stream);
var message = new ScaleoutMessage();
message.Messages = new List <Message>();
int count = binaryReader.ReadInt32();
for (int i = 0; i < count; i++)
{
message.Messages.Add(Message.ReadFrom(stream));
}
message.ServerCreationTime = new DateTime(binaryReader.ReadInt64());
return(message);
}
}
public static ScaleoutMessage FromBytes(byte[] data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
using (var stream = new MemoryStream(data))
{
var binaryReader = new BinaryReader(stream);
var message = new ScaleoutMessage();
message.Messages = new List<Message>();
int count = binaryReader.ReadInt32();
for (int i = 0; i < count; i++)
{
message.Messages.Add(Message.ReadFrom(stream));
}
message.ServerCreationTime = new DateTime(binaryReader.ReadInt64());
return message;
}
}
private void OnReceivedCore(int streamIndex, ulong id, ScaleoutMessage scaleoutMessage)
{
Counters.ScaleoutMessageBusMessagesReceivedPerSec.IncrementBy(scaleoutMessage.Messages.Count);
_logger.WriteInformation(String.Format("OnReceived({0}, {1}, {2})", streamIndex, id, scaleoutMessage.Messages.Count));
var localMapping = new LocalEventKeyInfo[scaleoutMessage.Messages.Count];
var keys = new HashSet <string>();
for (var i = 0; i < scaleoutMessage.Messages.Count; ++i)
{
Message message = scaleoutMessage.Messages[i];
// Remember where this message came from
message.MappingId = id;
message.StreamIndex = streamIndex;
keys.Add(message.Key);
ulong localId = Save(message);
MessageStore <Message> messageStore = Topics[message.Key].Store;
localMapping[i] = new LocalEventKeyInfo(message.Key, localId, messageStore);
}
// Get the stream for this payload
ScaleoutMappingStore store = StreamManager.Streams[streamIndex];
// Publish only after we've setup the mapping fully
store.Add(id, scaleoutMessage, localMapping);
// Schedule after we're done
foreach (var eventKey in keys)
{
ScheduleEvent(eventKey);
}
}
public ScaleoutMapping(ulong id, ScaleoutMessage message)
: this(id, message, new Dictionary <string, IList <LocalEventKeyInfo> >())
{
}
new internal void OnReceived(int streamIndex, ulong id, ScaleoutMessage messages)
{
base.OnReceived(streamIndex, id, messages);
}
private void OnReceivedCore(int streamIndex, ulong id, ScaleoutMessage scaleoutMessage)
{
Counters.ScaleoutMessageBusMessagesReceivedPerSec.IncrementBy(scaleoutMessage.Messages.Count);
_trace.TraceInformation("OnReceived({0}, {1}, {2})", streamIndex, id, scaleoutMessage.Messages.Count);
var localMapping = new Dictionary<string, IList<LocalEventKeyInfo>>(StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < scaleoutMessage.Messages.Count; ++i)
{
Message message = scaleoutMessage.Messages[i];
// Remember where this message came from
message.MappingId = id;
message.StreamIndex = streamIndex;
IList<LocalEventKeyInfo> keyInfo;
if (!localMapping.TryGetValue(message.Key, out keyInfo))
{
keyInfo = new List<LocalEventKeyInfo>();
localMapping.Add(message.Key, keyInfo);
}
ulong localId = Save(message);
MessageStore<Message> messageStore = Topics[message.Key].Store;
keyInfo.Add(new LocalEventKeyInfo(localId, messageStore));
}
// Get the stream for this payload
ScaleoutMappingStore store = StreamManager.Streams[streamIndex];
// Publish only after we've setup the mapping fully
store.Add(id, scaleoutMessage, localMapping);
// Schedule after we're done
foreach (var eventKey in localMapping.Keys)
{
ScheduleEvent(eventKey);
}
}
public void SingleMessageOnlyVerifyIds()
{
var store = new ScaleoutStore(10);
var message = new ScaleoutMessage();
store.Add(new ScaleoutMapping(10ul, message));
Assert.Equal(10ul, store.MinMappingId);
Assert.Equal(10ul, store.MaxMapping.Id);
}
public ScaleoutMapping(ulong id, ScaleoutMessage message)
: this(id, message, ListHelper <LocalEventKeyInfo> .Empty)
{
}
public void AssertMessagesWithCursorForRange(int[] values, ulong targetId, ulong firstId, int count)
{
var store = new ScaleoutStore(10);
var message = new ScaleoutMessage();
foreach (var v in values)
{
store.Add(new ScaleoutMapping((ulong)v, message));
}
var result = store.GetMessagesByMappingId(targetId);
Assert.Equal(firstId, result.FirstMessageId);
Assert.Equal(count, result.Messages.Count);
}
private void OnReceivedCore(int streamIndex, ulong id, ScaleoutMessage scaleoutMessage)
{
Counters.ScaleoutMessageBusMessagesReceivedPerSec.IncrementBy(scaleoutMessage.Messages.Count);
_trace.TraceInformation("OnReceived({0}, {1}, {2})", streamIndex, id, scaleoutMessage.Messages.Count);
var localMapping = new LocalEventKeyInfo[scaleoutMessage.Messages.Count];
var keys = new HashSet<string>();
for (var i = 0; i < scaleoutMessage.Messages.Count; ++i)
{
Message message = scaleoutMessage.Messages[i];
// Remember where this message came from
message.MappingId = id;
message.StreamIndex = streamIndex;
keys.Add(message.Key);
ulong localId = Save(message);
MessageStore<Message> messageStore = Topics[message.Key].Store;
localMapping[i] = new LocalEventKeyInfo(message.Key, localId, messageStore);
}
// Get the stream for this payload
ScaleoutMappingStore store = StreamManager.Streams[streamIndex];
// Publish only after we've setup the mapping fully
store.Add(id, scaleoutMessage, localMapping);
// Schedule after we're done
foreach (var eventKey in keys)
{
ScheduleEvent(eventKey);
}
}
public void Publish(int streamIndex, ulong id, IList<Message> messages, DateTime creationTime)
{
var message = new ScaleoutMessage
{
Messages = messages,
ServerCreationTime = creationTime,
};
OnReceived(streamIndex, id, message);
}
public void AccurateMappingIds()
{
var store = new ScaleoutStore(10);
var message1 = new ScaleoutMessage();
store.Add(new ScaleoutMapping(10ul, message1));
var message2 = new ScaleoutMessage();
store.Add(new ScaleoutMapping(15ul, message2));
Assert.Equal(10ul, store.MinMappingId);
Assert.Equal(15ul, store.MaxMapping.Id);
}
public ScaleoutMapping(ulong id, ScaleoutMessage message)
: this(id, message, ListHelper<LocalEventKeyInfo>.Empty)
{
}
public void MinMappingIdMovesWhenOverflow()
{
var store = new ScaleoutStore(5);
int id = 0;
for (int i = 0; i < store.FragmentSize + 1; i++)
{
for (int j = 0; j < store.FragmentCount; j++)
{
var message = new ScaleoutMessage();
store.Add(new ScaleoutMapping((ulong)id, message));
id++;
}
}
Assert.Equal((ulong)store.FragmentSize - 1, store.MinMappingId);
}
private void forwardMessage(ulong id, ScaleoutMessage smsg)
{
//lock (_recvLock)
{
OnReceived(0, id, smsg);
lastReceived = DateTime.Now;
}
}
public void GettingMessagesWithCursorLowerThanMinReturnsAll()
{
var store = new ScaleoutStore(10);
for (int i = 5; i < 10; i++)
{
var message = new ScaleoutMessage();
store.Add(new ScaleoutMapping((ulong)i, message));
}
var result = store.GetMessagesByMappingId(4);
Assert.Equal(0ul, result.FirstMessageId);
Assert.Equal(5ul, store.MinMappingId);
Assert.Equal(5, result.Messages.Count);
}
public void GettingMessagesWithCursorInbetweenOnElementRangeGetsAll()
{
var store = new ScaleoutStore(10);
var message = new ScaleoutMessage();
store.Add(new ScaleoutMapping((ulong)1, message));
var result = store.GetMessagesByMappingId(2);
Assert.Equal(0ul, result.FirstMessageId);
Assert.Equal(0, result.Messages.Count);
}
/// <summary>
/// Invoked when a payload is received from the backplane. There should only be one active call at any time.
/// </summary>
/// <param name="streamIndex">id of the stream.</param>
/// <param name="id">id of the payload within that stream.</param>
/// <param name="message">The scaleout message.</param>
/// <returns></returns>
protected virtual void OnReceived(int streamIndex, ulong id, ScaleoutMessage message)
{
StreamManager.OnReceived(streamIndex, id, message);
}
/// <summary>
/// Invoked when a payload is received from the backplane. There should only be one active call at any time.
/// </summary>
/// <param name="streamIndex">id of the stream.</param>
/// <param name="id">id of the payload within that stream.</param>
/// <param name="message">The scaleout message.</param>
/// <returns></returns>
protected virtual void OnReceived(int streamIndex, ulong id, ScaleoutMessage message)
{
StreamManager.OnReceived(streamIndex, id, message);
}
public void GettingMessagesWithCursorBiggerThanMaxReturnsNothingIfNewer()
{
var store = new ScaleoutStore(10);
for (int i = 0; i < 5; i++)
{
var message = new ScaleoutMessage();
store.Add(new ScaleoutMapping((ulong)i, message));
}
var result = store.GetMessagesByMappingId(6);
Assert.Equal(0, result.Messages.Count);
}
public void GettingMessagesWithSentinelCursorReturnsEverything()
{
var store = new ScaleoutStore(10);
var message = new ScaleoutMessage();
store.Add(new ScaleoutMapping((ulong)0, message));
var result = store.GetMessagesByMappingId(UInt64.MaxValue);
Assert.Equal(0ul, result.FirstMessageId);
Assert.Equal(1, result.Messages.Count);
}
