/** * Returns a new {@link LocalClientTransport} that is connected to this {@code * LocalServerTransport}. * * @return a new {@link LocalClientTransport} that is connected to this {@code * LocalServerTransport} */ public LocalClientTransport clientTransport() { return LocalClientTransport.create(name); }
/** * Creates an instance. * * @param name the name of this {@link ServerTransport} that clients will connect to * @return a new instance * @throws NullPointerException if {@code name} is {@code null} */ public static LocalServerTransport create(String name) { Objects.requireNonNull(name, "name must not be null"); return new LocalServerTransport(name); }
/** * Creates a new instance. * * @param name the name of the {@link ServerTransport} instance to connect to * @return a new instance * @throws NullPointerException if {@code name} is {@code null} */ public static LocalClientTransport create(String name) { Objects.requireNonNull(name, "name must not be null"); return new LocalClientTransport(name); }
@Override public Mono<DuplexConnection> connect() { return Mono.defer( () -> { ServerDuplexConnectionAcceptor server = LocalServerTransport.findServer(name); if (server == null) { return Mono.error(new IllegalArgumentException("Could not find server: " + name)); } UnicastProcessor<Frame> in = UnicastProcessor.create(); UnicastProcessor<Frame> out = UnicastProcessor.create(); MonoProcessor<Void> closeNotifier = MonoProcessor.create(); server.accept(new LocalDuplexConnection(out, in, closeNotifier)); return Mono.just((DuplexConnection) new LocalDuplexConnection(in, out, closeNotifier)); }); } }
@DisplayName("connects to server") @Test void connect() { LocalServerTransport serverTransport = LocalServerTransport.createEphemeral(); serverTransport .start(duplexConnection -> Mono.empty()) .flatMap(closeable -> LocalClientTransport.create(serverTransport.getName()).connect()) .as(StepVerifier::create) .expectNextCount(1) .verifyComplete(); }
@DisplayName("returns the configured name") @Test void name() { assertThat(new LocalSocketAddress("test-name").getName()).isEqualTo("test-name"); } }
/** * Creates an instance with a random name. * * @return a new instance with a random name */ public static LocalServerTransport createEphemeral() { return create(UUID.randomUUID().toString()); }
/** * Creates a new instance * * @param name the name of the server * @param acceptor the {@link ConnectionAcceptor} to call when the server has been created * @throws NullPointerException if {@code name} or {@code acceptor} is {@code null} */ ServerDuplexConnectionAcceptor(String name, ConnectionAcceptor acceptor) { Objects.requireNonNull(name, "name must not be null"); this.address = new LocalSocketAddress(name); this.acceptor = Objects.requireNonNull(acceptor, "acceptor must not be null"); }
@Override public void dispose() { if (!registry.remove(address.getName(), this)) { throw new AssertionError(); } onClose.onComplete(); }
@DisplayName("returns null if server hasn't been started") @Test void findServerMissingName() { assertThat(LocalServerTransport.findServer("test-name")).isNull(); }
@DisplayName("creates transports with ephemeral names") @Test void ephemeral() { LocalServerTransport serverTransport1 = LocalServerTransport.createEphemeral(); LocalServerTransport serverTransport2 = LocalServerTransport.createEphemeral(); assertThat(serverTransport1.getName()).isNotEqualTo(serverTransport2.getName()); }
@DisplayName("starts local server transport") @Test void start() { LocalServerTransport.createEphemeral() .start(duplexConnection -> Mono.empty()) .as(StepVerifier::create) .expectNextCount(1) .verifyComplete(); }
@Override public UriHandler getUriHandler() { return new LocalUriHandler(); }
@DisplayName("dispose removes name from registry") @Test void dispose() { LocalServerTransport.dispose("test-name"); }
@Override public Optional<ClientTransport> buildClient(URI uri) { Objects.requireNonNull(uri, "uri must not be null"); if (!SCHEME.equals(uri.getScheme())) { return Optional.empty(); } return Optional.of(LocalClientTransport.create(uri.getSchemeSpecificPart())); }
@Override public Optional<ServerTransport> buildServer(URI uri) { Objects.requireNonNull(uri, "uri must not be null"); if (!SCHEME.equals(uri.getScheme())) { return Optional.empty(); } return Optional.of(LocalServerTransport.create(uri.getSchemeSpecificPart())); } }
@DisplayName("creates client") @Test void create() { assertThat(LocalClientTransport.create("test-name")).isNotNull(); }
@DisplayName("throws NullPointerException with null name") @Test void createNullName() { assertThatNullPointerException() .isThrownBy(() -> LocalClientTransport.create(null)) .withMessage("name must not be null"); } }