Example usage for io.netty.handler.codec.mqtt MqttPublishMessage variableHeader

List of usage examples for io.netty.handler.codec.mqtt MqttPublishMessage variableHeader

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.handler.codec.mqtt.*
  5. MqttPublishMessage
  6. variableHeader

Introduction

In this page you can find the example usage for io.netty.handler.codec.mqtt MqttPublishMessage variableHeader.

Prototype

@Override
    public MqttPublishVariableHeader variableHeader()

Source Link

Usage

From source file:com.caricah.iotracah.server.mqttserver.transform.MqttIOTTransformerImpl.java

License:Apache License

@Override
public IOTMessage toIOTMessage(MqttMessage serverMessage) {

    MqttFixedHeader fxH = serverMessage.fixedHeader();

    if (null == fxH) {
        return null;
    }/*from ww  w  . ja v  a2s . c  o m*/

    switch (fxH.messageType()) {

    case PUBLISH:

        MqttPublishMessage publishMessage = (MqttPublishMessage) serverMessage;

        MqttPublishVariableHeader pubVH = publishMessage.variableHeader();

        ByteBuffer byteBuffer = publishMessage.payload().nioBuffer();

        return PublishMessage.from(pubVH.messageId(), fxH.isDup(), fxH.qosLevel().value(), fxH.isRetain(),
                pubVH.topicName(), byteBuffer, true);

    case PUBACK:

        MqttPubAckMessage pubAckMessage = (MqttPubAckMessage) serverMessage;

        MqttMessageIdVariableHeader msgIdVH = pubAckMessage.variableHeader();
        return AcknowledgeMessage.from(msgIdVH.messageId());

    case PUBREC:

        msgIdVH = (MqttMessageIdVariableHeader) serverMessage.variableHeader();
        return PublishReceivedMessage.from(msgIdVH.messageId());

    case PUBREL:

        msgIdVH = (MqttMessageIdVariableHeader) serverMessage.variableHeader();
        return ReleaseMessage.from(msgIdVH.messageId(), fxH.isDup());

    case PUBCOMP:

        msgIdVH = (MqttMessageIdVariableHeader) serverMessage.variableHeader();

        return CompleteMessage.from(msgIdVH.messageId());
    case PINGREQ:
    case PINGRESP:
        return Ping.from(fxH.isDup(), fxH.qosLevel().value(), fxH.isRetain());

    case CONNECT:

        MqttConnectMessage mqttConnectMessage = (MqttConnectMessage) serverMessage;
        MqttConnectVariableHeader conVH = mqttConnectMessage.variableHeader();
        MqttConnectPayload conPayload = mqttConnectMessage.payload();

        boolean isAnnonymousConnect = (!conVH.hasPassword() && !conVH.hasUserName());

        ConnectMessage connectionMessage = ConnectMessage.from(fxH.isDup(), fxH.qosLevel().value(),
                fxH.isRetain(), conVH.name(), conVH.version(), conVH.isCleanSession(), isAnnonymousConnect,
                conPayload.clientIdentifier(), conPayload.userName(), conPayload.password(),
                conVH.keepAliveTimeSeconds(), "");

        connectionMessage.setHasWill(conVH.isWillFlag());
        connectionMessage.setRetainWill(conVH.isWillRetain());
        connectionMessage.setWillQos(conVH.willQos());
        connectionMessage.setWillTopic(conPayload.willTopic());
        connectionMessage.setWillMessage(conPayload.willMessage());
        return connectionMessage;

    case CONNACK:

        MqttConnAckMessage connAckMessage = (MqttConnAckMessage) serverMessage;
        MqttConnAckVariableHeader connAckVH = connAckMessage.variableHeader();

        return ConnectAcknowledgeMessage.from(fxH.isDup(), fxH.qosLevel().value(), fxH.isRetain(), 20,
                connAckVH.connectReturnCode());

    case SUBSCRIBE:

        MqttSubscribeMessage subMsg = (MqttSubscribeMessage) serverMessage;
        msgIdVH = subMsg.variableHeader();
        MqttSubscribePayload subPayload = subMsg.payload();

        SubscribeMessage subscribeMessage = SubscribeMessage.from(msgIdVH.messageId(), fxH.isDup(),
                fxH.qosLevel().value(), fxH.isRetain());

        subPayload.topicSubscriptions().forEach(tSub -> {
            subscribeMessage.getTopicFilterList()
                    .add(new AbstractMap.SimpleEntry<>(tSub.topicName(), tSub.qualityOfService().value()));
        });

        return subscribeMessage;

    case UNSUBSCRIBE:

        MqttUnsubscribeMessage unSubMsg = (MqttUnsubscribeMessage) serverMessage;

        msgIdVH = unSubMsg.variableHeader();
        MqttUnsubscribePayload unsubscribePayload = unSubMsg.payload();

        return UnSubscribeMessage.from(msgIdVH.messageId(), fxH.isDup(), fxH.qosLevel().value(), fxH.isRetain(),
                unsubscribePayload.topics());

    case DISCONNECT:
        return DisconnectMessage.from(false);

    default:
        return null;
    }
}

From source file:io.crate.mqtt.netty.MqttMessageLogger.java

private void logMQTTMessage(ChannelHandlerContext ctx, Object message, String direction) {
    if (logger.isTraceEnabled() && message instanceof MqttMessage) {
        MqttMessage msg = (MqttMessage) message;
        String clientID = NettyUtils.clientID(ctx.channel());
        MqttMessageType messageType = msg.fixedHeader().messageType();
        switch (messageType) {
        case CONNECT:
        case CONNACK:
        case PINGREQ:
        case PINGRESP:
        case DISCONNECT:
            logger.trace("{} {} <{}>", direction, messageType, clientID);
            break;
        case SUBSCRIBE:
            MqttSubscribeMessage subscribe = (MqttSubscribeMessage) msg;
            logger.trace("{} SUBSCRIBE <{}> to topics {}", direction, clientID,
                    subscribe.payload().topicSubscriptions());
            break;
        case UNSUBSCRIBE:
            MqttUnsubscribeMessage unsubscribe = (MqttUnsubscribeMessage) msg;
            logger.trace("{} UNSUBSCRIBE <{}> to topics <{}>", direction, clientID,
                    unsubscribe.payload().topics());
            break;
        case PUBLISH:
            MqttPublishMessage publish = (MqttPublishMessage) msg;
            logger.trace("{} PUBLISH <{}> to topics <{}>", direction, clientID,
                    publish.variableHeader().topicName());
            break;
        case PUBREC:
        case PUBCOMP:
        case PUBREL:
        case PUBACK:
        case UNSUBACK:
            logger.trace("{} {} <{}> packetID <{}>", direction, messageType, clientID, messageId(msg));
            break;
        case SUBACK:
            MqttSubAckMessage suback = (MqttSubAckMessage) msg;
            List<Integer> grantedQoSLevels = suback.payload().grantedQoSLevels();
            logger.trace("{} SUBACK <{}> packetID <{}>, grantedQoses {}", direction, clientID, messageId(msg),
                    grantedQoSLevels);//from   w  ww .j a v a 2  s . co m
            break;
        default:
            logger.trace("{} {} <{}> Unknown message type received.", direction, messageType, clientID);
        }
    }
}

From source file:io.crate.mqtt.operations.MqttIngestService.java

/**
 * Parse the payload of the provided mqtt message and find which {@link IngestRule}s match the message properties.
 * For every matched rule, execute the insert into the rule's target table.
 * If we encounter exceptions whilst executing the rules we try to send the ackCallback that failure that's not a
 * "row already exists" (because, in case of messages with the isDup flag set to true, we will send the PUBACK reply
 * to the message).//from  w w  w. ja  va 2 s.  c  o m
 * We do not want to acknowledge the message until all message rules are successfully applied (if
 * the only detected failure(s) is "row already exists", namely {@link VersionConflictEngineException}, we trigger
 * the ackCallback, as for QoS 1 (at least once) we expect message redeliveries)
 */
public void doInsert(String clientId, MqttPublishMessage msg, BiConsumer<Object, Throwable> ackCallback) {
    if (isInitialized == false) {
        throw new IllegalStateException("Service was not initialized");
    }

    Map<String, Object> payload = parsePayloadToMap(msg.content());
    if (payload == null) {
        return;
    }

    Set<Tuple<Predicate<Row>, IngestRule>> predicateAndIngestRules = predicateAndIngestRulesReference.get();
    int packetId = msg.variableHeader().packetId();
    Object[] args = new Object[] { clientId, packetId, msg.variableHeader().topicName(), payload };
    List<Object> argsAsList = Arrays.asList(args);

    boolean messageMatchedRule = false;
    boolean callbackNotified = false;
    Session session = sqlOperations.createSession(Schemas.DOC_SCHEMA_NAME, crateUser, Option.NONE, 1);
    List<CompletableFuture<?>> insertOperationsFuture = new ArrayList<>(predicateAndIngestRules.size());
    for (Tuple<Predicate<Row>, IngestRule> entry : predicateAndIngestRules) {
        if (entry.v1().test(new RowN(args))) {
            messageMatchedRule = true;
            IngestRule ingestRule = entry.v2();

            try {
                session.parse(ingestRule.getName(),
                        "insert into " + TableIdent.fromIndexName(ingestRule.getTargetTable()).fqn()
                                + " (\"client_id\", \"packet_id\", \"topic\", \"ts\", \"payload\") "
                                + "values (?, ?, ?, CURRENT_TIMESTAMP, ?)",
                        FIELD_TYPES);
                session.bind(Session.UNNAMED, ingestRule.getName(), argsAsList, null);
                BaseResultReceiver resultReceiver = new BaseResultReceiver();
                insertOperationsFuture.add(resultReceiver.completionFuture().exceptionally(t -> {
                    if (SQLExceptions.isDocumentAlreadyExistsException(t)) {
                        if (msg.fixedHeader().isDup()) {
                            // we are dealing with QoS1, so redeliveries and duplicate insert exceptions are
                            // normal in case of a duplicate message - indicated by the isDup flag
                            return null;
                        }
                    }

                    Exceptions.rethrowUnchecked(t);
                    return null;
                }));
                session.execute(Session.UNNAMED, 0, resultReceiver);
                session.sync();
            } catch (SQLActionException e) {
                ackCallback.accept(null, e);
                callbackNotified = true;
                break;
            }
        }
    }
    session.close();

    if (callbackNotified == false) {
        CompletableFuture<Void> allResultsComplete = CompletableFuture
                .allOf(insertOperationsFuture.toArray(new CompletableFuture[0]));

        allResultsComplete.whenComplete((r, t) -> {
            if (t != null) {
                // the actual cause is wrapped in a CompletionException by CompletableFuture#allOf
                ackCallback.accept(null, t.getCause());
            } else {
                ackCallback.accept(r, null);
            }
        });
    }

    if (messageMatchedRule == false) {
        LOGGER.warn(
                "Message with client_id {} and packet_id {} did not match any rule. The message will not be "
                        + "acknowledged",
                clientId, packetId);
    }
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Parsed MQTT message into arguments: {}", argsAsList);
    }
}

From source file:io.crate.mqtt.protocol.MqttProcessor.java

public void handlePublish(Channel channel, MqttPublishMessage msg) {
    final MqttQoS qos = msg.fixedHeader().qosLevel();
    String clientId = NettyUtils.clientID(channel);
    switch (qos) {
    case AT_LEAST_ONCE:
        SendPubAckCallback ackCallback = new SendPubAckCallback(channel, msg.variableHeader().packetId(),
                msg.fixedHeader().isDup());
        ingestService.doInsert(clientId, msg, ackCallback);
        break;/* www  .j ava 2s  .c om*/
    default:
        String message = String.format(Locale.ENGLISH, "QoS %s (%s) is not supported.", qos.value(),
                qos.name());
        throw new UnsupportedOperationException(message);
    }
}

From source file:io.moquette.server.Server.java

License:Open Source License

/**
 * Use the broker to publish a message. It's intended for embedding applications. It can be used
 * only after the server is correctly started with startServer.
 *
 * @param msg//w  ww  .j  a  v a2 s.  c o m
 *            the message to forward.
 * @param clientId
 *            the id of the sending server.
 * @throws IllegalStateException
 *             if the server is not yet started
 */
public void internalPublish(MqttPublishMessage msg, final String clientId) {
    final int messageID = msg.variableHeader().messageId();
    if (!m_initialized) {
        LOG.error("Moquette is not started, internal message cannot be published. CId={}, messageId={}",
                clientId, messageID);
        throw new IllegalStateException("Can't publish on a server is not yet started");
    }
    LOG.debug("Publishing message. CId={}, messageId={}", clientId, messageID);
    m_processor.internalPublish(msg, clientId);
}

From source file:io.moquette.spi.impl.BrokerInterceptor.java

License:Open Source License

@Override
public void notifyTopicPublished(final MqttPublishMessage msg, final String clientID, final String username) {
    int messageId = msg.variableHeader().messageId();
    String topic = msg.variableHeader().topicName();
    for (final InterceptHandler handler : this.handlers.get(InterceptPublishMessage.class)) {
        LOG.debug(/*w w w .  j  ava  2  s .  c om*/
                "Notifying MQTT PUBLISH message to interceptor. CId={}, messageId={}, topic={}, interceptorId={}",
                clientID, messageId, topic, handler.getID());
        executor.execute(new Runnable() {

            @Override
            public void run() {
                handler.onPublish(new InterceptPublishMessage(msg, clientID, username));
            }
        });
    }
}

From source file:net.anyflow.lannister.message.Message.java

License:Apache License

public static Message newMessage(String clientId, MqttPublishMessage published) {
    return new Message(published.variableHeader().messageId(), published.variableHeader().topicName(), clientId,
            NettyUtil.copy(published.payload()), published.fixedHeader().qosLevel(),
            published.fixedHeader().isRetain());
}

From source file:net.anyflow.lannister.packetreceiver.PublishReceiver.java

License:Apache License

@Override
protected void channelRead0(ChannelHandlerContext ctx, MqttPublishMessage msg) throws Exception {
    logger.debug("packet incoming [message={}]", msg.toString());
    Statistics.SELF.add(Statistics.Criterion.MESSAGES_PUBLISH_RECEIVED, 1);

    Session session = Session.NEXUS.get(ctx.channel().id());
    if (session == null) {
        logger.error("None exist session message [message={}]", msg.toString());

        ctx.channel().disconnect().addListener(ChannelFutureListener.CLOSE).addListener(fs -> // [MQTT-4.8.0-1]
        Plugins.SELF.get(DisconnectEventListener.class).disconnected(new AbnormalDisconnectEventArgs()));
        return;//from   w w  w . ja v a  2 s  .  co  m
    }

    session.setLastIncomingTime(new Date());

    if (!TopicMatcher.isValid(msg.variableHeader().topicName(), false)) {
        session.dispose(true);
        return;
    }

    Message message = Message.newMessage(session.clientId(), msg);

    if (!Plugins.SELF.get(PublishEventListener.class).allowPublish(new PublishEventArgs() {
        @Override
        public IMessage message() {
            return message;
        }
    })) {
        session.dispose(true);
        return;
    }

    // TODO What to do when sender re-publish message corrensponds to
    // unacked status?

    // TODO Until it has received the corresponding PUBREL packet, the
    // Receiver MUST acknowledge any subsequent PUBLISH packet with the same
    // Packet Identifier by sending a PUBREC. It MUST NOT cause duplicate
    // messages to be delivered to any onward recipients in this
    // case.[MQTT-4.3.3-2].

    final Topic topic = Topic.NEXUS.publish(message);

    switch (msg.fixedHeader().qosLevel()) {
    case AT_MOST_ONCE:
        return; // QoS 0 do not send any acknowledge packet [MQTT-3.3.4-1]

    case AT_LEAST_ONCE:
        session.send(MessageFactory.puback(msg.variableHeader().messageId())).addListener(
                f -> topic.removeInboundMessageStatus(session.clientId(), msg.variableHeader().messageId())); // [MQTT-3.3.4-1],[MQTT-2.3.1-6]
        logger.debug("Inbound message status REMOVED [clientId={}, messageId={}]", session.clientId(),
                msg.variableHeader().messageId());
        return;

    case EXACTLY_ONCE:
        session.send(MessageFactory.pubrec(msg.variableHeader().messageId()))
                .addListener(f -> topic.setInboundMessageStatus(session.clientId(),
                        msg.variableHeader().messageId(), InboundMessageStatus.Status.PUBRECED)); // [MQTT-3.3.4-1],[MQTT-2.3.1-6]
        return;

    default:
        session.dispose(true); // [MQTT-3.3.1-4]
        return;
    }
}

From source file:org.apache.activemq.artemis.core.protocol.mqtt.MQTTProtocolHandler.java

License:Apache License

void handlePublish(MqttPublishMessage message) throws Exception {
    session.getMqttPublishManager().handleMessage(message.variableHeader().packetId(),
            message.variableHeader().topicName(), message.fixedHeader().qosLevel().value(), message.payload(),
            message.fixedHeader().isRetain());
}

From source file:org.thingsboard.mqtt.MqttChannelHandler.java

License:Apache License

private void invokeHandlersForIncomingPublish(MqttPublishMessage message) {
    boolean handlerInvoked = false;
    for (MqttSubscription subscription : ImmutableSet.copyOf(this.client.getSubscriptions().values())) {
        if (subscription.matches(message.variableHeader().topicName())) {
            if (subscription.isOnce() && subscription.isCalled()) {
                continue;
            }//from w  w w .  j  a  va  2 s.  co m
            message.payload().markReaderIndex();
            subscription.setCalled(true);
            subscription.getHandler().onMessage(message.variableHeader().topicName(), message.payload());
            if (subscription.isOnce()) {
                this.client.off(subscription.getTopic(), subscription.getHandler());
            }
            message.payload().resetReaderIndex();
            handlerInvoked = true;
        }
    }
    if (!handlerInvoked && client.getDefaultHandler() != null) {
        client.getDefaultHandler().onMessage(message.variableHeader().topicName(), message.payload());
    }
    message.payload().release();
}