Java IConfig.getProperty方法代码示例

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
public void init(IConfig props) {
        this.metrics = new MetricRegistry();
        this.publishesMetrics = metrics.meter("publish.requests");
        this.subscribeMetrics = metrics.meter("subscribe.requests");
        this.connectedClientsMetrics = metrics.counter("connect.num_clients");
//        ConsoleReporter reporter = ConsoleReporter.forRegistry(metrics)
//            .convertRatesTo(TimeUnit.SECONDS)
//            .convertDurationsTo(TimeUnit.MILLISECONDS)
//            .build();
//        reporter.start(1, TimeUnit.MINUTES);
        final String email = props.getProperty(METRICS_LIBRATO_EMAIL_PROPERTY_NAME);
        final String token = props.getProperty(METRICS_LIBRATO_TOKEN_PROPERTY_NAME);
        final String source = props.getProperty(METRICS_LIBRATO_SOURCE_PROPERTY_NAME);

        Librato.reporter(this.metrics, email, token)
            .setSource(source)
            .start(10, TimeUnit.SECONDS);
    }
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
private void initializePlainTCPTransport(final NettyMQTTHandler handler,
                                         IConfig props) throws IOException {
    LOG.info("Configuring TCP MQTT transport");
    final MoquetteIdleTimeoutHandler timeoutHandler = new MoquetteIdleTimeoutHandler();
    String host = props.getProperty(BrokerConstants.HOST_PROPERTY_NAME);
    String tcpPortProp = props.getProperty(PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
    if (DISABLED_PORT_BIND.equals(tcpPortProp)) {
        LOG.info("Property {} has been set to {}. TCP MQTT will be disabled", BrokerConstants.PORT_PROPERTY_NAME,
            DISABLED_PORT_BIND);
        return;
    }
    int port = Integer.parseInt(tcpPortProp);
    initFactory(host, port, "TCP MQTT", new PipelineInitializer() {

        @Override
        void init(ChannelPipeline pipeline) {
            pipeline.addFirst("idleStateHandler", new IdleStateHandler(nettyChannelTimeoutSeconds, 0, 0));
            pipeline.addAfter("idleStateHandler", "idleEventHandler", timeoutHandler);
            // pipeline.addLast("logger", new LoggingHandler("Netty", LogLevel.ERROR));
            if (errorsCather.isPresent()) {
                pipeline.addLast("bugsnagCatcher", errorsCather.get());
            }
            pipeline.addFirst("bytemetrics", new BytesMetricsHandler(m_bytesMetricsCollector));
            pipeline.addLast("decoder", new MqttDecoder());
            pipeline.addLast("encoder", MqttEncoder.INSTANCE);
            pipeline.addLast("metrics", new MessageMetricsHandler(m_metricsCollector));
            pipeline.addLast("messageLogger", new MQTTMessageLogger());
            if (metrics.isPresent()) {
                pipeline.addLast("wizardMetrics", metrics.get());
            }
            pipeline.addLast("handler", handler);
        }
    });
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
private void initializeWebSocketTransport(final NettyMQTTHandler handler, IConfig props) throws IOException {
    LOG.info("Configuring Websocket MQTT transport");
    String webSocketPortProp = props.getProperty(WEB_SOCKET_PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
    if (DISABLED_PORT_BIND.equals(webSocketPortProp)) {
        // Do nothing no WebSocket configured
        LOG.info("Property {} has been setted to {}. Websocket MQTT will be disabled",
            BrokerConstants.WEB_SOCKET_PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
        return;
    }
    int port = Integer.parseInt(webSocketPortProp);

    final MoquetteIdleTimeoutHandler timeoutHandler = new MoquetteIdleTimeoutHandler();

    String host = props.getProperty(BrokerConstants.HOST_PROPERTY_NAME);
    initFactory(host, port, "Websocket MQTT", new PipelineInitializer() {

        @Override
        void init(ChannelPipeline pipeline) {
            pipeline.addLast(new HttpServerCodec());
            pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
            pipeline.addLast("webSocketHandler",
                    new WebSocketServerProtocolHandler("/mqtt", MQTT_SUBPROTOCOL_CSV_LIST));
            pipeline.addLast("ws2bytebufDecoder", new WebSocketFrameToByteBufDecoder());
            pipeline.addLast("bytebuf2wsEncoder", new ByteBufToWebSocketFrameEncoder());
            pipeline.addFirst("idleStateHandler", new IdleStateHandler(nettyChannelTimeoutSeconds, 0, 0));
            pipeline.addAfter("idleStateHandler", "idleEventHandler", timeoutHandler);
            pipeline.addFirst("bytemetrics", new BytesMetricsHandler(m_bytesMetricsCollector));
            pipeline.addLast("decoder", new MqttDecoder());
            pipeline.addLast("encoder", MqttEncoder.INSTANCE);
            pipeline.addLast("metrics", new MessageMetricsHandler(m_metricsCollector));
            pipeline.addLast("messageLogger", new MQTTMessageLogger());
            pipeline.addLast("handler", handler);
        }
    });
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
private void initializeSSLTCPTransport(final NettyMQTTHandler handler, IConfig props, final SSLContext sslContext)
        throws IOException {
    LOG.info("Configuring SSL MQTT transport");
    String sslPortProp = props.getProperty(SSL_PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
    if (DISABLED_PORT_BIND.equals(sslPortProp)) {
        // Do nothing no SSL configured
        LOG.info("Property {} has been set to {}. SSL MQTT will be disabled",
            BrokerConstants.SSL_PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
        return;
    }

    int sslPort = Integer.parseInt(sslPortProp);
    LOG.info("Starting SSL on port {}", sslPort);

    final MoquetteIdleTimeoutHandler timeoutHandler = new MoquetteIdleTimeoutHandler();
    String host = props.getProperty(BrokerConstants.HOST_PROPERTY_NAME);
    String sNeedsClientAuth = props.getProperty(BrokerConstants.NEED_CLIENT_AUTH, "false");
    final boolean needsClientAuth = Boolean.valueOf(sNeedsClientAuth);
    initFactory(host, sslPort, "SSL MQTT", new PipelineInitializer() {

        @Override
        void init(ChannelPipeline pipeline) throws Exception {
            pipeline.addLast("ssl", createSslHandler(sslContext, needsClientAuth));
            pipeline.addFirst("idleStateHandler", new IdleStateHandler(nettyChannelTimeoutSeconds, 0, 0));
            pipeline.addAfter("idleStateHandler", "idleEventHandler", timeoutHandler);
            // pipeline.addLast("logger", new LoggingHandler("Netty", LogLevel.ERROR));
            pipeline.addFirst("bytemetrics", new BytesMetricsHandler(m_bytesMetricsCollector));
            pipeline.addLast("decoder", new MqttDecoder());
            pipeline.addLast("encoder", MqttEncoder.INSTANCE);
            pipeline.addLast("metrics", new MessageMetricsHandler(m_metricsCollector));
            pipeline.addLast("messageLogger", new MQTTMessageLogger());
            pipeline.addLast("handler", handler);
        }
    });
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
private void initializeWSSTransport(final NettyMQTTHandler handler, IConfig props, final SSLContext sslContext)
        throws IOException {
    LOG.info("Configuring secure websocket MQTT transport");
    String sslPortProp = props.getProperty(WSS_PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
    if (DISABLED_PORT_BIND.equals(sslPortProp)) {
        // Do nothing no SSL configured
        LOG.info("Property {} has been set to {}. Secure websocket MQTT will be disabled",
            BrokerConstants.WSS_PORT_PROPERTY_NAME, DISABLED_PORT_BIND);
        return;
    }
    int sslPort = Integer.parseInt(sslPortProp);
    final MoquetteIdleTimeoutHandler timeoutHandler = new MoquetteIdleTimeoutHandler();
    String host = props.getProperty(BrokerConstants.HOST_PROPERTY_NAME);
    String sNeedsClientAuth = props.getProperty(BrokerConstants.NEED_CLIENT_AUTH, "false");
    final boolean needsClientAuth = Boolean.valueOf(sNeedsClientAuth);
    initFactory(host, sslPort, "Secure websocket", new PipelineInitializer() {

        @Override
        void init(ChannelPipeline pipeline) throws Exception {
            pipeline.addLast("ssl", createSslHandler(sslContext, needsClientAuth));
            pipeline.addLast("httpEncoder", new HttpResponseEncoder());
            pipeline.addLast("httpDecoder", new HttpRequestDecoder());
            pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
            pipeline.addLast("webSocketHandler",
                    new WebSocketServerProtocolHandler("/mqtt", MQTT_SUBPROTOCOL_CSV_LIST));
            pipeline.addLast("ws2bytebufDecoder", new WebSocketFrameToByteBufDecoder());
            pipeline.addLast("bytebuf2wsEncoder", new ByteBufToWebSocketFrameEncoder());
            pipeline.addFirst("idleStateHandler", new IdleStateHandler(nettyChannelTimeoutSeconds, 0, 0));
            pipeline.addAfter("idleStateHandler", "idleEventHandler", timeoutHandler);
            pipeline.addFirst("bytemetrics", new BytesMetricsHandler(m_bytesMetricsCollector));
            pipeline.addLast("decoder", new MqttDecoder());
            pipeline.addLast("encoder", MqttEncoder.INSTANCE);
            pipeline.addLast("metrics", new MessageMetricsHandler(m_metricsCollector));
            pipeline.addLast("messageLogger", new MQTTMessageLogger());
            pipeline.addLast("handler", handler);
        }
    });
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
public DBAuthenticator(IConfig conf) {
    this(conf.getProperty(BrokerConstants.DB_AUTHENTICATOR_DRIVER, ""),
         conf.getProperty(BrokerConstants.DB_AUTHENTICATOR_URL, ""),
         conf.getProperty(BrokerConstants.DB_AUTHENTICATOR_QUERY, ""),
         conf.getProperty(BrokerConstants.DB_AUTHENTICATOR_DIGEST, ""));
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
public void init(IConfig props) {
    final String token = props.getProperty(BUGSNAG_TOKEN_PROPERTY_NAME);
    this.bugsnag = new Bugsnag(token);
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
@Override
public void initialize(ProtocolProcessor processor, IConfig props, ISslContextCreator sslCtxCreator)
        throws IOException {
    LOG.info("Initializing Netty acceptor...");

    nettySoBacklog = Integer.parseInt(props.getProperty(BrokerConstants.NETTY_SO_BACKLOG_PROPERTY_NAME, "128"));
    nettySoReuseaddr = Boolean
            .parseBoolean(props.getProperty(BrokerConstants.NETTY_SO_REUSEADDR_PROPERTY_NAME, "true"));
    nettyTcpNodelay = Boolean
            .parseBoolean(props.getProperty(BrokerConstants.NETTY_TCP_NODELAY_PROPERTY_NAME, "true"));
    nettySoKeepalive = Boolean
            .parseBoolean(props.getProperty(BrokerConstants.NETTY_SO_KEEPALIVE_PROPERTY_NAME, "true"));
    nettyChannelTimeoutSeconds = Integer
            .parseInt(props.getProperty(BrokerConstants.NETTY_CHANNEL_TIMEOUT_SECONDS_PROPERTY_NAME, "10"));

    boolean epoll = Boolean.parseBoolean(props.getProperty(BrokerConstants.NETTY_EPOLL_PROPERTY_NAME, "false"));
    if (epoll) {
        LOG.info("Netty is using Epoll");
        m_bossGroup = new EpollEventLoopGroup();
        m_workerGroup = new EpollEventLoopGroup();
        channelClass = EpollServerSocketChannel.class;
    } else {
        LOG.info("Netty is using NIO");
        m_bossGroup = new NioEventLoopGroup();
        m_workerGroup = new NioEventLoopGroup();
        channelClass = NioServerSocketChannel.class;
    }

    final NettyMQTTHandler mqttHandler = new NettyMQTTHandler(processor);

    final boolean useFineMetrics = Boolean.parseBoolean(props.getProperty(METRICS_ENABLE_PROPERTY_NAME, "false"));
    if (useFineMetrics) {
        DropWizardMetricsHandler metricsHandler = new DropWizardMetricsHandler();
        metricsHandler.init(props);
        this.metrics = Optional.of(metricsHandler);
    } else {
        this.metrics = Optional.empty();
    }

    final boolean useBugSnag = Boolean.parseBoolean(props.getProperty(BUGSNAG_ENABLE_PROPERTY_NAME, "false"));
    if (useBugSnag) {
        BugSnagErrorsHandler bugSnagHandler = new BugSnagErrorsHandler();
        bugSnagHandler.init(props);
        this.errorsCather = Optional.of(bugSnagHandler);
    } else {
        this.errorsCather = Optional.empty();
    }
    initializePlainTCPTransport(mqttHandler, props);
    initializeWebSocketTransport(mqttHandler, props);
    String sslTcpPortProp = props.getProperty(BrokerConstants.SSL_PORT_PROPERTY_NAME);
    String wssPortProp = props.getProperty(BrokerConstants.WSS_PORT_PROPERTY_NAME);
    if (sslTcpPortProp != null || wssPortProp != null) {
        SSLContext sslContext = sslCtxCreator.initSSLContext();
        if (sslContext == null) {
            LOG.error("Can't initialize SSLHandler layer! Exiting, check your configuration of jks");
            return;
        }
        initializeSSLTCPTransport(mqttHandler, props, sslContext);
        initializeWSSTransport(mqttHandler, props, sslContext);
    }
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
public MapDBPersistentStore(IConfig props, ScheduledExecutorService scheduler) {
    this.m_storePath = props.getProperty(BrokerConstants.PERSISTENT_STORE_PROPERTY_NAME, "");
    this.m_autosaveInterval = Integer
            .parseInt(props.getProperty(BrokerConstants.AUTOSAVE_INTERVAL_PROPERTY_NAME, "30"));
    this.m_scheduler = scheduler;
}
 

import io.moquette.server.config.IConfig; //导入方法依赖的package包/类
public H2PersistentStore(IConfig props, ScheduledExecutorService scheduler) {
    this.storePath = props.getProperty(BrokerConstants.PERSISTENT_STORE_PROPERTY_NAME, "");
    this.autosaveInterval = Integer.parseInt(props.getProperty(BrokerConstants.AUTOSAVE_INTERVAL_PROPERTY_NAME, "30"));
    this.scheduler = scheduler;
}