public void Handle(ClientMessage.ConnectToPersistentSubscription message)
{
if (!_started)
{
return;
}
var streamAccess = _readIndex.CheckStreamAccess(
message.EventStreamId, StreamAccessType.Read, message.User);
if (!streamAccess.Granted)
{
message.Envelope.ReplyWith(new ClientMessage.SubscriptionDropped(message.CorrelationId,
SubscriptionDropReason.AccessDenied));
return;
}
List <PersistentSubscription> subscribers;
if (!_subscriptionTopics.TryGetValue(message.EventStreamId, out subscribers))
{
message.Envelope.ReplyWith(new ClientMessage.SubscriptionDropped(message.CorrelationId,
SubscriptionDropReason.NotFound));
return;
}
var key = BuildSubscriptionGroupKey(message.EventStreamId, message.SubscriptionId);
PersistentSubscription subscription;
if (!_subscriptionsById.TryGetValue(key, out subscription))
{
message.Envelope.ReplyWith(new ClientMessage.SubscriptionDropped(message.CorrelationId,
SubscriptionDropReason.NotFound));
return;
}
if (subscription.HasReachedMaxClientCount)
{
message.Envelope.ReplyWith(new ClientMessage.SubscriptionDropped(message.CorrelationId,
SubscriptionDropReason.SubscriberMaxCountReached));
return;
}
Log.Debug("New connection to persistent subscription {subscriptionKey} by {connectionId}", key,
message.ConnectionId);
var lastEventNumber = _readIndex.GetStreamLastEventNumber(message.EventStreamId);
var lastCommitPos = _readIndex.LastIndexedPosition;
var subscribedMessage =
new ClientMessage.PersistentSubscriptionConfirmation(key, message.CorrelationId, lastCommitPos,
lastEventNumber);
message.Envelope.ReplyWith(subscribedMessage);
var name = message.User == null ? "anonymous" : message.User.Identity.Name;
subscription.AddClient(message.CorrelationId, message.ConnectionId, message.ConnectionName, message.Envelope,
message.AllowedInFlightMessages, name, message.From);
}
private ClientMessage.ReadEventCompleted ReadEvent(ClientMessage.ReadEvent msg)
{
using (HistogramService.Measure(_readerReadHistogram)) {
try {
var access = _readIndex.CheckStreamAccess(msg.EventStreamId, StreamAccessType.Read, msg.User);
if (!access.Granted)
{
return(NoData(msg, ReadEventResult.AccessDenied));
}
var result = _readIndex.ReadEvent(msg.EventStreamId, msg.EventNumber);
var record = result.Result == ReadEventResult.Success && msg.ResolveLinkTos
? ResolveLinkToEvent(result.Record, msg.User, null)
: ResolvedEvent.ForUnresolvedEvent(result.Record);
if (record == null)
{
return(NoData(msg, ReadEventResult.AccessDenied));
}
if ((result.Result == ReadEventResult.NoStream ||
result.Result == ReadEventResult.NotFound) &&
result.OriginalStreamExists &&
SystemStreams.IsSystemStream(msg.EventStreamId))
{
return(NoData(msg, ReadEventResult.Success));
}
return(new ClientMessage.ReadEventCompleted(msg.CorrelationId, msg.EventStreamId, result.Result,
record.Value, result.Metadata, access.Public, null));
} catch (Exception exc) {
Log.ErrorException(exc, "Error during processing ReadEvent request.");
return(NoData(msg, ReadEventResult.Error, exc.Message));
}
}
}
private ClientMessage.ReadEventCompleted ReadEvent(ClientMessage.ReadEvent msg)
{
try
{
var access = _readIndex.CheckStreamAccess(msg.EventStreamId, StreamAccessType.Read, msg.User);
if (!access.Granted)
{
return(NoData(msg, ReadEventResult.AccessDenied));
}
var result = _readIndex.ReadEvent(msg.EventStreamId, msg.EventNumber);
var record = result.Result == ReadEventResult.Success && msg.ResolveLinkTos
? ResolveLinkToEvent(result.Record, msg.User)
: new ResolvedEvent(result.Record);
if (record == null)
{
return(NoData(msg, ReadEventResult.AccessDenied));
}
return(new ClientMessage.ReadEventCompleted(msg.CorrelationId, msg.EventStreamId, result.Result,
record.Value, result.Metadata, access.Public, null));
}
catch (Exception exc)
{
Log.ErrorException(exc, "Error during processing ReadEvent request.");
return(NoData(msg, ReadEventResult.Error, exc.Message));
}
}
public void Handle(ClientMessage.CreatePersistentSubscription message)
{
if (!_started)
{
return;
}
var key = BuildSubscriptionGroupKey(message.EventStreamId, message.GroupName);
Log.Debug("Creating persistent subscription {0}", key);
//TODO revisit for permissions. maybe make admin only?
var streamAccess = _readIndex.CheckStreamAccess(SystemStreams.SettingsStream, StreamAccessType.Write, message.User);
if (!streamAccess.Granted)
{
message.Envelope.ReplyWith(new ClientMessage.CreatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.CreatePersistentSubscriptionCompleted.CreatePersistentSubscriptionResult.AccessDenied,
"You do not have permissions to create streams"));
return;
}
if (_subscriptionsById.ContainsKey(key))
{
message.Envelope.ReplyWith(new ClientMessage.CreatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.CreatePersistentSubscriptionCompleted.CreatePersistentSubscriptionResult.AlreadyExists,
"Group '" + message.GroupName + "' already exists."));
return;
}
if (message.EventStreamId == null || message.EventStreamId == "" || message.EventStreamId == "$all")
{
message.Envelope.ReplyWith(new ClientMessage.CreatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.CreatePersistentSubscriptionCompleted.CreatePersistentSubscriptionResult.Fail,
"Bad stream name."));
return;
}
if (!_consumerStrategyRegistry.ValidateStrategy(message.NamedConsumerStrategy))
{
message.Envelope.ReplyWith(new ClientMessage.CreatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.CreatePersistentSubscriptionCompleted.CreatePersistentSubscriptionResult.Fail,
string.Format("Consumer strategy {0} does not exist.", message.NamedConsumerStrategy)));
return;
}
CreateSubscriptionGroup(message.EventStreamId,
message.GroupName,
message.ResolveLinkTos,
message.StartFrom,
message.RecordStatistics,
message.MaxRetryCount,
message.LiveBufferSize,
message.BufferSize,
message.ReadBatchSize,
ToTimeout(message.CheckPointAfterMilliseconds),
message.MinCheckPointCount,
message.MaxCheckPointCount,
message.MaxSubscriberCount,
message.NamedConsumerStrategy,
ToTimeout(message.MessageTimeoutMilliseconds)
);
Log.Debug("New persistent subscription {0}", key);
_config.Updated = DateTime.Now;
_config.UpdatedBy = message.User.Identity.Name;
_config.Entries.Add(new PersistentSubscriptionEntry
{
Stream = message.EventStreamId,
Group = message.GroupName,
ResolveLinkTos = message.ResolveLinkTos,
CheckPointAfter = message.CheckPointAfterMilliseconds,
ExtraStatistics = message.RecordStatistics,
HistoryBufferSize = message.BufferSize,
LiveBufferSize = message.LiveBufferSize,
MaxCheckPointCount = message.MaxCheckPointCount,
MinCheckPointCount = message.MinCheckPointCount,
MaxRetryCount = message.MaxRetryCount,
ReadBatchSize = message.ReadBatchSize,
MaxSubscriberCount = message.MaxSubscriberCount,
MessageTimeout = message.MessageTimeoutMilliseconds,
NamedConsumerStrategy = message.NamedConsumerStrategy,
StartFrom = message.StartFrom
});
SaveConfiguration(() => message.Envelope.ReplyWith(new ClientMessage.CreatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.CreatePersistentSubscriptionCompleted.CreatePersistentSubscriptionResult.Success, "")));
}
