private NetworkTransport(
ILocalAddressProvider localAddressProvider,
ProtocolSerializer serializer,
LocalObserver localObserver,
IRemoteManagerFactory remoteManagerFactory,
REEFFileNames fileNames)
{
_serializer = serializer;
_fileNames = fileNames;
// Instantiate the remote manager.
_remoteManager = remoteManagerFactory.GetInstance(localAddressProvider.LocalAddress, new ByteCodec());
// Listen to the java bridge on the local end point.
_remoteManager.RegisterObserver(localObserver);
Logger.Log(Level.Info, "Local observer listening to java bridge on: [{0}]", _remoteManager.LocalEndpoint);
// Instantiate a remote observer to send messages to the java bridge.
IPEndPoint javaIpEndPoint = GetJavaBridgeEndpoint();
Logger.Log(Level.Info, "Connecting to java bridge on: [{0}]", javaIpEndPoint);
_remoteObserver = _remoteManager.GetRemoteObserver(javaIpEndPoint);
// Negotiate the protocol.
Send(0, new BridgeProtocol(100));
}
private StreamingNetworkService(
IObserver <NsMessage <T> > universalObserver,
IObserver <IRemoteMessage <NsMessage <T> > > remoteMessageUniversalObserver,
INameClient nameClient,
StreamingRemoteManagerFactory remoteManagerFactory,
NsMessageStreamingCodec <T> codec,
ILocalAddressProvider localAddressProvider)
{
_remoteManager = remoteManagerFactory.GetInstance(localAddressProvider.LocalAddress, codec);
if (universalObserver != null)
{
// Create and register incoming message handler
// TODO[REEF-419] This should use the TcpPortProvider mechanism
var anyEndpoint = new IPEndPoint(IPAddress.Any, 0);
_universalObserverDisposable = _remoteManager.RegisterObserver(anyEndpoint, universalObserver);
}
else
{
_universalObserverDisposable = null;
}
_remoteMessageUniversalObserver = remoteMessageUniversalObserver != null?
_remoteManager.RegisterObserver(remoteMessageUniversalObserver) : null;
_nameClient = nameClient;
_connectionMap = new Dictionary <IIdentifier, IConnection <T> >();
Logger.Log(Level.Verbose, "Started network service");
}
private StreamingNetworkService(
IObserver <IRemoteMessage <NsMessage <T> > > remoteMessageUniversalObserver,
INameClient nameClient,
StreamingRemoteManagerFactory remoteManagerFactory,
NsMessageStreamingCodec <T> codec,
ILocalAddressProvider localAddressProvider)
: this(null, remoteMessageUniversalObserver, nameClient, remoteManagerFactory, codec, localAddressProvider)
{
}
private DefaultRemoteManagerFactory(
ITcpPortProvider tcpPortProvider,
ITcpClientConnectionFactory tcpClientFactory,
ILocalAddressProvider localAddressProvider)
{
_tcpPortProvider = tcpPortProvider;
_localAddressProvider = localAddressProvider;
_tcpClientFactory = tcpClientFactory;
}
private NameServer(
[Parameter(typeof(NamingConfigurationOptions.NameServerPort))] int port,
ILocalAddressProvider addressProvider,
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(addressProvider.LocalAddress, port), handler,
codec, tcpPortProvider);
_server.Run();
LocalEndpoint = _server.LocalEndpoint;
}
public NetworkService(
[Parameter(typeof(NetworkServiceOptions.NetworkServicePort))] int nsPort,
IObserver <NsMessage <T> > messageHandler,
IIdentifierFactory idFactory,
ICodec <T> codec,
INameClient nameClient,
ILocalAddressProvider localAddressProvider,
IRemoteManagerFactory remoteManagerFactory)
{
_codec = new NsMessageCodec <T>(codec, idFactory);
IPAddress localAddress = localAddressProvider.LocalAddress;
_remoteManager = remoteManagerFactory.GetInstance(localAddress, nsPort, _codec);
_messageHandler = messageHandler;
NamingClient = nameClient;
_connectionMap = new Dictionary <IIdentifier, IConnection <T> >();
LOGGER.Log(Level.Verbose, "Started network service");
}
/// <summary>
/// Constructs a DefaultRemoteManager. Does not listen for incoming messages.
/// </summary>
/// <param name="localAddressProvider">The local address provider</param>
/// <param name="codec">The codec used for serializing messages</param>
/// <param name="tcpClientFactory">provides TcpClient for given endpoint</param>
internal DefaultRemoteManager(
ILocalAddressProvider localAddressProvider,
ICodec <T> codec,
ITcpClientConnectionFactory tcpClientFactory)
{
using (LOGGER.LogFunction("DefaultRemoteManager::DefaultRemoteManager"))
{
if (codec == null)
{
throw new ArgumentNullException("codec");
}
_tcpClientFactory = tcpClientFactory;
_observerContainer = new ObserverContainer <T>();
_codec = new RemoteEventCodec <T>(codec);
_cachedClients = new Dictionary <IPEndPoint, ProxyObserver>();
LocalEndpoint = new IPEndPoint(localAddressProvider.LocalAddress, 0);
Identifier = new SocketRemoteIdentifier(LocalEndpoint);
}
}
