public ScaleoutStreamManager(Func <int, IList <Message>, Task> send,
Action <int, ulong, ScaleoutMessage> receive,
int streamCount,
TraceSource trace,
IPerformanceCounterManager performanceCounters,
ScaleoutConfiguration configuration,
int maxScaleoutMappings)
{
if (configuration.QueueBehavior != QueuingBehavior.Disabled && configuration.MaxQueueLength == 0)
{
throw new InvalidOperationException(Resources.Error_ScaleoutQueuingConfig);
}
_streams = new ScaleoutStream[streamCount];
_send = send;
_receive = receive;
var receiveMapping = new ScaleoutMappingStore[streamCount];
performanceCounters.ScaleoutStreamCountTotal.RawValue = streamCount;
performanceCounters.ScaleoutStreamCountBuffering.RawValue = streamCount;
performanceCounters.ScaleoutStreamCountOpen.RawValue = 0;
for (int i = 0; i < streamCount; i++)
{
_streams[i] = new ScaleoutStream(trace, "Stream(" + i + ")", configuration.QueueBehavior, configuration.MaxQueueLength, performanceCounters);
receiveMapping[i] = new ScaleoutMappingStore(maxScaleoutMappings);
}
Streams = new ReadOnlyCollection <ScaleoutMappingStore>(receiveMapping);
}
private IEnumerable <Tuple <ScaleoutMapping, int> > GetMappings()
{
var enumerators = new List <CachedStreamEnumerator>();
var singleStream = _streams.Count == 1;
for (var streamIndex = 0; streamIndex < _streams.Count; ++streamIndex)
{
// Get the mapping for this stream
ScaleoutMappingStore store = _streams[streamIndex];
Cursor cursor = _cursors[streamIndex];
// Try to find a local mapping for this payload
var enumerator = new CachedStreamEnumerator(store.GetEnumerator(cursor.Id),
streamIndex);
enumerators.Add(enumerator);
}
var counter = 0;
while (enumerators.Count > 0)
{
ScaleoutMapping minMapping = null;
CachedStreamEnumerator minEnumerator = null;
for (int i = enumerators.Count - 1; i >= 0; i--)
{
counter += 1;
CachedStreamEnumerator enumerator = enumerators[i];
ScaleoutMapping mapping;
if (enumerator.TryMoveNext(out mapping))
{
if (minMapping == null || mapping.ServerCreationTime < minMapping.ServerCreationTime)
{
minMapping = mapping;
minEnumerator = enumerator;
}
}
else
{
enumerators.RemoveAt(i);
}
}
if (minMapping != null)
{
minEnumerator.ClearCachedValue();
yield return(Tuple.Create(minMapping, minEnumerator.StreamIndex));
}
}
_trace.TraceEvent(TraceEventType.Verbose, 0, $"End of mappings (connection ID: {Identity}). Total mappings processed: {counter}");
}
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);
}
}