public void ExampleMethod()
{
var config = new MeepoConfig
{
Logger = new ConsoleLogger()
};
// IP Address to expose
var address = new TcpAddress(IPAddress.Loopback, 9201);
// Nodes to connect to
var serverAddresses = new[] { new TcpAddress(IPAddress.Loopback, 9200) };
using (var meepo = new MeepoNode(address, serverAddresses, config))
{
meepo.Start();
meepo.MessageReceived += x => System.Console.WriteLine(x.Bytes.Decode());
while (true)
{
var text = System.Console.ReadLine();
if (text.ToLower() == "q")
{
break;
}
meepo.SendAsync(text).Wait();
}
}
}
public static void Main()
{
var config = new MeepoConfig
{
BufferSizeInBytes = 1000,
Logger = new ConsoleLogger()
};
var address = new TcpAddress(IPAddress.Loopback, 9201);
var serverAddresses = new[] { new TcpAddress(IPAddress.Loopback, 9200) };
using (meepoNode = new MeepoNode(address, serverAddresses, config))
{
meepoNode.Start();
meepoNode.MessageReceived += OnMessageReceived;
while (true)
{
var text = System.Console.ReadLine();
if (text.ToLower() == "q")
{
return;
}
meepoNode.SendAsync(text).Wait();
}
}
}
public void Ctor_WhenCalledWithNullServers_ShouldThrowException()
{
var listenerAddress = new TcpAddress(IPAddress.Any, 80);
var config = new MeepoConfig();
Assert.Throws <ArgumentNullException>(() => new MeepoNode(listenerAddress, serverAddresses: null));
Assert.Throws <ArgumentNullException>(() => new MeepoNode(listenerAddress, null, config));
}
private MeepoServer GetSutObject()
{
var config = new MeepoConfig
{
Logger = logger.Object
};
return(new MeepoServer(clientManagerProvider.Object, config));
}
public ClientFactory(MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
{
this.config = config;
this.cancellationToken = cancellationToken;
this.messageReceived = messageReceived;
this.clientConnectionFailed = clientConnectionFailed;
}
public void Ctor_WhenCalledWithNullLogger_ShouldThrowException()
{
var listenerAddress = new TcpAddress(IPAddress.Any, 80);
var serverAddresses = new TcpAddress[0];
var config = new MeepoConfig
{
Logger = null
};
Assert.Throws <ArgumentNullException>(() => new MeepoNode(listenerAddress, config));
Assert.Throws <ArgumentNullException>(() => new MeepoNode(listenerAddress, serverAddresses, config));
}
public ClientManager(
TcpListener listener,
IEnumerable <TcpAddress> serverAddresses,
CancellationToken cancellationToken,
MeepoConfig config,
MessageReceivedHandler messageReceived)
{
this.listener = listener;
this.serverAddresses = serverAddresses;
this.cancellationToken = cancellationToken;
clientFactory = new ClientFactory(config, cancellationToken, messageReceived, RemoveClient);
}
public ClientManagerProvider(
MeepoConfig config,
TcpAddress listenerAddress,
IEnumerable <TcpAddress> serverAddresses,
MessageReceivedHandler messageReceived)
{
logger = config.Logger;
this.config = config;
this.listenerAddress = listenerAddress;
this.serverAddresses = serverAddresses;
this.messageReceived = messageReceived;
}
public ClientWrapper(
TcpAddress address,
MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
: this(config, cancellationToken, messageReceived, clientConnectionFailed)
{
Address = address;
IsToServer = true;
Connected = Connect().Result;
}
private ClientWrapper(
MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
{
Id = Guid.NewGuid();
logger = config.Logger;
this.config = config;
this.cancellationToken = cancellationToken;
this.messageReceived = messageReceived;
this.clientConnectionFailed = clientConnectionFailed;
}
public ClientWrapper(
TcpClient client,
MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
: this(config, cancellationToken, messageReceived, clientConnectionFailed)
{
IsToServer = false;
Client = client;
Client.ApplyConfig(config);
Connected = true;
StartListening();
}
public static MeepoNode StartServer(int port, ILogger logger, MessageReceivedHandler messageReceived, int buffer = 1000)
{
var address = new TcpAddress(IPAddress.Loopback, port);
var config = new MeepoConfig
{
Logger = logger,
BufferSizeInBytes = buffer
};
var tmp = new MeepoNode(address, config);
tmp.MessageReceived += messageReceived;
tmp.Start();
return(tmp);
}
public MeepoServer(IClientManagerProvider clientManagerProvider, MeepoConfig config)
{
this.clientManagerProvider = clientManagerProvider;
logger = config.Logger;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="listenerAddress">Address you want to expose</param>
/// <param name="serverAddresses">List of server addresses to connect to</param>
/// <param name="config">Custom MeepoNode configuration</param>
public MeepoNode(TcpAddress listenerAddress, IEnumerable <TcpAddress> serverAddresses, MeepoConfig config)
{
if (serverAddresses == null)
{
throw new ArgumentNullException(nameof(serverAddresses));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (config.Logger == null)
{
throw new ArgumentNullException(nameof(config));
}
var clientManagerProvider = new ClientManagerProvider(config, listenerAddress, serverAddresses, OnMessageReceived);
server = new MeepoServer(clientManagerProvider, config);
stateMachine = new MeepoStateMachine(config.Logger);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="listenerAddress">Address you want to expose</param>
/// <param name="config">Custom MeepoNode configuration</param>
public MeepoNode(TcpAddress listenerAddress, MeepoConfig config) : this(listenerAddress, new TcpAddress[] { }, config)
{
}
public MessageBufferReader(MeepoConfig config, TcpClient client, MessageReceivedHandler messageReceived)
{
this.config = config;
this.client = client;
this.messageReceived = messageReceived;
}
