public void Correctly_sends_the_message()
{
sender.Send(message);
var node = BackupNodes[0];
var order = A.SequentialCallContext();
A.CallTo(() => client.Connect(node.Address, node.Port))
.MustHaveHappened(Repeated.Exactly.Once).InOrder(order);
A.CallTo(() => messagesSender.Send(message, client.GetStream()))
.MustHaveHappened(Repeated.Exactly.Once).InOrder(order);
A.CallTo(() => client.Dispose())
.MustHaveHappened(Repeated.Exactly.Once).InOrder(order);
}
//the function send the command to the service to get the data(status and photos number)
public void sendCommand()
{
if (m_client != null)
{
//check if the client connect
if (m_client.Connect())
{
m_client.Send(new CommandRecievedEventArgs((int)CommandEnum.WebStatusCommand, null, null).ToJson());
//wait till the
SpinWait.SpinUntil(() => stop);
}
else
{
initialize();
}
}
else
{
try
{
m_client = TcpClientChannel.ClientInstance;
m_client.DataReceived += GetMessageFromClient;
sendCommand();
}
catch { }
}
}
/// <summary>
/// Connects the specified end point.
/// </summary>
/// <param name="endPoint">The end point.</param>
/// <param name="bufferSize">Size of the buffer.</param>
/// <param name="clientStreamFactory">The client stream factory.</param>
/// <returns>
/// Network Stream instance
/// </returns>
public NetworkStream Connect(AddressEndPoint endPoint, int bufferSize, IClientStreamFactory clientStreamFactory)
{
DoDisposeCheck();
if (endPoint == null)
{
ThrowHelper.ThrowArgumentNullException("endPoint");
}
if (bufferSize < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException("bufferSize");
}
if (clientStreamFactory == null)
{
ThrowHelper.ThrowArgumentNullException("clientStreamFactory");
}
ITcpClient client = mNetworkFactory.CreateTcpClient();
client.Connect(endPoint); // ez dobhat kivételt
client.Client.SendBufferSize = bufferSize;
client.Client.ReceiveBufferSize = bufferSize;
client.Client.SendTimeout = Timeout.Infinite;
client.Client.ReceiveTimeout = Timeout.Infinite;
client.Client.SetKeepAliveValues(true, DefaultSocketKeepAliveTime, DefaultSocketKeepAliveTimeInterval);
client.Client.NoDelay = this.NoDelay;
if (LOGGER.IsDebugEnabled)
{
LOGGER.Debug(string.Format("SYNAPSE_NETWORK_MANAGER, create client network stream for connection. Factory type: '{0}'. Connection remote endpoint: '{1}'", clientStreamFactory.GetType().FullName, endPoint.ToString()));
}
return(clientStreamFactory.CreateNetworkStream(client));
}
//the function send the command to the service to get the data(status and photos number)
public void sendCommand()
{
if (m_client != null)
{
//check if the client connect
if (m_client.Connect())
{
m_client.Send(new CommandRecievedEventArgs((int)CommandEnum.GetConfigCommand, null, null).ToJson());
}
else
{
initialize();
}
}
else
{
try
{
m_client = TcpClientChannel.ClientInstance;
isDelete = false;
m_client.DataReceived += GetMessageFromClient;
sendCommand();
} catch { }
}
}
private async void BtnConnectSwitch_Click(object sender, EventArgs e)
{
try
{
if (btnConnectSwitch.Text == @"连接")
{
// 连接到目标服务器
if (!_client.Connect())
{
throw new Exception($"error code: {_client.ErrorCode}, error message: {_client.ErrorMessage}");
}
btnConnectSwitch.Text = @"断开";
// 等待服务停止
await _client.WaitAsync();
// 停止以后还原按钮标题
btnConnectSwitch.Text = @"连接";
}
else
{
// 断开连接
await _client.StopAsync();
}
}
catch (Exception ex)
{
AddLog($"exception: {ex.Message}");
}
}
public string Color()
{
if (m_client != null && m_client.Connect())
{
return("Blue");
}
return("Black");
}
public string Color()
{
if (m_client != null && m_client.Connect())
{
return("White");
}
return("LightGray");
}
private static System.IO.Stream GetSslStream(ITcpClient client)
{
client.ReceiveBufferSize = 1024 * 1000 * 2;
client.SendTimeout = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
client.ReceiveTimeout = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;
client.Connect(_hostName, 443);
return(client.GetSslStream(_hostName));
}
/// <summary>
/// Reconnects this instance.
/// </summary>
private void Reconnect()
{
m_client = new TcpClientChannel();
connected = m_client.Connect(DEFAULT_IP, DEFAULT_PORT);
if (!connected)
{
m_client = null;
return;
}
Start();
}
private void TryConnect(ITcpClient client)
{
logger.Debug("Connecting to CS.");
try
{
client.Connect(config.Address, config.Port);
}
catch (Exception ex)
{
logger.Error("Connection failed, throwing CannotSendMessageException, exception was caught: " + ex.Message);
throw new CannotSendMessageException("Cannot connect to the server.", ex);
}
}
private bool Connect(ITcpClient client)
{
if (client.Connected)
{
return(true);
}
// do the connect
if (Proxy == null)
{
//EB.Debug.Log("Connecting to " + _uri.Host + " on port " + _uri.Port);
if (!client.Connect(_uri.Host, _uri.Port, 5 * 1000))
{
client.Close();
Error("Connect failed", client.Error);
return(false);
}
}
else
{
//EB.Debug.Log("Connecting to proxy" + Proxy.Host + " on port " + Proxy.Port);
if (!client.Connect(Proxy.Host, Proxy.Port, 5 * 1000))
{
client.Close();
Error("Connect proxy failed", client.Error);
return(false);
}
}
// nothing should ever take longer than x seconds
client.ReadTimeout = kReadTimeout * 1000;
client.WriteTimeout = kWriteTimeout * 1000;
_connectionFailures = 0;
return(true);
}
/// <summary>
/// This method is called processing the tcp command.
/// </summary>
/// <returns></returns>
public int OnExecute()
{
_logger.LogDebug("OnExecute()");
// Setting default options from appsettings.json file.
OptionSettings = Parent.OptionSettings;
if (OptionSettings)
{
Console.WriteLine($"TcpMaster: {JsonConvert.SerializeObject(_settings.TcpMaster, Formatting.Indented)}");
Console.WriteLine($"TcpSlave: {JsonConvert.SerializeObject(_settings.TcpSlave, Formatting.Indented)}");
}
try
{
// Overriding TCP client options.
_client.TcpMaster.ReceiveTimeout = ReceiveTimeout;
_client.TcpMaster.SendTimeout = SendTimeout;
_client.TcpSlave.Address = Address;
_client.TcpSlave.Port = Port;
_client.TcpSlave.ID = SlaveID;
if (_client.Connect())
{
Console.WriteLine($"Modbus TCP slave found at {Address}:{Port}.");
return(0);
}
else
{
Console.WriteLine($"Modbus TCP slave not found at {Address}:{Port}.");
return(1);
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"TcpCommand - {ex.Message}");
return(-1);
}
finally
{
if (_client.Connected)
{
_client.Disconnect();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="requests">Requests to send</param>
/// <returns>Responses from the server</returns>
public Message[] SendRequests(Message[] requests)
{
byte[] requestsBytes;
int count = _converter.MessagesToBytes(out requestsBytes, requests);
ITcpClient _tcpClient = _tcpFactory.Create();
_tcpClient.Connect(_address, _port);
using (INetworkStream networkStream = _tcpClient.GetStream())
{
networkStream.Write(requestsBytes, count);
byte[] responseBytes = new byte[Properties.Settings.Default.MaxBufferSize];
int len = networkStream.Read(responseBytes, Properties.Settings.Default.MaxBufferSize);
networkStream.Close();
_tcpClient.Close();
return(_converter.BytesToMessages(responseBytes, len));
}
}
public EnvironmentResponse Connect(IClient client, ITcpClient tcpClient, Configuration configuration)
{
this.semaphore.Wait();
try
{
tcpClient.Connect(configuration.Hostname, configuration.Port);
using (var session = this.sessionFactory.Create(client))
{
return(this.startRequestWriter.WriteStart(session, configuration.Mode, configuration.Secret));
}
}
finally
{
this.semaphore.Release();
}
}
public string GetHttpsContent()
{
if (!string.IsNullOrWhiteSpace(_content))
{
return(Content);
}
_tcpClient.Connect(this.WebsiteDomain, this.Port);
using StreamWriter streamWriter = new StreamWriter(_tcpClient.GetSslStreamWrite(this.WebsiteDomain))
{
AutoFlush = true
};
using StreamReader streamReader = new StreamReader(_tcpClient.GetSslStreamRead(this.WebsiteDomain));
WriteHttpGetRequest(streamWriter, this.WebsiteDomain);
ReadHttpHeader(streamReader, out var contentLength);
return(Content = ReadHttpBody(streamReader, contentLength));
}
public bool Connect(string ip, int port)
{
DisConnect();
mTcpClient = new TcpClient();
bool ret = mTcpClient.Connect(ip, port, cSocketConnWaitTime);
if (ret)
{
mConnecting = true;
canUpdate = true;
}
else
{
mTcpClient.Release();
mTcpClient = null;
}
return(ret);
}
//------------------------------------------------------------------------------
//
// Method: AttemptConnect
//
//------------------------------------------------------------------------------
/// <summary>
/// Attempts to connect to the specified IP address and port, and retries for the specified number of times if the attempt is unsuccessful.
/// </summary>
private void AttemptConnect()
{
int connectAttempt = 0;
while (connectAttempt <= connectRetryCount)
{
try
{
client.Connect(ipAddress, port);
logger.Log(this, LogLevel.Information, "Connected to " + ipAddress.ToString() + ":" + port + ".");
break;
}
catch (System.Net.Sockets.SocketException socketException)
{
logger.Log(this, LogLevel.Error, "SocketException with error code " + socketException.ErrorCode + " occurred whilst trying to connect to " + ipAddress.ToString() + ":" + port + ".", socketException);
if (connectRetryInterval > 0)
{
Thread.Sleep(connectRetryInterval);
}
}
catch (System.Security.SecurityException securityException)
{
logger.Log(this, LogLevel.Error, "SecurityException occurred whilst trying to connect to " + ipAddress.ToString() + ":" + port + ".", securityException);
if (connectRetryInterval > 0)
{
Thread.Sleep(connectRetryInterval);
}
}
catch (Exception e)
{
throw new Exception("Error connecting to " + ipAddress.ToString() + ":" + port + ".", e);
}
connectAttempt = connectAttempt + 1;
}
if (client.Connected == false)
{
throw new Exception("Failed to connect to " + ipAddress.ToString() + ":" + port + " after " + connectAttempt + " attempts.");
}
}
public void Connect()
{
_tcpClient = new TcpClientAdapter(new TcpClient());
try
{
_tcpClient.Connect(_address, _port);
}
catch (Exception e)
{
Console.WriteLine("An exception has been encountered while connecting to {0} on port {1}. Exception message: {2}", _address, _port, e.Message);
Console.WriteLine("{0} will now exit", nameof(Connection));
throw new Exception(e.Message);
}
_status = 1;
_tcpClient.ReceiveBufferSize = 1024;
_tcpClient.SendBufferSize = 1024;
_timer = new System.Timers.Timer();
_timer.Interval = DISCONNECTTIMERINTERVAL; //the timer is set to 5000ms (5s)
_timer.Elapsed += new ElapsedEventHandler(this.timerHandler);
InitiateThreads();
}
/// <summary>
/// Constructs the communication singleton
/// </summary>
private CommunicationSingleton()
{
m_client = new TcpClientChannel();
Connected = m_client.Connect(DEFAULT_IP, DEFAULT_PORT);
Start();
}
public void Connects_with_the_client()
{
Handle();
A.CallTo(() => tcpClient.Connect(Address, Port)).MustHaveHappened(Repeated.Exactly.Once);
}
/// <summary>
/// Method to send a Modbus read request to a Modbus slave and returns the requested value(s)
/// providing common communication setup and associated exception handling (logging).
/// A TCP client is created and used to send the request to the Modbus TCP client.
/// The following requests are supported:
///
/// Single Coil
/// Single Discrete Input
/// Single Holding Register
/// Single Input Register
///
/// Multiple Coils
/// Multiple Discrete Inputs
/// Multiple Holding Registers
/// Multiple Input Registers
///
/// Additional datatypes (single values, value arrays and strings) with read
/// only access (discrete inputs and input registers) and read / write access
/// (coils and holding registers) are supported:
///
/// ASCII String (multiple registers)
/// Hex String (multiple registers)
/// Bool (single coil)
/// Bits (single register)
/// Short (single register)
/// UShort (single register)
/// Int32 (two registers)
/// UInt32 (two registers)
/// Float (two registers)
/// Double (four registers)
/// Long (four registers)
/// ULong (four registers)
///
/// </summary>
/// <param name="request">The <see cref="ModbusRequestData"/> data.</param>
/// <param name="function">The function name.</param>
/// <returns>A task returning an action method result.</returns>
protected async Task <IActionResult> ModbusReadRequest(ModbusRequestData request, string function)
{
try
{
request.Master = _client.TcpMaster;
request.Slave = _client.TcpSlave;
if (_client.Connect())
{
switch (function)
{
case "ReadCoilAsync":
{
bool[] values = await _client.ReadCoilsAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseData <bool>(request, values[0])));
}
case "ReadCoilsAsync":
{
bool[] values = await _client.ReadCoilsAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <bool>(request, values)));
}
case "ReadInputAsync":
{
bool[] values = await _client.ReadInputsAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseData <bool>(request, values[0])));
}
case "ReadInputsAsync":
{
bool[] values = await _client.ReadInputsAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <bool>(request, values)));
}
case "ReadHoldingRegisterAsync":
{
ushort[] values = await _client.ReadHoldingRegistersAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseData <ushort>(request, values[0])));
}
case "ReadHoldingRegistersAsync":
{
ushort[] values = await _client.ReadHoldingRegistersAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <ushort>(request, values)));
}
case "ReadInputRegisterAsync":
{
ushort[] values = await _client.ReadInputRegistersAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseData <ushort>(request, values[0])));
}
case "ReadInputRegistersAsync":
{
ushort[] values = await _client.ReadInputRegistersAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <ushort>(request, values)));
}
case "ReadOnlyStringAsync":
{
string value = await _client.ReadOnlyStringAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseStringData(request, value)));
}
case "ReadOnlyHexStringAsync":
{
string value = await _client.ReadOnlyHexStringAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseStringData(request, value)));
}
case "ReadOnlyBoolAsync":
{
bool value = await _client.ReadOnlyBoolAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <bool>(request, value)));
}
case "ReadOnlyBitsAsync":
{
BitArray value = await _client.ReadOnlyBitsAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseStringData(request, value.ToDigitString())));
}
case "ReadOnlyShortAsync":
{
short value = await _client.ReadOnlyShortAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <short>(request, value)));
}
case "ReadOnlyUShortAsync":
{
ushort value = await _client.ReadOnlyUShortAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <ushort>(request, value)));
}
case "ReadOnlyInt32Async":
{
int value = await _client.ReadOnlyInt32Async(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <int>(request, value)));
}
case "ReadOnlyUInt32Async":
{
uint value = await _client.ReadOnlyUInt32Async(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <uint>(request, value)));
}
case "ReadOnlyFloatAsync":
{
float value = await _client.ReadOnlyFloatAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <float>(request, value)));
}
case "ReadOnlyDoubleAsync":
{
double value = await _client.ReadOnlyDoubleAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <double>(request, value)));
}
case "ReadOnlyLongAsync":
{
long value = await _client.ReadOnlyLongAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <long>(request, value)));
}
case "ReadOnlyULongAsync":
{
ulong value = await _client.ReadOnlyULongAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <ulong>(request, value)));
}
case "ReadOnlyBoolArrayAsync":
{
bool[] values = await _client.ReadOnlyBoolArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <bool>(request, values)));
}
case "ReadOnlyBytesAsync":
{
byte[] values = await _client.ReadOnlyBytesAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <byte>(request, values)));
}
case "ReadOnlyShortArrayAsync":
{
short[] values = await _client.ReadOnlyShortArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <short>(request, values)));
}
case "ReadOnlyUShortArrayAsync":
{
ushort[] values = await _client.ReadOnlyUShortArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <ushort>(request, values)));
}
case "ReadOnlyInt32ArrayAsync":
{
int[] values = await _client.ReadOnlyInt32ArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <int>(request, values)));
}
case "ReadOnlyUInt32ArrayAsync":
{
uint[] values = await _client.ReadOnlyUInt32ArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <uint>(request, values)));
}
case "ReadOnlyFloatArrayAsync":
{
float[] values = await _client.ReadOnlyFloatArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <float>(request, values)));
}
case "ReadOnlyDoubleArrayAsync":
{
double[] values = await _client.ReadOnlyDoubleArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <double>(request, values)));
}
case "ReadOnlyLongArrayAsync":
{
long[] values = await _client.ReadOnlyLongArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <long>(request, values)));
}
case "ReadOnlyULongArrayAsync":
{
ulong[] values = await _client.ReadOnlyULongArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <ulong>(request, values)));
}
case "ReadStringAsync":
{
string value = await _client.ReadStringAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseStringData(request, value)));
}
case "ReadHexStringAsync":
{
string value = await _client.ReadHexStringAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseStringData(request, value)));
}
case "ReadBoolAsync":
{
bool value = await _client.ReadBoolAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <bool>(request, value)));
}
case "ReadBitsAsync":
{
BitArray value = await _client.ReadBitsAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseStringData(request, value.ToDigitString())));
}
case "ReadShortAsync":
{
short value = await _client.ReadShortAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <short>(request, value)));
}
case "ReadUShortAsync":
{
ushort value = await _client.ReadUShortAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <ushort>(request, value)));
}
case "ReadInt32Async":
{
int value = await _client.ReadInt32Async(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <int>(request, value)));
}
case "ReadUInt32Async":
{
uint value = await _client.ReadUInt32Async(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <uint>(request, value)));
}
case "ReadFloatAsync":
{
float value = await _client.ReadFloatAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <float>(request, value)));
}
case "ReadDoubleAsync":
{
double value = await _client.ReadDoubleAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <double>(request, value)));
}
case "ReadLongAsync":
{
long value = await _client.ReadLongAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <long>(request, value)));
}
case "ReadULongAsync":
{
ulong value = await _client.ReadULongAsync(request.Slave.ID, request.Offset);
_logger.LogTrace($"{function}(): {value}");
return(Ok(new ModbusResponseData <ulong>(request, value)));
}
case "ReadBoolArrayAsync":
{
bool[] values = await _client.ReadBoolArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <bool>(request, values)));
}
case "ReadBytesAsync":
{
byte[] values = await _client.ReadBytesAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <byte>(request, values)));
}
case "ReadShortArrayAsync":
{
short[] values = await _client.ReadShortArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <short>(request, values)));
}
case "ReadUShortArrayAsync":
{
ushort[] values = await _client.ReadUShortArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <ushort>(request, values)));
}
case "ReadInt32ArrayAsync":
{
int[] values = await _client.ReadInt32ArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <int>(request, values)));
}
case "ReadUInt32ArrayAsync":
{
uint[] values = await _client.ReadUInt32ArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <uint>(request, values)));
}
case "ReadFloatArrayAsync":
{
float[] values = await _client.ReadFloatArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <float>(request, values)));
}
case "ReadDoubleArrayAsync":
{
double[] values = await _client.ReadDoubleArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <double>(request, values)));
}
case "ReadLongArrayAsync":
{
long[] values = await _client.ReadLongArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <long>(request, values)));
}
case "ReadULongArrayAsync":
{
ulong[] values = await _client.ReadULongArrayAsync(request.Slave.ID, request.Offset, request.Number);
_logger.LogTrace($"{function}(): {values}");
return(Ok(new ModbusResponseArrayData <ulong>(request, values)));
}
default:
_logger.LogError($"TCP master read request {function}() not supported.");
return(NotFound($"TCP master read request {function}() not supported."));
}
}
else
{
_logger.LogError($"TCP client ({request.Slave.Address}:{request.Slave.Port}) not connected.");
return(NotFound("TCP client not connected."));
}
}
catch (ArgumentOutOfRangeException are)
{
_logger.LogError(are, $"{function}() Argument out of Range Exception.");
return(BadRequest($"Argument out of Range Exception: {are.Message}"));
}
catch (ArgumentException aex)
{
_logger.LogError(aex, $"{function}() Argument Exception.");
return(BadRequest($"Argument Exception: {aex.Message}"));
}
catch (FormatException fex)
{
_logger.LogError(fex, $"{function}() Format Exception.");
return(BadRequest($"Format Exception: {fex.Message}"));
}
catch (NModbus.SlaveException mse)
{
_logger.LogError(mse, $"{function}() Modbus SlaveException.");
return(StatusCode(502, $"Modbus SlaveException: {mse.Message}"));
}
catch (InvalidOperationException ioe)
{
_logger.LogError(ioe, $"{function}() Invalid Operation Exception.");
return(StatusCode(500, $"Invalid Operation Exception: {ioe.Message}"));
}
catch (SocketException se)
{
_logger.LogError(se, $"{function}() Socket Exception.");
return(StatusCode(500, $"Socket Exception: {se.Message}"));
}
catch (TimeoutException tex)
{
_logger.LogError(tex, $"{function}() Timeout Exception.");
return(StatusCode(500, $"Timeout Exception: {tex.Message}"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"{function}() Exception.");
return(StatusCode(500, $"Exception: {ex.Message}"));
}
finally
{
if (_client.Connected)
{
_client.Disconnect();
}
}
}
bool DoConnect()
{
if (Proxy == null)
{
_client = TcpClientFactory.Create(_uri.Scheme == "wss");
EB.Debug.Log("connect " + _uri.Host + " on port " + _uri.Port);
if (!_client.Connect(_uri.Host, _uri.Port, 5 * 1000))
{
_client.Close();
_client = null;
_state = WebSocketState.None;
Error("failed to connect");
return(false);
}
}
else
{ // use proxy
bool secure = _uri.Scheme == "wss";
_client = TcpClientFactory.Create(secure);
if (secure)
{
(_client as TcpClientEvent).ConnectedEvent += delegate(object sender)
{
const string CRLF = "\r\n";
string request = "CONNECT " + _uri.Host + ":" + _uri.Port + " HTTP/1.1" + CRLF
+ "Host: " + _uri.HostAndPort + CRLF
+ CRLF;
var bytes = Encoding.GetBytes(request);
_client.Write(bytes, 0, bytes.Length);
string header = ReadLine(_client).ToLower();
if (!header.StartsWith("http/1.1 200 connection established") && !header.StartsWith("http/1.0 200 connection established"))
{
_client.Close();
_state = WebSocketState.None;
throw new System.Net.WebException("failed to connect to proxy");
}
// read the headers
while (true)
{
var line = ReadLine(_client);
//Debug.Log("line: " + line + " " + line.Length);
if (line.Length == 0)
{
break;
}
}
};
}
EB.Debug.Log("connect proxy " + Proxy.Host + " on port " + Proxy.Port);
if (!_client.Connect(Proxy.Host, Proxy.Port, 5 * 1000))
{
_client.Close();
_client = null;
_state = WebSocketState.None;
Error("failed to connect proxy");
return(false);
}
}
_client.ReadTimeout = 5 * 1000;
_client.WriteTimeout = 5 * 1000;
if (!_running)
{
return(false);
}
return(true);
}
void SendLoop()
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
try
{
if (_client != null && _client.Connected)
{
if (_sendqueue.Count == 0)
{
/* This is where we make sure that the while loop doesn't eat CPU time when
* there's nothing in the queue */
lock (_syncQueue)
Monitor.Wait(_syncQueue);
}
/* Because of the Dispose method, this can still be 0 after the Monitor.Wait */
if (_sendqueue.Count > 0)
{
/* Here we actually get a buffer and only remove it when sending has succeeded */
Tuple <byte[], int, int> buffer;
if (_sendqueue.TryPeek(out buffer))
{
_client.Write(buffer.Item1, buffer.Item2, buffer.Item3);
while (!_sendqueue.TryDequeue(out buffer))
{
;
}
}
}
}
else
{
/* This is a very easy reconnect state machine with a simple backoff timer of
* maximum 1 minute */
int backoffCntr = 0;
while (!_client.Connected)
{
Task.Delay(TimeSpan.FromMilliseconds(backoffCntr * 500)).Wait(_cancellationTokenSource.Token);
try
{
_client.Connect();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
}
if (backoffCntr < 120)
{
++backoffCntr;
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
_client.Close();
}
}
}
/// <summary>
/// Starts listening to the WAS. Uses the event 'WasConnectionStateChanged' to report changes of the connection-state.
/// If any data is on the client-stream available, the method will report the progress using the 'WasObjectChanged' event.
/// This method also starts a new timer to send the KeepAlive-Message.
/// </summary>
private void StartWorker(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
ITcpClient tcpClient = null;
System.Timers.Timer t = null;
try
{
tcpClient = this.mCoreObjectFactory.CreateTcpClient();
tcpClient.Connect(AicSettings.Global.WasIp, AicSettings.Global.WasPort);
t = new System.Timers.Timer(Constants.WasKeepAliveTimeout.TotalMilliseconds);
t.Elapsed += delegate { SendKeepAliveMessage(tcpClient); };
t.Start();
tcpClient.GetStream().Write(Constants.GetAlarmsCommandBytes, 0, Constants.GetAlarmsCommandBytes.Length);
if (this.WasConnectionStateChanged != null)
{
Thread eventThread = new Thread(new ThreadStart(delegate
{
this.WasConnectionStateChanged(true, false);
}))
{
IsBackground = true
};
eventThread.Start();
}
while (!worker.CancellationPending)
{
// Check if the connection to the WAS got lost
if (!tcpClient.IsConnected())
{
this.mLogger.LogError("WAS disconnected while waiting for new data", ErrorType.WasListener_WasDisconnectWhileWaiting);
throw new SocketException();
}
// Check if any data from the WAS is available
else if (!tcpClient.GetStream().DataAvailable)
{
Thread.Sleep((int)Constants.WasRequestCycleTimeout.TotalMilliseconds);
continue;
}
this.HandleWasData(tcpClient);
}
}
catch (Exception ex)
{
this.mLogger.LogError("(WasListener/StartWorker/Exception)", ErrorType.Undefined, ex);
throw ex;
}
finally
{
lock (this.mLocker)
{
if (t != null)
{
t.Dispose();
}
if (tcpClient != null)
{
if (tcpClient.Connected)
{
// The networkstream will not close itself - see MSDN
IStream networkStream = tcpClient.GetStream();
networkStream.Close();
}
tcpClient.Close();
}
this.mIsRunning = false;
}
}
}
