feat: add device discover request

Signed-off-by: wei <[email protected]>

Author: instpe

mdtp-client/pom.xml

@@ -21,6 +21,11 @@
             <artifactId>mdtp-common</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.protocol-laboratory</groupId>
+            <artifactId>mdtp-server</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

mdtp-client/src/main/java/io/github/protocol/mdtp/client/MdtpClient.java

@@ -1,21 +1,30 @@
 package io.github.protocol.mdtp.client;
 
+import io.github.protocol.mdtp.common.model.CDATHeader;
+import io.github.protocol.mdtp.common.model.DeviceDiscoveryRequest;
+import io.github.protocol.mdtp.common.model.MdtpPacket;
+import io.github.protocol.mdtp.common.model.MessageBodyHeader;
 import io.netty.bootstrap.Bootstrap;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
+import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 
 import java.io.Closeable;
 import java.io.IOException;
 
 @Slf4j
+@Data
 public class MdtpClient implements Closeable {
     private final MdtpClientConfig config;
 
+    private ChannelFuture channelFuture;
+
     private EventLoopGroup group;
 
     public MdtpClient(MdtpClientConfig config) {
@@ -37,7 +46,7 @@ public void start() throws Exception {
                     protected void initChannel(SocketChannel ch) throws Exception {
                     }
                 });
-        ChannelFuture channelFuture = bootstrap.connect().sync();
+        this.channelFuture = bootstrap.connect().sync();
         if (channelFuture.isSuccess()) {
             log.info("mdtp client started");
         } else {
@@ -55,4 +64,40 @@ public void close() throws IOException {
         this.group.shutdownGracefully();
         log.info("mdtp client closed");
     }
+
+    public void sendDeviceDiscoveryRequest(int[] deviceTypes) {
+        log.info("start to send device discovery request.");
+        DeviceDiscoveryRequest request = new DeviceDiscoveryRequest();
+        request.setMessageBodyHeader(MessageBodyHeader.DEVICE_DISCOVERY_REQUEST);
+        log.info("" + request.getMessageBodyHeader().toShort());
+        request.setRequestId(request.generateRequestId());
+
+        if (deviceTypes == null) {
+            request.setDeviceTypeCount((byte) 0);
+        }
+
+        if (deviceTypes != null && deviceTypes.length > 0) {
+            request.setMask((byte) 1);
+            request.setDeviceTypeCount((byte) deviceTypes.length);
+            request.setDeviceTypes(deviceTypes);
+        }
+
+        CDATHeader cdatHeader = new CDATHeader();
+        cdatHeader.setFormatType((byte) 0x02);
+        cdatHeader.setProtocolVersion((byte) 1);
+        cdatHeader.setMessageLength((short) 0);
+        cdatHeader.setTimestamp(System.currentTimeMillis());
+        cdatHeader.setFlags((byte) 0b01100000);
+        cdatHeader.setSequenceNumber(0);
+        cdatHeader.setLogicalChannelId(0);
+
+        MdtpPacket packet = new MdtpPacket();
+        packet.setHeader(cdatHeader);
+        packet.setSecurityHeader(null);
+        packet.setBody(request);
+        packet.setSignature(null);
+
+        this.channelFuture.channel().writeAndFlush(packet.toByteBuf(Unpooled.buffer()));
+        log.info("send device discovery request success: " + packet);
+    }
 }

mdtp-client/src/test/java/MdtpClientTest.java

@@ -0,0 +1,83 @@
+import io.github.protocol.mdtp.client.MdtpClient;
+import io.github.protocol.mdtp.client.MdtpClientConfig;
+import io.github.protocol.mdtp.common.model.DeviceDiscoveryRequest;
+import io.github.protocol.mdtp.common.model.MdtpPacket;
+import io.github.protocol.mdtp.server.MdtpServer;
+import io.github.protocol.mdtp.server.MdtpServerConfig;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.embedded.EmbeddedChannel;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.ConnectException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class MdtpClientTest {
+
+    private MdtpClientConfig config;
+    private MdtpClient mdtpClient;
+
+    private MdtpServer mdtpServer;
+    private EventLoopGroup groupMock;
+    private ChannelFuture channelFutureMock;
+
+    private EmbeddedChannel embeddedChannel;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        MdtpServerConfig mdtpServerConfig  = new MdtpServerConfig().host("localhost").port(4146);
+        mdtpServer = new MdtpServer(mdtpServerConfig);
+        mdtpServer.start();
+
+        config = new MdtpClientConfig().host("localhost").port(4146);
+        mdtpClient = new MdtpClient(config);
+
+        groupMock = mock(EventLoopGroup.class);
+        channelFutureMock = mock(ChannelFuture.class);
+
+        mdtpClient.setGroup(groupMock);
+        mdtpClient.setChannelFuture(channelFutureMock);
+    }
+
+    @AfterEach
+    public void close() throws IOException {
+        mdtpServer.close();
+    }
+
+    @Test
+    public void testStartConnectionFailure() {
+        ChannelFuture channelFutureMock = mock(ChannelFuture.class);
+        when(channelFutureMock.isSuccess()).thenReturn(false);
+        mdtpClient.setGroup(null);
+        mdtpClient.setChannelFuture(channelFutureMock);
+        assertThrows(ConnectException.class, () -> {
+            mdtpClient.start();
+        });
+    }
+
+    @Test
+    public void testClose() throws IOException {
+        mdtpClient.close();
+        verify(groupMock).shutdownGracefully();
+    }
+
+    @Test
+    public void testSendDeviceDiscoveryRequest() {
+        Channel channelMock = mock(Channel.class);
+        when(channelFutureMock.channel()).thenReturn(channelMock);
+        int[] deviceTypes = {1, 2, 3};
+        mdtpClient.sendDeviceDiscoveryRequest(deviceTypes);
+        verify(channelMock).writeAndFlush(any());
+    }
+
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/DeviceDiscoveryRequestDecoder.java

@@ -0,0 +1,12 @@
+package io.github.protocol.mdtp.common.codec;
+
+import io.github.protocol.mdtp.common.model.AbstractMessageBody;
+import io.github.protocol.mdtp.common.model.DeviceDiscoveryRequest;
+import io.netty.buffer.ByteBuf;
+
+public class DeviceDiscoveryRequestDecoder implements MessageBodyDecoder {
+    @Override
+    public AbstractMessageBody handle(ByteBuf in) {
+        return DeviceDiscoveryRequest.fromByteBuf(in);
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/MdtpDecoder.java

@@ -0,0 +1,34 @@
+package io.github.protocol.mdtp.common.codec;
+
+
+import io.github.protocol.mdtp.common.model.AbstractMessageBody;
+import io.github.protocol.mdtp.common.model.CDATHeader;
+import io.github.protocol.mdtp.common.model.MdtpPacket;
+import io.github.protocol.mdtp.common.model.MessageBodyHeader;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+
+@Slf4j
+public class MdtpDecoder extends ByteToMessageDecoder {
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+
+        MdtpPacket mdtpPacket = new MdtpPacket();
+        CDATHeader header = CDATHeader.fromByteBuf(in);
+
+        MessageBodyHeader messageBodyHeader = MessageBodyHeader.fromByteBuf(in);
+        MessageBodyDecoder messageDecode = MessageDecoderFactory.getDecoder(messageBodyHeader);
+        AbstractMessageBody messageBody = messageDecode.handle(in);
+        messageBody.setMessageBodyHeader(messageBodyHeader);
+
+        mdtpPacket.setHeader(header);
+        mdtpPacket.setBody(messageBody);
+
+        out.add(mdtpPacket);
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/MessageBodyDecoder.java

@@ -0,0 +1,8 @@
+package io.github.protocol.mdtp.common.codec;
+
+import io.github.protocol.mdtp.common.model.AbstractMessageBody;
+import io.netty.buffer.ByteBuf;
+
+public interface MessageBodyDecoder {
+    AbstractMessageBody handle(ByteBuf in);
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/codec/MessageDecoderFactory.java

@@ -0,0 +1,19 @@
+package io.github.protocol.mdtp.common.codec;
+
+import io.github.protocol.mdtp.common.model.MessageBodyHeader;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MessageDecoderFactory {
+
+    private static final Map<Short, MessageBodyDecoder> decoders = new HashMap<>();
+
+    static {
+        decoders.put(MessageBodyHeader.DEVICE_DISCOVERY_REQUEST.toShort(), new DeviceDiscoveryRequestDecoder());
+    }
+
+    public static MessageBodyDecoder getDecoder(MessageBodyHeader header) {
+        return decoders.get(header.toShort());
+    }
+}

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/AbstractMessageBody.java

@@ -7,22 +7,15 @@
 
 @Data
 public abstract class AbstractMessageBody {
-    private short messageBodyHeader;
-
-    public void setMessageBodyHeader(MessageType messageType, ServiceGroup serviceGroup, DiscoveryServiceCode serviceCode) {
-        this.messageBodyHeader = 0;
-        this.messageBodyHeader |= (short) (messageType.getCode() & 0b111);
-        this.messageBodyHeader |= (short) ((serviceGroup.getCode() & 0b1111111) << 3);
-        this.messageBodyHeader |= (short) ((serviceCode.getCode() & 0b111111) << 10);
-    }
+    private MessageBodyHeader messageBodyHeader;
 
     public short generateRequestId() {
         UUID uuid = UUID.randomUUID();
         return (short) (uuid.getLeastSignificantBits() & 0xFFFF);
     }
 
     public ByteBuf toByteBuf(ByteBuf buffer) {
-        buffer.writeShort(messageBodyHeader);
+        messageBodyHeader.toByteBuf(buffer);
         return buffer;
     }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/CDATHeader.java

@@ -35,4 +35,18 @@ public ByteBuf toByteBuf(ByteBuf buffer) {
         buffer.writeInt(logicalChannelId);
         return buffer;
     }
+
+    public static CDATHeader fromByteBuf(ByteBuf buffer) {
+        CDATHeader header = new CDATHeader();
+
+        header.setFormatType(buffer.readByte());
+        header.setProtocolVersion(buffer.readByte());
+        header.setMessageLength(buffer.readShort());
+        header.setTimestamp(buffer.readLong());
+        header.setFlags(buffer.readByte());
+        header.setSequenceNumber(buffer.readInt());
+        header.setLogicalChannelId(buffer.readInt());
+
+        return header;
+    }
 }

mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryRequest.java

@@ -5,7 +5,8 @@
 
 
 @Data
-public class DeviceDiscoveryRequest extends AbstractMessageBody {
+public class DeviceDiscoveryRequest extends AbstractMessageBody{
+
     private short requestId;
 
     private byte mask;
@@ -19,8 +20,10 @@ public ByteBuf toByteBuf(ByteBuf buffer) {
         buffer.writeShort(requestId);
         buffer.writeByte(mask);
         buffer.writeByte(deviceTypeCount);
-        for (int deviceType : deviceTypes) {
-            buffer.writeInt(deviceType);
+        if (deviceTypeCount > 0) {
+            for (int deviceType : deviceTypes) {
+                buffer.writeInt(deviceType);
+            }
         }
         return buffer;
     }