Examples with EndpointBuilder org.jboss.remoting3.EndpointBuilder used on opensource projects

Example 1 with EndpointBuilder

use of org.jboss.remoting3.EndpointBuilder in project jboss-remoting by jboss-remoting.

the class TimeOutConnectionTestCase method doTest.

private void doTest(OptionMap connectionProviderOptions) throws Exception {
    try (final ServerSocketChannel channel = ServerSocketChannel.open()) {
        channel.configureBlocking(true);
        channel.socket().bind(new InetSocketAddress("localhost", 30123));
        Thread acceptThread = new Thread(new Accept(channel));
        acceptThread.start();
        // create endpoint, auth provider, etc, create server
        final EndpointBuilder endpointBuilder = Endpoint.builder();
        final XnioWorker.Builder workerBuilder = endpointBuilder.buildXnioWorker(Xnio.getInstance());
        workerBuilder.setCoreWorkerPoolSize(4).setMaxWorkerPoolSize(4).setWorkerIoThreads(4);
        endpointBuilder.setEndpointName("test");
        try (Endpoint ep = endpointBuilder.build()) {
            endpoint = ep;
            final SecurityDomain.Builder domainBuilder = SecurityDomain.builder();
            final SimpleMapBackedSecurityRealm mainRealm = new SimpleMapBackedSecurityRealm();
            domainBuilder.addRealm("mainRealm", mainRealm);
            domainBuilder.setDefaultRealmName("mainRealm");
            final PasswordFactory passwordFactory = PasswordFactory.getInstance("clear");
            mainRealm.setPasswordMap("bob", passwordFactory.generatePassword(new ClearPasswordSpec("pass".toCharArray())));
            // create connect and close endpoint threads
            IoFuture<Connection> futureConnection = AuthenticationContext.empty().with(MatchRule.ALL, AuthenticationConfiguration.empty().useName("bob").usePassword("pass")).run(new PrivilegedAction<IoFuture<Connection>>() {

                public IoFuture<Connection> run() {
                    try {
                        return ep.connect(new URI("remote://localhost:30123"), OptionMap.EMPTY);
                    } catch (URISyntaxException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            assertEquals(Status.WAITING, futureConnection.await(500, TimeUnit.MILLISECONDS));
            ep.close();
            assertEquals(Status.CANCELLED, futureConnection.getStatus());
            acceptThread.join();
        } finally {
            endpoint = null;
        }
    }
}

Example 2 with EndpointBuilder

use of org.jboss.remoting3.EndpointBuilder in project jboss-ejb-client by wildfly.

the class DummyServer method start.

public void start() throws Exception {
    logger.info("Starting " + this);
    // create a Remoting endpoint
    final OptionMap options = OptionMap.EMPTY;
    EndpointBuilder endpointBuilder = Endpoint.builder();
    endpointBuilder.setEndpointName(this.endpointName);
    endpointBuilder.buildXnioWorker(Xnio.getInstance()).populateFromOptions(options);
    endpoint = endpointBuilder.build();
    if (startTxServer) {
        final RemotingTransactionService remotingTransactionService = RemotingTransactionService.builder().setEndpoint(endpoint).setTransactionContext(LocalTransactionContext.getCurrent()).build();
        remotingTransactionService.register();
    }
    // add a connection provider factory for the URI scheme "remote"
    // endpoint.addConnectionProvider("remote", new RemoteConnectionProviderFactory(), OptionMap.create(Options.SSL_ENABLED, Boolean.FALSE));
    final NetworkServerProvider serverProvider = endpoint.getConnectionProviderInterface("remote", NetworkServerProvider.class);
    // set up a security realm called default with a user called test
    final SimpleMapBackedSecurityRealm realm = new SimpleMapBackedSecurityRealm();
    realm.setPasswordMap("test", ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, "test".toCharArray()));
    // set up a security domain which has realm "default"
    final SecurityDomain.Builder domainBuilder = SecurityDomain.builder();
    // add the security realm called "default" to the security domain
    domainBuilder.addRealm("default", realm).build();
    domainBuilder.setDefaultRealmName("default");
    domainBuilder.setPermissionMapper((permissionMappable, roles) -> PermissionVerifier.ALL);
    SecurityDomain testDomain = domainBuilder.build();
    // set up a SaslAuthenticationFactory (i.e. a SaslServerFactory)
    SaslAuthenticationFactory saslAuthenticationFactory = SaslAuthenticationFactory.builder().setSecurityDomain(testDomain).setMechanismConfigurationSelector(mechanismInformation -> {
        switch(mechanismInformation.getMechanismName()) {
            case "ANONYMOUS":
            case "PLAIN":
                {
                    return MechanismConfiguration.EMPTY;
                }
            default:
                return null;
        }
    }).setFactory(SaslFactories.getElytronSaslServerFactory()).build();
    final OptionMap serverOptions = OptionMap.create(Options.SASL_MECHANISMS, Sequence.of("ANONYMOUS"), Options.SASL_POLICY_NOANONYMOUS, Boolean.FALSE);
    final SocketAddress bindAddress = new InetSocketAddress(InetAddress.getByName(host), port);
    this.server = serverProvider.createServer(bindAddress, serverOptions, saslAuthenticationFactory, null);
    // set up an association to handle invocations, session creations and module/toopology listensrs
    // the association makes use of a module deployment repository as well a sa  cluster registry
    Association dummyAssociation = new DummyAssociationImpl(this, deploymentRepository, clusterRegistry);
    // set up a remoting transaction service
    RemotingTransactionService.Builder txnServiceBuilder = RemotingTransactionService.builder();
    txnServiceBuilder.setEndpoint(endpoint);
    txnServiceBuilder.setTransactionContext(LocalTransactionContext.getCurrent());
    RemotingTransactionService transactionService = txnServiceBuilder.build();
    // setup remote EJB service
    RemoteEJBService remoteEJBService = RemoteEJBService.create(dummyAssociation, transactionService, DEFAULT_CLASS_FILTER);
    remoteEJBService.serverUp();
    // Register an EJB channel open listener
    OpenListener channelOpenListener = remoteEJBService.getOpenListener();
    try {
        registration = endpoint.registerService("jboss.ejb", new OpenListener() {

            @Override
            public void channelOpened(Channel channel) {
                currentConnections.add(channel);
                channelOpenListener.channelOpened(channel);
            }

            @Override
            public void registrationTerminated() {
            }
        }, OptionMap.EMPTY);
    } catch (ServiceRegistrationException e) {
        throw new Exception(e);
    }
}

Example 3 with EndpointBuilder

use of org.jboss.remoting3.EndpointBuilder in project wildfly-core by wildfly.

the class EndpointService method start.

/**
 * {@inheritDoc}
 */
public void start(final StartContext context) throws StartException {
    final Endpoint endpoint;
    final EndpointBuilder builder = Endpoint.builder();
    builder.setEndpointName(endpointName);
    builder.setXnioWorker(workerSupplier.get());
    try {
        endpoint = builder.build();
    } catch (IOException e) {
        throw RemotingLogger.ROOT_LOGGER.couldNotStart(e);
    }
    // Reuse the options for the remote connection factory for now
    this.endpoint = endpoint;
    endpointConsumer.accept(endpoint);
}

Example 4 with EndpointBuilder

use of org.jboss.remoting3.EndpointBuilder in project jboss-remoting by jboss-remoting.

the class EndpointImpl method construct.

static EndpointImpl construct(final EndpointBuilder endpointBuilder) throws IOException {
    final String endpointName = endpointBuilder.getEndpointName();
    final List<ConnectionProviderFactoryBuilder> factoryBuilders = endpointBuilder.getConnectionProviderFactoryBuilders();
    final EndpointImpl endpoint;
    OptionMap defaultConnectionOptionMap = endpointBuilder.getDefaultConnectionOptionMap();
    final List<ConnectionBuilder> connectionBuilders = endpointBuilder.getConnectionBuilders();
    final Map<URI, OptionMap> connectionOptions = new HashMap<>();
    if (connectionBuilders != null)
        for (ConnectionBuilder connectionBuilder : connectionBuilders) {
            final URI destination = connectionBuilder.getDestination();
            final OptionMap.Builder optionBuilder = OptionMap.builder();
            if (connectionBuilder.getHeartbeatInterval() != -1) {
                optionBuilder.set(RemotingOptions.HEARTBEAT_INTERVAL, connectionBuilder.getHeartbeatInterval());
            } else {
                optionBuilder.set(RemotingOptions.HEARTBEAT_INTERVAL, defaultConnectionOptionMap.get(RemotingOptions.HEARTBEAT_INTERVAL));
            }
            if (connectionBuilder.getReadTimeout() != -1) {
                optionBuilder.set(Options.READ_TIMEOUT, connectionBuilder.getReadTimeout());
            } else {
                optionBuilder.set(Options.READ_TIMEOUT, defaultConnectionOptionMap.get(Options.READ_TIMEOUT));
            }
            if (connectionBuilder.getWriteTimeout() != -1) {
                optionBuilder.set(Options.WRITE_TIMEOUT, connectionBuilder.getWriteTimeout());
            } else {
                optionBuilder.set(Options.WRITE_TIMEOUT, defaultConnectionOptionMap.get(Options.WRITE_TIMEOUT));
            }
            if (connectionBuilder.getIPTrafficClass() != -1) {
                optionBuilder.set(Options.IP_TRAFFIC_CLASS, connectionBuilder.getIPTrafficClass());
            }
            if (connectionBuilder.isSetTcpKeepAlive()) {
                optionBuilder.set(Options.KEEP_ALIVE, connectionBuilder.isTcpKeepAlive());
            } else {
                optionBuilder.set(Options.KEEP_ALIVE, defaultConnectionOptionMap.get(Options.KEEP_ALIVE));
            }
            connectionOptions.put(destination, optionBuilder.getMap());
        }
    XnioWorker xnioWorker = endpointBuilder.getXnioWorker();
    if (xnioWorker == null) {
        final XnioWorker.Builder workerBuilder = endpointBuilder.getWorkerBuilder();
        if (workerBuilder == null) {
            xnioWorker = XnioWorker.getContextManager().get();
            endpoint = new EndpointImpl(xnioWorker, false, endpointName, connectionOptions, defaultConnectionOptionMap);
        } else {
            final AtomicReference<EndpointImpl> endpointRef = new AtomicReference<EndpointImpl>();
            workerBuilder.setDaemon(true);
            workerBuilder.setWorkerName(endpointName == null ? "Remoting (anonymous)" : "Remoting \"" + endpointName + "\"");
            workerBuilder.setTerminationTask(() -> {
                final EndpointImpl e = endpointRef.getAndSet(null);
                if (e != null) {
                    e.closeComplete();
                }
            });
            xnioWorker = workerBuilder.build();
            endpointRef.set(endpoint = new EndpointImpl(xnioWorker, true, endpointName, connectionOptions.isEmpty() ? Collections.emptyMap() : connectionOptions, defaultConnectionOptionMap));
        }
    } else {
        endpoint = new EndpointImpl(xnioWorker, false, endpointName, connectionOptions.isEmpty() ? Collections.emptyMap() : connectionOptions, defaultConnectionOptionMap);
    }
    boolean ok = false;
    try {
        if (factoryBuilders != null)
            for (ConnectionProviderFactoryBuilder factoryBuilder : factoryBuilders) {
                final String className = factoryBuilder.getClassName();
                final String moduleName = factoryBuilder.getModuleName();
                final ClassLoader classLoader;
                if (moduleName != null) {
                    classLoader = ModuleLoader.getClassLoaderFromModule(moduleName);
                } else if (className == null) {
                    throw new IllegalArgumentException("Either class or module name required for connection provider factory");
                } else {
                    classLoader = EndpointImpl.class.getClassLoader();
                }
                if (className == null) {
                    final ServiceLoader<ConnectionProviderFactory> loader = ServiceLoader.load(ConnectionProviderFactory.class, classLoader);
                    for (ConnectionProviderFactory factory : loader) {
                        endpoint.addConnectionProvider(factoryBuilder.getScheme(), factory, OptionMap.EMPTY);
                        for (String alias : factoryBuilder.getAliases()) {
                            endpoint.addConnectionProvider(alias, factory, OptionMap.EMPTY);
                        }
                    }
                } else
                    try {
                        final Class<? extends ConnectionProviderFactory> factoryClass = classLoader.loadClass(className).asSubclass(ConnectionProviderFactory.class);
                        final ConnectionProviderFactory factory = factoryClass.newInstance();
                        endpoint.addConnectionProvider(factoryBuilder.getScheme(), factory, OptionMap.EMPTY);
                        for (String alias : factoryBuilder.getAliases()) {
                            endpoint.addConnectionProvider(alias, factory, OptionMap.EMPTY);
                        }
                    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                        throw new IllegalArgumentException("Unable to load connection provider factory class '" + className + "'", e);
                    }
            }
        // remote (SSL is explicit in URL)
        final RemoteConnectionProviderFactory remoteConnectionProviderFactory = new RemoteConnectionProviderFactory();
        endpoint.addConnectionProvider("remote", remoteConnectionProviderFactory, OptionMap.create(Options.SSL_ENABLED, Boolean.TRUE, Options.SSL_STARTTLS, Boolean.TRUE));
        endpoint.addConnectionProvider("remote+tls", remoteConnectionProviderFactory, OptionMap.create(Options.SECURE, Boolean.TRUE));
        // old (SSL is config-based)
        endpoint.addConnectionProvider("remoting", remoteConnectionProviderFactory, OptionMap.create(Options.SSL_ENABLED, Boolean.TRUE, Options.SSL_STARTTLS, Boolean.TRUE));
        // http - SSL is handled by the HTTP layer
        final HttpUpgradeConnectionProviderFactory httpUpgradeConnectionProviderFactory = new HttpUpgradeConnectionProviderFactory();
        endpoint.addConnectionProvider("remote+http", httpUpgradeConnectionProviderFactory, OptionMap.create(Options.SSL_ENABLED, Boolean.FALSE, Options.SSL_STARTTLS, Boolean.TRUE));
        endpoint.addConnectionProvider("remote+https", httpUpgradeConnectionProviderFactory, OptionMap.create(Options.SECURE, Boolean.TRUE));
        // old
        endpoint.addConnectionProvider("http-remoting", httpUpgradeConnectionProviderFactory, OptionMap.create(Options.SSL_ENABLED, Boolean.FALSE, Options.SSL_STARTTLS, Boolean.TRUE));
        endpoint.addConnectionProvider("https-remoting", httpUpgradeConnectionProviderFactory, OptionMap.create(Options.SECURE, Boolean.TRUE));
        ok = true;
        return endpoint;
    } finally {
        if (!ok)
            endpoint.closeAsync();
    }
}

Example 5 with EndpointBuilder

use of org.jboss.remoting3.EndpointBuilder in project jboss-ejb-client by wildfly.

the class RemotingLegacyConfiguration method getConfiguredEndpoint.

public Endpoint getConfiguredEndpoint() {
    final JBossEJBProperties properties = JBossEJBProperties.getCurrent();
    if (properties == null) {
        return null;
    }
    Logs.MAIN.legacyEJBPropertiesRemotingConfigurationInUse();
    final EndpointBuilder endpointBuilder = Endpoint.builder();
    final String endpointName = properties.getEndpointName();
    if (endpointName != null) {
        endpointBuilder.setEndpointName(endpointName);
    }
    OptionMap endpointCreationOptions = properties.getEndpointCreationOptions();
    if (endpointCreationOptions != null && endpointCreationOptions.size() > 0) {
        if (!endpointCreationOptions.contains(Options.THREAD_DAEMON)) {
            endpointCreationOptions = OptionMap.builder().addAll(endpointCreationOptions).set(Options.THREAD_DAEMON, true).getMap();
        }
        endpointBuilder.buildXnioWorker(Xnio.getInstance()).populateFromOptions(endpointCreationOptions);
    }
    final List<JBossEJBProperties.ConnectionConfiguration> connectionList = properties.getConnectionList();
    List<URI> uris = new ArrayList<URI>();
    for (JBossEJBProperties.ConnectionConfiguration connectionConfiguration : connectionList) {
        final OptionMap connectionOptions = connectionConfiguration.getConnectionOptions();
        final URI uri = CommonLegacyConfiguration.getUri(connectionConfiguration, connectionOptions);
        if (uri == null) {
            continue;
        }
        if (connectionConfiguration.isConnectEagerly()) {
            uris.add(uri);
        }
        final ConnectionBuilder connectionBuilder = endpointBuilder.addConnection(uri);
        connectionBuilder.setHeartbeatInterval(connectionOptions.get(RemotingOptions.HEARTBEAT_INTERVAL, RemotingOptions.DEFAULT_HEARTBEAT_INTERVAL));
        if (connectionOptions.get(Options.READ_TIMEOUT, -1) != -1) {
            connectionBuilder.setReadTimeout(connectionOptions.get(Options.READ_TIMEOUT, -1));
        }
        if (connectionOptions.get(Options.WRITE_TIMEOUT, -1) != -1) {
            connectionBuilder.setWriteTimeout(connectionOptions.get(Options.WRITE_TIMEOUT, -1));
        }
        connectionBuilder.setTcpKeepAlive(connectionOptions.get(Options.KEEP_ALIVE, false));
    }
    final Endpoint endpoint;
    try {
        endpoint = endpointBuilder.build();
    } catch (IOException e) {
        throw Logs.MAIN.failedToConstructEndpoint(e);
    }
    for (URI uri : uris) {
        endpoint.getConnection(uri, "ejb", "jboss");
    }
    return endpoint;
}