use of org.infinispan.server.router.routes.Route 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;
}
use of org.infinispan.server.router.routes.Route in project infinispan by infinispan.
the class SniRouteHandler method decode.
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
super.decode(ctx, in, out);
if (isHandShaked()) {
// At this point Netty has replaced SNIHandler (formally this) with SSLHandler in the pipeline.
// Now we need to add other handlers at the tail of the queue
RouterLogger.SERVER.debugf("Handshaked with hostname %s", hostname());
Optional<Route<SniRouteSource, HotRodServerRouteDestination>> route = routingTable.streamRoutes(SniRouteSource.class, HotRodServerRouteDestination.class).filter(r -> r.getRouteSource().getSniHostName().equals(this.hostname())).findAny();
HotRodServerRouteDestination routeDestination = route.orElseThrow(() -> RouterLogger.SERVER.noRouteFound()).getRouteDestination();
ChannelInitializer<Channel> channelInitializer = routeDestination.getProtocolServer().getInitializer();
ctx.pipeline().addLast(channelInitializer);
RouterLogger.SERVER.debug("Replaced with route destination's handlers");
}
}
use of org.infinispan.server.router.routes.Route in project infinispan by infinispan.
the class ChannelInboundHandlerDelegator method channelRead0.
@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) {
String[] uriSplitted = msg.uri().split("/");
// we are paring something like this: /rest/<context or prefix>/...
if (uriSplitted.length < 2) {
throw RouterLogger.SERVER.noRouteFound();
}
String context = uriSplitted[2];
RouterLogger.SERVER.debugf("Decoded context %s", context);
Optional<Route<PrefixedRouteSource, RestServerRouteDestination>> route = routingTable.streamRoutes(PrefixedRouteSource.class, RestServerRouteDestination.class).filter(r -> r.getRouteSource().getRoutePrefix().equals(context)).findAny();
RestServerRouteDestination routeDestination = route.orElseThrow(RouterLogger.SERVER::noRouteFound).getRouteDestination();
RestRequestHandler restHandler = (RestRequestHandler) routeDestination.getProtocolServer().getRestChannelInitializer().getRestHandler();
// before passing it to REST Handler, we need to replace path. The handler should not be aware of additional context
// used for multi-tenant prefixes
StringBuilder uriWithoutMultiTenantPrefix = new StringBuilder();
for (int i = 0; i < uriSplitted.length; ++i) {
if (i == 1) {
// this is the main uri prefix - "rest", we want to get rid of that.
continue;
}
uriWithoutMultiTenantPrefix.append(uriSplitted[i]);
if (i < uriSplitted.length - 1) {
uriWithoutMultiTenantPrefix.append("/");
}
}
msg.setUri(uriWithoutMultiTenantPrefix.toString());
restHandler.channelRead0(ctx, msg);
}
use of org.infinispan.server.router.routes.Route in project infinispan by infinispan.
the class ConfigurationTest method shouldBuildProperRouterConfiguration.
@Test
public void shouldBuildProperRouterConfiguration() {
// given
RouterConfigurationBuilder multiTenantConfigurationBuilder = new RouterConfigurationBuilder();
RouteSource s1 = new RouteSource() {
};
RouteDestination d1 = () -> null;
// when
multiTenantConfigurationBuilder.hotrod().tcpKeepAlive(true).receiveBufferSize(1).sendBufferSize(1).tcpNoDelay(false).port(1010).ip(InetAddress.getLoopbackAddress()).rest().port(1111).ip(InetAddress.getLoopbackAddress()).routing().add(new Route(s1, d1));
RouterConfiguration routerConfiguration = multiTenantConfigurationBuilder.build();
HotRodRouterConfiguration hotRodRouterConfiguration = routerConfiguration.hotRodRouter();
RestRouterConfiguration restRouterConfiguration = routerConfiguration.restRouter();
// then
assertThat(hotRodRouterConfiguration.getPort()).isEqualTo(1010);
assertThat(hotRodRouterConfiguration.getIp()).isEqualTo(InetAddress.getLoopbackAddress());
assertThat(hotRodRouterConfiguration.tcpKeepAlive()).isTrue();
assertThat(hotRodRouterConfiguration.tcpNoDelay()).isFalse();
assertThat(hotRodRouterConfiguration.sendBufferSize()).isEqualTo(1);
assertThat(hotRodRouterConfiguration.receiveBufferSize()).isEqualTo(1);
assertThat(restRouterConfiguration.getPort()).isEqualTo(1111);
assertThat(restRouterConfiguration.getIp()).isEqualTo(InetAddress.getLoopbackAddress());
assertThat(routerConfiguration.routingTable().routesCount()).isEqualTo(1);
}
use of org.infinispan.server.router.routes.Route in project infinispan by infinispan.
the class ProtocolServerEndpointRouterTest method shouldRouteToProperHotRodServerBasedOnSniHostName.
/**
* In this scenario we create 2 HotRod servers, each one with different credentials and SNI name. We also create a
* new client for each server. The clients use proper TrustStores as well as SNI names.
* <p>
* The router should match properly SNI based routes and connect clients to proper server instances.
*/
@Test
public void shouldRouteToProperHotRodServerBasedOnSniHostName() {
// given
hotrodServer1 = HotRodTestingUtil.startHotRodServerWithoutTransport("default");
hotrodServer2 = HotRodTestingUtil.startHotRodServerWithoutTransport("default");
HotRodServerRouteDestination hotrod1Destination = new HotRodServerRouteDestination("HotRod1", hotrodServer1);
SniNettyRouteSource hotrod1Source = new SniNettyRouteSource("hotrod1", KEYSTORE_LOCATION_FOR_HOTROD_1, "secret".toCharArray());
Route<SniNettyRouteSource, HotRodServerRouteDestination> routeToHotrod1 = new Route<>(hotrod1Source, hotrod1Destination);
HotRodServerRouteDestination hotrod2Destination = new HotRodServerRouteDestination("HotRod2", hotrodServer2);
SniNettyRouteSource hotrod2Source = new SniNettyRouteSource("hotrod2", KEYSTORE_LOCATION_FOR_HOTROD_2, "secret".toCharArray());
Route<SniNettyRouteSource, HotRodServerRouteDestination> routeToHotrod2 = new Route<>(hotrod2Source, hotrod2Destination);
RouterConfigurationBuilder routerConfigurationBuilder = new RouterConfigurationBuilder();
routerConfigurationBuilder.hotrod().port(0).ip(InetAddress.getLoopbackAddress()).routing().add(routeToHotrod1).add(routeToHotrod2);
router = new Router(routerConfigurationBuilder.build());
router.start();
InetAddress routerIp = router.getRouter(EndpointRouter.Protocol.HOT_ROD).get().getIp();
int routerPort = router.getRouter(EndpointRouter.Protocol.HOT_ROD).get().getPort();
// when
hotrod1Client = HotRodClientTestingUtil.createWithSni(routerIp, routerPort, "hotrod1", TRUSTSTORE_LOCATION_FOR_HOTROD_1, "secret".toCharArray());
hotrod2Client = HotRodClientTestingUtil.createWithSni(routerIp, routerPort, "hotrod2", TRUSTSTORE_LOCATION_FOR_HOTROD_2, "secret".toCharArray());
hotrod1Client.getCache("default").put("test", "hotrod1");
hotrod2Client.getCache("default").put("test", "hotrod2");
// then
Cache<String, String> hotrod1Cache = hotrodServer1.getCacheManager().getCache("default");
Cache<String, String> hotrod2Cache = hotrodServer2.getCacheManager().getCache("default");
assertThat(hotrod1Cache.size()).isEqualTo(1);
assertThat(hotrod2Cache.size()).isEqualTo(1);
assertThat(hotrod1Cache.get("test")).isEqualTo("hotrod1");
assertThat(hotrod2Cache.get("test")).isEqualTo("hotrod2");
}
Aggregations