/// <summary>
/// Constructs a DefaultRemoteManager listening on the specified address and
/// a specific port.
/// </summary>
/// <param name="localAddress">The address to listen on</param>
/// <param name="tcpPortProvider">Tcp port provider</param>
/// <param name="streamingCodec">Streaming codec</param>
/// <param name="tcpClientFactory">provides TcpClient for given endpoint</param>
internal StreamingRemoteManager(IPAddress localAddress,
ITcpPortProvider tcpPortProvider,
IStreamingCodec <T> streamingCodec,
ITcpClientConnectionFactory tcpClientFactory)
{
if (localAddress == null)
{
throw new ArgumentNullException("localAddress");
}
_tcpClientFactory = tcpClientFactory;
_observerContainer = new ObserverContainer <T>();
_cachedClients = new Dictionary <IPEndPoint, ProxyObserver>();
_remoteEventCodec = new RemoteEventStreamingCodec <T>(streamingCodec);
// Begin to listen for incoming messages
_server = new StreamingTransportServer <IRemoteEvent <T> >(localAddress,
_observerContainer,
tcpPortProvider,
_remoteEventCodec);
_server.Run();
LocalEndpoint = _server.LocalEndpoint;
Identifier = new SocketRemoteIdentifier(LocalEndpoint);
}
public DefaultRemoteManager(IPEndPoint localEndpoint, ICodec <T> codec, ITcpPortProvider tcpPortProvider)
{
if (localEndpoint == null)
{
throw new ArgumentNullException("localEndpoint");
}
if (localEndpoint.Port < 0)
{
throw new ArgumentException("Listening port must be greater than or equal to zero");
}
if (codec == null)
{
throw new ArgumentNullException("codec");
}
_codec = new RemoteEventCodec <T>(codec);
_observerContainer = new ObserverContainer <T>();
_cachedClients = new Dictionary <IPEndPoint, ProxyObserver>();
// Begin to listen for incoming messages
_server = new TransportServer <IRemoteEvent <T> >(localEndpoint, _observerContainer, _codec,
tcpPortProvider);
_server.Run();
LocalEndpoint = _server.LocalEndpoint;
Identifier = new SocketRemoteIdentifier(LocalEndpoint);
}
private StreamingRemoteManagerFactory(ITcpPortProvider tcpPortProvider,
ITcpClientConnectionFactory tcpClientFactory,
IInjector injector)
{
_tcpPortProvider = tcpPortProvider;
_tcpClientFactory = tcpClientFactory;
_injector = injector;
}
private DefaultRemoteManagerFactory(
ITcpPortProvider tcpPortProvider,
ITcpClientConnectionFactory tcpClientFactory,
ILocalAddressProvider localAddressProvider)
{
_tcpPortProvider = tcpPortProvider;
_localAddressProvider = localAddressProvider;
_tcpClientFactory = tcpClientFactory;
}
/// <summary>
/// Constructs a TransportServer to listen for remote events.
/// Listens on the specified remote endpoint. When it receives a remote
/// event, it will invoke the specified remote handler.
/// </summary>
/// <param name="localEndpoint">Endpoint to listen on</param>
/// <param name="remoteHandler">The handler to invoke when receiving incoming
/// remote messages</param>
/// <param name="codec">The codec to encode/decode</param>
/// <param name="tcpPortProvider">provides port numbers to listen</param>
public TransportServer(IPEndPoint localEndpoint,
IObserver <TransportEvent <T> > remoteHandler,
ICodec <T> codec,
ITcpPortProvider tcpPortProvider)
{
_listener = new TcpListener(localEndpoint.Address, localEndpoint.Port);
_remoteObserver = remoteHandler;
_cancellationSource = new CancellationTokenSource();
_cancellationSource.Token.ThrowIfCancellationRequested();
_codec = codec;
_tcpPortProvider = tcpPortProvider;
_disposed = false;
}
/// <summary>
/// Constructs a TransportServer to listen for remote events.
/// Listens on the specified remote endpoint. When it receives a remote
/// event, it will invoke the specified remote handler.
/// </summary>
/// <param name="address">Endpoint address to listen on</param>
/// <param name="remoteHandler">The handler to invoke when receiving incoming
/// remote messages</param>
/// <param name="tcpPortProvider">Find port numbers if listenport is 0</param>
/// <param name="streamingCodec">Streaming codec</param>
internal StreamingTransportServer(
IPAddress address,
IObserver <TransportEvent <T> > remoteHandler,
ITcpPortProvider tcpPortProvider,
IStreamingCodec <T> streamingCodec)
{
_listener = new TcpListener(address, 0);
_remoteObserver = remoteHandler;
_tcpPortProvider = tcpPortProvider;
_cancellationSource = new CancellationTokenSource();
_cancellationSource.Token.ThrowIfCancellationRequested();
_streamingCodec = streamingCodec;
_disposed = false;
}
private NameServer(
[Parameter(typeof(NamingConfigurationOptions.NameServerPort))] int port,
ITcpPortProvider tcpPortProvider)
{
IObserver <TransportEvent <NamingEvent> > handler = CreateServerHandler();
_idToAddrMap = new Dictionary <string, IPEndPoint>();
ICodec <NamingEvent> codec = CreateServerCodec();
// Start transport server, get listening IP endpoint
_logger.Log(Level.Info, "Starting naming server");
_server = new TransportServer <NamingEvent>(
new IPEndPoint(NetworkUtils.LocalIPAddress, port), handler,
codec, tcpPortProvider);
_server.Run();
LocalEndpoint = _server.LocalEndpoint;
}
public WritableRemoteManager(IPAddress localAddress, int port, ITcpPortProvider tcpPortProvider, IInjector injector)
{
if (localAddress == null)
{
throw new ArgumentNullException("localAddress");
}
if (port < 0)
{
throw new ArgumentException("Listening port must be greater than or equal to zero");
}
_observerContainer = new WritableObserverContainer <T>();
_cachedClients = new Dictionary <IPEndPoint, ProxyObserver>();
_injector = injector;
IPEndPoint localEndpoint = new IPEndPoint(localAddress, port);
// Begin to listen for incoming messages
_server = new WritableTransportServer <IWritableRemoteEvent <T> >(localEndpoint, _observerContainer, tcpPortProvider, injector);
_server.Run();
LocalEndpoint = _server.LocalEndpoint;
Identifier = new SocketRemoteIdentifier(LocalEndpoint);
}
private StreamingRemoteManagerFactory(ITcpPortProvider tcpPortProvider, IInjector injector)
{
_tcpPortProvider = tcpPortProvider;
_injector = injector;
}
/// <summary>
/// Constructs a TransportServer to listen for remote events.
/// Listens on the specified remote endpoint. When it recieves a remote
/// event, it will envoke the specified remote handler.
/// </summary>
/// <param name="port">Port to listen on</param>
/// <param name="remoteHandler">The handler to invoke when receiving incoming
/// remote messages</param>
/// <param name="tcpPortProvider">Find port numbers if listenport is 0</param>
/// <param name="injector">The injector to pass arguments to incoming messages</param>
public WritableTransportServer(int port, IObserver <TransportEvent <T> > remoteHandler, ITcpPortProvider tcpPortProvider, IInjector injector)
: this(new IPEndPoint(NetworkUtils.LocalIPAddress, port), remoteHandler, tcpPortProvider, injector)
{
}
private DefaultRemoteManagerFactory(ITcpPortProvider tcpPortProvider)
{
_tcpPortProvider = tcpPortProvider;
}
public DefaultRemoteManager(IPAddress localAddress, ICodec <T> codec, ITcpPortProvider tcpPortProvider) :
this(localAddress, 0, codec, tcpPortProvider)
{
}
private WritableRemoteManagerFactory(ITcpPortProvider tcpPortProvider, IInjector injector)
{
_tcpPortProvider = tcpPortProvider;
_injector = injector;
}
