@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(); } }); }
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(); } }
server = ProtonServer.create(vertx, options); server.saslAuthenticatorFactory(() -> new SaslAuthenticator(keycloakSessionFactory, config, useTls, this)); server.connectHandler(this::connectHandler); LOG.info("Starting server on "+hostname+":"+ port); server.listen(port, hostname, event -> { if(event.failed())
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(); }
private ProtonServer createProtonServer(final ProtonServerOptions options) { return ProtonServer.create(vertx, options) .saslAuthenticatorFactory(saslAuthenticatorFactory); }
@Override public void stop() { if (server != null) { server.close(); } }
/** * {@inheritDoc} */ @Override protected int getActualPort() { return secureServer != null ? secureServer.actualPort() : Constants.PORT_UNCONFIGURED; }
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 ProtonServer createProtonServer(ProtonServerOptions options) { return ProtonServer.create(vertx, options) .saslAuthenticatorFactory(saslAuthenticatorFactory); }
@Override public void stop() { if (server != null) { server.close(); } }
/** * {@inheritDoc} */ @Override protected int getActualInsecurePort() { return insecureServer != null ? insecureServer.actualPort() : Constants.PORT_UNCONFIGURED; }
@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 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 ProtonServer createProtonServer(final ProtonServerOptions options) { return ProtonServer.create(vertx, options) .saslAuthenticatorFactory(saslAuthenticatorFactory); }
@Override public void stop(Future<Void> shutdownHandler) { if (server != null) { server.close(done -> { LOG.info("HonoServer has been shut down"); shutdownHandler.complete(); }); } else { LOG.info("HonoServer has been already shut down"); shutdownHandler.complete(); } }
public int port() { if (server == null) { return 0; } return server.actualPort(); }
/** * 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> 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 ProtonServer createServer(final ProtonServer server, final ProtonServerOptions options) { final ProtonServer createdServer = (server != null) ? server : ProtonServer.create(this.vertx, options); if (getConfig().isAuthenticationRequired()) { createdServer.saslAuthenticatorFactory(authenticatorFactory); } else { // use proton's default authenticator -> SASL ANONYMOUS createdServer.saslAuthenticatorFactory(null); } return createdServer; }
public void close() { server.close(); }