/// <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; }