public ClientConnection(Socket sock)
: base(sock)
{
if (SlotId == 0)
SlotId = -1;
var remoteEndPoint = (IPEndPoint)sock.RemoteEndPoint;
_remoteAddress = new TcpAddress(remoteEndPoint.Address, remoteEndPoint.Port);
sock.LingerState = new LingerOption(true, 10);
sock.NoDelay = true;
var ctx = new HookContext
{
Connection = this
};
var args = new HookArgs.NewConnection();
HookPoints.NewConnection.Invoke(ref ctx, ref args);
if (ctx.CheckForKick())
return;
_isReceiving = true; //The connection was established, so we can begin reading
}
void ISocket.Connect(RemoteAddress address)
{
TcpAddress tcpAddress = (TcpAddress)address;
this._connection.Connect(tcpAddress.Address, tcpAddress.Port);
this._remoteAddress = address;
}
public static void TcpClientLoop(object threadContext)
{
RemoteAddress address = new TcpAddress(Netplay.ServerIP, Netplay.ListenPort);
Netplay.ClientLoopSetup(address);
Main.menuMode = 14;
bool flag = true;
while (flag)
{
flag = false;
try
{
Netplay.Connection.Socket.Connect(new TcpAddress(Netplay.ServerIP, Netplay.ListenPort));
flag = false;
}
catch
{
if (!Netplay.disconnect && Main.gameMenu)
{
flag = true;
}
}
}
}
public void Setup()
{
topicRouter = mockTopicRouter.Object;
monitorCache = mockMonitorCache.Object;
subscriptionsCache = mockSubscriptionsCache.Object;
subscriberFactory = mockSubscriberFactory.Object;
subscriber = mockSubscriber.Object;
monitor = mockMonitor.Object;
address = TcpAddress.Localhost(5555);
routing = SubscriberRouting.For <ISubscriber>(address);
mockTopicRouter
.Setup(m => m.RoutingFor <Topic>(out routing))
.Returns(true);
mockSubscriberFactory
.Setup(m => m.CreateSubscriber(It.IsAny <IAddress>()))
.Returns(subscriber);
mockSubscriberFactory
.SetupGet(m => m.SubscriberType)
.Returns(typeof(ISubscriber));
mockSubscriberFactory
.SetupGet(m => m.SubscriberMonitor)
.Returns(monitor);
}
public ClientConnection(Socket sock)
: base(sock)
{
if (SlotId == 0)
{
SlotId = -1;
}
var remoteEndPoint = (IPEndPoint)sock.RemoteEndPoint;
_remoteAddress = new TcpAddress(remoteEndPoint.Address, remoteEndPoint.Port);
sock.LingerState = new LingerOption(true, 10);
var ctx = new HookContext
{
Connection = this
};
var args = new HookArgs.NewConnection();
HookPoints.NewConnection.Invoke(ref ctx, ref args);
if (ctx.CheckForKick())
{
return;
}
_isReceiving = true; //The connection was established, so we can begin reading
}
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 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 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));
}
void ISocket.Connect(RemoteAddress address)
{
_remoteAddress = address as TcpAddress;
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect(_remoteAddress.Address, _remoteAddress.Port);
SetSocket(sock);
}
public Subscriber()
{
router = UnityBuilder.Named("Subscriber")
.WithTransport <NetMQTransport>(t => t.WithSubscriber(TcpAddress.Localhost(5556)))
.Build();
throw new NotImplementedException();
//router.Subscribe<Observation>(AsyncHandler);
}
public ClientWrapper GetClient(TcpAddress address)
{
return(new ClientWrapper(
address,
config,
cancellationToken,
messageReceived,
clientConnectionFailed));
}
public void CreateNewSubscriber_ReturnsSubscriber()
{
// Arrange
var factory = new NetMQFactory(requestDispatcher, topicDispatcher, monitor, messageFactory);
// Act
var subscriber = factory.CreateSubscriber(TcpAddress.Localhost(5555));
// Assert
Assert.That(subscriber, Is.Not.Null);
}
public void CreateNewPublisher_ReturnsPublisher()
{
// Arrange
var factory = new NetMQFactory(requestDispatcher, topicDispatcher, monitor, messageFactory);
// Act
var publisher = factory.CreatePublisher(TcpAddress.Wildcard(5555));
// Assert
Assert.That(publisher, Is.Not.Null);
}
void Terraria.Net.Sockets.ISocket.Connect(RemoteAddress address)
{
TcpAddress tcpAddress = (TcpAddress)address;
this._connection.Connect(tcpAddress.Address, tcpAddress.Port);
this._remoteAddress = address;
lock (_connection)
{
this._connectionDisposed = false;
}
}
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 static void Run()
{
var router = UnityBuilder.Named("TestServer")
.WithTransport <NetMQTransport>(t => t.WithReceiver(TcpAddress.Wildcard(5555)))
.WithHandlers(h => h.WithAsyncRequestHandler <TestMessage, TestMessage>(Handler))
.BuildAndStart();
Console.WriteLine("Press enter to stop server");
Console.ReadLine();
router.Stop();
}
public async Task SenderReceiver_WhenBoundAndConnected_PassesMessage()
{
// Arrange
var responseStr = "Hello, World!";
var requestStr = "Hello";
var receivedRequest = string.Empty;
ushort port = 6555;
var called = false;
mockRequestDispatcher
.Setup(m => m.Handle(ref It.Ref <RequestTask> .IsAny))
.Callback(new Handler((ref RequestTask task) => {
called = true;
receivedRequest = (string)task.Request;
task.ResponseSender(responseStr);
}));
var packageFactory = new PackageFactory();
var serializer = new DotNetSerializer();
var serializerCache = new SerializerCache();
var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory);
var sender = new NetMQSender(new DealerSocket(), messageFactory);
var receiver = new NetMQReceiver(new RouterSocket(), messageFactory, requestDispatcher);
var poller = new NetMQPoller();
serializerCache.AddSerializer(serializer);
sender.AddAddress(TcpAddress.Localhost(port));
sender.InitializeConnection();
receiver.AddAddress(TcpAddress.Wildcard(port));
receiver.InitializeConnection();
poller.Add(sender.PollableSocket);
poller.Add(receiver.PollableSocket);
poller.RunAsync();
var package = new DataPackage <string>(new GuidPackageId(), requestStr);
// Act
var response = await sender.SendAndReceive(package, TimeSpan.FromSeconds(5));
// Cleanup
poller.StopAsync();
sender.TerminateConnection();
receiver.TerminateConnection();
// Assert
Assert.That(called, Is.True);
Assert.That(receivedRequest, Is.EqualTo(requestStr));
Assert.That((string)response, Is.EqualTo(responseStr));
}
public void ClientThread(object context)
{
Main.gameMenu = true;
Main.menuMode = 888;
Main.MenuUI.SetState(new UINetworkConnection());
object[] parameter = (object[])context;
bool exitThread = false;
DimPlayer player = (DimPlayer)parameter[0];
int numberOfAttempt = 0;
RemoteAddress adress = new TcpAddress(Netplay.ServerIP, 7776);
ClientLoopSetup(adress);
ISocket secondarySocket = new TcpSocket();
secondarySocket.Connect(new TcpAddress(Netplay.ServerIP, 7776));
while (!exitThread)
{
try
{
Thread.Sleep(2500);
if (secondarySocket.IsDataAvailable())
{
byte[] data = new byte[ushort.MaxValue];
secondarySocket.AsyncReceive(data, 0, ushort.MaxValue, new SocketReceiveCallback(Netplay.Connection.ClientReadCallBack), null);
using (MemoryStream stream = new MemoryStream(data))
{
BinaryReader reader = new BinaryReader(new MemoryStream(data));
}
numberOfAttempt++;
}
else
{
byte[] data = new byte[ushort.MaxValue];
using (MemoryStream stream = new MemoryStream(data))
{
BinaryWriter writer = new BinaryWriter(stream);
writer.Write("hey");
secondarySocket.AsyncSend(writer.BaseStream.ReadAllBytes(), 0, ushort.MaxValue, new SocketSendCallback(Netplay.Connection.ClientWriteCallBack), null);
}
}
}
catch (Exception e)
{
LogManager.GetLogger("Second thread").Error(e.Message, e);
}
}
Netplay.Connection.Socket.Close();
Netplay.StartTcpClient();
player.inTransit = false;
}
public static void Run()
{
Console.Write("Enter server name: ");
var serverName = Console.ReadLine();
var router = UnityBuilder.Named("TestClient")
.WithTransport <NetMQTransport>(t => { t.WithSender(TcpAddress.FromNameAndPort(serverName, 5555)).For <TestMessage>(); })
.BuildAndStart();
var client = new Client(router);
client.Start();
}
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 void Connect(RemoteAddress address)
{
if (this._connection == null)
{
this._connection = new TcpClient();
this._connection.NoDelay = true;
}
TcpAddress tcpAddress = (TcpAddress)address;
this._connection.Connect(tcpAddress.Address, tcpAddress.Port);
this._remoteAddress = address;
}
public ClientWrapper(
TcpAddress address,
MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
: this(config, cancellationToken, messageReceived, clientConnectionFailed)
{
Address = address;
IsToServer = true;
Connected = Connect().Result;
}
static void Main(string[] args)
{
var container = new UnityContainer();
container.RegisterSingleton <UserMessageService>();
var router =
UnityBuilder
.FromContainer(container)
.WithName("ExampleServer")
.WithSerializer <DotNetSerializer>()
.WithSerializer <JsonSerializer>(true, serializer => serializer.Settings.SerializationBinder = new NetCoreSerializationBinder())
.WithTransport <NetMQTransport>(t =>
{
t.WithReceiver(TcpAddress.Localhost(5555));
t.WithPublisher(TcpAddress.Localhost(5556));
})
.WithHandlers(config =>
config
.WithRequestHandler <UserConnecting, Response <User>, UserMessageService>()
.WithRequestHandler <UserDisconecting, Response <User>, UserMessageService>()
.WithRequestHandler <ConnectedUsers, ConnectedUsersList, UserMessageService>()
.WithRequestHandler <PostMessage, Response <Message>, UserMessageService>())
.BuildAndStart();
Console.Title = "Chat Server";
Console.WriteLine("Press enter to stop server");
var server = container.Resolve <UserMessageService>();
var running = true;
while (running)
{
var input = Console.ReadLine();
switch (input)
{
case "reset":
server.Reset();
break;
case "exit":
running = false;
break;
}
}
router.Stop();
}
public void AddPublisher_WithExistingPublisherForAddress_ThrowsInvalidOperationException()
{
// Arrange
var address = TcpAddress.Wildcard(5555); // Doesn't seem to work when using the mockAddress
var cache = new PublisherCache(monitorCache);
cache.AddFactory(factory);
cache.AddPublisher <IPublisher>(address);
// Act
TestDelegate addPublisher = () => cache.AddPublisher <IPublisher>(address);
// Assert
Assert.That(addPublisher, Throws.InvalidOperationException);
}
public void Remove_WithUnaddedAddress_DoesNothing()
{
// Arrange
var socket = new RouterSocket();
var receiver = new NetMQReceiver(socket, messageFactory, requestDispatcher);
// Act
TestDelegate test = () => receiver.RemoveAddress(TcpAddress.Wildcard(5555));
// Assert
Assert.That(test, Throws.Nothing);
// Cleanup
receiver.Dispose();
}
public void AddReceiver_WithExistingReceiverForAddress_ThrowsInvalidOperationException()
{
// Arrange
var address = TcpAddress.Wildcard(5555);
var cache = new ReceiverCache(monitorCache);
cache.AddFactory(receiverFactory);
cache.AddReceiver <IReceiver>(address);
// Act
TestDelegate addReceiver = () => cache.AddReceiver <IReceiver>(address);
// Assert
Assert.That(addReceiver, Throws.InvalidOperationException);
}
private static TestNode CreateNode(IRoutingConfig routingConfig, List <IAddress> nodes, int id)
{
var connectionConfig = Substitute.For <IConnectionConfig>();
var address = new TcpAddress(new IPEndPoint(IPAddress.Loopback, 16800 + id));
connectionConfig.LocalAddress.Returns(address);
connectionConfig.PreconfiguredNodes.Returns(_ => nodes.Where(n => !Equals(n, address)).ToList());
connectionConfig.ConnectingSocketMaxTTL.Returns(TimeSpan.FromMilliseconds(50));
connectionConfig.ConnectingSocketsToConnectionsMultiplier.Returns(5);
nodes.Add(address);
var encryptionManager = Substitute.For <IEncryptionManager>();
var encoder = Substitute.For <IMessageEncoder>();
encryptionManager.CreateEncoder(Arg.Any <IConnection>()).Returns(encoder);
return(new TestNode(new TcpConnectionManager(connectionConfig, routingConfig, encryptionManager)));
}
public void AddAddress_WithNewAddress_AddsToAddresses()
{
// Arrange
var socket = new RouterSocket();
var receiver = new NetMQReceiver(socket, messageFactory, requestDispatcher);
var address = TcpAddress.Wildcard(5555);
// Act
receiver.AddAddress(address);
// Assert
CollectionAssert.Contains(receiver.Addresses, address);
// Cleanup
receiver.Dispose();
}
public void RemoveAllAddresses_WithAddedAddresses_IsConnectedFalse()
{
// Arrange
var socket = new PublisherSocket();
var publisher = new NetMQPublisher(socket, messageFactory);
publisher.AddAddress(TcpAddress.Wildcard(5555));
// Act
publisher.RemoveAllAddresses();
// Assert
Assert.That(publisher.IsConnected, Is.False);
// Cleanup
publisher.Dispose();
}
public void RemoveAllAddresses_WithAddedAddresses_IsConnectedFalse()
{
// Arrange
var socket = new SubscriberSocket();
var subscriber = new NetMQSubscriber(socket, messageFactory, topicDispatcher);
subscriber.AddAddress(TcpAddress.Wildcard(5555));
// Act
subscriber.RemoveAllAddresses();
// Assert
Assert.That(subscriber.IsConnected, Is.False);
// Cleanup
subscriber.Dispose();
}
public void RemoveAllAddresses_WithAddedAddresses_ClearsAddresses()
{
// Arrange
var socket = new PublisherSocket();
var publisher = new NetMQPublisher(socket, messageFactory);
publisher.AddAddress(TcpAddress.Wildcard(5555));
// Act
publisher.RemoveAllAddresses();
// Assert
CollectionAssert.IsEmpty(publisher.Addresses);
// Cleanup
publisher.Dispose();
}
void ISocket.Connect(RemoteAddress address)
{
_remoteAddress = address as TcpAddress;
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect(_remoteAddress.Address, _remoteAddress.Port);
SetSocket(sock);
}
