Examples with SinglePortRouterConfiguration org.infinispan.server.router.configuration.SinglePortRouterConfiguration used on opensource projects

Example 1 with SinglePortRouterConfiguration

use of org.infinispan.server.router.configuration.SinglePortRouterConfiguration in project infinispan by infinispan.

the class Server method run.

public synchronized CompletableFuture<ExitStatus> run() {
    CompletableFuture<ExitStatus> r = exitHandler.getExitFuture();
    if (status == ComponentStatus.RUNNING) {
        return r;
    }
    protocolServers = new ConcurrentHashMap<>(4);
    try {
        // Load any server extensions
        extensions = new Extensions();
        extensions.load(classLoader);
        // Create the cache manager
        cacheManager = new DefaultCacheManager(configurationBuilderHolder, false);
        // Retrieve the server configuration
        serverConfiguration = SecurityActions.getCacheManagerConfiguration(cacheManager).module(ServerConfiguration.class);
        serverConfiguration.setServer(this);
        // Initialize the data sources
        dataSources = new HashMap<>();
        InitialContext initialContext = new InitialContext();
        for (DataSourceConfiguration dataSourceConfiguration : serverConfiguration.dataSources().values()) {
            DataSource dataSource = DataSourceFactory.create(dataSourceConfiguration);
            dataSources.put(dataSourceConfiguration.name(), dataSource);
            initialContext.bind(dataSourceConfiguration.jndiName(), dataSource);
        }
        // Start the cache manager
        SecurityActions.startCacheManager(cacheManager);
        BasicComponentRegistry bcr = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(BasicComponentRegistry.class.getName());
        blockingManager = bcr.getComponent(BlockingManager.class).running();
        serverStateManager = new ServerStateManagerImpl(this, cacheManager, bcr.getComponent(GlobalConfigurationManager.class).running());
        bcr.registerComponent(ServerStateManager.class, serverStateManager, false);
        ScheduledExecutorService timeoutExecutor = bcr.getComponent(KnownComponentNames.TIMEOUT_SCHEDULE_EXECUTOR, ScheduledExecutorService.class).running();
        // BlockingManager of single container used for writing the global manifest, but this will need to change
        // when multiple containers are supported by the server. Similarly, the default cache manager is used to create
        // the clustered locks.
        Path dataRoot = serverRoot.toPath().resolve(properties.getProperty(INFINISPAN_SERVER_DATA_PATH));
        backupManager = new BackupManagerImpl(blockingManager, cacheManager, dataRoot);
        backupManager.init();
        // Register the task manager
        taskManager = bcr.getComponent(TaskManager.class).running();
        taskManager.registerTaskEngine(extensions.getServerTaskEngine(cacheManager));
        // Initialize the OpenTracing integration
        RequestTracer.start();
        for (EndpointConfiguration endpoint : serverConfiguration.endpoints().endpoints()) {
            // Start the protocol servers
            SinglePortRouteSource routeSource = new SinglePortRouteSource();
            Set<Route<? extends RouteSource, ? extends RouteDestination>> routes = ConcurrentHashMap.newKeySet();
            endpoint.connectors().parallelStream().forEach(configuration -> {
                try {
                    Class<? extends ProtocolServer> protocolServerClass = configuration.getClass().getAnnotation(ConfigurationFor.class).value().asSubclass(ProtocolServer.class);
                    ProtocolServer protocolServer = Util.getInstance(protocolServerClass);
                    protocolServer.setServerManagement(this, endpoint.admin());
                    if (configuration instanceof HotRodServerConfiguration) {
                        ElytronSASLAuthenticationProvider.init((HotRodServerConfiguration) configuration, serverConfiguration, timeoutExecutor);
                    } else if (configuration instanceof RestServerConfiguration) {
                        ElytronHTTPAuthenticator.init((RestServerConfiguration) configuration, serverConfiguration);
                    } else if (configuration instanceof RespServerConfiguration) {
                        ElytronRESPAuthenticator.init((RespServerConfiguration) configuration, serverConfiguration, blockingManager);
                    }
                    protocolServers.put(protocolServer.getName() + "-" + configuration.name(), protocolServer);
                    SecurityActions.startProtocolServer(protocolServer, configuration, cacheManager);
                    ProtocolServerConfiguration protocolConfig = protocolServer.getConfiguration();
                    if (protocolConfig.startTransport()) {
                        log.protocolStarted(protocolServer.getName(), configuration.socketBinding(), protocolConfig.host(), protocolConfig.port());
                    } else {
                        if (protocolServer instanceof HotRodServer) {
                            routes.add(new Route<>(routeSource, new HotRodServerRouteDestination(protocolServer.getName(), (HotRodServer) protocolServer)));
                            extensions.apply((HotRodServer) protocolServer);
                        } else if (protocolServer instanceof RestServer) {
                            routes.add(new Route<>(routeSource, new RestServerRouteDestination(protocolServer.getName(), (RestServer) protocolServer)));
                        } else if (protocolServer instanceof RespServer) {
                            routes.add(new Route<>(routeSource, new RespServerRouteDestination(protocolServer.getName(), (RespServer) protocolServer)));
                        }
                        log.protocolStarted(protocolServer.getName());
                    }
                } catch (Throwable t) {
                    throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
                }
            });
            // Next we start the single-port endpoints
            SinglePortRouterConfiguration singlePortRouter = endpoint.singlePortRouter();
            SinglePortEndpointRouter endpointServer = new SinglePortEndpointRouter(singlePortRouter);
            endpointServer.start(new RoutingTable(routes), cacheManager);
            protocolServers.put("endpoint-" + endpoint.socketBinding(), endpointServer);
            log.protocolStarted(endpointServer.getName(), singlePortRouter.socketBinding(), singlePortRouter.host(), singlePortRouter.port());
            log.endpointUrl(Util.requireNonNullElse(cacheManager.getAddress(), "local"), singlePortRouter.ssl().enabled() ? "https" : "http", singlePortRouter.host(), singlePortRouter.port());
        }
        serverStateManager.start();
        // Change status
        this.status = ComponentStatus.RUNNING;
        log.serverStarted(Version.getBrandName(), Version.getBrandVersion(), timeService.timeDuration(startTime, TimeUnit.MILLISECONDS));
    } catch (Exception e) {
        r.completeExceptionally(e);
    }
    r = r.handle((status, t) -> {
        if (t != null) {
            Server.log.serverFailedToStart(Version.getBrandName(), t);
        }
        localShutdown(status);
        return null;
    });
    return r;
}

Example 2 with SinglePortRouterConfiguration

use of org.infinispan.server.router.configuration.SinglePortRouterConfiguration in project infinispan by infinispan.

the class SinglePortRouterBuilder method build.

/**
 * Builds {@link HotRodRouterConfiguration}.
 */
public SinglePortRouterConfiguration build() {
    if (this.enabled) {
        try {
            validate();
        } catch (Exception e) {
            throw RouterLogger.SERVER.configurationValidationError(e);
        }
        SslConfigurationBuilder sslConfigurationBuilder = new SslConfigurationBuilder(null);
        if (sslContext != null) {
            sslConfigurationBuilder.sslContext(sslContext).enable();
        }
        AttributeSet attributes = SinglePortRouterConfiguration.attributeDefinitionSet();
        attributes.attribute(ProtocolServerConfiguration.NAME).set(name);
        attributes.attribute(ProtocolServerConfiguration.HOST).set(ip.getHostName());
        attributes.attribute(ProtocolServerConfiguration.PORT).set(port);
        attributes.attribute(ProtocolServerConfiguration.IDLE_TIMEOUT).set(100);
        attributes.attribute(ProtocolServerConfiguration.RECV_BUF_SIZE).set(receiveBufferSize);
        attributes.attribute(ProtocolServerConfiguration.SEND_BUF_SIZE).set(sendBufferSize);
        return new SinglePortRouterConfiguration(attributes.protect(), sslConfigurationBuilder.create(), new IpFilterConfiguration(Collections.emptyList()));
    }
    return null;
}

Example 3 with SinglePortRouterConfiguration

use of org.infinispan.server.router.configuration.SinglePortRouterConfiguration in project keycloak by keycloak.

the class HotRodUtils method createHotRodMapStoreServer.

/**
 * Not suitable for a production usage. Only for development and test purposes.
 * Also do not use in clustered environment.
 * @param hotRodServer HotRodServer
 * @param hotRodCacheManager DefaultCacheManager
 * @param embeddedPort int
 */
public static void createHotRodMapStoreServer(HotRodServer hotRodServer, DefaultCacheManager hotRodCacheManager, int embeddedPort) {
    HotRodServerConfigurationBuilder hotRodServerConfigurationBuilder = new HotRodServerConfigurationBuilder();
    hotRodServerConfigurationBuilder.startTransport(false);
    hotRodServerConfigurationBuilder.port(embeddedPort);
    hotRodServer.start(hotRodServerConfigurationBuilder.build(), hotRodCacheManager);
    RestServerConfigurationBuilder restServerConfigurationBuilder = new RestServerConfigurationBuilder();
    restServerConfigurationBuilder.startTransport(false);
    restServerConfigurationBuilder.port(embeddedPort);
    RestServer restServer = new RestServer();
    restServer.start(restServerConfigurationBuilder.build(), hotRodCacheManager);
    SinglePortRouteSource routeSource = new SinglePortRouteSource();
    Set<Route<? extends RouteSource, ? extends RouteDestination>> routes = new HashSet<>();
    routes.add(new Route<>(routeSource, new HotRodServerRouteDestination("hotrod", hotRodServer)));
    routes.add(new Route<>(routeSource, new RestServerRouteDestination("rest", restServer)));
    SinglePortRouterConfiguration singlePortRouter = new SinglePortServerConfigurationBuilder().port(embeddedPort).build();
    SinglePortEndpointRouter endpointServer = new SinglePortEndpointRouter(singlePortRouter);
    endpointServer.start(new RoutingTable(routes));
}

Example 4 with SinglePortRouterConfiguration

use of org.infinispan.server.router.configuration.SinglePortRouterConfiguration in project infinispan by infinispan.

the class ServerConfigurationParserTest method validateConfiguration.

private void validateConfiguration(ServerConfiguration configuration) {
    // Interfaces
    assertEquals(2, configuration.networkInterfaces().size());
    NetworkAddress defaultInterface = configuration.networkInterfaces().get("default").getNetworkAddress();
    assertNotNull(defaultInterface);
    assertTrue(defaultInterface.getAddress().isLoopbackAddress());
    // Socket bindings
    Map<String, SocketBindingConfiguration> socketBindings = configuration.socketBindings();
    assertEquals(5, socketBindings.size());
    assertEquals(11221, socketBindings.get("memcached").port());
    assertEquals(12221, socketBindings.get("memcached-2").port());
    assertEquals(11222, socketBindings.get("default").port());
    assertEquals(11223, socketBindings.get("hotrod").port());
    assertEquals(8080, socketBindings.get("rest").port());
    // Security realms
    Map<String, RealmConfiguration> realms = configuration.security().realms().realms();
    assertEquals(3, realms.size());
    RealmConfiguration realmConfiguration = realms.get("default");
    assertEquals("default", realmConfiguration.name());
    realmConfiguration = realms.get("using-credentials");
    assertEquals("using-credentials", realmConfiguration.name());
    // Data Sources
    Map<String, DataSourceConfiguration> dataSources = configuration.dataSources();
    assertEquals(2, dataSources.size());
    DataSourceConfiguration dataSource = dataSources.get("database");
    assertEquals("jdbc/database", dataSource.jndiName());
    assertEquals("jdbc:h2:tcp://${org.infinispan.test.host.address}:1521/test", dataSource.url());
    assertEquals("test", dataSource.username());
    assertEquals("test", new String(dataSource.password()));
    assertEquals("SELECT 1", dataSource.initialSql());
    assertEquals("org.h2.Driver", dataSource.driver());
    assertEquals(10, dataSource.maxSize());
    assertEquals(1, dataSource.minSize());
    assertEquals(1, dataSource.initialSize());
    assertEquals(1, dataSource.connectionProperties().size());
    assertEquals(10000, dataSource.leakDetection());
    assertEquals(1000, dataSource.backgroundValidation());
    assertEquals(500, dataSource.validateOnAcquisition());
    assertEquals("somevalue", dataSource.connectionProperties().get("someproperty"));
    dataSource = dataSources.get("database-with-credential");
    assertEquals("test", new String(dataSource.password()));
    // Connectors
    List<ProtocolServerConfiguration> connectors = configuration.endpoints().endpoints().get(0).connectors();
    assertEquals(3, connectors.size());
    assertTrue(connectors.get(0) instanceof HotRodServerConfiguration);
    assertTrue(connectors.get(1) instanceof RestServerConfiguration);
    assertTrue(connectors.get(2) instanceof MemcachedServerConfiguration);
    // Ensure endpoints are bound to the interfaces
    SinglePortRouterConfiguration singlePortRouter = configuration.endpoints().endpoints().get(0).singlePortRouter();
    assertEquals(socketBindings.get("default").interfaceConfiguration().getNetworkAddress().getAddress().getHostAddress(), singlePortRouter.host());
    assertEquals(socketBindings.get("default").port(), singlePortRouter.port());
    assertEquals(socketBindings.get("memcached").port(), configuration.endpoints().endpoints().get(0).connectors().get(2).port());
    assertEquals("strongPassword", new String(((Supplier<char[]>) realmProvider(realmConfiguration, LdapRealmConfiguration.class).attributes().attribute(Attribute.CREDENTIAL).get()).get()));
    assertEquals("secret", new String(((Supplier<char[]>) realmConfiguration.serverIdentitiesConfiguration().sslConfiguration().trustStore().attributes().attribute(Attribute.PASSWORD).get()).get()));
    assertEquals("1fdca4ec-c416-47e0-867a-3d471af7050f", new String(((Supplier<char[]>) realmProvider(realmConfiguration, TokenRealmConfiguration.class).oauth2Configuration().attributes().attribute(Attribute.CLIENT_SECRET).get()).get()));
}