Refine search
@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()); }
public void setMaxTextMessageBufferSize(int bufferSize) { this.webSocketContainer.setDefaultMaxTextMessageBufferSize(bufferSize); }
public long getMaxSessionIdleTimeout() { return this.webSocketContainer.getDefaultMaxSessionIdleTimeout(); }
@Autowired private LogWebSocketHandler socketHandler; private WebSocketContainer container; private TestWebSocketClient client; @Before public void setup() { container = ContainerProvider.getWebSocketContainer(); client = new TestWebSocketClient(); } @Test public void createSessionAfterOpenLogWebSocketHandler() throws Exception { container.connectToServer(client , URI.create("ws://localhost:8080/path")); while( !socketHandler.isOpen()){ // sometime it is doesn't work, but I dont know solution of this problem // wait until socket is open } Assert.assertTrue( socketHandler.isOpen() ); }
/** * Connect the WebSocket to the server pointing to /ws/{token} to receive events. * * @throws SaltException in case of an error during stream initialization */ private void initializeStream(URI uri, Token token, long sessionIdleTimeout, long idleTimeout) throws SaltException { try { URI adjustedURI = new URI(uri.getScheme() == "https" ? "wss" : "ws", uri.getSchemeSpecificPart(), uri.getFragment()) .resolve("ws/" + token.getToken()); websocketContainer.setDefaultMaxSessionIdleTimeout(sessionIdleTimeout); // Initiate the websocket handshake synchronized (websocketContainer) { session = websocketContainer.connectToServer(this, adjustedURI); session.setMaxIdleTimeout(idleTimeout); } } catch (URISyntaxException | DeploymentException | IOException e) { throw new SaltException(e); } }
private static WebSocketClientEndpoint connect(WebSocketContainer webSocketContainer, XDIWebSocketClient xdiWebSocketClient, URI xdiWebSocketEndpointUri) throws Exception { // init websocket endpoint List<String> preferredSubprotocols = Arrays.asList(new String[] { "xdi" }); List<Extension> extensions = null; List<Class<? extends Encoder>> encoders = null; List<Class<? extends Decoder>> decoders = null; ClientEndpointConfig.Configurator clientEndpointConfigConfigurator = new ClientEndpointConfig.Configurator() { }; ClientEndpointConfig.Builder clientEndpointConfigBuilder = ClientEndpointConfig.Builder.create(); clientEndpointConfigBuilder.preferredSubprotocols(preferredSubprotocols); clientEndpointConfigBuilder.extensions(extensions); clientEndpointConfigBuilder.encoders(encoders); clientEndpointConfigBuilder.decoders(decoders); clientEndpointConfigBuilder.configurator(clientEndpointConfigConfigurator); ClientEndpointConfig clientEndpointConfig = clientEndpointConfigBuilder.build(); clientEndpointConfig.getUserProperties().put("xdiWebSocketClient", xdiWebSocketClient); clientEndpointConfig.getUserProperties().put("xdiWebSocketEndpointUri", xdiWebSocketEndpointUri); // connect websocket endpoint WebSocketClientEndpoint webSocketEndpoint = new WebSocketClientEndpoint(); Session session = webSocketContainer.connectToServer(webSocketEndpoint, clientEndpointConfig, URI.create(xdiWebSocketEndpointUri.toString())); webSocketEndpoint.setSession(session); // done log.info("Connected WebSocket endpoint for " + xdiWebSocketEndpointUri + " with preferred subprotocols " + preferredSubprotocols); return webSocketEndpoint; }
/** * Connects to the WebSocketServer creating a WebSocket session * * @return - the WebSocket session created * @throws WebSocketException * - If a message handler has already been registered for the * associated message type */ public Session connect() throws WebSocketException { try { WebSocketContainer container = ContainerProvider .getWebSocketContainer(); logger.info("Opening connection to {}", uri.toString()); wsSession = container.connectToServer(this, wsConfig, uri); wsSession.addMessageHandler(this.handler); } catch (Exception e) { throw new WebSocketException(e); } return wsSession; }
private void connectToServer(String serverAddress, int webSocketPort, int connectionRetryLimit) { WebSocketContainer container = ContainerProvider.getWebSocketContainer(); container.setDefaultMaxTextMessageBufferSize(Integer.MAX_VALUE); String uriAddress = String.format(SERVER_URI, serverAddress, webSocketPort); Exception innerException = null; do { try { session = container.connectToServer(ClientEndpoint.class, new URI(uriAddress)); LOGGER.info("Connected to server address: " + uriAddress); return; } catch (DeploymentException | IOException | URISyntaxException e) { innerException = e; connectionRetryLimit--; } try { Thread.sleep(1000); } catch (InterruptedException e) { } } while (connectionRetryLimit > 0); LOGGER.error("Connecting to server failed!", innerException); throw new ServerConnectionFailedException("Connecting to server retry limit reached.", innerException); }
@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; } }
@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); } }); }
maxTextMessageBufferSize = container.getDefaultMaxTextMessageBufferSize(); maxBinaryMessageBufferSize = container.getDefaultMaxBinaryMessageBufferSize(); service = ((ExecutorServiceProvider) container).getScheduledExecutorService(); setMaxIdleTimeout(container.getDefaultMaxSessionIdleTimeout());
public void setMaxBinaryMessageBufferSize(int bufferSize) { this.webSocketContainer.setDefaultMaxBinaryMessageBufferSize(bufferSize); }
public static WebSocketClientEndpoint connect(XDIWebSocketClient xdiWebSocketClient, URI xdiWebSocketEndpointUri) throws Exception { // create client container WebSocketContainer webSocketContainer = ContainerProvider.getWebSocketContainer(); // set default timeout long oldDefaultMaxSessionIdleTimeout = webSocketContainer.getDefaultMaxSessionIdleTimeout(); long newDefaultMaxSessionIdleTimeout = 0; webSocketContainer.setDefaultMaxSessionIdleTimeout(newDefaultMaxSessionIdleTimeout); if (log.isDebugEnabled()) log.debug("Changed default max session idle timeout from " + oldDefaultMaxSessionIdleTimeout + " to " + newDefaultMaxSessionIdleTimeout); // connect return connect(webSocketContainer, xdiWebSocketClient, xdiWebSocketEndpointUri); }
public void setMaxSessionIdleTimeout(long timeoutInMillis) { this.webSocketContainer.setDefaultMaxSessionIdleTimeout(timeoutInMillis); }
/** * @author Arun Gupta */ public class Client { final static CountDownLatch messageLatch = new CountDownLatch(1); public static void main(String[] args) { try { WebSocketContainer container = ContainerProvider.getWebSocketContainer(); String uri = "ws://echo.websocket.org:80/"; System.out.println("Connecting to " + uri); container.connectToServer(MyClientEndpoint.class, URI.create(uri)); messageLatch.await(100, TimeUnit.SECONDS); } catch (DeploymentException | InterruptedException | IOException ex) { Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex); } } }
@Override public void onWebSocketConnect(final Session frontEndSession) { /* * Let's connect to the backend, this is where the Backend-to-frontend * plumbing takes place */ container = ContainerProvider.getWebSocketContainer(); final ProxyInboundClient backendSocket = new ProxyInboundClient(getMessageCallback()); /* build the configuration */ /* Attempt Connect */ try { backendSession = container.connectToServer(backendSocket, clientConfig, backend); LOG.onConnectionOpen(backend.toString()); } catch (DeploymentException e) { LOG.connectionFailed(e); throw new RuntimeException(e); } catch (IOException e) { LOG.connectionFailed(e); throw new RuntimeIOException(e); } super.onWebSocketConnect(frontEndSession); this.frontendSession = frontEndSession; }
@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 = () -> { 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; } }
@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); } }); }
maxTextMessageBufferSize = container.getDefaultMaxTextMessageBufferSize(); maxBinaryMessageBufferSize = container.getDefaultMaxBinaryMessageBufferSize(); service = ((ExecutorServiceProvider) container).getScheduledExecutorService(); setMaxIdleTimeout(container.getDefaultMaxSessionIdleTimeout());
@Override public void setDefaultMaxBinaryMessageBufferSize(int i) { if (webSocketContainer == null) { maxBinaryMessageBufferSize = i; } else { webSocketContainer.setDefaultMaxBinaryMessageBufferSize(i); } }