private static ByteBuf encodeMessageWithOnlySingleByteFixedHeader( ByteBufAllocator byteBufAllocator, MqttMessage message) { MqttFixedHeader mqttFixedHeader = message.fixedHeader(); ByteBuf buf = byteBufAllocator.buffer(2); buf.writeByte(getFixedHeaderByte1(mqttFixedHeader)); buf.writeByte(0); return buf; }
@Override public String toString() { return new StringBuilder(StringUtil.simpleClassName(this)) .append('[') .append("fixedHeader=").append(fixedHeader() != null ? fixedHeader().toString() : "") .append(", variableHeader=").append(variableHeader() != null ? variableHeader.toString() : "") .append(", payload=").append(payload() != null ? payload.toString() : "") .append(']') .toString(); } }
public MqttQoS getQos() { return msg.fixedHeader().qosLevel(); } }
public boolean isDupFlag() { return msg.fixedHeader().isDup(); }
public boolean isRetainFlag() { return msg.fixedHeader().isRetain(); }
public static MqttMessage getMqttPubcompMessage(MqttMessage message) { assert message.fixedHeader().messageType() == MqttMessageType.PUBREL; MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBCOMP, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), message.fixedHeader().remainingLength() ); return new MqttMessage(fixedHeader); }
public static MqttMessage getMqttPubrelMessage(MqttMessage message) { assert message.fixedHeader().messageType() == MqttMessageType.PUBREC; MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PUBREL, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), message.fixedHeader().remainingLength() ); return new MqttMessage(fixedHeader); }
public static MqttMessage getMqttPingrespMessage(MqttMessage message) { assert message.fixedHeader().messageType() == MqttMessageType.PINGREQ; MqttFixedHeader fixedHeader = new MqttFixedHeader( MqttMessageType.PINGRESP, message.fixedHeader().isDup(), message.fixedHeader().qosLevel(), message.fixedHeader().isRetain(), 0 ); return new MqttMessage(fixedHeader); }
void sendIfWritableElseDrop(MqttMessage msg) { if (LOG.isDebugEnabled()) { LOG.debug("OUT {} on channel {}", msg.fixedHeader().messageType(), channel); } if (channel.isWritable()) { channel.write(msg).addListener(FIRE_EXCEPTION_ON_FAILURE); } }
@Override public void channelRead(ChannelHandlerContext ctx, Object message) { MqttMessage msg = (MqttMessage) message; MqttMessageType messageType = msg.fixedHeader().messageType(); switch (messageType) { case PUBLISH: this.publishesMetrics.mark(); break; case SUBSCRIBE: this.subscribeMetrics.mark(); break; case CONNECT: this.connectedClientsMetrics.inc(); break; case DISCONNECT: this.connectedClientsMetrics.dec(); break; default: break; } ctx.fireChannelRead(message); }
@Override public void channelRead(ChannelHandlerContext ctx, Object message) throws Exception { MqttMessage msg = NettyUtils.validateMessage(message); final MQTTConnection mqttConnection = mqttConnection(ctx.channel()); try { mqttConnection.handleMessage(msg); } catch (Throwable ex) { //ctx.fireExceptionCaught(ex); LOG.error("Error processing protocol message: {}", msg.fixedHeader().messageType(), ex); ctx.channel().close().addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) { LOG.info("Closed client channel due to exception in processing"); } }); } finally { ReferenceCountUtil.release(msg); } }
private static ByteBuf encodeMessageWithOnlySingleByteFixedHeaderAndMessageId( ByteBufAllocator byteBufAllocator, MqttMessage message) { MqttFixedHeader mqttFixedHeader = message.fixedHeader(); MqttMessageIdVariableHeader variableHeader = (MqttMessageIdVariableHeader) message.variableHeader(); int msgId = variableHeader.messageId(); int variableHeaderBufferSize = 2; // variable part only has a message id int fixedHeaderBufferSize = 1 + getVariableLengthInt(variableHeaderBufferSize); ByteBuf buf = byteBufAllocator.buffer(fixedHeaderBufferSize + variableHeaderBufferSize); buf.writeByte(getFixedHeaderByte1(mqttFixedHeader)); writeVariableLengthInt(buf, variableHeaderBufferSize); buf.writeShort(msgId); return buf; }
@Override public void messageReceived(ChannelHandlerContext ctx, MqttMessage msg) { this.stats.incrementMqttStat(); MqttMessageType messageType = msg.fixedHeader().messageType(); switch (messageType) { case PUBLISH : MqttPublishMessage publishMessage = (MqttPublishMessage) msg; String topic = publishMessage.variableHeader().topicName(); switch (topic.toLowerCase()) { case "hardware" : hardware.messageReceived(state, publishMessage); break; } break; case PINGREQ : ctx.writeAndFlush( MqttMessageFactory.newMessage(msg.fixedHeader(), msg.variableHeader(), null), ctx.voidPromise()); break; case DISCONNECT : log.trace("Got disconnect. Closing..."); ctx.close(); break; } }
static byte encodeFlags(MqttMessage message) { byte flags = 0; if (message.fixedHeader().isDup()) { flags |= (byte) 0x08; } if (message.fixedHeader().isRetain()) { flags |= (byte) 0x01; } flags |= (byte) ((message.fixedHeader().qosLevel().value() & 0x03) << 1); return flags; }
/** * Validate that the provided message is an MqttMessage and that it does not contain a failed result. * * @param message to be validated * @return the casted provided message * @throws IOException in case of an fail message this will wrap the root cause * @throws ClassCastException if the provided message is no MqttMessage */ public static MqttMessage validateMessage(Object message) throws IOException, ClassCastException { MqttMessage msg = (MqttMessage) message; if (msg.decoderResult() != null && msg.decoderResult().isFailure()) { throw new IOException("invalid massage", msg.decoderResult().cause()); } if (msg.fixedHeader() == null) { throw new IOException("Unknown packet, no fixedHeader present, no cause provided"); } return msg; }
@Override public void channelRead(ChannelHandlerContext ctx, Object message) { MqttMessage msg = (MqttMessage) message; LOG.info("Received a message of type {}", msg.fixedHeader().messageType()); m_client.messageReceived(msg); }
private void doConnect(MqttConnectMessage connectMessage) { final CountDownLatch latch = new CountDownLatch(1); this.setCallback(msg -> { receivedMsg = msg; latch.countDown(); }); this.sendMessage(connectMessage); try { latch.await(200, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw new RuntimeException("Cannot receive message in 200 ms", e); } if (!(this.receivedMsg instanceof MqttConnAckMessage)) { MqttMessageType messageType = this.receivedMsg.fixedHeader().messageType(); throw new RuntimeException("Expected a CONN_ACK message but received " + messageType); } }
MqttMessageType messageType = msg.fixedHeader().messageType(); switch (messageType) { case CONNACK:
switch (message.fixedHeader().messageType()) { case CONNECT: return encodeConnectMessage(byteBufAllocator, (MqttConnectMessage) message); "Unknown message type: " + message.fixedHeader().messageType().value());
void handleMessage(MqttMessage msg) { MqttMessageType messageType = msg.fixedHeader().messageType(); LOG.debug("Received MQTT message, type: {}, channel: {}", messageType, channel); switch (messageType) {