org.apache.camel.component.paho.mqtt5.PahoMqtt5Configuration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of camel-paho-mqtt5 Show documentation
Camel Eclipse Paho support for MQTT v5
The newest version!
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.camel.component.paho.mqtt5;

import java.util.Map;
import java.util.Properties;

import javax.net.SocketFactory;
import javax.net.ssl.HostnameVerifier;

import org.apache.camel.RuntimeCamelException;
import org.apache.camel.spi.Metadata;
import org.apache.camel.spi.UriParam;
import org.apache.camel.spi.UriParams;
import org.eclipse.paho.mqttv5.common.packet.MqttProperties;

@UriParams
public class PahoMqtt5Configuration implements Cloneable {

    @UriParam
    private String clientId;
    @UriParam(defaultValue = PahoMqtt5Constants.DEFAULT_BROKER_URL)
    private String brokerUrl = PahoMqtt5Constants.DEFAULT_BROKER_URL;
    @UriParam(defaultValue = "2")
    private int qos = PahoMqtt5Constants.DEFAULT_QOS;
    @UriParam
    private boolean retained;
    @UriParam(defaultValue = "MEMORY")
    private PahoMqtt5Persistence persistence = PahoMqtt5Persistence.MEMORY;
    @UriParam
    private String filePersistenceDirectory;

    @UriParam(defaultValue = "60")
    private int keepAliveInterval = 60;
    @UriParam(defaultValue = "65535")
    private int receiveMaximum = 65535;
    @UriParam
    private String willTopic;
    @UriParam
    private String willPayload;
    @UriParam(defaultValue = "1")
    private int willQos = 1;
    @UriParam(defaultValue = "false")
    private boolean willRetained;
    @UriParam
    private MqttProperties willMqttProperties;
    @UriParam(label = "security")
    @Metadata(secret = true)
    private String userName;
    @UriParam(label = "security")
    @Metadata(secret = true)
    private String password;
    @UriParam(label = "security")
    private SocketFactory socketFactory;
    @UriParam(label = "security")
    private Properties sslClientProps;
    @UriParam(label = "security", defaultValue = "true")
    private boolean httpsHostnameVerificationEnabled = true;
    @UriParam(label = "security")
    private HostnameVerifier sslHostnameVerifier;
    @UriParam(defaultValue = "true")
    private boolean cleanStart = true;
    @UriParam(defaultValue = "30")
    private int connectionTimeout = 30;
    @UriParam
    private String serverURIs;
    @UriParam(defaultValue = "true")
    private boolean automaticReconnect = true;
    @UriParam(defaultValue = "128000")
    private int maxReconnectDelay = 128000;
    @UriParam(label = "advanced")
    private Map customWebSocketHeaders;
    @UriParam(label = "advanced", defaultValue = "1")
    private int executorServiceTimeout = 1;
    @UriParam(defaultValue = "-1")
    private long sessionExpiryInterval = -1;

    public String getClientId() {
        return clientId;
    }

    /**
     * MQTT client identifier. The identifier must be unique.
     */
    public void setClientId(String clientId) {
        this.clientId = clientId;
    }

    public String getBrokerUrl() {
        return brokerUrl;
    }

    /**
     * The URL of the MQTT broker.
     */
    public void setBrokerUrl(String brokerUrl) {
        this.brokerUrl = brokerUrl;
    }

    public int getQos() {
        return qos;
    }

    /**
     * Client quality of service level (0-2).
     */
    public void setQos(int qos) {
        this.qos = qos;
    }

    public boolean isRetained() {
        return retained;
    }

    /**
     * Retain option
     */
    public void setRetained(boolean retained) {
        this.retained = retained;
    }

    public PahoMqtt5Persistence getPersistence() {
        return persistence;
    }

    /**
     * Client persistence to be used - memory or file.
     */
    public void setPersistence(PahoMqtt5Persistence persistence) {
        this.persistence = persistence;
    }

    public String getFilePersistenceDirectory() {
        return filePersistenceDirectory;
    }

    /**
     * Base directory used by file persistence. Will by default use user directory.
     */
    public void setFilePersistenceDirectory(String filePersistenceDirectory) {
        this.filePersistenceDirectory = filePersistenceDirectory;
    }

    public String getUserName() {
        return userName;
    }

    /**
     * Username to be used for authentication against the MQTT broker
     */
    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    /**
     * Password to be used for authentication against the MQTT broker
     */
    public void setPassword(String password) {
        this.password = password;
    }

    public int getKeepAliveInterval() {
        return keepAliveInterval;
    }

    /**
     * Sets the keep alive interval. This value, measured in seconds, defines the maximum time interval between messages
     * sent or received. It enables the client to detect if the server is no longer available, without having to wait
     * for the TCP/IP timeout. The client will ensure that at least one message travels across the network within each
     * keep alive period. In the absence of a data-related message during the time period, the client sends a very small
     * ping message, which the server will acknowledge. A value of 0 disables keepalive processing in the client.
     * 
     * The default value is 60 seconds
     * 
     */
    public void setKeepAliveInterval(int keepAliveInterval) {
        this.keepAliveInterval = keepAliveInterval;
    }

    public int getReceiveMaximum() {
        return receiveMaximum;
    }

    /**
     * Sets the Receive Maximum. This value represents the limit of QoS 1 and QoS 2 publications that the client is
     * willing to process concurrently. There is no mechanism to limit the number of QoS 0 publications that the Server
     * might try to send.
     * 
     * The default value is 65535
     * 
     */
    public void setReceiveMaximum(int receiveMaximum) {
        this.receiveMaximum = receiveMaximum;
    }

    public String getWillTopic() {
        return willTopic;
    }

    /**
     * Sets the "Last Will and Testament" (LWT) for the connection. In the event that this client unexpectedly loses its
     * connection to the server, the server will publish a message to itself using the supplied details.
     *
     * The topic to publish to.
     */
    public void setWillTopic(String willTopic) {
        this.willTopic = willTopic;
    }

    public String getWillPayload() {
        return willPayload;
    }

    /**
     * Sets the "Last Will and Testament" (LWT) for the connection. In the event that this client unexpectedly loses its
     * connection to the server, the server will publish a message to itself using the supplied details.
     *
     * The byte payload for the message.
     */
    public void setWillPayload(String willPayload) {
        this.willPayload = willPayload;
    }

    public int getWillQos() {
        return willQos;
    }

    /**
     * Sets the "Last Will and Testament" (LWT) for the connection. In the event that this client unexpectedly loses its
     * connection to the server, the server will publish a message to itself using the supplied details.
     *
     * The quality of service to publish the message at (0, 1 or 2).
     */
    public void setWillQos(int willQos) {
        this.willQos = willQos;
    }

    public boolean isWillRetained() {
        return willRetained;
    }

    /**
     * Sets the "Last Will and Testament" (LWT) for the connection. In the event that this client unexpectedly loses its
     * connection to the server, the server will publish a message to itself using the supplied details.
     *
     * Whether or not the message should be retained.
     */
    public void setWillRetained(boolean willRetained) {
        this.willRetained = willRetained;
    }

    public MqttProperties getWillMqttProperties() {
        return willMqttProperties;
    }

    /**
     * Sets the "Last Will and Testament" (LWT) for the connection. In the event that this client unexpectedly loses its
     * connection to the server, the server will publish a message to itself using the supplied details.
     *
     * The MQTT properties set for the message.
     */
    public void setWillMqttProperties(MqttProperties properties) {
        this.willMqttProperties = properties;
    }

    public SocketFactory getSocketFactory() {
        return socketFactory;
    }

    /**
     * Sets the SocketFactory to use. This allows an application to apply its own policies around the creation of
     * network sockets. If using an SSL connection, an SSLSocketFactory can be used to supply application-specific
     * security settings.
     */
    public void setSocketFactory(SocketFactory socketFactory) {
        this.socketFactory = socketFactory;
    }

    public Properties getSslClientProps() {
        return sslClientProps;
    }

    /**
     * Sets the SSL properties for the connection.
     * 
     * Note that these properties are only valid if an implementation of the Java Secure Socket Extensions (JSSE) is
     * available. These properties are not used if a custom SocketFactory has been set.
     *
     * The following properties can be used:
     * 
     * 
     * com.ibm.ssl.protocol
     * One of: SSL, SSLv3, TLS, TLSv1, SSL_TLS.
     * com.ibm.ssl.contextProvider
     * 
Underlying JSSE provider. For example "IBMJSSE2" or "SunJSSE"
     *
     * com.ibm.ssl.keyStore
     * The name of the file that contains the KeyStore object that you want the KeyManager to use. For example
     * /mydir/etc/key.p12
     *
     * com.ibm.ssl.keyStorePassword
     * The password for the KeyStore object that you want the KeyManager to use. The password can either be in
     * plain-text, or may be obfuscated using the static method:
     * com.ibm.micro.security.Password.obfuscate(char[] password). This obfuscates the password using a
     * simple and insecure XOR and Base64 encoding mechanism. Note that this is only a simple scrambler to obfuscate
     * clear-text passwords.
     *
     * com.ibm.ssl.keyStoreType
     * Type of key store, for example "PKCS12", "JKS", or "JCEKS".
     *
     * com.ibm.ssl.keyStoreProvider
     * Key store provider, for example "IBMJCE" or "IBMJCEFIPS".
     *
     * com.ibm.ssl.trustStore
     * The name of the file that contains the KeyStore object that you want the TrustManager to use.
     *
     * com.ibm.ssl.trustStorePassword
     * The password for the TrustStore object that you want the TrustManager to use. The password can either be in
     * plain-text, or may be obfuscated using the static method:
     * com.ibm.micro.security.Password.obfuscate(char[] password). This obfuscates the password using a
     * simple and insecure XOR and Base64 encoding mechanism. Note that this is only a simple scrambler to obfuscate
     * clear-text passwords.
     *
     * com.ibm.ssl.trustStoreType
     * The type of KeyStore object that you want the default TrustManager to use. Same possible values as
     * "keyStoreType".
     *
     * com.ibm.ssl.trustStoreProvider
     * Trust store provider, for example "IBMJCE" or "IBMJCEFIPS".
     *
     * com.ibm.ssl.enabledCipherSuites
     * A list of which ciphers are enabled. Values are dependent on the provider, for example:
     * SSL_RSA_WITH_AES_128_CBC_SHA;SSL_RSA_WITH_3DES_EDE_CBC_SHA.
     *
     * com.ibm.ssl.keyManager
     * Sets the algorithm that will be used to instantiate a KeyManagerFactory object instead of using the default
     * algorithm available in the platform. Example values: "IbmX509" or "IBMJ9X509".
     *
     * com.ibm.ssl.trustManager
     * Sets the algorithm that will be used to instantiate a TrustManagerFactory object instead of using the default
     * algorithm available in the platform. Example values: "PKIX" or "IBMJ9X509".
     * 
     */
    public void setSslClientProps(Properties sslClientProps) {
        this.sslClientProps = sslClientProps;
    }

    public boolean isHttpsHostnameVerificationEnabled() {
        return httpsHostnameVerificationEnabled;
    }

    /**
     * Whether SSL HostnameVerifier is enabled or not. The default value is true.
     */
    public void setHttpsHostnameVerificationEnabled(boolean httpsHostnameVerificationEnabled) {
        this.httpsHostnameVerificationEnabled = httpsHostnameVerificationEnabled;
    }

    public HostnameVerifier getSslHostnameVerifier() {
        return sslHostnameVerifier;
    }

    /**
     * Sets the HostnameVerifier for the SSL connection. Note that it will be used after handshake on a connection and
     * you should do actions by yourself when hostname is verified error.
     * 
     * There is no default HostnameVerifier
     * 
     */
    public void setSslHostnameVerifier(HostnameVerifier sslHostnameVerifier) {
        this.sslHostnameVerifier = sslHostnameVerifier;
    }

    public boolean isCleanStart() {
        return cleanStart;
    }

    /**
     * Sets whether the client and server should remember state across restarts and reconnects.
     * 
     * If set to false both the client and server will maintain state across restarts of the client, the server and
     * the connection. As state is maintained:
     * 
     * Message delivery will be reliable meeting the specified QOS even if the client, server or connection are
     * restarted.
     * 
The server will treat a subscription as durable.
     * 
     * 
If set to true the client and server will not maintain state across restarts of the client, the server or the
     * connection. This means
     * 
     * Message delivery to the specified QOS cannot be maintained if the client, server or connection are restarted
     * 
The server will treat a subscription as non-durable
     * 
     * 
     */
    public void setCleanStart(boolean cleanStart) {
        this.cleanStart = cleanStart;
    }

    public int getConnectionTimeout() {
        return connectionTimeout;
    }

    /**
     * Sets the connection timeout value. This value, measured in seconds, defines the maximum time interval the client
     * will wait for the network connection to the MQTT server to be established. The default timeout is 30 seconds. A
     * value of 0 disables timeout processing meaning the client will wait until the network connection is made
     * successfully or fails.
     */
    public void setConnectionTimeout(int connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public String getServerURIs() {
        return serverURIs;
    }

    /**
     * Set a list of one or more serverURIs the client may connect to. Multiple servers can be separated by comma.
     * 
     * Each serverURI specifies the address of a server that the client may connect to. Two types of
     * connection are supported tcp:// for a TCP connection and ssl:// for a TCP connection
     * secured by SSL/TLS. For example:
     * 

     * tcp://localhost:1883
     * ssl://localhost:8883
     * 
     * If the port is not specified, it will default to 1883 for tcp://" URIs, and 8883 for
     * ssl:// URIs.
     * 
     * If serverURIs is set then it overrides the serverURI parameter passed in on the constructor of the MQTT client.
     * 

     * When an attempt to connect is initiated the client will start with the first serverURI in the list and work
     * through the list until a connection is established with a server. If a connection cannot be made to any of the
     * servers then the connect attempt fails.
     * 

     * Specifying a list of servers that a client may connect to has several uses:
     * 

     * High Availability and reliable message delivery
     * 
     * Some MQTT servers support a high availability feature where two or more "equal" MQTT servers share state. An MQTT
     * client can connect to any of the "equal" servers and be assured that messages are reliably delivered and durable
     * subscriptions are maintained no matter which server the client connects to.
     * 
     * 
     * The cleansession flag must be set to false if durable subscriptions and/or reliable message delivery is required.
     * 
     * 
     * Hunt List
     * 
     * A set of servers may be specified that are not "equal" (as in the high availability option). As no state is
     * shared across the servers reliable message delivery and durable subscriptions are not valid. The cleansession
     * flag must be set to true if the hunt list mode is used
     * 
     * 
     * 
     */
    public void setServerURIs(String serverURIs) {
        this.serverURIs = serverURIs;
    }

    public boolean isAutomaticReconnect() {
        return automaticReconnect;
    }

    /**
     * Sets whether the client will automatically attempt to reconnect to the server if the connection is lost.
     * 
     * If set to false, the client will not attempt to automatically reconnect to the server in the event that the
     * connection is lost.
     * If set to true, in the event that the connection is lost, the client will attempt to reconnect to the server.
     * It will initially wait 1 second before it attempts to reconnect, for every failed reconnect attempt, the delay
     * will double until it is at 2 minutes at which point the delay will stay at 2 minutes.
     * 
     */
    public void setAutomaticReconnect(boolean automaticReconnect) {
        this.automaticReconnect = automaticReconnect;
    }

    public int getMaxReconnectDelay() {
        return maxReconnectDelay;
    }

    /**
     * Get the maximum time (in millis) to wait between reconnects
     */
    public void setMaxReconnectDelay(int maxReconnectDelay) {
        this.maxReconnectDelay = maxReconnectDelay;
    }

    public Map getCustomWebSocketHeaders() {
        return customWebSocketHeaders;
    }

    /**
     * Sets the Custom WebSocket Headers for the WebSocket Connection.
     */
    public void setCustomWebSocketHeaders(Map customWebSocketHeaders) {
        this.customWebSocketHeaders = customWebSocketHeaders;
    }

    public int getExecutorServiceTimeout() {
        return executorServiceTimeout;
    }

    /**
     * Set the time in seconds that the executor service should wait when terminating before forcefully terminating. It
     * is not recommended to change this value unless you are absolutely sure that you need to.
     */
    public void setExecutorServiceTimeout(int executorServiceTimeout) {
        this.executorServiceTimeout = executorServiceTimeout;
    }

    public long getSessionExpiryInterval() {
        return sessionExpiryInterval;
    }

    /**
     * Sets the Session Expiry Interval.
     *
     * This value, measured in seconds, defines the maximum time that the broker will maintain the session for once the
     * client disconnects. Clients should only connect with a long Session Expiry interval if they intend to connect to
     * the server at some later point in time.
     *
     * By default this value is -1 and so will not be sent, in this case, the session will not expire. If a 0 is sent,
     * the session will end immediately once the Network Connection is closed. When the client has determined that it
     * has no longer any use for the session, it should disconnect with a Session Expiry Interval set to 0.
     */
    public void setSessionExpiryInterval(long sessionExpiryInterval) {
        this.sessionExpiryInterval = sessionExpiryInterval;
    }

    public PahoMqtt5Configuration copy() {
        try {
            return (PahoMqtt5Configuration) clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }
}