public InMemoryConnection(IWampBinding <TMessage> binding, IObservable <WampMessage <TMessage> > incoming, IObserver <WampMessage <TMessage> > outgoing, IScheduler scheduler, ISubject <Unit> connectionOpen, ISubject <Unit> connectionClosed)
{
mIncoming = incoming;
mOutgoing = outgoing;
mConnectionOpen = connectionOpen;
mScheduler = scheduler;
mConnectionClosed = connectionClosed;
mBinding = binding;
IDisposable connectionClosedSubscription =
mConnectionClosed.Subscribe(x => RaiseConnectionClosed());
IDisposable connectionOpenSubscription =
mConnectionOpen.Subscribe(x => RaiseConnectionOpen());
IDisposable inputSubscription = mIncoming
.ObserveOn(mScheduler)
.Subscribe(x => OnNewMessage(x),
ex => OnError(ex),
() => OnCompleted());
mSubscription =
new CompositeDisposable(connectionClosedSubscription,
connectionOpenSubscription,
inputSubscription);
}
/// <summary>
/// Creates a new instance of <see cref="WampClientBuilderFactory{TMessage}"/>.
/// </summary>
/// <param name="outgoingSerializer">The <see cref="IWampOutgoingRequestSerializer"/>
/// used to serialize methods call to <see cref="WampMessage{TMessage}"/>s.</param>
/// <param name="outgoingHandlerBuilder">The <see cref="IWampOutgoingMessageHandler"/>
/// used to create the <see cref="IWampOutgoingMessageHandler"/> used to
/// handle outgoing <see cref="WampMessage{TMessage}"/>s.</param>
public WampClientBuilderFactory(IWampOutgoingRequestSerializer outgoingSerializer,
IWampOutgoingMessageHandlerBuilder <TMessage> outgoingHandlerBuilder, IWampBinding <TMessage> binding)
{
mOutgoingSerializer = outgoingSerializer;
mOutgoingHandlerBuilder = outgoingHandlerBuilder;
mBinding = binding;
}
/// <summary>
/// Creates a new instance of <see cref="WampClientBuilder{TMessage}"/>.
/// </summary>
/// <param name="outgoingSerializer">A <see cref="IWampOutgoingRequestSerializer"/>
/// used to serialize message calls into <see cref="WampMessage{TMessage}"/>s</param>
/// <param name="outgoingHandlerBuilder">An <see cref="IWampOutgoingMessageHandlerBuilder{TMessage}"/> used to build
/// a <see cref="IWampOutgoingMessageHandler"/> per connection.</param>
/// <param name="container">A <see cref="IWampClientContainer{TMessage,TClient}"/> that contains all clients.</param>
public WampClientBuilder(IWampOutgoingRequestSerializer outgoingSerializer, IWampOutgoingMessageHandlerBuilder <TMessage> outgoingHandlerBuilder, IWampClientContainer <TMessage, IWampClientProxy <TMessage> > container, IWampBinding <TMessage> binding)
{
mOutgoingSerializer = outgoingSerializer;
mOutgoingHandlerBuilder = outgoingHandlerBuilder;
mContainer = container;
mBinding = binding;
}
public IControlledWampConnection <TMessage> Activate <TMessage>(IWampBinding <TMessage> binding)
{
IControlledWampConnection <TMessage> connection = mConnectionActivator.Activate(binding);
ScheduledWampConnection <TMessage> result = new ScheduledWampConnection <TMessage>(connection, mScheduler);
return(result);
}
public RecordAndPlayInterceptor(IWampOutgoingRequestSerializer outgoingSerializer, IMessagePlayer <TMessage> player, IMessageRecorder <TMessage> recorder, IWampBinding <TMessage> binding)
{
mOutgoingSerializer = outgoingSerializer;
mPlayer = player;
mRecorder = recorder;
mBinding = binding;
}
protected MessageWebSocketConnection(string uri,
IWampBinding <TMessage> binding, SocketMessageType messageType)
{
mUri = uri;
mBinding = binding;
mSocketMessageType = messageType;
}
public WebSocket4NetConnection(string serverAddress,
IWampBinding <TMessage> binding,
Action <SecurityOption> configureSecurityOptions)
: this(new WebSocket(serverAddress, binding.Name, WebSocketVersion.None), binding)
{
configureSecurityOptions?.Invoke(WebSocket.Security);
}
public static IWampBindingHost CreateHost <TMessage>
(this IWampBinding <TMessage> binding,
IWampHostedRealmContainer realmContainer,
IWampConnectionListener <TMessage> connectionListener,
IWampUriValidator uriValidator,
IWampSessionMapper sessionIdMap)
{
if (binding is IWampRouterBinding <TMessage> routerBinding)
{
return(routerBinding.CreateHost(realmContainer, connectionListener, sessionIdMap));
}
else
{
IWampRouterBuilder routerBuilder = new WampRouterBuilder(uriValidator);
WampBindingHost <TMessage> result =
new WampBindingHost <TMessage>(realmContainer,
routerBuilder,
connectionListener,
binding,
sessionIdMap);
return(result);
}
}
public static IWampBindingHost CreateHost <TMessage>
(this IWampBinding <TMessage> binding,
IWampHostedRealmContainer realmContainer,
IWampConnectionListener <TMessage> connectionListener,
IWampUriValidator uriValidator)
{
IWampRouterBinding <TMessage> routerBinding = binding as IWampRouterBinding <TMessage>;
if (routerBinding != null)
{
return(routerBinding.CreateHost(realmContainer, connectionListener));
}
else
{
IWampRouterBuilder routerBuilder = new WampRouterBuilder(uriValidator);
WampBindingHost <TMessage> result =
new WampBindingHost <TMessage>(realmContainer,
routerBuilder,
connectionListener,
binding);
return(result);
}
}
public IWampChannel CreateChannel<TMessage>(string realm, IControlledWampConnection<TMessage> connection,
IWampBinding<TMessage> binding, IWampClientAuthenticator authenticator)
{
WampChannelBuilder<TMessage> builder = GetChannelBuilder(binding);
WampChannel<TMessage> channel = builder.CreateChannel(realm, connection, authenticator);
return channel;
}
private WebSocket ActivateWebSocket(IWampBinding binaryBinding)
{
WebSocket webSocket = mWebSocketFactory(binaryBinding.Name);
SecurityOptionsConfigureAction?.Invoke(webSocket.Security);
return(webSocket);
}
public IControlledWampConnection <TMessage> CreateClientConnection <TMessage>
(IWampBinding <TMessage> binding, IScheduler scheduler)
{
InMemoryConnectionListener <TMessage> casted =
GetOrRegisterBinding(binding);
return(casted.CreateClientConnection(scheduler));
}
public IWampChannel CreateChannel<TMessage>(string realm, Func<IControlledWampConnection<TMessage>> connectionFactory,
IWampBinding<TMessage> binding,
IWampClientAuthenticator authenticator)
{
return this.CreateChannel(realm,
new ReviveClientConnection<TMessage>(connectionFactory), binding,
authenticator);
}
public WampPubSubServer(IWampTopicContainer topicContainer, IWampEventSerializer eventSerializer, IWampBinding <TMessage> binding, IWampUriValidator uriValidator)
{
mLogger = LogProvider.GetLogger(this.GetType());
mBinding = binding;
mUriValidator = uriValidator;
mEventSerializer = eventSerializer;
mRawTopicContainer = new WampRawTopicContainer <TMessage>(topicContainer, mEventSerializer, mBinding);
}
public WampRawTopicContainer(IWampTopicContainer topicContainer,
IWampEventSerializer eventSerializer,
IWampBinding <TMessage> binding)
{
mTopicContainer = topicContainer;
mEventSerializer = eventSerializer;
mBinding = binding;
}
public WampAuthenticationSessionServer(IWampBinding <TMessage> binding,
IWampHostedRealmContainer realmContainer,
IWampRouterBuilder builder,
IWampEventSerializer eventSerializer,
IWampSessionAuthenticatorFactory sessionAuthenticatorFactory)
: base(binding, realmContainer, builder, eventSerializer)
{
mSessionAuthenticatorFactory = sessionAuthenticatorFactory;
}
public WebSocket4NetConnection(WebSocket webSocket,
IWampBinding <TMessage> binding)
{
mBinding = binding;
mWebSocket = webSocket;
mWebSocket.Opened += WebSocketOnOpened;
mWebSocket.Closed += WebSocketOnClosed;
mWebSocket.Error += WebSocketOnError;
}
private IWampConnectionListener <TMessage> RegisterBinding <TMessage>(IWampBinding <TMessage> binding)
{
InMemoryConnectionListener <TMessage> result =
new InMemoryConnectionListener <TMessage>(mRouterScheduler, binding);
mBindings[binding.Name] = result;
return(result);
}
public WampRawTopic(string topicUri, SubscribeOptions subscribeOptions, IWampCustomizedSubscriptionId customizedSubscriptionId, IWampEventSerializer serializer, IWampBinding <TMessage> binding)
{
mSerializer = serializer;
mSubscriberBook = new RawTopicSubscriberBook(this);
mTopicUri = topicUri;
mBinding = binding;
mSubscribeOptions = subscribeOptions;
mCustomizedSubscriptionId = customizedSubscriptionId;
}
private WampChannelBuilder<TMessage> GetChannelBuilder<TMessage>(IWampBinding<TMessage> binding)
{
object result =
mBindingToChannelBuilder.GetOrAdd
(binding,
x => new WampChannelBuilder<TMessage>(binding));
return (WampChannelBuilder<TMessage>) result;
}
protected WampAuthenticationBinding(IWampBinding <TMessage> binding,
IWampSessionAuthenticatorFactory sessionAuthenticationFactory,
IWampUriValidator uriValidator)
{
mBinding = binding;
mUriValidator = uriValidator;
mSessionAuthenticationFactory =
new RestrictedSessionAuthenticationFactory(sessionAuthenticationFactory);
}
public IControlledWampConnection <TMessage> Activate <TMessage>(IWampBinding <TMessage> binding)
{
Func <IControlledWampConnection <TMessage> > factory =
() => GetConnectionFactory(binding);
ReviveClientConnection <TMessage> result =
new ReviveClientConnection <TMessage>(factory);
return(result);
}
public WebSocket4NetConnection(WebSocket webSocket,
IWampBinding <TMessage> binding)
{
Binding = binding;
mWebSocket = webSocket;
mLogger = LogProvider.GetLogger(this.GetType());
mWebSocket.Opened += WebSocketOnOpened;
mWebSocket.Closed += WebSocketOnClosed;
mWebSocket.Error += WebSocketOnError;
}
private static WampClientBuilderFactory <TMessage> GetWampClientBuilder(IWampBinding <TMessage> binding, IWampOutgoingRequestSerializer outgoingRequestSerializer)
{
WampOutgoingMessageHandlerBuilder <TMessage> wampOutgoingMessageHandlerBuilder =
new WampOutgoingMessageHandlerBuilder <TMessage>();
return(new WampClientBuilderFactory <TMessage>
(outgoingRequestSerializer,
wampOutgoingMessageHandlerBuilder,
binding));
}
private void RegisterBinding(IWampBinding binding, ConnectionListener listener)
{
if (mBindings.ContainsKey(binding.Name))
{
throw new ArgumentException("Already registered a binding for protocol: " +
binding.Name,
nameof(binding));
}
mBindings.Add(binding.Name, listener);
}
public IWampConnectionListener <TMessage> GetListener <TMessage>(IWampBinding <TMessage> binding)
{
if (!(binding is IWampTextBinding <TMessage> textBinding))
{
throw new ArgumentException("This transport supports only text binding.", nameof(binding));
}
else
{
return(GetListener(textBinding));
}
}
private IControlledWampConnection <TMessage> GetConnectionFactory <TMessage>(IWampBinding <TMessage> binding)
{
IWampTextBinding <TMessage> textBinding = binding as IWampTextBinding <TMessage>;
if (textBinding != null)
{
return(CreateTextConnection(textBinding));
}
throw new Exception();
}
public WampRpcServer(IWampRpcOperationCatalog catalog, IWampBinding <TMessage> binding, IWampUriValidator uriValidator)
{
mInvoker = catalog;
mUriValidator = uriValidator;
mLogger = LogProvider.GetLogger(this.GetType());
mFormatter = binding.Formatter;
mHandler = new WampCalleeInvocationHandler <TMessage>(binding.Formatter);
mCalleeCatalog = new WampCalleeOperationCatalog <TMessage>
(catalog, mHandler);
}
public WampRealmProxy(string name, IWampServerProxy proxy, IWampBinding <TMessage> binding, IWampClientAuthenticator authenticator)
{
mName = name;
mProxy = proxy;
IWampFormatter <TMessage> formatter = binding.Formatter;
mMonitor = new WampSessionClient <TMessage>(this, formatter, authenticator);
mRpcCatalog = new WampRpcOperationCatalogProxy <TMessage>(proxy, formatter, mMonitor);
mTopicContainer = new WampTopicContainerProxy <TMessage>(proxy, formatter, mMonitor);
mServices = new WampRealmProxyServiceProvider(this);
mAuthenticator = authenticator;
}
public WampChannelBuilder(IWampBinding <TMessage> binding)
{
mBinding = binding;
IWampFormatter <TMessage> formatter = mBinding.Formatter;
mFactory =
new WampServerProxyBuilder <TMessage, IWampClient <TMessage>, IWampServerProxy>(
new WampOutgoingRequestSerializer <TMessage>(formatter),
new WampServerProxyOutgoingMessageHandlerBuilder <TMessage, IWampClient <TMessage> >
(new WampServerProxyIncomingMessageHandlerBuilder <TMessage, IWampClient <TMessage> >(formatter)));
}
