Example #1
0
        // FIXME?(AFL): kinda ugly signature
        public void SendRequest(TRequest request, TimeSpan?requestTimeout, string destinationClientID = null, bool retained = false)
        {
            requestTimeout = requestTimeout ?? TimeSpan.FromSeconds(20);

            var wrappedRequest = _requestSerializer.SerializeMessage(request);

            wrappedRequest.Source      = _client.Options.ClientOptions.ClientId;;
            wrappedRequest.Destination = destinationClientID;

            var payload       = _requestSerializer.SerializeWrapper(wrappedRequest);
            var packedMessage = new MqttApplicationMessageBuilder()
                                .WithTopic(RequestTopic)
                                .WithPayload(payload)
                                .WithQualityOfServiceLevel(_qosLevel)
                                .WithRetainFlag(retained)
                                .Build();

            try
            {
                _client.PublishAsync(packedMessage, _cancellationToken.Token).Wait();
            }
            catch (Exception e)
            {
                Log.Error($"Failed to publish response message on topic \"{ResponseTopic}\". Exception: {e}");
                throw;
            }
        }
Example #2
0
        public bool HandleMessageReceived(string serializedMessage)
        {
            EndpointMessage requestMessage;

            if (!_requestDeserializer.Deserialize(serializedMessage, out requestMessage))
            {
                return(false);
            }

            var requestSource      = requestMessage.Source;
            var requestDestination = requestMessage.Destination;

            // Ignore request if its meant for another bot
            if (!string.IsNullOrEmpty(requestDestination) && !string.Equals(requestDestination, _client.Options.ClientOptions.ClientId))
            {
                return(true);
            }

            TRequest request;

            if (!_requestDeserializer.Deserialize(requestMessage, out request))
            {
                return(false);
            }

            var response        = _requestReceivedHandler(request);
            var responseMessage = _responseSerializer.SerializeMessage(response);

            responseMessage.Source      = requestDestination;
            responseMessage.Destination = requestSource;

            var payload       = _responseSerializer.SerializeWrapper(responseMessage);
            var packedMessage = new MqttApplicationMessageBuilder()
                                .WithTopic(ResponseTopic)
                                .WithPayload(payload)
                                .WithQualityOfServiceLevel(_qosLevel)
                                .Build();

            try
            {
                _client.PublishAsync(packedMessage, _cancellationToken.Token).Wait();
            }
            catch (Exception e)
            {
                Log.Error($"Failed to publish response message on topic \"{ResponseTopic}\". Exception: {e}");
                throw;
            }

            return(true);
        }