private static String protocolName(@Nullable SessionProtocol protocol) { return protocol != null ? protocol.uriText() : "<unknown>"; }
/** * Returns the {@link SSLSession} of the connection. * * @return the {@link SSLSession}, or {@code null} if the {@link SessionProtocol} is not TLS. */ @Nullable protected final SSLSession sslSession() { checkState(!sessionProtocol.isTls() || sslSession != null, "sslSession must be set for a TLS-enabled protocol: %s", sessionProtocol); return sessionProtocol.isTls() ? sslSession : null; }
private static HttpUrl convertToOkHttpUrl(HttpClient baseHttpClient, String basePath, String groupPrefix) { final URI uri = baseHttpClient.uri(); final SessionProtocol sessionProtocol = Scheme.tryParse(uri.getScheme()) .map(Scheme::sessionProtocol) .orElseGet(() -> SessionProtocol.of(uri.getScheme())); final String authority = uri.getAuthority(); final String protocol = sessionProtocol.isTls() ? "https" : "http"; final HttpUrl parsed; if (authority.startsWith("group:")) { parsed = HttpUrl.parse(protocol + "://" + authority.replace("group:", groupPrefix) + basePath); } else { parsed = HttpUrl.parse(protocol + "://" + authority + basePath); } assert parsed != null; return parsed; } }
/** * Returns the URI for the {@link Server} of the specified protocol. * * @throws IllegalStateException if the {@link Server} is not started or * it did not open a port of the protocol. */ public String uri(SessionProtocol protocol, String path) { requireNonNull(protocol, "protocol"); requireNonNull(path, "path"); // This will ensure that the server has started. server(); final int port; if (!protocol.isTls() && hasHttp()) { port = httpPort(); } else if (protocol.isTls() && hasHttps()) { port = httpsPort(); } else { throw new IllegalStateException("can't find the specified port"); } return protocol.uriText() + "://127.0.0.1:" + port + path; }
private HttpEndpointHealthChecker( ClientFactory clientFactory, Endpoint endpoint, SessionProtocol protocol, String healthCheckPath, int healthCheckPort, Function<? super ClientOptionsBuilder, ClientOptionsBuilder> configurator) { final String scheme = protocol.uriText(); final String ipAddr = endpoint.ipAddr(); final HttpClientBuilder builder; if (ipAddr == null) { builder = new HttpClientBuilder(scheme + "://" + endpoint.authority()); } else { final int port = healthCheckPort > 0 ? healthCheckPort : endpoint.port(protocol.defaultPort()); if (endpoint.ipFamily() == StandardProtocolFamily.INET) { builder = new HttpClientBuilder(scheme + "://" + ipAddr + ':' + port); } else { builder = new HttpClientBuilder(scheme + "://[" + ipAddr + "]:" + port); } builder.setHttpHeader(HttpHeaderNames.AUTHORITY, endpoint.authority()); } httpClient = builder.factory(clientFactory) .options(configurator.apply(new ClientOptionsBuilder()).build()) .build(); this.healthCheckPath = healthCheckPath; }
if (port == sessionProtocol.defaultPort()) { authority = hostname; } else { requestHeaders.scheme(sessionProtocol.isTls() ? "https" : "http");
@Override public void operationComplete(ChannelFuture f) { final Channel ch = f.channel(); assert ch.eventLoop().inEventLoop(); if (f.isSuccess()) { serverChannels.add(ch); ch.closeFuture() .addListener((ChannelFutureListener) future -> serverChannels.remove(future.channel())); final InetSocketAddress localAddress = (InetSocketAddress) ch.localAddress(); final ServerPort actualPort = new ServerPort(localAddress, port.protocols()); // Update the boss thread so its name contains the actual port. Thread.currentThread().setName(bossThreadName(actualPort)); synchronized (activePorts) { // Update the map of active ports. activePorts.put(localAddress, actualPort); } if (logger.isInfoEnabled()) { if (localAddress.getAddress().isAnyLocalAddress() || localAddress.getAddress().isLoopbackAddress()) { port.protocols().forEach(p -> logger.info( "Serving {} at {} - {}://127.0.0.1:{}/", p.name(), localAddress, p.uriText(), localAddress.getPort())); } else { logger.info("Serving {} at {}", Joiner.on('+').join(port.protocols()), localAddress); } } } } }
/** * Adds a new {@link ServerPort} that listens to the specified {@code port} of all available network * interfaces using the specified protocol. * * @deprecated Use {@link #http(int)} or {@link #https(int)}. * @see <a href="#no_port_specified">What happens if no HTTP(S) port is specified?</a> */ @Deprecated public ServerBuilder port(int port, String protocol) { return port(port, SessionProtocol.of(requireNonNull(protocol, "protocol"))); }
private static int guessServerPort(SessionProtocol sessionProtocol, @Nullable String authority) { if (authority == null) { return sessionProtocol.defaultPort(); } final int lastColonPos = authority.lastIndexOf(':'); if (lastColonPos < 0) { return sessionProtocol.defaultPort(); } final int port; try { port = Integer.parseInt(authority.substring(lastColonPos + 1)); } catch (NumberFormatException e) { return sessionProtocol.defaultPort(); } if (port <= 0 || port >= 65536) { return sessionProtocol.defaultPort(); } return port; }
/** * Sets the API base URL. * * @see Builder#baseUrl(String) */ public ArmeriaRetrofitBuilder baseUrl(String baseUrl) { requireNonNull(baseUrl, "baseUrl"); final URI uri = URI.create(baseUrl); checkArgument(SessionProtocol.find(uri.getScheme()).isPresent(), "baseUrl must have an HTTP scheme: %s", baseUrl); final String path = uri.getPath(); if (!path.isEmpty() && !SLASH.equals(path.substring(path.length() - 1))) { throw new IllegalArgumentException("baseUrl must end with /: " + baseUrl); } this.baseUrl = baseUrl; return this; }
/** * Adds a new {@link ServerPort} that listens to the specified {@code localAddress} using the specified * protocol. * * @deprecated Use {@link #http(InetSocketAddress)} or {@link #https(InetSocketAddress)}. */ @Deprecated public ServerBuilder port(InetSocketAddress localAddress, String protocol) { return port(localAddress, SessionProtocol.of(requireNonNull(protocol, "protocol"))); }
remoteAddress.getHostString(), remoteAddress.getPort(), H1C.defaultPort());
sessionProtocol = SessionProtocol.find(schemeStr).orElseThrow( () -> new IllegalArgumentException("uri.scheme is not valid: " + uri)); } else {
/** * Returns the {@link Scheme} of the specified {@link SerializationFormat} and {@link SessionProtocol}. * This method returns the same {@link Scheme} instance for the same combination of * {@link SerializationFormat} and {@link SessionProtocol}. */ public static Scheme of(SerializationFormat serializationFormat, SessionProtocol sessionProtocol) { return SCHEMES.get(requireNonNull(serializationFormat, "serializationFormat").uriText() + '+' + requireNonNull(sessionProtocol, "sessionProtocol").uriText()); }
/** * Finds the {@link SSLSession} of the current TLS connection. * * @return the {@link SSLSession} if found, or {@code null} if {@link SessionProtocol} is not TLS, * the {@link SSLSession} is not found or {@link Channel} is {@code null}. */ @Nullable public static SSLSession findSslSession(@Nullable Channel channel, SessionProtocol sessionProtocol) { if (!sessionProtocol.isTls()) { return null; } return findSslSession(channel); }
/** * Returns a newly-created {@link Retrofit} based on the properties of this builder. */ public Retrofit build() { checkState(baseUrl != null, "baseUrl not set"); final URI uri = URI.create(baseUrl); final String fullUri = SessionProtocol.of(uri.getScheme()) + "://" + uri.getAuthority(); final HttpClient baseHttpClient = HttpClient.of( clientFactory, fullUri, configurator.apply(fullUri, new ClientOptionsBuilder()).build()); return retrofitBuilder.baseUrl(convertToOkHttpUrl(baseHttpClient, uri.getPath(), GROUP_PREFIX)) .callFactory(new ArmeriaCallFactory( baseHttpClient, clientFactory, configurator, streaming ? SubscriberFactory.streaming(callbackExecutor) : SubscriberFactory.blocking())) .build(); }
final int port = ((InetSocketAddress) sCtx.remoteAddress()).getPort(); final String hostname = sCtx.virtualHost().defaultHostname(); if (port == ctx.sessionProtocol().defaultPort()) { authority = hostname; } else { authority = endpoint.authority(); } else { final int defaultPort = cCtx.sessionProtocol().defaultPort(); final int port = endpoint.port(defaultPort); if (port == defaultPort) {
@Override public void connectionOpen(SessionProtocol protocol, InetSocketAddress remoteAddr, InetSocketAddress localAddr, AttributeMap attrs) throws Exception { final int activeChannels = this.activeChannels.incrementAndGet(); if (logger.isInfoEnabled()) { attrs.attr(OPEN_NANOS).set(ticker.read()); logger.info("[L:{} - R:{}][{}] OPEN (active channels: {})", localAddr, remoteAddr, protocol.uriText(), activeChannels); } }
@Nullable private static String getAuthority(RequestContext ctx, HttpHeaders headers) { String authority = headers.authority(); if (authority != null) { final Pattern portPattern = ctx.sessionProtocol().isTls() ? PORT_443 : PORT_80; final Matcher m = portPattern.matcher(authority); if (m.find()) { authority = authority.substring(0, m.start()); } return authority; } return null; }