public void ShouldProvideConnectionStatus()
{
using var client = new TcpClientAdapter();
client.Connect("localhost", Port);
Assert.IsTrue(client.Connected);
this.listener.Stop();
try
{
// Since Connected only reports as of the last operation, we must send or receive data to
// get the state as of now.
client.GetStream().Write(new byte[0], 0, 0);
// To deal with reconnection in real scenarios, the resulting IOException should be caught and
// then attempt a retry with the exact same client.
}
catch (IOException)
{
//
}
Assert.IsFalse(client.Connected);
this.listener.Start();
}
void MakeSureClientIsConnected()
{
if (_client != null && !_client.Connected)
{
_client.Dispose();
_client = null;
_adapter.Dispose();
_adapter = null;
_master.Dispose();
_master = null;
}
if (_client == null)
{
_client = new TcpClient(_configuration.Ip, _configuration.Port);
_adapter = new TcpClientAdapter(_client);
var factory = new ModbusFactory();
if (_configuration.UseASCII)
{
_master = factory.CreateAsciiMaster(_adapter);
}
else if (_configuration.Protocol == Protocol.Tcp)
{
_master = factory.CreateMaster(_client);
}
else
{
_master = factory.CreateRtuMaster(_adapter);
}
}
}
public void ShouldProvideAccessToInternalNetworkStream()
{
using (var client = new TcpClientAdapter("localhost", Port))
{
Assert.IsNotNull(client.GetStream());
}
}
private IModbusMaster CreateTcpMaster(ModbusFactory factory)
{
_tcpClient = new TcpClient(_configurationSettings.IpAddress, _configurationSettings.IpPort);
IModbusMaster master = null;
if (_configurationSettings.ConnectionType.CurrentType == ConnectionType.TcpIp)
{
master = factory.CreateMaster(_tcpClient);
}
if (_configurationSettings.ConnectionType.CurrentType == ConnectionType.RtuAsciiOverTcpIp)
{
var adapter = new TcpClientAdapter(_tcpClient);
if (_configurationSettings.UseRtu)
{
master = factory.CreateRtuMaster(adapter);
}
if (_configurationSettings.UseAscii)
{
master = factory.CreateAsciiMaster(adapter);
}
}
master.Transport.ReadTimeout = _configurationSettings.Timeout;
return(master);
}
internal HttpListenerResponse(HttpListenerRequest request, TcpClientAdapter client)
{
Headers = new HttpListenerResponseHeaders(this);
this._client = client;
this.Request = request;
}
public IModbusMaster CreateRtuOverTcpMaster(TcpClient client)
{
var adapter = new TcpClientAdapter(client);
var transport = new ModbusRtuOverTcpTransport(adapter, this, Logger);
return(new ModbusIpMaster(transport));
}
public IModbusMaster CreateMaster(TcpClient client)
{
var adapter = new TcpClientAdapter(client);
var transport = CreateIpTransport(adapter);
return(new ModbusIpMaster(transport));
}
public void ShouldProvideSemaphore()
{
using var client = new TcpClientAdapter();
var semaphore = client.Semaphore;
Assert.AreEqual(1, semaphore.CurrentCount);
Assert.AreSame(client.Semaphore, semaphore);
}
public void ShouldProvideAccessToInternalNetworkStream()
{
using var client = new TcpClientAdapter();
client.Connect("localhost", Port);
Assert.IsNotNull(client.StreamReader);
Assert.IsNotNull(client.StreamWriter);
}
/// <inheritdoc/>
public void Dispose()
{
_client?.Dispose();
_client = null;
_adapter?.Dispose();
_adapter = null;
_master?.Dispose();
_master = null;
}
public void AddingToTheMessageList()
{
var client = new TcpClientAdapter(new TcpClient());
var server = new Connection(80);
var receiver = new Receiver(client, server);
receiver.SendMessage("test message");
Assert.IsTrue(receiver.MessageList.Count > 0);
}
public void ConnectAsyncThrowsArgumentExceptionWhenNoAddressForAddressFamilyCanBeFound()
{
var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
var sut = new TcpClientAdapter(socket);
Assert.Throws <ArgumentException>(() =>
{
sut.ConnectAsync("localhost", 5672).GetAwaiter().GetResult();
});
}
public void startClient(TcpClient inClientSocket, string clientName, Hashtable clientList)
{
_clientName = clientName;
_clientList = clientList;
_adapter = new TcpClientAdapter(inClientSocket);
//client communication should happen in own thread
new Thread(() => DoChat()).Start();
}
public void DisposesTcpClient()
{
// Arrange
var tcpClient = new TcpClient();
var target = new TcpClientAdapter <TcpClient>(tcpClient);
// Act
target.Dispose();
// Assert
Assert.Null(tcpClient.Client);
}
public void ShouldBeAbleToConnectAndReconnectSynchronously()
{
using var client = new TcpClientAdapter();
Assert.IsFalse(client.Connected);
client.Connect("localhost", Port);
Assert.IsTrue(client.Connected);
client.Connect("localhost", Port);
Assert.IsTrue(client.Connected);
}
public async Task ShouldBeAbleToConnectAndReconnectAsynchronously()
{
using var client = new TcpClientAdapter();
Assert.IsFalse(client.Connected);
await client.ConnectAsync("localhost", Port);
Assert.IsTrue(client.Connected);
await client.ConnectAsync("localhost", Port);
Assert.IsTrue(client.Connected);
}
public void ReceiverStartedProperly()
{
var client = new TcpClientAdapter(new TcpClient());
var server = new Connection(80);
var receiver = new Receiver(client, server);
try
{
receiver.Start();
}
catch
{
Assert.Fail();
}
}
private void btnConnect_Click(object sender, RoutedEventArgs e)
{
if (_chatClient is null || _chatClient.IsConnected == false)
{
var ipAddress = ucIpAddress.Address;
var port = int.Parse(tbxPort.Text);
var _adapter = new TcpClientAdapter(new System.Net.Sockets.TcpClient());
_messageSender = new MessageSender.MessageSender(_adapter);
_chatClient = new Client(_messageSender);
_chatClient.ReadMessage += _chatClient_OnGetMessage;
_chatClient.Connected += _chatClient_Connected;
_chatClient.Disconnected += _chatClient_Disconnected;
_chatClient.OnException += _chatClient_OnException;
_chatClient.Connect(ipAddress, port);
}
public void ReceiverDisconnectedProperly()
{
var client = new TcpClientAdapter(new TcpClient());
var server = new Connection(80);
var receiver = new Receiver(client, server);
try
{
receiver.Start();
receiver.Disconnect();
}
catch (AggregateException e)
{
Assert.Fail();
}
}
private static void TestSocket()
{
using (TcpClientAdapter port = new TcpClientAdapter(GetTcpClient()))
{
Tcp tcp = new Tcp(port);
//tcp.TestReadCoils();
//tcp.TestWriteSingleCoil();
//tcp.TestWriteMultipleCoils();
tcp.TestReadHoldingRegisters();
tcp.TestWriteSingleRegister();
tcp.TestWriteMultipleRegisters();
//tcp.TestReadInputs();
//tcp.TestReadInputRegisters();
}
}
private async Task OpenTransportAsync()
{
await ExecuteAsync(async() =>
{
AddStatusMessage("Connecting...");
var timeoutCancellationToken = _operationTimeout.ToCancellationToken();
X509Certificate2 clientCertificate = null;
if (!string.IsNullOrWhiteSpace(ClientCertificateThumbprint))
{
ClientCertificateThumbprint = ClientCertificateThumbprint
.Replace(" ", "")
.Replace("", "");
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
try
{
store.Open(OpenFlags.ReadOnly);
var certificates = store.Certificates.Find(X509FindType.FindByThumbprint, ClientCertificateThumbprint, false);
if (certificates.Count > 0)
{
clientCertificate = certificates[0];
var identity = clientCertificate.GetIdentity();
if (identity != null)
{
var fromVariableViewModel = this.Variables.FirstOrDefault(v => v.Name.Equals("from", StringComparison.OrdinalIgnoreCase));
if (fromVariableViewModel == null)
{
fromVariableViewModel = new VariableViewModel()
{
Name = "from"
};
this.Variables.Add(fromVariableViewModel);
}
fromVariableViewModel.Value = identity.ToString();
}
}
else
{
AddStatusMessage("The specified certificate was not found", true);
}
}
finally
{
store.Close();
}
}
if (_hostUri.Scheme == WebSocketTransportListener.UriSchemeWebSocket ||
_hostUri.Scheme == WebSocketTransportListener.UriSchemeWebSocketSecure)
{
Transport = new ClientWebSocketTransport(
new JsonNetSerializer(),
this);
}
else
{
TcpClient = new TcpClientAdapter(new TcpClient());
Transport = new TcpTransport(
TcpClient,
new JsonNetSerializer(),
_hostUri.Host,
clientCertificate,
traceWriter: this);
}
await Transport.OpenAsync(_hostUri, timeoutCancellationToken);
_connectionCts = new CancellationTokenSource();
var dispatcher = Dispatcher.CurrentDispatcher;
_receiveTask = ReceiveAsync(
Transport,
(e) => ReceiveEnvelopeAsync(e, dispatcher),
_connectionCts.Token)
.WithCancellation(_connectionCts.Token)
.ContinueWith(t =>
{
IsConnected = false;
if (t.Exception != null)
{
AddStatusMessage(string.Format("Disconnected with errors: {0}", t.Exception.InnerException.Message.RemoveCrLf()), true);
}
else
{
AddStatusMessage("Disconnected");
}
}, TaskScheduler.FromCurrentSynchronizationContext());
IsConnected = true;
CanSendAsRaw = true;
AddStatusMessage("Connected");
});
}
public IModbusMaster CreateMaster(TcpClient client)
{
var adapter = new TcpClientAdapter(client);
return(CreateIpMaster(adapter));
}
internal HttpListenerRequest(TcpClientAdapter client)
{
this._client = client;
Headers = new HttpListenerRequestHeaders(this);
}
