public void is_port_unused_should_return_true_on_get_random_unused_port()
{
var port = TcpUtil.GetRandomUnusedPort();
var isPortUnused = TcpUtil.IsPortUnused(port);
Assert.IsTrue(isPortUnused);
}
/// <remarks>
/// Selecting a random port is more complicated than just usint tcp://*.* because we want to avoid using a port
/// that was used for another environment. If we were to share a port between two environments, clients from the
/// second environment might try to send us messages that we would have to discard
/// </remarks>>
public void SelectRandomPort(PeerId peerId, string environment)
{
_logger.InfoFormat("Selecting random port for {0}", environment);
var directory = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
var forbiddenPorts = directory.GetFiles("*.inboundport.*").Select(ReadPort).Where(port => port.HasValue).ToHashSet();
if (forbiddenPorts.Any())
{
_logger.InfoFormat("Ports already reserved for other environments: {0}", string.Join(", ", forbiddenPorts));
}
int?selectedPort = null;
do
{
var port = TcpUtil.GetRandomUnusedPort();
if (!forbiddenPorts.Contains(port))
{
selectedPort = port;
}
} while (!selectedPort.HasValue);
SetPort(selectedPort.Value);
}
public void OkNowIKnowThatMyMessagesAreLostAfterDisconnect()
{
var message = new byte[50];
var receiveBuffer = new byte[100];
using (var context = ZmqContext.Create())
{
var sendEndpoint = string.Format("tcp://localhost:{0}", TcpUtil.GetRandomUnusedPort());
var receiveEndpoint = sendEndpoint.Replace("localhost", "*");
var receiver = context.CreateSocket(SocketType.PULL);
receiver.ReceiveHighWatermark = 10;
receiver.Bind(receiveEndpoint);
var sender = context.CreateSocket(SocketType.PUSH);
sender.SendHighWatermark = 10;
sender.Connect(sendEndpoint);
for (var i = 0; i < 10; ++i)
{
var sendStatus = sender.Send(message);
Console.WriteLine(sendStatus);
}
for (var i = 0; i < 10; ++i)
{
var bytes = receiver.Receive(receiveBuffer, 200.Milliseconds());
Console.WriteLine(bytes);
}
receiver.Unbind(receiveEndpoint);
for (var i = 0; i < 10; ++i)
{
var sendStatus = sender.Send(message);
Console.WriteLine(sendStatus);
}
sender.Disconnect(sendEndpoint);
sender.Connect(sendEndpoint);
var oneMoreSend = sender.SendWithTimeout(message, message.Length, 1000.Milliseconds());
Console.WriteLine(oneMoreSend);
receiver.Bind(receiveEndpoint);
var receivedMessageCount = 0;
while (receiver.Receive(receiveBuffer, 2000.Milliseconds()) != -1)
{
++receivedMessageCount;
}
Console.WriteLine("{0} received messages", receivedMessageCount);
}
}
public virtual void Setup()
{
ClientConfiguration = new ClientConfiguration();
ServerConfiguration = new ServerConfiguration(TcpUtil.GetRandomUnusedPort());
ServerEndPoint = new IPEndPoint(IPAddress.Loopback, ServerConfiguration.ListeningPort);
var serializationRegistries = new SerializationRegistries();
ConfigureSerialization(serializationRegistries);
Client = new RioClient(ClientConfiguration, new SerializationEngine(serializationRegistries.Client));
Server = new RioServer(ServerConfiguration, new SerializationEngine(serializationRegistries.Server));
}
public void should_reuse_last_endpoint_port_when_available_in_current_dir()
{
const string peerId = "Abc.Peer.0";
var expectedPortFilePath = PathUtil.InBaseDirectory(peerId + ".inboundport.test");
var expectedPort = TcpUtil.GetRandomUnusedPort();
File.WriteAllText(expectedPortFilePath, expectedPort.ToString());
var transport = CreateAndStartZmqTransport(peerId: peerId);
var endpoint = new ZmqEndPoint(transport.InboundEndPoint);
endpoint.GetPort().ShouldEqual(expectedPort);
}
public void should_not_reuse_a_port_used_in_another_envionment()
{
const string peerId = "Abc.Peer.0";
var doNotUsePortFilePath = PathUtil.InBaseDirectory(peerId + ".inboundport.secondenv");
var expectedPort = TcpUtil.GetRandomUnusedPort() + 5; // scientifical method to determine what port will be used by the transport :P
File.WriteAllText(doNotUsePortFilePath, expectedPort.ToString());
var transport = CreateAndStartZmqTransport(peerId: peerId);
var endpoint = new ZmqEndPoint(transport.InboundEndPoint);
endpoint.GetPort().ShouldNotEqual(expectedPort);
Console.WriteLine("{0} => {1}", endpoint.GetPort(), expectedPort);
}
public void OkNowIKnowThatMyMessagesAreNotLostAfterDisconnect()
{
var message = new byte[100];
var receiveBuffer = new byte[100];
Console.WriteLine("ZMQ v{0}", ZmqUtil.GetVersion().ToString(3));
Console.WriteLine(Environment.Is64BitProcess ? "x64" : "x86");
using (var context = new ZmqContext())
using (var receiver = new ZmqSocket(context, ZmqSocketType.PULL))
using (var sender = new ZmqSocket(context, ZmqSocketType.PUSH))
{
var port = TcpUtil.GetRandomUnusedPort();
var receiveEndpoint = $"tcp://*:{port}";
var sendEndpoint = $"tcp://localhost:{port}";
receiver.SetOption(ZmqSocketOption.RCVHWM, 2_000);
receiver.SetOption(ZmqSocketOption.RCVTIMEO, 200);
receiver.SetOption(ZmqSocketOption.RCVBUF, 100_000);
receiver.Bind(receiveEndpoint);
sender.SetOption(ZmqSocketOption.SNDHWM, 2_000);
//sender.SetOption(ZmqSocketOption.RCVHWM, 1);
sender.SetOption(ZmqSocketOption.SNDTIMEO, 200);
receiver.SetOption(ZmqSocketOption.SNDBUF, 100_000);
sender.Connect(sendEndpoint);
var sendCount = 0;
while (sender.TrySend(message, 0, message.Length, out _))
{
sendCount++;
}
Console.WriteLine("{0} sent messages", sendCount);
sender.TryDisconnect(sendEndpoint);
sender.Connect(sendEndpoint);
var receivedMessageCount = 0;
while (receiver.TryReadMessage(ref receiveBuffer, out _, out _))
{
receivedMessageCount++;
}
Console.WriteLine("{0} received messages", receivedMessageCount);
}
}
public void should_support_peer_endpoint_modifications()
{
var senderTransport = CreateAndStartZmqTransport();
var receivedMessages = new ConcurrentBag <TransportMessage>();
var receiverTransport = CreateAndStartZmqTransport(onMessageReceived: receivedMessages.Add);
var receiver = new Peer(receiverTransport.PeerId, receiverTransport.InboundEndPoint);
senderTransport.Send(new FakeCommand(0).ToTransportMessage(), new[] { receiver });
Wait.Until(() => receivedMessages.Count == 1, 2.Seconds());
var newEndPoint = "tcp://127.0.0.1:" + TcpUtil.GetRandomUnusedPort();
receiverTransport.Stop();
receiverTransport = CreateAndStartZmqTransport(newEndPoint, receivedMessages.Add);
receiver.EndPoint = receiverTransport.InboundEndPoint;
senderTransport.Send(new FakeCommand(0).ToTransportMessage(), new[] { receiver });
Wait.Until(() => receivedMessages.Count == 2, 2.Seconds(), "unable to receive message");
}
public void OkNowIKnowThatMyMessagesAreLostAfterDisconnect()
{
var message = new byte[50];
var receiveBuffer = new byte[100];
Console.WriteLine("ZMQ v{0}", ZmqUtil.GetVersion().ToString(3));
Console.WriteLine(Environment.Is64BitProcess ? "x64" : "x86");
using (var context = new ZmqContext())
using (var receiver = new ZmqSocket(context, ZmqSocketType.PULL))
using (var sender = new ZmqSocket(context, ZmqSocketType.PUSH))
{
var sendEndpoint = $"tcp://localhost:{TcpUtil.GetRandomUnusedPort()}";
var receiveEndpoint = sendEndpoint.Replace("localhost", "*");
receiver.SetOption(ZmqSocketOption.RCVHWM, 10);
receiver.SetOption(ZmqSocketOption.RCVTIMEO, 200);
receiver.Bind(receiveEndpoint);
sender.SetOption(ZmqSocketOption.SNDHWM, 10);
sender.Connect(sendEndpoint);
for (var i = 0; i < 10; ++i)
{
var sendStatus = sender.TrySend(message, 0, message.Length, out var error);
Console.WriteLine($"SEND: {sendStatus} - {error.ToErrorMessage()}");
}
for (var i = 0; i < 10; ++i)
{
var receiveStatus = receiver.TryReadMessage(ref receiveBuffer, out var bytes, out var error);
Console.WriteLine($"RECV: {receiveStatus} - {bytes} - {error.ToErrorMessage()}");
}
receiver.TryUnbind(receiver.GetOptionString(ZmqSocketOption.LAST_ENDPOINT));
for (var i = 0; i < 10; ++i)
{
var sendStatus = sender.TrySend(message, 0, message.Length, out var error);
Console.WriteLine($"SEND: {sendStatus} - {error.ToErrorMessage()}");
}
sender.TryDisconnect(sender.GetOptionString(ZmqSocketOption.LAST_ENDPOINT));
sender.SetOption(ZmqSocketOption.SNDTIMEO, 1000);
sender.Connect(sendEndpoint);
{
var sendStatus = sender.TrySend(message, 0, message.Length, out var error);
Console.WriteLine($"SEND: {sendStatus} - {error.ToErrorMessage()}");
}
receiver.SetOption(ZmqSocketOption.RCVTIMEO, 2000);
receiver.Bind(receiveEndpoint);
var receivedMessageCount = 0;
while (receiver.TryReadMessage(ref receiveBuffer, out _, out _))
{
++receivedMessageCount;
}
Console.WriteLine("{0} received messages", receivedMessageCount);
}
}
