@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 ProtonServer createProtonServer(ProtonServerOptions options) { return ProtonServer.create(vertx, options) .saslAuthenticatorFactory(saslAuthenticatorFactory); }
private ProtonServer createProtonServer(final ProtonServerOptions options) { return ProtonServer.create(vertx, options) .saslAuthenticatorFactory(saslAuthenticatorFactory); }
private ProtonServer createProtonServer(final ProtonServerOptions options) { return ProtonServer.create(vertx, options) .saslAuthenticatorFactory(saslAuthenticatorFactory); }
@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()); } }); }
/** * 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 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 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 = ProtonServer.create(vertx, options);