static void Main()
{
var serverPublicKey = new X509Certificate2(@"C:\Users\node\Desktop\scs\SSLSamples\CertificateFiles\Server\publicKey.cer");
Console.WriteLine("Press enter to connect to the server...");
Console.ReadLine(); //Wait user to press enter
//Create a client object to connect a server on 127.0.0.1 (local) IP and listens 10085 TCP port
// using (var client = ScsClientFactory.CreateClient(new ScsTcpEndPoint("127.0.0.1", 10085)))
using (var client = SslScsClientFactory.CreateSslClient(new ScsTcpEndPoint("127.0.0.1", 10085)
, serverPublicKey
, "127.0.0.1"))
{
//Create a RequestReplyMessenger that uses the client as internal messenger.
using (var requestReplyMessenger = new RequestReplyMessenger <IScsClient>(client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
client.Connect(); //Connect to the server
Console.Write("Write some message to be sent to server: ");
var messageText = Console.ReadLine(); //Get a message from user
//Send user message to the server and get response
var response = requestReplyMessenger.SendMessageAndWaitForResponse(new ScsTextMessage(messageText));
Console.WriteLine("Response to message: " + ((ScsTextMessage)response).Text);
Console.WriteLine("Press enter to disconnect from server...");
Console.ReadLine(); //Wait user to press enter
}
}
}
static void Main()
{
Console.WriteLine("Press enter to connect to the server...");
Console.ReadLine(); //Wait user to press enter
//Create a client object to connect a server on 127.0.0.1 (local) IP and listens 10085 TCP port
using (var client = ScsClientFactory.CreateClient(new ScsTcpEndPoint("127.0.0.1", 10085)))
{
//Create a RequestReplyMessenger that uses the client as internal messenger.
using (var requestReplyMessenger = new RequestReplyMessenger<IScsClient>(client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
client.Connect(); //Connect to the server
Console.Write("Write some message to be sent to server: ");
var messageText = Console.ReadLine(); //Get a message from user
//Send user message to the server and get response
var response = requestReplyMessenger.SendMessageAndWaitForResponse(new ScsTextMessage(messageText));
Console.WriteLine("Response to message: " + ((ScsTextMessage) response).Text);
Console.WriteLine("Press enter to disconnect from server...");
Console.ReadLine(); //Wait user to press enter
}
}
}
static void Main()
{
Console.WriteLine("Press enter to connect to the server...");
Console.ReadLine(); //Wait user to press enter
//Create a client object to connect a server on 127.0.0.1 (local) IP and listens 10085 TCP port
using (var client = ScsClientFactory.CreateClient(new ScsTcpEndPoint("127.0.0.1", 10085)))
{
//Create a RequestReplyMessenger that uses the client as internal messenger.
using (var requestReplyMessenger = new RequestReplyMessenger <IScsClient>(client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
client.Connect(); //Connect to the server
Console.Write("Write some message to be sent to server: ");
var messageText = Console.ReadLine(); //Get a message from user
//Send user message to the server and get response
var response = requestReplyMessenger.SendMessageAndWaitForResponse(new ScsTextMessage(messageText));
Console.WriteLine("Response to message: " + ((ScsTextMessage)response).Text);
Console.WriteLine("Press enter to disconnect from server...");
Console.ReadLine(); //Wait user to press enter
}
}
}
/// <summary>
/// Handles MessageReceived events of all clients, evaluates each message,
/// finds appropriate service object and invokes appropriate method.
///
/// </summary>
/// <param name="sender">Source of event</param><param name="e">Event arguments</param>
private void Client_MessageReceived(object sender, MessageEventArgs e)
{
RequestReplyMessenger <IScsServerClient> requestReplyMessenger = (RequestReplyMessenger <IScsServerClient>)sender;
ScsRemoteInvokeMessage remoteInvokeMessage = e.Message as ScsRemoteInvokeMessage;
if (remoteInvokeMessage == null)
{
return;
}
try
{
IScsServiceClient scsServiceClient = this._serviceClients[requestReplyMessenger.Messenger.ClientId];
if (scsServiceClient == null)
{
requestReplyMessenger.Messenger.Disconnect();
}
else
{
ScsServiceApplication.ServiceObject serviceObject = this._serviceObjects[remoteInvokeMessage.ServiceClassName];
if (serviceObject == null)
{
ScsServiceApplication.SendInvokeResponse((IMessenger)requestReplyMessenger, (IScsMessage)remoteInvokeMessage, (object)null, new ScsRemoteException("There is no service with name '" + remoteInvokeMessage.ServiceClassName + "'"));
}
else
{
try
{
serviceObject.Service.CurrentClient = scsServiceClient;
object returnValue;
try
{
returnValue = serviceObject.InvokeMethod(remoteInvokeMessage.MethodName, remoteInvokeMessage.Parameters);
}
finally
{
serviceObject.Service.CurrentClient = (IScsServiceClient)null;
}
ScsServiceApplication.SendInvokeResponse((IMessenger)requestReplyMessenger, (IScsMessage)remoteInvokeMessage, returnValue, (ScsRemoteException)null);
}
catch (TargetInvocationException ex)
{
Exception innerException = ex.InnerException;
ScsServiceApplication.SendInvokeResponse((IMessenger)requestReplyMessenger, (IScsMessage)remoteInvokeMessage, (object)null, new ScsRemoteException(innerException.Message + Environment.NewLine + "Service Version: " + serviceObject.ServiceAttribute.Version, innerException));
}
catch (Exception ex)
{
ScsServiceApplication.SendInvokeResponse((IMessenger)requestReplyMessenger, (IScsMessage)remoteInvokeMessage, (object)null, new ScsRemoteException(ex.Message + Environment.NewLine + "Service Version: " + serviceObject.ServiceAttribute.Version, ex));
}
}
}
}
catch (Exception ex)
{
ScsServiceApplication.SendInvokeResponse((IMessenger)requestReplyMessenger, (IScsMessage)remoteInvokeMessage, (object)null, new ScsRemoteException("An error occured during remote service method call.", ex));
}
}
/// <summary>
/// Creates a new ScsServiceClient object.
///
/// </summary>
/// <param name="client">Underlying IScsClient object to communicate with server</param><param name="clientObject">The client object that is used to call method invokes in client side.
/// May be null if client has no methods to be invoked by server.</param>
public ScsServiceClient(IScsClient client, object clientObject)
{
this._client = client;
this._clientObject = clientObject;
this._client.Connected += new EventHandler(this.Client_Connected);
this._client.Disconnected += new EventHandler(this.Client_Disconnected);
this._requestReplyMessenger = new RequestReplyMessenger <IScsClient>(client);
this._requestReplyMessenger.MessageReceived += new EventHandler <MessageEventArgs>(this.RequestReplyMessenger_MessageReceived);
this._realServiceProxy = new AutoConnectRemoteInvokeProxy <T, IScsClient>(this._requestReplyMessenger, (IConnectableClient)this);
this.ServiceProxy = (T)this._realServiceProxy.GetTransparentProxy();
}
/// <summary>
/// Handles ClientConnected event of _scsServer object.
///
/// </summary>
/// <param name="sender">Source of event</param><param name="e">Event arguments</param>
private void ScsServer_ClientConnected(object sender, ServerClientEventArgs e)
{
RequestReplyMessenger <IScsServerClient> requestReplyMessenger = new RequestReplyMessenger <IScsServerClient>(e.Client);
requestReplyMessenger.MessageReceived += new EventHandler <MessageEventArgs>(this.Client_MessageReceived);
requestReplyMessenger.Start();
IScsServiceClient serviceClient = ScsServiceClientFactory.CreateServiceClient(e.Client, requestReplyMessenger);
this._serviceClients[serviceClient.ClientId] = serviceClient;
this.OnClientConnected(serviceClient);
}
/// <summary>
/// ´Send a text command to a static node and get a response
/// </summary>
/// <param name="command">the command in sql like syntax</param>
/// <returns>The Repsonse of the command</returns>
public byte[] SendCommandAndWaitForResponse(byte[] command)
{
//Create a RequestReplyMessenger that uses the client as internal messenger.
using (var requestReplyMessenger = new RequestReplyMessenger<IScsClient>(_client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
//_client.Connect(); //Connect to the server
//Send message to the server and get response
return ((ScsRawDataMessage)requestReplyMessenger.SendMessageAndWaitForResponse(new ScsRawDataMessage(command))).MessageData;
}
}
/// <summary>
/// Handles ClientConnected event of _scsServer object.
/// </summary>
/// <param name="sender">Source of event</param>
/// <param name="e">Event arguments</param>
private void ScsServer_ClientConnected(object sender, ServerClientEventArgs e)
{
var requestReplyMessenger = new RequestReplyMessenger <IScsServerClient>(e.Client);
requestReplyMessenger.MessageReceived += Client_MessageReceived;
requestReplyMessenger.Start();
var serviceClient = ScsServiceClientFactory.CreateServiceClient(e.Client, requestReplyMessenger);
_serviceClients[serviceClient.ClientId] = serviceClient;
OnClientConnected(serviceClient);
}
public override void Dispose()
{
try
{
if (Messenger != null)
{
Messenger.Dispose();
Messenger = null;
}
base.Dispose();
}
catch { }
}
/// <summary>
/// Creates a new ScsServiceClient object.
/// </summary>
/// <param name="client">Underlying IScsClient object to communicate with server</param>
/// <param name="clientObject">The client object that is used to call method invokes in client side.
/// May be null if client has no methods to be invoked by server.</param>
public ScsServiceClient(IScsClient client, object clientObject)
{
_client = client;
_clientObject = clientObject;
_client.Connected += Client_Connected;
_client.Disconnected += Client_Disconnected;
_requestReplyMessenger = new RequestReplyMessenger <IScsClient>(client);
_requestReplyMessenger.MessageReceived += RequestReplyMessenger_MessageReceived;
_realServiceProxy = new AutoConnectRemoteInvokeProxy <T, IScsClient>(_requestReplyMessenger, this);
ServiceProxy = (T)_realServiceProxy.GetTransparentProxy();
}
public override void Dispose()
{
try
{
if (Messenger != null)
{
Messenger.Dispose();
Messenger = null;
}
base.Dispose();
}
catch { }
}
/// <summary>
/// Sends response to the remote application that invoked a service method.
///
/// </summary>
/// <param name="requestMessage">Request message</param><param name="returnValue">Return value to send</param><param name="exception">Exception to send</param>
private void SendInvokeResponse(IScsMessage requestMessage, object returnValue, ScsRemoteException exception)
{
try
{
RequestReplyMessenger <IScsClient> requestReplyMessenger = this._requestReplyMessenger;
ScsRemoteInvokeReturnMessage invokeReturnMessage1 = new ScsRemoteInvokeReturnMessage();
invokeReturnMessage1.RepliedMessageId = requestMessage.MessageId;
invokeReturnMessage1.ReturnValue = returnValue;
invokeReturnMessage1.RemoteException = exception;
ScsRemoteInvokeReturnMessage invokeReturnMessage2 = invokeReturnMessage1;
requestReplyMessenger.SendMessage((IScsMessage)invokeReturnMessage2);
}
catch
{
}
}
public static void SendAction(string ip, int port, int?operationId, string actionName, int connectionTimeout = 3000)
{
string message = $"{operationId},{actionName},0";
//Create a client object to connect a server
using (var client = ScsClientFactory.CreateClient(new ScsTcpEndPoint(ip, port)))
{
//Create a RequestReplyMessenger that uses the client as internal messenger.
using (var requestReplyMessenger = new RequestReplyMessenger <IScsClient>(client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
client.ConnectTimeout = connectionTimeout;
client?.Connect(); //Connect to the server
Thread.Sleep(700);
//Send user message to the server
requestReplyMessenger.SendMessage(new ScsTextMessage(message));
}
}
}
/// <summary>
/// Send a Message and Wati for Reply
/// </summary>
/// <typeparam name="T">The expected Value</typeparam>
/// <param name="msg">the message to send</param>
/// <returns></returns>
public static Task<IScsMessage> SendMessageWithReplyAsync(this IScsClient client, IScsMessage msg)
{
TaskCompletionSource<IScsMessage> tcs = new TaskCompletionSource<IScsMessage>();
using (var requestReplyMessenger = new RequestReplyMessenger<IScsClient>(client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
//Send user message to the server and get response
try {
var response = requestReplyMessenger.SendMessageAndWaitForResponse(msg);
tcs.SetResult(response);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}
return tcs.Task;
}
/// <summary>
/// Отправка сообщения по сети и ожидание ответа
/// </summary>
public static string SendActionAndWaitForResponse(string ip, int port, int?operationId, string actionName, int connectionTimeout = 3000, int responseTimeOut = 5000)
{
string result = null;
string message = $"{operationId},{actionName},1";
//Create a client object to connect a server
using (var client = ScsClientFactory.CreateClient(new ScsTcpEndPoint(ip, port)))
{
//Create a RequestReplyMessenger that uses the client as internal messenger.
using (var requestReplyMessenger = new RequestReplyMessenger <IScsClient>(client))
{
requestReplyMessenger.Start(); //Start request/reply messenger
client.ConnectTimeout = connectionTimeout;
client.Connect(); //Connect to the server
Thread.Sleep(700);
//Send user message to the server and get response
var response = requestReplyMessenger.SendMessageAndWaitForResponse(new ScsTextMessage(message), responseTimeOut);
result = ((ScsTextMessage)response).Text;
}
}
return(result);
}
public override bool Connect(string remote_ip, int remote_port, int timeout = 10000)
{
try
{
this.ServerIp = remote_ip;
this.ServerPort = remote_port;
EzWireProtocol protocol = new EzWireProtocol();
protocol.DataReceived += protocol_DataReceived;//接收到数据，但不一定是message
_client = ScsClientFactory.CreateClient(new ScsTcpEndPoint(remote_ip, remote_port));
_client.WireProtocol = protocol;
_client.ConnectTimeout = timeout;
_client.Connected += client_Connected;
_client.Disconnected += client_Disconnected;
Messenger = new RequestReplyMessenger<IScsClient>(_client);
Messenger.MessageReceived += messenger_MessageReceived;
Messenger.Start();
_client.Connect();
this._remain_life_number = this.DefaultLifeNumber;
Helper.start_timer(ref _1s_timer, "1s timer", 1000, _1s_timer_Elapsed);
}
catch (Exception ex)
{
EzLogger.GlobalLogger.warning(string.Format("{0}{2}{1}{2}", ex.Message, ex.StackTrace, Environment.NewLine));
Dispose();
return false;
}
return true;
}
public override bool Connect(string remote_ip, int remote_port, int timeout = 10000)
{
try
{
this.ServerIp = remote_ip;
this.ServerPort = remote_port;
EzWireProtocol protocol = new EzWireProtocol();
protocol.DataReceived += protocol_DataReceived;//接收到数据，但不一定是message
_client = ScsClientFactory.CreateClient(new ScsTcpEndPoint(remote_ip, remote_port));
_client.WireProtocol = protocol;
_client.ConnectTimeout = timeout;
_client.Connected += client_Connected;
_client.Disconnected += client_Disconnected;
Messenger = new RequestReplyMessenger <IScsClient>(_client);
Messenger.MessageReceived += messenger_MessageReceived;
Messenger.Start();
_client.Connect();
this._remain_life_number = this.DefaultLifeNumber;
Helper.start_timer(ref _1s_timer, "1s timer", 1000, _1s_timer_Elapsed);
}
catch (Exception ex)
{
EzLogger.GlobalLogger.warning(string.Format("{0}{2}{1}{2}", ex.Message, ex.StackTrace, Environment.NewLine));
Dispose();
return(false);
}
return(true);
}
/// <summary>
/// Creates a new service client object that is used in server-side.
/// </summary>
/// <param name="serverClient">Underlying server client object</param>
/// <param name="requestReplyMessenger">RequestReplyMessenger object to send/receive messages over serverClient</param>
/// <returns></returns>
public static IScsServiceClient CreateServiceClient(IScsServerClient serverClient, RequestReplyMessenger <IScsServerClient> requestReplyMessenger)
{
return(new ScsServiceClient(serverClient, requestReplyMessenger));
}
/// <summary>
/// Creates a new ScsServiceClient object.
/// </summary>
/// <param name="serverClient">Reference to underlying IScsServerClient object</param>
/// <param name="requestReplyMessenger">RequestReplyMessenger to send messages</param>
public ScsServiceClient(IScsServerClient serverClient, RequestReplyMessenger <IScsServerClient> requestReplyMessenger)
{
_serverClient = serverClient;
_serverClient.Disconnected += Client_Disconnected;
_requestReplyMessenger = requestReplyMessenger;
}
/// <summary>
/// Handles MessageReceived events of all clients, evaluates each message, finds appropriate
/// service object and invokes appropriate method.
/// </summary>
/// <param name="sender">Source of event</param>
/// <param name="e">Event arguments</param>
private void Client_MessageReceived(object sender, MessageEventArgs e)
{
// Get RequestReplyMessenger object (sender of event) to get client
RequestReplyMessenger <IScsServerClient> requestReplyMessenger = (RequestReplyMessenger <IScsServerClient>)sender;
// Cast message to ScsRemoteInvokeMessage and check it
if (!(e.Message is ScsRemoteInvokeMessage invokeMessage))
{
return;
}
try
{
// Get client object
IScsServiceClient client = _serviceClients[requestReplyMessenger.Messenger.ClientId];
if (client == null)
{
requestReplyMessenger.Messenger.Disconnect();
return;
}
// Get service object
ServiceObject serviceObject = _serviceObjects[invokeMessage.ServiceClassName];
if (serviceObject == null)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteException("There is no service with name '" + invokeMessage.ServiceClassName + "'"));
return;
}
// Invoke method
try
{
// Set client to service, so user service can get client in service method using
// CurrentClient property.
object returnValue;
serviceObject.Service.CurrentClient = client;
try
{
returnValue = serviceObject.InvokeMethod(invokeMessage.MethodName, invokeMessage.Parameters);
}
finally
{
// Set CurrentClient as null since method call completed
serviceObject.Service.CurrentClient = null;
}
// Send method invocation return value to the client
SendInvokeResponse(requestReplyMessenger, invokeMessage, returnValue, null, invokeMessage.Parameters);
}
catch (TargetInvocationException ex)
{
Exception innerEx = ex.InnerException;
if (innerEx != null)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteInvocationException(invokeMessage.ServiceClassName, serviceObject.ServiceAttribute?.Version ?? "", invokeMessage.MethodName, innerEx.Message, innerEx));
}
}
catch (Exception ex)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteInvocationException(invokeMessage.ServiceClassName, serviceObject.ServiceAttribute?.Version ?? "", invokeMessage.MethodName, ex.Message, ex));
}
}
catch (Exception ex)
{
SendInvokeResponse(requestReplyMessenger, invokeMessage, null, new ScsRemoteException("An error occured during remote service method call.", ex));
}
}
/// <summary>
/// Creates a new RemoteInvokeProxy object.
///
/// </summary>
/// <param name="clientMessenger">Messenger object that is used to send/receive messages</param>
public RemoteInvokeProxy(RequestReplyMessenger <TMessenger> clientMessenger)
: base(typeof(TProxy))
{
this._clientMessenger = clientMessenger;
}
/// <summary>
/// Creates a new AutoConnectRemoteInvokeProxy object.
/// </summary>
/// <param name="clientMessenger">Messenger object that is used to send/receive messages</param>
/// <param name="client">Reference to the client object that is used to connect/disconnect</param>
public AutoConnectRemoteInvokeProxy(RequestReplyMessenger <TMessenger> clientMessenger, IConnectableClient client)
: base(clientMessenger)
{
_client = client;
}
/// <summary>
/// Creates a new RemoteInvokeProxy object.
/// </summary>
/// <param name="clientMessenger">Messenger object that is used to send/receive messages</param>
public RemoteInvokeProxy(RequestReplyMessenger <TMessenger> clientMessenger)
{
_clientMessenger = clientMessenger;
}
/// <summary>
/// Creates a new service client object that is used in server-side.
/// </summary>
/// <param name="serverClient">Underlying server client object</param>
/// <param name="requestReplyMessenger">RequestReplyMessenger object to send/receive messages over serverClient</param>
/// <returns></returns>
public static IScsServiceClient CreateServiceClient(IScsServerClient serverClient, RequestReplyMessenger<IScsServerClient> requestReplyMessenger)
{
return new ScsServiceClient(serverClient, requestReplyMessenger);
}
/// <summary>
/// Creates a new ScsServiceClient object.
///
/// </summary>
/// <param name="serverClient">Reference to underlying IScsServerClient object</param><param name="requestReplyMessenger">RequestReplyMessenger to send messages</param>
public ScsServiceClient(IScsServerClient serverClient, RequestReplyMessenger <IScsServerClient> requestReplyMessenger)
{
this._serverClient = serverClient;
this._serverClient.Disconnected += new EventHandler(this.Client_Disconnected);
this._requestReplyMessenger = requestReplyMessenger;
}
public RequestReplyTcpClient(bool auto_heart_beat)
: base(auto_heart_beat)
{
this.Messenger = null;
}
public ClientSender(IScsClient client, RequestReplyMessenger <IScsClient> clientRequestReply)
{
_clientUtility = new ConnectionUtility(client, clientRequestReply);
}