/// <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 { }; }
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); }