private void HandleAsNonMaster(ClientMessage.UpdatePersistentSubscription message)
{
if (_master == null)
{
DenyRequestBecauseNotReady(message.Envelope, message.CorrelationId);
}
else
{
DenyRequestBecauseNotMaster(message.CorrelationId, message.Envelope);
}
}
private void PostSubscription(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var groupname = match.BoundVariables["subscription"];
var stream = match.BoundVariables["stream"];
var envelope = new SendToHttpEnvelope(
_networkSendQueue, http,
(args, message) => http.ResponseCodec.To(message),
(args, message) => {
int code;
var m = message as ClientMessage.UpdatePersistentSubscriptionCompleted;
if (m == null)
{
throw new Exception("unexpected message " + message);
}
switch (m.Result)
{
case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult
.Success:
code = HttpStatusCode.OK;
//TODO competing return uri to subscription
break;
case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult
.DoesNotExist:
code = HttpStatusCode.NotFound;
break;
case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult
.AccessDenied:
code = HttpStatusCode.Unauthorized;
break;
default:
code = HttpStatusCode.InternalServerError;
break;
}
return(new ResponseConfiguration(code, http.ResponseCodec.ContentType,
http.ResponseCodec.Encoding,
new KeyValuePair <string, string>("location",
MakeUrl(http, "/subscriptions/" + stream + "/" + groupname))));
});
http.ReadTextRequestAsync(
(o, s) => {
var data = http.RequestCodec.From <SubscriptionConfigData>(s);
var config = ParseConfig(data);
if (!ValidateConfig(config, http))
{
return;
}
var message = new ClientMessage.UpdatePersistentSubscription(Guid.NewGuid(),
Guid.NewGuid(),
envelope,
stream,
groupname,
config.ResolveLinktos,
config.StartFrom,
config.MessageTimeoutMilliseconds,
config.ExtraStatistics,
config.MaxRetryCount,
config.BufferSize,
config.LiveBufferSize,
config.ReadBatchSize,
config.CheckPointAfterMilliseconds,
config.MinCheckPointCount,
config.MaxCheckPointCount,
config.MaxSubscriberCount,
CalculateNamedConsumerStrategyForOldClients(data),
http.User,
"",
"");
Publish(message);
}, x => Log.Debug(x, "Reply Text Content Failed."));
}
public void Handle(ClientMessage.UpdatePersistentSubscription message)
{
if (!_started)
{
return;
}
var key = BuildSubscriptionGroupKey(message.EventStreamId, message.GroupName);
Log.Debug("Updating persistent subscription {0}", key);
var streamAccess = _readIndex.CheckStreamAccess(SystemStreams.SettingsStream, StreamAccessType.Write, message.User);
if (!streamAccess.Granted)
{
message.Envelope.ReplyWith(new ClientMessage.UpdatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.AccessDenied,
"You do not have permissions to update the subscription"));
return;
}
if (!_subscriptionsById.ContainsKey(key))
{
message.Envelope.ReplyWith(new ClientMessage.UpdatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.DoesNotExist,
"Group '" + message.GroupName + "' does not exist."));
return;
}
if (!_consumerStrategyRegistry.ValidateStrategy(message.NamedConsumerStrategy))
{
message.Envelope.ReplyWith(new ClientMessage.UpdatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.Fail,
string.Format("Consumer strategy {0} does not exist.", message.NamedConsumerStrategy)));
return;
}
RemoveSubscription(message.EventStreamId, message.GroupName);
RemoveSubscriptionConfig(message.User.Identity.Name, message.EventStreamId, message.GroupName);
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)
);
_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.UpdatePersistentSubscriptionCompleted(message.CorrelationId,
ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.Success, "")));
}