private void OnUpdated(string subscriptionId, ITransientDestination subscriberReplyDestination, TUpdate update)
{
if (IsSubscribed(subscriptionId))
{
SendUpdate(subscriptionId, subscriberReplyDestination, update);
}
}
public async Task <IPrivateEndPoint <T> > GetPrivateEndPoint <T>(ITransientDestination destination)
{
var dest = (WampTransientDestination)destination;
var subID = await _meta.LookupSubscriptionIdAsync(dest.Topic, new SubscribeOptions { Match = "exact" });
Log.DebugFormat("Create subscription {0} ({1})", subID, dest);
if (!subID.HasValue)
{
// subscription is already disposed
Log.ErrorFormat("Subscription not found for topic {0}", dest.Topic);
throw new Exception("No subscribers found for private subscription.");
}
var sessionID = (await _meta.GetSubscribersAsync(subID.Value)).FirstOrDefault();
if (sessionID == 0)
{
Log.ErrorFormat("Subscription found but there are no subscriptions for topic {0}", dest.Topic);
throw new Exception("No subscribers found for private subscription.");
}
var breaker =
_sessionTeardowns.Where(s => s == sessionID).Select(_ => Unit.Default)
.Merge(_subscriptionTeardowns.Where(s => s == subID.Value).Select(_ => Unit.Default))
.Merge(_brokerTeardown)
.Take(1)
.Do(o => Log.DebugFormat("Remove subscription for {0} ({1})", subID, dest));
var subject = _channel.RealmProxy.Services.GetSubject <T>(dest.Topic);
return(new PrivateEndPoint <T>(subject, breaker));
}
private void SendCompletion(string subscriptionId, ITransientDestination subscriberReplyDestination)
{
var message = _messageFactory.Create(_updateToLiveTime);
message.Properties.Set(RequestStreamKeys.SubscriptionId, subscriptionId);
message.Properties.Set(RequestStreamKeys.UpdateKind, UpdateKind.Completion);
SendMessage(subscriptionId, subscriberReplyDestination, message);
}
private void OnCompleted(string subscriptionId, ITransientDestination subscriberReplyDestination)
{
if (IsSubscribed(subscriptionId))
{
ProcessUnsubscription(subscriptionId);
SendCompletion(subscriptionId, subscriberReplyDestination);
}
}
private void OnFailed(string subscriptionId, ITransientDestination subscriberReplyDestination, Exception error)
{
if (IsSubscribed(subscriptionId))
{
ProcessUnsubscription(subscriptionId);
SendError(subscriptionId, subscriberReplyDestination, error.Message);
}
}
private void SendAck(string subscriptionId, ITransientDestination subscriberReplyDestination, string clientId)
{
var message = _messageFactory.Create(_updateToLiveTime);
message.Properties.Set(OperationKeys.ClientId, clientId);
message.Properties.Set(OperationKeys.ServerId, _serverId);
message.Properties.Set(RequestStreamKeys.SubscriptionId, subscriptionId);
message.Properties.Set(RequestStreamKeys.UpdateKind, UpdateKind.Ack);
SendMessage(subscriptionId, subscriberReplyDestination, message);
}
private void SendMessage(string subscriptionId,
ITransientDestination subscriberReplyDestination,
IMessage message)
{
try
{
_publisher.Publish(message, subscriberReplyDestination);
}
catch (MessagingException)
{
Log.Error("Failed to publish message to subscriber");
ProcessUnsubscription(subscriptionId);
}
}
private void SendUpdate(string subscriptionId, ITransientDestination subscriberReplyDestination, TUpdate update)
{
try
{
var payload = _serializer.Serialize(update);
var message = _messageFactory.Create(payload, _updateToLiveTime);
message.Properties.Set(RequestStreamKeys.SubscriptionId, subscriptionId);
message.Properties.Set(RequestStreamKeys.UpdateKind, UpdateKind.Update);
SendMessage(subscriptionId, subscriberReplyDestination, message);
}
catch (SerializationException e)
{
OnFailed(subscriptionId,
subscriberReplyDestination,
new MessagingException("Failed to serialize update", e));
}
}
public void Publish(IMessage message, ITransientDestination subDestination)
{
throw new NotImplementedException();
}
