@Override public <T extends Service<HttpRequest, HttpResponse>> T service() { return cfg.service(); }
private static boolean isSupported( ServiceConfig serviceCfg, Set<Class<? extends Service<?, ?>>> supportedServiceTypes) { return supportedServiceTypes.stream().anyMatch(type -> serviceCfg.service().as(type).isPresent()); }
@Override public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) { return serviceConfigs.stream() .flatMap(c -> c.service().as(GrpcService.class).get().services().stream()) .flatMap(s -> docstringExtractor.getAllDocStrings(s.getClass().getClassLoader()) .entrySet().stream()) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a)); }
@Override public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) { return serviceConfigs.stream() .flatMap(c -> c.service().as(THttpService.class).get().entries().values().stream()) .flatMap(entry -> entry.interfaces().stream().map(Class::getClassLoader)) .flatMap(loader -> docstringExtractor.getAllDocStrings(loader) .entrySet().stream()) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a)); }
ServiceConfig build(VirtualHost virtualHost) { requireNonNull(virtualHost, "virtualHost"); return new ServiceConfig(virtualHost, pathMapping(), service()); }
/** * Finds the {@link List} of {@link VirtualHost}s that contains the specified {@link Service}. If there's * no match, an empty {@link List} is returned. Note that this is potentially an expensive operation and * thus should not be used in a performance-sensitive path. */ public List<VirtualHost> findVirtualHosts(Service<?, ?> service) { requireNonNull(service, "service"); @SuppressWarnings("rawtypes") final Class<? extends Service> serviceType = service.getClass(); final List<VirtualHost> res = new ArrayList<>(); for (VirtualHost h : virtualHosts) { for (ServiceConfig c : h.serviceConfigs()) { // Consider the case where the specified service is decorated before being added. final Service<?, ?> s = c.service(); @SuppressWarnings("rawtypes") final Optional<? extends Service> sOpt = s.as(serviceType); if (!sOpt.isPresent()) { continue; } if (sOpt.get() == service) { res.add(c.virtualHost()); break; } } } return res; }
private static ServiceConfig findServiceConfig(Server server, String path, Service<?, ?> service) { for (ServiceConfig cfg : server.config().defaultVirtualHost().serviceConfigs()) { final Optional<String> exactPath = cfg.pathMapping().exactPath(); if (!exactPath.isPresent()) { continue; } if (!path.equals(exactPath.get())) { continue; } if (cfg.service().as(service.getClass()).isPresent()) { return cfg; } } throw new Error(); // Never reaches here. } }
@Override public ServiceSpecification generateSpecification(Set<ServiceConfig> serviceConfigs) { requireNonNull(serviceConfigs, "serviceConfigs"); final Map<Class<?>, Set<MethodInfo>> methodInfos = new HashMap<>(); final Map<Class<?>, String> serviceDescription = new HashMap<>(); serviceConfigs.forEach(sc -> { final Optional<AnnotatedHttpService> service = sc.service().as(AnnotatedHttpService.class); service.ifPresent( httpService -> { addMethodInfo(methodInfos, sc.virtualHost().hostnamePattern(), httpService); addServiceDescription(serviceDescription, httpService); }); }); return generate(serviceDescription, methodInfos); }
VirtualHost decorate(@Nullable Function<Service<HttpRequest, HttpResponse>, Service<HttpRequest, HttpResponse>> decorator) { if (decorator == null) { return this; } final List<ServiceConfig> services = this.services.stream().map(cfg -> { final PathMapping pathMapping = cfg.pathMapping(); final Service<HttpRequest, HttpResponse> service = decorator.apply(cfg.service()); final String loggerName = cfg.loggerName().orElse(null); return new ServiceConfig(pathMapping, service, loggerName); }).collect(Collectors.toList()); return new VirtualHost(defaultHostname(), hostnamePattern(), sslContext(), services, producibleMediaTypes()); }
private VirtualHost normalizeDefaultVirtualHost(VirtualHost h, @Nullable SslContext defaultSslContext) { final SslContext sslCtx = h.sslContext() != null ? h.sslContext() : defaultSslContext; return new VirtualHost( h.defaultHostname(), "*", sslCtx, h.serviceConfigs().stream().map( e -> new ServiceConfig(e.pathMapping(), e.service(), e.loggerName().orElse(null))) .collect(Collectors.toList()), h.producibleMediaTypes(), rejectedPathMappingHandler, host -> h.accessLogger()); }
Server(ServerConfig config, @Nullable DomainNameMapping<SslContext> sslContexts) { this.config = requireNonNull(config, "config"); this.sslContexts = sslContexts; startStop = new ServerStartStopSupport(config.startStopExecutor()); connectionLimitingHandler = new ConnectionLimitingHandler(config.maxNumConnections()); config.setServer(this); // Server-wide cache metrics. final MeterIdPrefix idPrefix = new MeterIdPrefix("armeria.server.parsedPathCache"); PathAndQuery.registerMetrics(config.meterRegistry(), idPrefix); // Invoke the serviceAdded() method in Service so that it can keep the reference to this Server or // add a listener to it. config.serviceConfigs().forEach(cfg -> ServiceCallbackInvoker.invokeServiceAdded(cfg, cfg.service())); }
@Override public ServiceSpecification generateSpecification(Set<ServiceConfig> serviceConfigs) { final Map<Class<?>, EntryBuilder> map = new LinkedHashMap<>(); for (ServiceConfig c : serviceConfigs) { final THttpService service = c.service().as(THttpService.class).get(); service.entries().forEach((serviceName, entry) -> { for (Class<?> iface : entry.interfaces()) { final Class<?> serviceClass = iface.getEnclosingClass(); final EntryBuilder builder = map.computeIfAbsent(serviceClass, cls -> new EntryBuilder(serviceClass)); // Add all available endpoints. Accept only the services with exact and prefix path // mappings, whose endpoint path can be determined. final PathMapping pathMapping = c.pathMapping(); final String path = pathMapping.exactPath().orElse(pathMapping.prefix().orElse(null)); if (path != null) { builder.endpoint(new EndpointInfoBuilder(c.virtualHost().hostnamePattern(), path) .fragment(serviceName) .defaultFormat(service.defaultSerializationFormat()) .availableFormats(service.allowedSerializationFormats()) .build()); } } }); } final List<Entry> entries = map.values().stream() .map(EntryBuilder::build) .collect(Collectors.toList()); return generate(entries); }
final Map<String, ServiceEntryBuilder> map = new LinkedHashMap<>(); for (ServiceConfig serviceConfig : serviceConfigs) { final GrpcService grpcService = serviceConfig.service().as(GrpcService.class).get(); final ImmutableSet.Builder<MediaType> supportedMediaTypesBuilder = ImmutableSet.builder(); supportedMediaTypesBuilder.addAll(grpcService.supportedSerializationFormats() .stream() .map(SerializationFormat::mediaType)::iterator); if (serviceConfig.service().as(UnframedGrpcService.class).isPresent()) { if (grpcService.supportedSerializationFormats().contains(GrpcSerializationFormats.PROTO)) {
private static Service<?, ?> service(ServerBuilder sb) { final Server server = sb.build(); return server.config().defaultVirtualHost().serviceConfigs().get(0).service(); }
final Service<HttpRequest, HttpResponse> service = serviceCfg.service(); final Channel channel = ctx.channel(); final InetAddress remoteAddress = ((InetSocketAddress) channel.remoteAddress()).getAddress();
@Override public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) { return serviceConfigs.stream() .flatMap(c -> c.service().as(GrpcService.class).get().services().stream()) .flatMap(s -> docstringExtractor.getAllDocStrings(s.getClass().getClassLoader()) .entrySet().stream()) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a)); }
@Override public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) { return serviceConfigs.stream() .flatMap(c -> c.service().as(THttpService.class).get().entries().values().stream()) .flatMap(entry -> entry.interfaces().stream().map(Class::getClassLoader)) .flatMap(loader -> docstringExtractor.getAllDocStrings(loader) .entrySet().stream()) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a)); }
@Override public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) { return serviceConfigs.stream() .flatMap(c -> c.service().as(THttpService.class).get().entries().values().stream()) .flatMap(entry -> entry.interfaces().stream().map(Class::getClassLoader)) .flatMap(loader -> docstringExtractor.getAllDocStrings(loader) .entrySet().stream()) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a)); }
@Override public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) { return serviceConfigs.stream() .flatMap(c -> c.service().as(THttpService.class).get().entries().values().stream()) .flatMap(entry -> entry.interfaces().stream().map(Class::getClassLoader)) .flatMap(loader -> docstringExtractor.getAllDocStrings(loader) .entrySet().stream()) .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a)); }
@Override public ServiceSpecification generateSpecification(Set<ServiceConfig> serviceConfigs) { final Map<Class<?>, EntryBuilder> map = new LinkedHashMap<>(); for (ServiceConfig c : serviceConfigs) { final THttpService service = c.service().as(THttpService.class).get(); service.entries().forEach((serviceName, entry) -> { for (Class<?> iface : entry.interfaces()) { final Class<?> serviceClass = iface.getEnclosingClass(); final EntryBuilder builder = map.computeIfAbsent(serviceClass, cls -> new EntryBuilder(serviceClass)); // Add all available endpoints. Accept only the services with exact and prefix path // mappings, whose endpoint path can be determined. final PathMapping pathMapping = c.pathMapping(); final String path = pathMapping.exactPath().orElse(pathMapping.prefix().orElse(null)); if (path != null) { builder.endpoint(new EndpointInfo( c.virtualHost().hostnamePattern(), path, serviceName, service.defaultSerializationFormat(), service.allowedSerializationFormats())); } } }); } final List<Entry> entries = map.values().stream() .map(EntryBuilder::build) .collect(Collectors.toList()); return generate(entries); }