Beispiel #1
0
        private async Task ProcessCall(CallInfo call)
        {
            RosMessage request = call.Request;

            // serialize and send request
            request.Serialized = request.Serialize();

            await connection.WriteBlock(BitConverter.GetBytes(request.Serialized.Length), 0, 4, cancel).ConfigureAwait(false);

            await connection.WriteBlock(request.Serialized, 0, request.Serialized.Length, cancel).ConfigureAwait(false);

            // read response header
            var receiveBuffer = await connection.ReadBlock(5, cancel).ConfigureAwait(false);

            bool success        = receiveBuffer[0] != 0;
            int  responseLength = BitConverter.ToInt32(receiveBuffer, 1);

            if (responseLength < 0 || responseLength > Connection.MESSAGE_SIZE_LIMIT)
            {
                var errorMessage = $"Message length exceeds limit of {Connection.MESSAGE_SIZE_LIMIT}. Dropping connection.";
                ROS.Error()(errorMessage);
                throw new ConnectionError(errorMessage);
            }

            if (responseLength > 0)
            {
                logger.LogDebug($"Reading message with length of {responseLength}.");
                receiveBuffer = await connection.ReadBlock(responseLength, cancel).ConfigureAwait(false);
            }
            else
            {
                receiveBuffer = new byte[0];
            }

            if (success)
            {
                call.Response.Serialized = receiveBuffer;
                call.Tcs.TrySetResult(true);
            }
            else
            {
                if (receiveBuffer.Length > 0)
                {
                    // call failed with reason
                    call.Tcs.TrySetException(new Exception(Encoding.UTF8.GetString(receiveBuffer)));
                }

                call.Tcs.TrySetResult(false);
            }
        }
Beispiel #2
0
 public virtual async Task ProcessResponse(RosMessage msg, bool success)
 {
     byte[] buf;
     if (success)
     {
         msg.Serialized = msg.Serialize();
         buf            = new byte[msg.Serialized.Length + 1 + 4];
         buf[0]         = (byte)(success ? 0x01 : 0x00);
         msg.Serialized.CopyTo(buf, 5);
         Array.Copy(BitConverter.GetBytes(msg.Serialized.Length), 0, buf, 1, 4);
     }
     else
     {
         buf    = new byte[1 + 4];
         buf[0] = (byte)(success ? 0x01 : 0x00);
         Array.Copy(BitConverter.GetBytes(0), 0, buf, 1, 4);
     }
     await connection.WriteBlock(buf, 0, buf.Length, cancel);
 }
 public virtual void processResponse(RosMessage msg, bool success)
 {
     byte[] buf;
     if (success)
     {
         msg.Serialized = msg.Serialize();
         buf            = new byte[msg.Serialized.Length + 1 + 4];
         buf[0]         = (byte)(success ? 0x01 : 0x00);
         msg.Serialized.CopyTo(buf, 5);
         Array.Copy(BitConverter.GetBytes(msg.Serialized.Length), 0, buf, 1, 4);
     }
     else
     {
         buf    = new byte[1 + 4];
         buf[0] = (byte)(success ? 0x01 : 0x00);
         Array.Copy(BitConverter.GetBytes(0), 0, buf, 1, 4);
     }
     connection.write(buf, buf.Length, onResponseWritten);
 }