/// <summary>
/// 1개이상의 Topic 을 Subscriber 할 경우 사용
/// </summary>
/// <param name="topic"></param>
/// <param name="type"></param>
/// <param name="msgHandler"></param>
/// <returns></returns>
public async Task AddSubscriber(string topic, string type, MessageReceivedHandler msgHandler)
{
try
{
if (!Data.Instance.isConnected)
{
return;
}
bool bcheck = false;
foreach (Subscriber subitem in Data.Instance.subs)
{
//같은 Topic 명이 있을 경우 subscriber에 추가 하지 않음.
if (subitem.Topic == topic)
{
return;
}
}
rosSubscriber sub = new rosSubscriber(topic, type, Data.Instance.md);
Data.Instance.subs.Add(sub);
sub.SetMessageHandler(msgHandler);
await sub.SubscribeAsync();
}
catch (Exception ex)
{
Console.Out.WriteLine("AddSubscriber err :={0}", ex.Message.ToString());
}
}
public Task <TServiceResponse> Call(TServiceRequest request = null)
{
TaskCompletionSource <TServiceResponse> taskCompletion = new TaskCompletionSource <TServiceResponse>();
MessageReceivedHandler rosbridgeMessageHandler = (object sender, RosbridgeMessageReceivedEventArgs args) =>
{
if (null != args)
{
RosServiceResponseMessage rosServiceResponse = args.RosbridgeMessage.ToObject <RosServiceResponseMessage>();
if (null != rosServiceResponse && rosServiceResponse.Id.Equals(_uniqueId))
{
if (null != rosServiceResponse.ValueList)
{
JObject responseObject = JObject.FromObject(rosServiceResponse.ValueList);
TServiceResponse rosServiceResponseObject =
responseObject.ToObject <TServiceResponse>();
taskCompletion.SetResult(rosServiceResponseObject);
}
else
{
taskCompletion.SetResult(null);
}
}
}
};
_messageDispatcher.MessageReceived += rosbridgeMessageHandler;
Task.Run(async() =>
{
if (null == request)
{
await _messageDispatcher.SendAsync(new RosCallServiceMessage()
{
Id = _uniqueId,
Service = ServiceName
});
}
else
{
JArray arguments = JArray.FromObject(request);
await _messageDispatcher.SendAsync(new RosCallServiceMessage()
{
Id = _uniqueId,
Service = ServiceName,
Arguments = arguments
});
}
await taskCompletion.Task;
_messageDispatcher.MessageReceived -= rosbridgeMessageHandler;
});
return(taskCompletion.Task);
}
/// <summary>
/// Tarea asíncrona que solicita al back pressure ser procesada y espera la respuesta de este para continuar o salir.
/// </summary>
private Task <string> ProcessAsync()
{
var tcs = new TaskCompletionSource <string>();
MessageReceivedHandler delegateBackPressure = delegate(object sender, bool cancel) {
string str = null;
if (cancel)
{
Exception = new Exception("Rechazado por back pressure.");
}
else
{
DateTime startDate = DateTime.Now;
PingMessage pingMessage = MessageService.SendPing();
DateTime endDate = DateTime.Now;
str = string.Format("Ping {0}: {1} segundos.", pingMessage.PingId.Id, (endDate - startDate).TotalSeconds);
}
BackPressureService.backPressure.RemoveRequest(request);
tcs.TrySetResult(str);
};
MessageReceived += delegateBackPressure;
Task <string> ret = tcs.Task;
BackPressureService.backPressure.AddObserver(this);
request = BackPressureService.backPressure.CreateRequest(this);
BackPressureService.backPressure.AddRequest(request);
return(ret);
}
/// <summary>
/// Creates a new instance of a <see cref="WebSocketNetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="listenerType">The listener type of client connection.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param>
public WebSocketNetworkListener(NetworkListenerType listenerType, ushort port, ClientConnectedHandler clientConnectedHandler,
MessageReceivedHandler messageReceivedHandler,
ClientDisconnectedHandler clientDisconnectedHandler,
ushort maxMessageBuffer) : base(port, clientConnectedHandler, messageReceivedHandler, clientDisconnectedHandler, maxMessageBuffer)
{
try
{
//var host = Dns.GetHostEntry(Dns.GetHostName());
//var hostIp = host.AddressList.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork).ToString();
_listenerType = listenerType;
_httpListener = new HttpListener();
_httpListener.Prefixes.Add($"http://localhost:{port}/");
_httpListener.Prefixes.Add($"http://127.0.0.1:{port}/");
//_httpListener.Prefixes.Add($"http://{hostIp}:{port}/");
_httpListener.Start();
Console.WriteLine($"Starting the WebSocket network listener on port: {port}.");
WaitForConnections();
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
public TMessage Send(TMessage message, TMessageKey responseKey, out int txSize, out int rxSize, TimeSpan?timeout = null)
{
var result = default(TMessage);
var s = 0;
var received = false;
var subscriber = new MessageReceivedHandler <TMessage, TMessageKey>((keyedMessage, size) =>
{
result = message;
s = size;
received = true;
});
Subscribe(responseKey, subscriber);
try
{
txSize = Send(message);
var rxBegin = DateTime.UtcNow;
// ReSharper disable once LoopVariableIsNeverChangedInsideLoop
while (received) // This variable is changed when the messagehandler above receives a message
{
if (null != timeout && (DateTime.UtcNow - rxBegin) >= timeout)
{
throw new TimeoutException();
}
Thread.CurrentThread.Join(5);
}
}
finally
{
Unsubscribe(responseKey, subscriber);
}
rxSize = s;
return(result);
}
protected virtual void OnMessageReceivedEvent(string msg)
{
MessageReceivedHandler handler = MessageReceivedEvent;
if (handler != null)
{
handler(msg);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpMessageDecoder" /> class.
/// </summary>
public HttpMessageDecoder()
{
_headerParser = new HeaderParser();
_headerParser.HeaderParsed = OnHeader;
_headerParser.RequestLineParsed = OnRequestLine;
_headerParser.Completed = OnHeaderParsed;
_messageReceived = delegate { };
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpMessageDecoder" /> class.
/// </summary>
public HttpMessageDecoder()
{
_headerParser = new HeaderParser();
_headerParser.HeaderParsed = OnHeader;
_headerParser.RequestLineParsed = OnRequestLine;
_headerParser.Completed = OnHeaderParsed;
_messageReceived = delegate { };
}
private void ChatHubProxyOnMessageReceived(SimpleMessage receivedMessage)
{
receivedMessage.IsLocalMessage = false;
Application.Current.Dispatcher.Invoke(() =>
{
MessageReceivedHandler?.Invoke(new MessageReceivedEventArgs(CipherHelper.DecryptMessage(receivedMessage)));
});
}
public void FreeMessageHandler()
{
if (null == _msgHandler)
{
return;
}
MessageReceived -= _msgHandler;
_msgHandler = null;
}
public void UnregisterOnMessageEvent(Guid resourceId, MessageReceivedHandler handler)
{
GatewaySocketClient client = null;
if (m_gatewayClients.TryGetValue(GetResourceUri(resourceId), out client))
{
client.OnMessageReceived -= handler;
}
}
public async Task ProcessActivity(Activity activity, BotCallbackHandler callback = null, MessageReceivedHandler messageReceivedHandler = null)
{
_messageReceivedHandler = messageReceivedHandler;
using (var context = new TurnContext(this, activity))
{
await RunPipelineAsync(context, callback, default(CancellationToken));
}
}
public static event MessageSentHandler OnMessageSent; // Called when a message is sent
#endregion
public Client(string IP)
{
this.IP = IP; // Set the IP
OnMessageReceived += new MessageReceivedHandler(MessageParse); // Add the received event
OnMessageSent += new MessageSentHandler(MessageSent); // Add the sent event
TClient = new TcpClient(); // Create a new TCP client
PacketThread = new Thread(new ThreadStart(PacketUpdate)); // Create a new thread for packet updates
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpMessageDecoder" /> class.
/// </summary>
/// <param name="messageSerializer">The message serializer.</param>
/// <exception cref="System.ArgumentNullException">messageSerializer</exception>
public HttpMessageDecoder(IMessageSerializer messageSerializer)
{
if (messageSerializer == null) throw new ArgumentNullException("messageSerializer");
_messageSerializer = messageSerializer;
_headerParser = new HeaderParser();
_headerParser.HeaderParsed = OnHeader;
_headerParser.RequestLineParsed = OnRequestLine;
_headerParser.Completed = OnHeaderParsed;
_messageReceived = delegate { };
}
public ClientFactory(MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
{
this.config = config;
this.cancellationToken = cancellationToken;
this.messageReceived = messageReceived;
this.clientConnectionFailed = clientConnectionFailed;
}
/// <summary>
/// Creates a new instance of a <see cref="NetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The number max of connected clients, the default value is 1000.</param>
public NetworkListener(ushort port, ClientConnectedHandler clientConnectedHandler,
MessageReceivedHandler messageReceivedHandler,
ClientDisconnectedHandler clientDisconnectedHandler,
ushort maxMessageBuffer)
{
_clientConnectedHandler = clientConnectedHandler;
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
_maxMessageBuffer = maxMessageBuffer;
}
protected override void HandleMessageAvailable(SystemMessage message)
{
_messageAvailableEvent.Set();
MessageReceivedHandler handler = PreviewMessage;
if (handler != null)
{
handler(this, message);
}
}
private void OnMessageReceived(short protovolType, short protocolVersion, byte[] messagePayload)
{
// Save the delegate field in a temporary field for thread safety
MessageReceivedHandler currentMessageReceived = MessageReceived;
if (currentMessageReceived != null)
{
// process received messages in current I/O thread.
currentMessageReceived(messagePayload);
}
}
/// <summary>
/// Creates a new instance of a <see cref="NetworkListener"/>.
/// </summary>
/// <param name="port">The port of server.</param>
/// <param name="clientConnectedHandler">The client connected handler callback implementation.</param>
public NetworkListener(MessageReceivedHandler messageReceivedHandler, DisconnectedHandler clientDisconnectedHandler)
{
try
{
_messageReceivedHandler = messageReceivedHandler;
_disconnectedHandler = clientDisconnectedHandler;
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
private void TryToSubscribe(string type, MessageReceivedHandler messageReceivedHandler)
{
try
{
proximityDevice.SubscribeForMessage(type, messageReceivedHandler);
Log($"Subscribed to {type}");
}
catch (Exception)
{
Log($"Cannot subscribe for {type}");
}
}
public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, IBasicProperties properties, byte[] body)
{
MessageReceivedHandler?.Invoke(this, new BasicDeliverEventArgs()
{
ConsumerTag = consumerTag,
DeliveryTag = deliveryTag,
Redelivered = redelivered,
Exchange = exchange,
RoutingKey = routingKey,
BasicProperties = properties,
Body = body
});
}
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;
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpMessageDecoder" /> class.
/// </summary>
/// <param name="messageSerializer">The message serializer.</param>
/// <exception cref="System.ArgumentNullException">messageSerializer</exception>
public HttpMessageDecoder(IMessageSerializer messageSerializer)
{
if (messageSerializer == null)
{
throw new ArgumentNullException("messageSerializer");
}
_messageSerializer = messageSerializer;
_headerParser = new HeaderParser();
_headerParser.HeaderParsed = OnHeader;
_headerParser.RequestLineParsed = OnRequestLine;
_headerParser.Completed = OnHeaderParsed;
_messageReceived = delegate { };
}
public ClientManager(
TcpListener listener,
IEnumerable <TcpAddress> serverAddresses,
CancellationToken cancellationToken,
MeepoConfig config,
MessageReceivedHandler messageReceived)
{
this.listener = listener;
this.serverAddresses = serverAddresses;
this.cancellationToken = cancellationToken;
clientFactory = new ClientFactory(config, cancellationToken, messageReceived, RemoveClient);
}
public Task <JToken> Call(dynamic arguments)
{
if (null == arguments)
{
throw new ArgumentNullException("arguments");
}
var tcs = new TaskCompletionSource <JToken>();
MessageReceivedHandler handler = delegate(object sender, MessageReceivedEventArgs e)
{
JToken value_id;
if (e.Message.TryGetValue("id", out value_id))
{
string id = value_id.ToString();
if (id.Equals(_uid))
{
JToken value_values;
if (e.Message.TryGetValue("values", out value_values))
{
tcs.SetResult(value_values);
}
else
{
tcs.SetResult(null);
}
}
}
};
// Register the callback
_md.MessageReceived += handler;
Task.Run(async() =>
{
await _md.SendAsync(new
{
op = "call_service",
id = _uid,
service = Service,
args = arguments
});
// Wait for the result
await tcs.Task;
_md.MessageReceived -= handler;
});
return(tcs.Task);
}
public ClientWrapper(
TcpAddress address,
MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
: this(config, cancellationToken, messageReceived, clientConnectionFailed)
{
Address = address;
IsToServer = true;
Connected = Connect().Result;
}
private ClientWrapper(
MeepoConfig config,
CancellationToken cancellationToken,
MessageReceivedHandler messageReceived,
ClientConnectionFailed clientConnectionFailed)
{
Id = Guid.NewGuid();
logger = config.Logger;
this.config = config;
this.cancellationToken = cancellationToken;
this.messageReceived = messageReceived;
this.clientConnectionFailed = clientConnectionFailed;
}
public void Start()
{
foreach (var messageType in _messageTypes)
{
var handler = new MessageReceivedHandler(this, messageType);
//to ensure uniqueness
_handlers.Add(messageType, handler);
_client.SubscribeAsync <InterprocessMessage>(new RedisChannel($"{_configuration.Channel}.{messageType.Name}",
RedisChannel.PatternMode.Literal), handler.OnMesssageReceived);
Log($"Subscribed to Redis channel {_configuration.Channel}");
}
}
public void SendMessage(string message, Action <string> responseCallBack, int msTimeout = 2000)
{
ManualResetEvent mr = new ManualResetEvent(false);
var responseHandler = new MessageReceivedHandler((com, resp) =>
{
responseCallBack(resp);
byte[] msg = Encoding.ASCII.GetBytes(resp);
var hex = BitConverter.ToString(msg);
Debug.Print($"{CommName} IN : {resp} ({hex})");
mr.Set();
});
MessageReceived += responseHandler;
SendMessage(message);
mr.WaitOne(msTimeout);
MessageReceived -= responseHandler; //Unsubscribe
}
void MessageReceivedWrapper(object sender, MessageReceivedArgs e)
{
MessageReceivedHandler eh = received_handler;
if (eh == null)
{
return;
}
foreach (MessageReceivedHandler d in eh.GetInvocationList())
{
if (e.RetVal != null && (Response)e.RetVal != Response.Passthrough)
{
break;
}
d(sender, e);
}
}
private void _md_MessageReceived(object sender, MessageReceivedEventArgs e)
{
MessageReceivedHandler tmp = MessageReceived;
if (null != tmp)
{
JToken value;
if (e.Message.TryGetValue("topic", out value))
{
string topic = value.ToString();
if (topic.Equals(Topic))
{
tmp(this, new MessageReceivedEventArgs(e.Message));
}
}
}
}
/// <summary>
/// Creates a new instance of a <see cref="UDPClient"/>.
/// </summary>
/// <param name="id">The identifier number of connected client.</param>
/// <param name="socketClient">The tcp client from connected client.</param>
/// <param name="messageReceivedHandler">The callback of message received handler implementation.</param>
/// <param name="clientDisconnectedHandler">The callback of client disconnected handler implementation.</param>
/// <param name="maxMessageBuffer">The max length of message buffer.</param>
public UDPClient(ushort id, UdpNetworkListener socketClient, EndPoint remoteEndPoint, MessageReceivedHandler messageReceivedHandler, ClientDisconnectedHandler clientDisconnectedHandler, ushort maxMessageBuffer)
{
try
{
_udpListener = socketClient;
_remoteEndPoint = remoteEndPoint;
_messageReceivedHandler = messageReceivedHandler;
_clientDisconnectedHandler = clientDisconnectedHandler;
Id = id;
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}.");
}
}
public void SendMessage(object sender, string msg, MessageReceivedHandler messageReceived, ExceptionHandler errorReceived)
{
string uriString = String.Format(ServicePoint + "/Services/SendMessage.ashx?msg={0}", msg);
//WebRequest.RegisterPrefix("http://", WebRequestCreator.ClientHttp);
//WebClient client = new WebClient();
//client.Credentials = new NetworkCredential("serviceuser", "password");
//client.UseDefaultCredentials = false;
//client.OpenReadCompleted += (s, e) =>
//{
// if (!e.Cancelled && (e.Error == null))
// {
// if (client.ResponseHeaders[HttpRequestHeader.ContentType].Contains("text/plain"))
// {
// Stream str = e.Result;
// StreamReader sr = new StreamReader(str);
// string x=sr.ReadToEnd();
// if (messageReceived != null) messageReceived(null, x);
// }
// else
// {
// Stream str = e.Result;
// StreamReader sr = new StreamReader(str);
// Exception exc = new Exception(sr.ReadToEnd());
// if (errorReceived != null) errorReceived("MessageService", exc);
// }
// }
// else
// {
// if (errorReceived != null) errorReceived("MessageService", e.Error );
// }
//};
//client.OpenReadAsync(new Uri(uriString, UriKind.Absolute));
HttpWebRequest client = WebRequest.CreateHttp(uriString);
client.BeginGetResponse((async) =>
{
HttpWebResponse res=null;
try
{
res = (HttpWebResponse)client.EndGetResponse(async);
}
catch (Exception v)
{
Exception vv=new Exception(v.Message + " URL : " + uriString);
if (errorReceived != null) errorReceived(async.AsyncState, new ServiceException(EErrorType.REQUEST, "Response error."));
return;
}
if (res.ContentType.Contains("text/plain"))
{
Stream str = res.GetResponseStream();
StreamReader sr = new StreamReader(str);
string x=sr.ReadToEnd();
if (messageReceived != null) messageReceived(async.AsyncState, x);
}
else
{
//REQUEST,SERVER,READER,NODATA
Stream str = res.GetResponseStream();
StreamReader sr = new StreamReader(str);
Exception exc = new Exception(sr.ReadToEnd());
if (errorReceived != null) errorReceived(async.AsyncState, exc);
}
}, sender);
}
private AsyncSocketListener()
{
MessageReceived = new MessageReceivedHandler(recievedData);
}
