public static ProtocolConnectionConfiguration create(final Endpoint endpoint, final URI uri) { return create(endpoint, uri, OptionMap.EMPTY); }
private static ProtocolConnectionConfiguration createConfiguration(final ProtocolConnectionConfiguration configuration, final Map<String, String> saslOptions, final CallbackHandler callbackHandler, final SSLContext sslContext) { final ProtocolConnectionConfiguration config = ProtocolConnectionConfiguration.copy(configuration); config.setCallbackHandler(callbackHandler); config.setSslContext(sslContext); config.setSaslOptions(saslOptions); return config; }
private Establishing(final ProtocolConnectionConfiguration configuration, final Channel.Receiver receiver, final CloseHandler<Channel> closeHandler) { this.receiver = receiver; this.channelOptions = configuration.getOptionMap(); this.connectionManager = ProtocolConnectionManager.create(configuration, this); this.closeHandler = closeHandler; this.timeout = configuration.getConnectionTimeout(); }
public static ProtocolConnectionConfiguration create(final Endpoint endpoint, final URI uri, final OptionMap options) { final ProtocolConnectionConfiguration configuration = new ProtocolConnectionConfiguration(); configuration.setEndpoint(endpoint); configuration.setUri(uri); configuration.setOptionMap(options); return configuration; }
public static ProtocolConnectionConfiguration copy(final ProtocolConnectionConfiguration old) { return copy(old, new ProtocolConnectionConfiguration()); }
final ProtocolConnectionConfiguration configuration = ProtocolConnectionConfiguration.create(endpoint, connectionURI, OptionMap.EMPTY); configuration.setCallbackHandler(HostControllerConnection.createClientCallbackHandler(userName, initialAuthKey)); configuration.setConnectionTimeout(SERVER_CONNECTION_TIMEOUT); configuration.setSslContext(sslContextSupplier.get()); this.responseAttachmentSupport = new ResponseAttachmentInputStreamSupport(scheduledExecutorSupplier.get());
/** * This continuously tries to reconnect in a separate thread and will only stop if the connection was established * successfully or the server gets shutdown. If there is currently a reconnect task active the connection paramaters * and callback will get updated. * * @param reconnectUri the updated connection uri * @param authKey the updated authentication key * @param callback the current callback */ synchronized void asyncReconnect(final URI reconnectUri, String authKey, final ReconnectCallback callback) { if (getState() != State.OPEN) { return; } // Update the configuration with the new credentials final ProtocolConnectionConfiguration config = ProtocolConnectionConfiguration.copy(configuration); config.setCallbackHandler(createClientCallbackHandler(userName, authKey)); config.setUri(reconnectUri); this.configuration = config; final ReconnectRunner reconnectTask = this.reconnectRunner; if (reconnectTask == null) { final ReconnectRunner task = new ReconnectRunner(); task.callback = callback; task.future = executorService.submit(task); } else { reconnectTask.callback = callback; } }
final ProtocolConnectionConfiguration config = ProtocolConnectionConfiguration.copy(configuration); config.setCallbackHandler(callbackHandler); config.setSslContext(sslContext); config.setUri(uri);
public static IoFuture<Connection> connect(final ProtocolConnectionConfiguration configuration, CallbackHandler handler) throws IOException { final ProtocolConnectionConfiguration config = ProtocolConnectionConfiguration.copy(configuration); config.setCallbackHandler(handler); return connect(config); }
channelConfig = ProtocolConnectionConfiguration.create(endpoint, connURI, DEFAULT_OPTIONS); channelConfig.setClientBindAddress(clientBindAddress); this.saslOptions = saslOptions; channelConfig.setSaslOptions(saslOptions); if(connectionTimeout > 0) { channelConfig.setConnectionTimeout(connectionTimeout); channelConfig.setTimeoutHandler(timeoutHandler);
private static IoFuture<Connection> connect(final CallbackHandler handler, final ProtocolConnectionConfiguration configuration) throws IOException { configuration.validate(); final Endpoint endpoint = configuration.getEndpoint(); final URI uri = configuration.getUri(); String clientBindAddress = configuration.getClientBindAddress(); Map<String, String> saslOptions = configuration.getSaslOptions(); mergedConfiguration = configureSaslMechanisms(saslOptions, isLocal(uri), mergedConfiguration); SSLContext sslContext = configuration.getSslContext(); if (sslContext == null) { try { OptionMap optionMap = configuration.getOptionMap(); for (Option option : optionMap) { builder.set(option, optionMap.get(option)); builder.set(Options.SSL_ENABLED, configuration.isSslEnabled()); if (optionMap.get(Options.SSL_STARTTLS) == null) builder.set(Options.SSL_STARTTLS, configuration.isUseStartTLS());
/** * Connect and register at the remote domain controller. * * @return connection the established connection * @throws IOException */ protected Connection openConnection() throws IOException { // Perhaps this can just be done once? CallbackHandler callbackHandler = null; SSLContext sslContext = null; if (realm != null) { sslContext = realm.getSSLContext(); CallbackHandlerFactory handlerFactory = realm.getSecretCallbackHandlerFactory(); if (handlerFactory != null) { String username = this.username != null ? this.username : localHostName; callbackHandler = handlerFactory.getCallbackHandler(username); } } final ProtocolConnectionConfiguration config = ProtocolConnectionConfiguration.copy(configuration); config.setCallbackHandler(callbackHandler); config.setSslContext(sslContext); // Connect return ProtocolConnectionUtils.connectSync(config); }
static ProtocolConnectionConfiguration create(final ModelControllerClientConfiguration client, final Endpoint endpoint) throws URISyntaxException { URI connURI; if(client.getProtocol() == null) { // WFLY-1462 for compatibility assume remoting if the standard native port is configured String protocol = client.getPort() == 9999 ? "remote://" : "remote+http://"; connURI = new URI(protocol + formatPossibleIpv6Address(client.getHost()) + ":" + client.getPort()); } else { connURI = new URI(client.getProtocol() + "://" + formatPossibleIpv6Address(client.getHost()) + ":" + client.getPort()); } final ProtocolConnectionConfiguration configuration = ProtocolConnectionConfiguration.create(endpoint, connURI, DEFAULT_OPTIONS); configuration.setClientBindAddress(client.getClientBindAddress()); final long timeout = client.getConnectionTimeout(); if(timeout > 0) { configuration.setConnectionTimeout(timeout); } return configuration; }
Establishing(final String serviceType, final Channel.Receiver receiver, final ProtocolConnectionConfiguration configuration) { this.serviceType = serviceType; this.receiver = receiver; this.channelOptions = configuration.getOptionMap(); this.connectionManager = ProtocolConnectionManager.create(configuration, this); }
private static OptionMap getOptions(final ProtocolConnectionConfiguration configuration) { final Map<String, String> saslOptions = configuration.getSaslOptions(); final OptionMap.Builder builder = OptionMap.builder(); builder.addAll(configuration.getOptionMap()); builder.set(SASL_POLICY_NOANONYMOUS, Boolean.FALSE); builder.set(SASL_POLICY_NOPLAINTEXT, Boolean.FALSE); if (isLocal(configuration.getUri()) == false) { builder.set(Options.SASL_DISALLOWED_MECHANISMS, Sequence.of(JBOSS_LOCAL_USER)); } List<Property> tempProperties = new ArrayList<Property>(saslOptions != null ? saslOptions.size() : 1); tempProperties.add(Property.of("jboss.sasl.local-user.quiet-auth", "true")); if (saslOptions != null) { for (String currentKey : saslOptions.keySet()) { tempProperties.add(Property.of(currentKey, saslOptions.get(currentKey))); } } builder.set(Options.SASL_PROPERTIES, Sequence.of(tempProperties)); builder.set(Options.SSL_ENABLED, true); builder.set(Options.SSL_STARTTLS, true); return builder.getMap(); }
private static IoFuture<Connection> connect(final CallbackHandler handler, final ProtocolConnectionConfiguration configuration) throws IOException { final Endpoint endpoint = configuration.getEndpoint(); final OptionMap options = getOptions(configuration); final CallbackHandler actualHandler = handler != null ? handler : new AnonymousCallbackHandler(); String clientBindAddress = configuration.getClientBindAddress(); if (clientBindAddress == null) { return endpoint.connect(configuration.getUri(), options, actualHandler, configuration.getSslContext()); } else { InetSocketAddress bindAddr = new InetSocketAddress(clientBindAddress, 0); InetSocketAddress destAddr = new InetSocketAddress(configuration.getUri().getHost(), configuration.getUri().getPort()); return endpoint.connect(REMOTE_PROTOCOL, bindAddr, destAddr, options, actualHandler, configuration.getSslContext()); } }
public ProtocolConnectionConfiguration copy() { return copy(this); }
long timeoutMillis = configuration.getConnectionTimeout(); CallbackHandler handler = configuration.getCallbackHandler(); final CallbackHandler actualHandler; ProtocolTimeoutHandler timeoutHandler = configuration.getTimeoutHandler(); throw ProtocolLogger.ROOT_LOGGER.failedToConnect(configuration.getUri(), future.getException()); throw ProtocolLogger.ROOT_LOGGER.couldNotConnect(configuration.getUri());
final CallbackHandler handler = configuration.getCallbackHandler(); final CallbackHandler actualHandler = handler != null ? handler : new AnonymousCallbackHandler(); final WrapperCallbackHandler wrapperHandler = new WrapperCallbackHandler(actualHandler); final IoFuture<Connection> future = connect(wrapperHandler, configuration); long timeoutMillis = configuration.getConnectionTimeout(); IoFuture.Status status = future.await(timeoutMillis, TimeUnit.MILLISECONDS); while (status == IoFuture.Status.WAITING) { throw ProtocolMessages.MESSAGES.failedToConnect(configuration.getUri(), future.getException()); throw ProtocolMessages.MESSAGES.couldNotConnect(configuration.getUri());
channelConfig.getUri().getScheme())) { throw (RedirectException) ex;