Java IConfig类代码示例

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 Server startBroker(Server server, IConfig memoryConfig) {
	try {
		server.startServer(memoryConfig);
		return server;
	} catch (final IOException e) {
		throw propagate(e);
	}
}
 

import io.moquette.server.config.IConfig; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException, IOException {
        IResourceLoader classpathLoader = new ClasspathResourceLoader();
        final IConfig classPathConfig = new ResourceLoaderConfig(classpathLoader);

        final Server mqttBroker = new Server();
        List<? extends InterceptHandler> userHandlers = Collections.singletonList(new PublisherListener());
        mqttBroker.startServer(classPathConfig, userHandlers);

        System.out.println("Broker started press [CTRL+C] to stop");
        //Bind  a shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Stopping broker");
            mqttBroker.stopServer();
            System.out.println("Broker stopped");
        }));

        Thread.sleep(20000);
        System.out.println("Before self publish");
        MqttPublishMessage message = MqttMessageBuilders.publish()
            .topicName("/exit")
            .retained(true)
//        qos(MqttQoS.AT_MOST_ONCE);
//        qQos(MqttQoS.AT_LEAST_ONCE);
            .qos(MqttQoS.EXACTLY_ONCE)
            .payload(Unpooled.copiedBuffer("Hello World!!".getBytes()))
            .build();

        mqttBroker.internalPublish(message, "INTRLPUB");
        System.out.println("After self publish");
    }
 

import io.moquette.server.config.IConfig; //导入依赖的package包/类
private IStore instantiateConfiguredStore(String storageClassName, IConfig props,
                                          ScheduledExecutorService scheduledExecutor) {
    LOG.info("Loading storage class {}", storageClassName);
    Class<? extends IStore> storageClass;
    try {
        storageClass = this.getClass().getClassLoader()
            .loadClass(storageClassName)
            .asSubclass(IStore.class);
    } catch (ClassNotFoundException cnfex) {
        LOG.error("Cannot find storage class " + storageClassName + " in classpath", cnfex);
        return null;
    }

    final Constructor<? extends IStore> constructor;
    try {
        constructor = storageClass
            .getConstructor(IConfig.class, ScheduledExecutorService.class);
    } catch (NoSuchMethodException nsmex) {
        LOG.error("Cannot find constructor with required params IConfig, ScheduledExecutorService ", nsmex);
        return null;
    }
    try {
        return constructor.newInstance(props, scheduledExecutor);
    } catch (InstantiationException | IllegalAccessException | InvocationTargetException ex) {
        LOG.error("Cannot instantiate the " + storageClassName + " instance", ex);
    }

    return null;
}
 

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包/类
@Before
public void setUp() throws Exception {
    scheduler = Executors.newScheduledThreadPool(1);

    cleanPersistenceFile(BrokerConstants.DEFAULT_PERSISTENT_PATH);
    Properties props = new Properties();
    props.setProperty(BrokerConstants.PERSISTENT_STORE_PROPERTY_NAME, BrokerConstants.DEFAULT_PERSISTENT_PATH);
    IConfig conf = new MemoryConfig(props);
    m_storageService = new MapDBPersistentStore(conf, scheduler);
    m_storageService.initStore();
    messagesStore = m_storageService.messagesStore();
    sessionsStore = m_storageService.sessionsStore();
    this.sessionsRepository = new SessionsRepository(sessionsStore, null);
}
 

import io.moquette.server.config.IConfig; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    scheduler = Executors.newScheduledThreadPool(1);

    cleanPersistenceFile(BrokerConstants.DEFAULT_PERSISTENT_PATH);
    Properties props = new Properties();
    props.setProperty(BrokerConstants.PERSISTENT_STORE_PROPERTY_NAME, BrokerConstants.DEFAULT_PERSISTENT_PATH);
    IConfig conf = new MemoryConfig(props);
    storageService = new MapDBPersistentStore(conf, scheduler);
    storageService.initStore();
}
 

import io.moquette.server.config.IConfig; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    scheduler = Executors.newScheduledThreadPool(1);

    cleanPersistenceFile(BrokerConstants.DEFAULT_PERSISTENT_PATH);
    Properties props = new Properties();
    props.setProperty(BrokerConstants.PERSISTENT_STORE_PROPERTY_NAME, BrokerConstants.DEFAULT_PERSISTENT_PATH);
    IConfig conf = new MemoryConfig(props);
    storageService = new H2PersistentStore(conf, scheduler);
    storageService.initStore();
}
 

import io.moquette.server.config.IConfig; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    scheduler = Executors.newScheduledThreadPool(1);

    cleanPersistenceFile(BrokerConstants.DEFAULT_PERSISTENT_PATH);
    Properties props = new Properties();
    props.setProperty(BrokerConstants.PERSISTENT_STORE_PROPERTY_NAME, BrokerConstants.DEFAULT_PERSISTENT_PATH);
    IConfig conf = new MemoryConfig(props);
    storageService = new H2PersistentStore(conf, scheduler);
    storageService.initStore();
    messagesStore = storageService.messagesStore();
    sessionsStore = storageService.sessionsStore();
    this.sessionsRepository = new SessionsRepository(sessionsStore, null);
}
 

import io.moquette.server.config.IConfig; //导入依赖的package包/类
public MemoryStorageService(IConfig props, ScheduledExecutorService scheduler) {
    m_messagesStore = new MemoryMessagesStore();
    m_sessionsStore = new MemorySessionStore();
    m_messagesStore.initStore();
    m_sessionsStore.initStore();
}
 

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包/类
/**
 * Configures a broker interceptor using the pool size specified in the IConfig argument.
 */
BrokerInterceptor(IConfig props, List<InterceptHandler> handlers) {
    this(Integer.parseInt(props.getProperty(BrokerConstants.BROKER_INTERCEPTOR_THREAD_POOL_SIZE, "1")), handlers);
}