@Override protected void openConnection() { this.taskExecutor.execute(() -> { try { if (logger.isInfoEnabled()) { logger.info("Connecting to WebSocket at " + getUri()); } Object endpointToUse = this.endpoint; if (endpointToUse == null) { Assert.state(this.endpointProvider != null, "No endpoint set"); endpointToUse = this.endpointProvider.getHandler(); } this.session = this.webSocketContainer.connectToServer(endpointToUse, getUri()); logger.info("Successfully connected to WebSocket"); } catch (Throwable ex) { logger.error("Failed to connect to WebSocket", ex); } }); }
@Override protected void openConnection() { this.taskExecutor.execute(() -> { try { if (logger.isInfoEnabled()) { logger.info("Connecting to WebSocket at " + getUri()); } Endpoint endpointToUse = this.endpoint; if (endpointToUse == null) { Assert.state(this.endpointProvider != null, "No endpoint set"); endpointToUse = this.endpointProvider.getHandler(); } ClientEndpointConfig endpointConfig = this.configBuilder.build(); this.session = getWebSocketContainer().connectToServer(endpointToUse, endpointConfig, getUri()); logger.info("Successfully connected to WebSocket"); } catch (Throwable ex) { logger.error("Failed to connect to WebSocket", ex); } }); }
@Test public void clientEndpointConfig() throws Exception { URI uri = new URI("ws://localhost/abc"); List<String> protocols = Collections.singletonList("abc"); this.headers.setSecWebSocketProtocol(protocols); this.wsClient.doHandshake(this.wsHandler, this.headers, uri).get(); ArgumentCaptor<ClientEndpointConfig> captor = ArgumentCaptor.forClass(ClientEndpointConfig.class); verify(this.wsContainer).connectToServer(any(Endpoint.class), captor.capture(), any(URI.class)); ClientEndpointConfig endpointConfig = captor.getValue(); assertEquals(protocols, endpointConfig.getPreferredSubprotocols()); }
@Test public void clientEndpointConfigWithUserProperties() throws Exception { Map<String,Object> userProperties = Collections.singletonMap("foo", "bar"); URI uri = new URI("ws://localhost/abc"); this.wsClient.setUserProperties(userProperties); this.wsClient.doHandshake(this.wsHandler, this.headers, uri).get(); ArgumentCaptor<ClientEndpointConfig> captor = ArgumentCaptor.forClass(ClientEndpointConfig.class); verify(this.wsContainer).connectToServer(any(Endpoint.class), captor.capture(), any(URI.class)); ClientEndpointConfig endpointConfig = captor.getValue(); assertEquals(userProperties, endpointConfig.getUserProperties()); }
@Test public void standardWebSocketClientConfiguratorInsertsHandshakeHeaders() throws Exception { URI uri = new URI("ws://localhost/abc"); this.headers.add("foo", "bar"); this.wsClient.doHandshake(this.wsHandler, this.headers, uri).get(); ArgumentCaptor<ClientEndpointConfig> captor = ArgumentCaptor.forClass(ClientEndpointConfig.class); verify(this.wsContainer).connectToServer(any(Endpoint.class), captor.capture(), any(URI.class)); ClientEndpointConfig endpointConfig = captor.getValue(); Map<String, List<String>> headers = new HashMap<>(); endpointConfig.getConfigurator().beforeRequest(headers); assertEquals(1, headers.size()); }
private Mono<Void> executeInternal(URI url, HttpHeaders requestHeaders, WebSocketHandler handler) { MonoProcessor<Void> completionMono = MonoProcessor.create(); return Mono.fromCallable( () -> { if (logger.isDebugEnabled()) { logger.debug("Connecting to " + url); } List<String> protocols = handler.getSubProtocols(); DefaultConfigurator configurator = new DefaultConfigurator(requestHeaders); Endpoint endpoint = createEndpoint(url, handler, completionMono, configurator); ClientEndpointConfig config = createEndpointConfig(configurator, protocols); return this.webSocketContainer.connectToServer(endpoint, config, url); }) .subscribeOn(Schedulers.elastic()) // connectToServer is blocking .then(completionMono); }
public DaemonMessagesClientEndpoint( String host, String port, boolean ssl, MessageEventService messageEventService ) throws KettleException { try { setAuthProperties(); String url = String.format( URL_TEMPLATE, ( ssl ? PRFX_WS_SSL : PRFX_WS ), host, port ); URI uri = new URI( url ); this.messageEventService = messageEventService; WebSocketContainer container = ContainerProvider.getWebSocketContainer(); container.connectToServer( this, ClientEndpointConfig.Builder.create() .encoders( Collections.singletonList( MessageEncoder.class ) ) .decoders( Collections.singletonList( MessageDecoder.class ) ) .configurator( new SessionConfigurator( uri, keytab, principal ) ) .build(), uri ); } catch ( Exception e ) { throw new KettleException( e ); } }
@Override protected ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandler webSocketHandler, HttpHeaders headers, final URI uri, List<String> protocols, List<WebSocketExtension> extensions, Map<String, Object> attributes) { int port = getPort(uri); InetSocketAddress localAddress = new InetSocketAddress(getLocalHost(), port); InetSocketAddress remoteAddress = new InetSocketAddress(uri.getHost(), port); final StandardWebSocketSession session = new StandardWebSocketSession(headers, attributes, localAddress, remoteAddress); final ClientEndpointConfig endpointConfig = ClientEndpointConfig.Builder.create() .configurator(new StandardWebSocketClientConfigurator(headers)) .preferredSubprotocols(protocols) .extensions(adaptExtensions(extensions)).build(); endpointConfig.getUserProperties().putAll(getUserProperties()); final Endpoint endpoint = new StandardWebSocketHandlerAdapter(webSocketHandler, session); Callable<WebSocketSession> connectTask = () -> { this.webSocketContainer.connectToServer(endpoint, endpointConfig, uri); return session; }; if (this.taskExecutor != null) { return this.taskExecutor.submitListenable(connectTask); } else { ListenableFutureTask<WebSocketSession> task = new ListenableFutureTask<>(connectTask); task.run(); return task; } }
try { System.out.println("sendMessageToRemoteGovernor :: "+message.getJson()); WebSocketContainer container = ContainerProvider.getWebSocketContainer(); session = container.connectToServer(XYZ.class, new URI("ws://localhost:8080/xyz/xyz")); session.getBasicRemote().sendObject(message); } catch (Exception e) { e.printStackTrace(); }
public WSClientEndpoint(URI endpointURI, ObjectSink sink) { try { WebSocketContainer container = ContainerProvider.getWebSocketContainer(); container.connectToServer(this, endpointURI); this.sink = sink; } catch (Exception e) { throw new RuntimeException(e); } }
final WebSocketContainer webSocketContainer = ContainerProvider.getWebSocketContainer(); Session session = webSocketContainer.connectToServer(new Endpoint() { @Override public void onOpen(Session session, EndpointConfig config) { // session.addMessageHandler( ... ); } }, URI.create("ws://some.uri"));
public void connect() throws IOException, DeploymentException { WebSocketContainer container = ContainerProvider.getWebSocketContainer(); container.connectToServer(this, wssUri); log.debug("client connected to the server: {}", wssUri); }
Comm(final URI url, JSONCall callback) { this.callback = callback; try { final WebSocketContainer c = ContainerProvider.getWebSocketContainer(); c.connectToServer(Comm.this, url); } catch (Exception ex) { wasAnError(ex); } }
@ScriptFunction(params = {"uri"}) public WebSocketClientSession(String aUri) throws Exception { super(); Scripts.getSpace().process(() -> { try { webSocketSession = ContainerProvider.getWebSocketContainer().connectToServer(endPoint, URI.create(aUri)); } catch (DeploymentException | IOException ex) { Logger.getLogger(WebSocketClientSession.class.getName()).log(Level.SEVERE, null, ex); } }); }
public static IPromise<ActorServer> Publish( Actor facade, String path, Coding coding) { _JSR356ServerConnector connector = new _JSR356ServerConnector(); try { ActorServer actorServer = new ActorServer(connector, facade, coding); actorServer.start(); ContainerProvider.getWebSocketContainer().connectToServer(connector, /*new DefaultClientEndpointConfig(),*/ new URI(path)); return new Promise<>(actorServer); } catch (Exception e) { e.printStackTrace(); return new Promise<>(null,e); } }
public Endpoint connect(String websocketUrl) throws Exception { ClientEndpointConfig clientEndpointConfig = ClientEndpointConfig.Builder.create().build(); ContainerProvider.getWebSocketContainer().connectToServer(endpoint, clientEndpointConfig, new URI(websocketUrl)); return endpoint; }
public Endpoint connect(String websocketUrl) throws Exception { ClientEndpointConfig clientEndpointConfig = ClientEndpointConfig.Builder.create().build(); ContainerProvider.getWebSocketContainer().connectToServer(endpoint, clientEndpointConfig, new URI(websocketUrl)); return endpoint; }
private Mono<Void> executeInternal(URI url, HttpHeaders requestHeaders, WebSocketHandler handler) { MonoProcessor<Void> completionMono = MonoProcessor.create(); return Mono.fromCallable( () -> { String[] subProtocols = beforeHandshake(url, requestHeaders, handler); DefaultConfigurator configurator = new DefaultConfigurator(requestHeaders); Endpoint endpoint = createEndpoint(url, handler, completionMono, configurator); ClientEndpointConfig config = createEndpointConfig(configurator, subProtocols); return this.webSocketContainer.connectToServer(endpoint, config, url); }) .subscribeOn(Schedulers.elastic()) // connectToServer is blocking .then(completionMono); }
@Override public void connect(final Channel channel, final TransportMessage transportMessage) { try { log.info("Connecting to websocket %s sessionId %s", channel.getUri(), transportMessage.getSessionId()); webSocketContainer.connectToServer(new GravityWebSocketEndpoint(channel), new GravityWebSocketEndpointConfig(channel, transportMessage), channel.getUri()); } catch (Exception e) { log.error(e, "Could not connect to uri %s", channel.getUri()); getStatusHandler().handleException(new TransportException("Could not connect to uri " + channel.getUri(), e)); } }
@Override public void connect(final Channel channel, final TransportMessage transportMessage) { try { log.info("Connecting to websocket %s sessionId %s", channel.getUri(), transportMessage.getSessionId()); webSocketContainer.connectToServer(new GravityWebSocketEndpoint(channel), new GravityWebSocketEndpointConfig(channel, transportMessage), channel.getUri()); } catch (Exception e) { log.error(e, "Could not connect to uri %s", channel.getUri()); getStatusHandler().handleException(new TransportException("Could not connect to uri " + channel.getUri(), e)); } }