@Override public void start() throws Exception { ProtonServer server = ProtonServer.create(vertx); // Configure how new connections are handled server.connectHandler((connection) -> { initConnection(vertx, connection); }); server.listen(PORT, (res) -> { if (res.succeeded()) { System.out.println("Listening on port " + res.result().actualPort()); } else { System.out.println("Failed to start listening on port " + PORT + ":"); res.cause().printStackTrace(); } }); }
@Override public void start(Future<Void> startPromise) { server = ProtonServer.create(vertx); server.connectHandler(this::connectHandler); server.listen(0, result -> { if (result.succeeded()) { log.info("[{}]: Starting server on port {}", containerId, server.actualPort()); startPromise.complete(); } else { log.error("[{}]: Error starting server", containerId, result.cause()); startPromise.fail(result.cause()); } }); }
private void startInsecureServer(Future<Void> startupHandler) { if (isOpenInsecurePort()) { final ProtonServerOptions options = createServerOptions(); insecureServer = createProtonServer(options) .connectHandler(this::handleRemoteConnectionOpenInsecurePort) .listen(amqpInsecurePort, honoConfig.getInsecurePortBindAddress(), bindAttempt -> { if (bindAttempt.succeeded()) { LOG.info("HonoServer insecure port listening on [{}:{}]", getInsecurePortBindAddress(), getInsecurePort()); if (getInsecurePort() != Constants.PORT_AMQP) LOG.warn("This is NOT the IANA standard insecure port {}!", Constants.PORT_AMQP); startupHandler.complete(); } else { LOG.error("cannot start up HonoServer (insecure port failed) ", bindAttempt.cause()); startupHandler.fail(bindAttempt.cause()); } }); } else { startupHandler.complete(); } }
/** * Start the AMQP server * * @param startFuture */ private void bindAmqpServer(Future<Void> startFuture) { ProtonServerOptions options = this.createServerOptions(); this.server = ProtonServer.create(this.vertx, options) .connectHandler(this::processConnection) .listen(ar -> { if (ar.succeeded()) { log.info("AMQP-Kafka Bridge started and listening on port {}", ar.result().actualPort()); log.info("Kafka bootstrap servers {}", this.bridgeConfigProperties.getKafkaConfigProperties().getBootstrapServers()); this.isReady = true; this.startHealthServer(); startFuture.complete(); } else { log.error("Error starting AMQP-Kafka Bridge", ar.cause()); startFuture.fail(ar.cause()); } }); }
private Future<Void> startSecureServer() { final Future<Void> startSecurePortTracker = Future.future(); if (isOpenSecurePort()) { final ProtonServerOptions options = createSecureServerOptions(); server = createProtonServer(options) .connectHandler(this::handleRemoteConnectionOpen) .listen(amqpPort, honoConfig.getBindAddress(), bindAttempt -> { if (bindAttempt.succeeded()) { LOG.info("HonoServer secure port listening on [{}:{}]", getBindAddress(), getPort()); if (getPort() != Constants.PORT_AMQPS) LOG.warn("This is NOT the IANA standard port {}!", Constants.PORT_AMQPS); startSecurePortTracker.complete(); } else { LOG.error("cannot start up HonoServer (secure port failed) ", bindAttempt.cause()); startSecurePortTracker.fail(bindAttempt.cause()); } }); } else { startSecurePortTracker.complete(); } return startSecurePortTracker; }
private Future<Void> startSecureServer() { if (isSecurePortEnabled()) { final int securePort = determineSecurePort(); final Future<Void> result = Future.future(); final ProtonServerOptions options = createServerOptions(); server = createProtonServer(options) .connectHandler(this::onRemoteConnectionOpen) .listen(securePort, getConfig().getBindAddress(), bindAttempt -> { if (bindAttempt.succeeded()) { if (getPort() == getPortDefaultValue()) { LOG.info("server listens on standard secure port [{}:{}]", getBindAddress(), getPort()); } else { LOG.warn("server listens on non-standard secure port [{}:{}], default is {}", getBindAddress(), getPort(), getPortDefaultValue()); } result.complete(); } else { LOG.error("cannot bind to secure port", bindAttempt.cause()); result.fail(bindAttempt.cause()); } }); return result; } else { LOG.info("secure port is not enabled"); return Future.succeededFuture(); } }
private Future<Void> startInsecureServer() { if (isInsecurePortEnabled()) { final int insecurePort = determineInsecurePort(); final Future<Void> result = Future.future(); final ProtonServerOptions options = createInsecureServerOptions(); insecureServer = createProtonServer(options) .connectHandler(this::onRemoteConnectionOpenInsecurePort) .listen(insecurePort, getConfig().getInsecurePortBindAddress(), bindAttempt -> { if (bindAttempt.succeeded()) { if (getInsecurePort() == getInsecurePortDefaultValue()) { LOG.info("server listens on standard insecure port [{}:{}]", getInsecurePortBindAddress(), getInsecurePort()); } else { LOG.warn("server listens on non-standard insecure port [{}:{}], default is {}", getInsecurePortBindAddress(), getInsecurePort(), getInsecurePortDefaultValue()); } result.complete(); } else { LOG.error("cannot bind to insecure port", bindAttempt.cause()); result.fail(bindAttempt.cause()); } }); return result; } else { LOG.info("insecure port is not enabled"); return Future.succeededFuture(); } }
private Future<Void> startInsecureServer() { if (isInsecurePortEnabled()) { final int insecurePort = determineInsecurePort(); final Future<Void> result = Future.future(); final ProtonServerOptions options = createInsecureServerOptions(); insecureServer = createProtonServer(options) .connectHandler(this::onRemoteConnectionOpenInsecurePort) .listen(insecurePort, getConfig().getInsecurePortBindAddress(), bindAttempt -> { if (bindAttempt.succeeded()) { if (getInsecurePort() == getInsecurePortDefaultValue()) { LOG.info("server listens on standard insecure port [{}:{}]", getInsecurePortBindAddress(), getInsecurePort()); } else { LOG.warn("server listens on non-standard insecure port [{}:{}], default is {}", getInsecurePortBindAddress(), getInsecurePort(), getInsecurePortDefaultValue()); } result.complete(); } else { LOG.error("cannot bind to insecure port", bindAttempt.cause()); result.fail(bindAttempt.cause()); } }); return result; } else { LOG.info("insecure port is not enabled"); return Future.succeededFuture(); } }
private Future<Void> startSecureServer() { if (isSecurePortEnabled()) { final int securePort = determineSecurePort(); final Future<Void> result = Future.future(); final ProtonServerOptions options = createServerOptions(); server = createProtonServer(options) .connectHandler(this::onRemoteConnectionOpen) .listen(securePort, getConfig().getBindAddress(), bindAttempt -> { if (bindAttempt.succeeded()) { if (getPort() == getPortDefaultValue()) { LOG.info("server listens on standard secure port [{}:{}]", getBindAddress(), getPort()); } else { LOG.warn("server listens on non-standard secure port [{}:{}], default is {}", getBindAddress(), getPort(), getPortDefaultValue()); } result.complete(); } else { LOG.error("cannot bind to secure port", bindAttempt.cause()); result.fail(bindAttempt.cause()); } }); return result; } else { LOG.info("secure port is not enabled"); return Future.succeededFuture(); } }
private Future<Void> bindInsecureServer() { if (isInsecurePortEnabled()) { final ProtonServerOptions options = new ProtonServerOptions() .setHost(getConfig().getInsecurePortBindAddress()) .setPort(determineInsecurePort()) .setMaxFrameSize(getConfig().getMaxFrameSize()); final Future<Void> result = Future.future(); insecureServer = createServer(insecureServer, options); insecureServer.connectHandler(this::onConnectRequest).listen(ar -> { if (ar.succeeded()) { LOG.info("insecure AMQP server listening on [{}:{}]", getConfig().getInsecurePortBindAddress(), getActualInsecurePort()); result.complete(); } else { result.fail(ar.cause()); } }); return result; } else { return Future.succeededFuture(); } }
private Future<Void> bindSecureServer() { if (isSecurePortEnabled()) { final ProtonServerOptions options = new ProtonServerOptions() .setHost(getConfig().getBindAddress()) .setPort(determineSecurePort()) .setMaxFrameSize(getConfig().getMaxFrameSize()); addTlsKeyCertOptions(options); addTlsTrustOptions(options); final Future<Void> result = Future.future(); secureServer = createServer(secureServer, options); secureServer.connectHandler(this::onConnectRequest).listen(ar -> { if (ar.succeeded()) { LOG.info("secure AMQP server listening on {}:{}", getConfig().getBindAddress(), getActualPort()); result.complete(); } else { LOG.error("cannot bind to secure port", ar.cause()); result.fail(ar.cause()); } }); return result; } else { return Future.succeededFuture(); } }
public MockServer(Vertx vertx, Handler<ProtonConnection> connectionHandler, ProtonServerOptions protonServerOptions) throws ExecutionException, InterruptedException { if(protonServerOptions == null) { protonServerOptions = new ProtonServerOptions(); } protonServerOptions.setReuseAddress(reuseAddress); server = ProtonServer.create(vertx, protonServerOptions); server.connectHandler(connectionHandler); FutureHandler<ProtonServer, AsyncResult<ProtonServer>> handler = FutureHandler.asyncResult(); server.listen(bindPort, handler); handler.get(); }
server.connectHandler(this::connectHandler); LOG.info("Starting server on "+hostname+":"+ port); server.listen(port, hostname, event -> {