private void ReceivedPublish(MqttMessage.Publish message) { JObject payload = StringToJObject(message.Payload); var aloxiMessage = AloxiMessage.Build(message.Operation, payload, message.ResponseTopic); PublishAloxiMessage(aloxiMessage, message.Topic); }
private void ReceivedPublishAlexaResponse(MqttMessage.PublishAlexaResponse message) { JObject payload = StringToJObject(message.SerializedResponse); var aloxiMessage = AloxiMessage.Build(AloxiMessageOperation.PipeAlexaResponse, payload); PublishAloxiMessage(aloxiMessage, this.alexaResponseTopic); }
public Task <TResponsePayload> RequestBridge <TResponsePayload>(AloxiMessageOperation operation, object requestPayload) where TResponsePayload : class { var requestMessage = AloxiMessage.Build(operation, Pack(requestPayload), this.configuration.TopicResponse); return(PublishAndAwaitResponse(configuration.TopicBridge, requestMessage) .ContinueWith <TResponsePayload>((publishTask) => { var responseMessage = publishTask.Result; if (responseMessage == null) { return null; } return UnpackTo <TResponsePayload>(responseMessage.Data); })); }
public Task <JObject> RequestBridgePassthrough(AloxiMessageOperation operation, JObject payload) { var requestMessage = AloxiMessage.Build(operation, payload, this.configuration.TopicResponse); Log.Debug(this.lambdaContext, $"PSC/RBP: Publishing AloxiMessage '{operation}' and waiting for response"); return(PublishAndAwaitResponse(configuration.TopicBridge, requestMessage) .ContinueWith <JObject>((publishTask) => { if (publishTask.Result == null) { Log.Warn(this.lambdaContext, $"PSC/RBP: Passing NULL through (we did not get a response?)"); return null; } Log.Debug(this.lambdaContext, $"PSC/RBP: Continueing with {publishTask?.Result?.Data?.Count} datanodes"); return publishTask.Result.Data; })); }
private void PublishAloxiMessage(AloxiMessage aloxiMessage, string topic) { byte[] data = this.jsonEncoding.GetBytes(JsonConvert.SerializeObject(aloxiMessage, this.jsonSettings)); this.client.Publish(topic, data); log.Debug("Published {0} bytes to topic '{1}'", data.Length, topic); }
public async Task <AloxiMessage> PublishAndAwaitResponse(string toTopic, AloxiMessage message) { if (String.IsNullOrWhiteSpace(message.ResponseTopic)) { throw new Exception("ResponseTopic is required for PublishAndAwaitResponse"); } ManualResetEvent msePublished = new ManualResetEvent(false); string responseTopic = message.ResponseTopic; // start "listen" task Log.Debug(this.lambdaContext, "PSC/PAAR: Starting request-response task"); Task <AloxiMessage> requestReponseTask = Task <AloxiMessage> .Run <AloxiMessage>(() => { ManualResetEvent mseReceived = new ManualResetEvent(false); AloxiMessage responseData = null; var subClient = CreateClient(); Log.Debug(this.lambdaContext, "PSC/PAAR/RRT: RequestResponseTask got client and connected"); subClient.MqttMsgSubscribed += (sender, e) => { Log.Debug(this.lambdaContext, "PSC/PAAR/RRT: subscribed, sending request"); var publishFlag = subClient.Publish(toTopic, translateToBytes(message)); msePublished.Set(); Log.Debug(this.lambdaContext, $"PSC/PAAR/RRT: published to topic '{toTopic}', return flag = {publishFlag}"); }; subClient.MqttMsgPublishReceived += (sender, e) => { Log.Debug(this.lambdaContext, "PSC/PAAR/RRT: received message"); try { AloxiMessage m = translateFromBytes(e.Message); if (m.Type != AloxiMessageType.AloxiComm) { return; } responseData = m; mseReceived.Set(); Log.Debug(this.lambdaContext, "PSC/PAAR/RRT: manual reset event completed"); } catch (Exception ex) { Log.Error(this.lambdaContext, $"PSC/PAAR/RRT: received message could not be processed: {ex.Message}"); // ignore message } }; var subscribeFlag = subClient.Subscribe(new string[] { responseTopic }, new byte[] { MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE }); Log.Debug(this.lambdaContext, $"PSC/PAAR/RRT: subscribed response topic '{responseTopic}', return flag = {subscribeFlag}"); bool?receivedSignal = null; try { // TODO wait for subscription confirmation receivedSignal = mseReceived.WaitOne(MAX_WAIT_FOR_RESPONSE); if (!receivedSignal.Value) { Log.Error(this.lambdaContext, $"PSC/PAAR/RRT: did not get response within {MAX_WAIT_FOR_RESPONSE}ms (expected on topic {responseTopic})"); } } catch (Exception ex) { throw new Exception("Failure with manual reset event", ex); } finally { subClient.Disconnect(); } Log.Debug(this.lambdaContext, $"PSC/PAAR/RRT: Returning from RequestSponseTask, receivedSignal={receivedSignal}, data type={responseData?.GetType().FullName}."); return(responseData); }); // wait for listen to complete or timing out Task waitingTask = Task.Delay(MAX_WAIT_FOR_RESPONSE + MAX_WAIT_FOR_PUBLISH); Log.Debug(this.lambdaContext, $"PSC/PAAR: Task id #{waitingTask.Id} is waiting task, task id #{requestReponseTask.Id} is request-response task"); Task completedTask = await Task.WhenAny(requestReponseTask, waitingTask); string taskname = "unknown"; if (Object.ReferenceEquals(completedTask, requestReponseTask)) { taskname = "REQ-RESP"; } if (Object.ReferenceEquals(completedTask, waitingTask)) { taskname = "WAITING"; } Log.Debug(this.lambdaContext, $"PSC/PAAR: A task completed, id #{completedTask.Id}, is {taskname}"); if (Object.ReferenceEquals(completedTask, requestReponseTask)) { if (requestReponseTask.Result == null) { Log.Warn(this.lambdaContext, $"PSC/PAAR: Returning NULL as the listenTask returned it!"); return(null); } else { Log.Debug(this.lambdaContext, $"PSC/PAAR: Returning data from listenTask is of type {requestReponseTask.Result?.GetType().FullName}"); return(requestReponseTask.Result); } } Log.Warn(this.lambdaContext, $"PSC/PAAR: Returning NULL as we got not answer in time!"); return(null); }
public void Publish(string toTopic, AloxiMessage message) { var client = CreateClient(); client.Publish(toTopic, translateToBytes(message), MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE, false); }
private static byte[] translateToBytes(AloxiMessage message) { string serialized = JsonConvert.SerializeObject(message, jsonSettings); return(ENCODING.GetBytes(serialized)); }