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