/** {@inheritDoc} */
public synchronized void start(StartContext context) throws StartException {
Security.addProvider(new JBossSaslProvider());
ProtocolChannelClient<ManagementChannel> client;
try {
ProtocolChannelClient.Configuration<ManagementChannel> configuration =
new ProtocolChannelClient.Configuration<ManagementChannel>();
configuration.setEndpoint(endpointInjector.getValue());
configuration.setUri(
new URI(
"remote://"
+ hcAddressInjector.getValue().getHostName()
+ ":"
+ hcAddressInjector.getValue().getPort()));
configuration.setChannelFactory(new ManagementChannelFactory());
client = ProtocolChannelClient.create(configuration);
} catch (Exception e) {
throw new StartException(e);
}
try {
client.connect(new ClientCallbackHandler());
channel = client.openChannel(RemotingServices.SERVER_CHANNEL);
channel.startReceiving();
} catch (IOException e) {
throw new StartException("Failed to start remote Host Controller connection", e);
}
}
/**
* Create a connection wrapper.
*
* @param connectionURI the connection URI
* @param callbackHandler the callback handler
* @return the connection wrapper
* @throws IOException
*/
DomainTestConnection createConnection(
final URI connectionURI, final CallbackHandler callbackHandler) throws IOException {
final ProtocolChannelClient.Configuration configuration =
new ProtocolChannelClient.Configuration();
configuration.setEndpoint(endpoint);
configuration.setUri(connectionURI);
final ProtocolChannelClient client = ProtocolChannelClient.create(configuration);
return new DomainTestConnection(client, callbackHandler, executorService);
}
CLIModelControllerClient(
final String protocol,
CallbackHandler handler,
String hostName,
int connectionTimeout,
final ConnectionCloseHandler closeHandler,
int port,
SSLContext sslContext)
throws IOException {
this.handler = handler;
this.sslContext = sslContext;
this.closeHandler = closeHandler;
this.channelAssociation =
new ManagementChannelHandler(
new ManagementClientChannelStrategy() {
@Override
public Channel getChannel() throws IOException {
return getOrCreateChannel();
}
@Override
public void close() throws IOException {}
},
executorService,
this);
channelConfig = new ProtocolChannelClient.Configuration();
try {
channelConfig.setUri(
new URI(protocol + "://" + formatPossibleIpv6Address(hostName) + ":" + port));
} catch (URISyntaxException e) {
throw new IOException("Failed to create URI", e);
}
channelConfig.setOptionMap(DEFAULT_OPTIONS);
if (connectionTimeout > 0) {
channelConfig.setConnectionTimeout(connectionTimeout);
}
channelConfig.setEndpoint(endpoint);
}
@Before
public void startChannelServer() throws Exception {
final ChannelServer.Configuration configuration = new ChannelServer.Configuration();
configuration.setEndpointName(ENDPOINT_NAME);
configuration.setUriScheme(URI_SCHEME);
configuration.setBindAddress(new InetSocketAddress("127.0.0.1", PORT));
channelServer = ChannelServer.create(configuration);
//
channelServer.addChannelOpenListener(
TEST_CHANNEL,
new OpenListener() {
@Override
public void channelOpened(final Channel channel) {
final MockController controller = new MockController();
final ManagementChannelHandler channels =
new ManagementChannelHandler(channel, remoteExecutors);
final ManagementRequestHandlerFactory handlerFactory =
new TransactionalProtocolOperationHandler(
controller, channels, new ResponseAttachmentInputStreamSupport());
channels.addHandlerFactory(handlerFactory);
transferQueue.offer(controller);
channel.addCloseHandler(channels);
channel.receiveMessage(channels.getReceiver());
}
@Override
public void registrationTerminated() {
//
}
});
final ProtocolChannelClient.Configuration connectionConfig =
new ProtocolChannelClient.Configuration();
connectionConfig.setEndpoint(channelServer.getEndpoint());
connectionConfig.setUri(new URI("" + URI_SCHEME + "://127.0.0.1:" + PORT + ""));
//
final ProtocolChannelClient client = ProtocolChannelClient.create(connectionConfig);
futureConnection =
client.connect(
new PasswordClientCallbackHandler("bob", ENDPOINT_NAME, "pass".toCharArray()));
}
@Override
public void connectionOpened(final Connection connection) throws IOException {
final Channel channel =
openChannel(connection, CHANNEL_SERVICE_TYPE, configuration.getOptionMap());
if (setChannel(channel)) {
channel.receiveMessage(channelHandler.getReceiver());
channel.addCloseHandler(channelHandler);
try {
// Start the registration process
channelHandler.executeRequest(new RegisterHostControllerRequest(), null).getResult().get();
} catch (Exception e) {
if (e.getCause() instanceof IOException) {
throw (IOException) e.getCause();
}
throw new IOException(e);
}
// Registered
registered();
} else {
channel.closeAsync();
}
}