@Override public void start() { if (!this.externallyManaged) { try { this.jettyClient.start(); } catch (Exception ex) { throw new IllegalStateException("Failed to start Jetty WebSocketClient", ex); } } }
@Override public void start() { try { this.client.start(); } catch (Exception ex) { throw new IllegalStateException("Failed to start Jetty WebSocketClient", ex); } }
@Override public TransportConnection connect( HostnamePort address ) throws Exception { URI target = uriGenerator.apply( address ); client = clientSupplier.get(); client.start(); Session session; try { session = client.connect( this, target ).get( 10, SECONDS ); } catch ( Exception e ) { throw new IOException( "Failed to connect to the server within 10 seconds", e ); } server = session.getRemote(); return this; }
public Session connect(AgentWebSocketClientController controller) throws Exception { if (webSocketClient == null || !webSocketClient.isRunning()) { if (webSocketClient != null) { webSocketClient.stop(); } webSocketClient = builder.build(); webSocketClient.start(); } LOG.info("Connecting to websocket endpoint: {}", urlService.getAgentRemoteWebSocketUrl()); ClientUpgradeRequest request = new ClientUpgradeRequest(); request.addExtensions("fragment;maxLength=" + getMessageBufferSize()); return webSocketClient.connect(controller, new URI(urlService.getAgentRemoteWebSocketUrl()), request).get(); }
try { httpClient.start(); wsClient.start(); } catch (Exception e) { throw new RuntimeException(e);
@SuppressWarnings("FutureReturnValueIgnored") @Test public void checkPlainConnect() throws Exception { LOG.info("*** checkPlainConnect ***"); String destUri = "ws://localhost:" + BrokerConstants.WEBSOCKET_PORT + "/mqtt"; MQTTWebSocket socket = new MQTTWebSocket(); client.start(); URI echoUri = new URI(destUri); ClientUpgradeRequest request = new ClientUpgradeRequest(); client.connect(socket, echoUri, request); LOG.info("Connecting to : {}", echoUri); boolean connected = socket.awaitConnected(4, TimeUnit.SECONDS); LOG.info("Connected was : {}", connected); assertTrue(connected); } }
private Code makeWsRequest(final String username, final String password) throws Exception { final WebSocketClient wsClient = new WebSocketClient(); wsClient.start(); try { final ClientUpgradeRequest request = new ClientUpgradeRequest(); if (!username.isEmpty()) { final String authHeader = "Basic " + buildBasicAuthHeader(username, password); request.setHeader(HttpHeaders.AUTHORIZATION, authHeader); } final WebSocketListener listener = new WebSocketListener(); final URI wsUri = REST_APP.getWsListener().resolve("/ws/query"); wsClient.connect(listener, wsUri, request); assertThat("Response received", listener.latch.await(30, TimeUnit.SECONDS), is(true)); final Throwable error = listener.error.get(); return error == null ? Code.OK : extractStatusCode(error); } finally { wsClient.stop(); } }
client.start(); activeSessions.clear();
public void start() { System.out.println("Starting websocket"); webSocketClient = new WebSocketClient(); try { webSocketClient.start(); } catch (Exception e) { LOGGER.error("", e); } try { URI uri = URI.create("ws://" + address + "/stream"); System.out.println(uri); webSocketImpl = new WebSocketImpl(this); ClientUpgradeRequest request = new ClientUpgradeRequest(); webSocketClient.connect(webSocketImpl, uri, request); webSocketImpl.waitForEndpointId(); running = true; } catch (IOException e) { LOGGER.error("", e); } }
@Override public void run(CommandLine theCommandLine) throws ParseException { String target = theCommandLine.getOptionValue("t"); if (isBlank(target) || (!target.startsWith("ws://") && !target.startsWith("wss://"))) { throw new ParseException("Target (-t) needs to be in the form \"ws://foo\" or \"wss://foo\""); } IdDt subsId = new IdDt(theCommandLine.getOptionValue("i")); WebSocketClient client = new WebSocketClient(); SimpleEchoSocket socket = new SimpleEchoSocket(subsId.getIdPart()); try { client.start(); URI echoUri = new URI(target); ClientUpgradeRequest request = new ClientUpgradeRequest(); ourLog.info("Connecting to : {}", echoUri); client.connect(socket, echoUri, request); while (!myQuit) { Thread.sleep(500L); } ourLog.info("Shutting down websocket client"); } catch (Exception e) { throw new CommandFailureException(e); } finally { try { client.stop(); } catch (Exception e) { ourLog.error("Failure", e); } } }
@Override public void start() { try { this.client.start(); } catch (Exception ex) { throw new IllegalStateException("Failed to start Jetty WebSocketClient", ex); } }
@Override public void start() { try { this.client.start(); } catch (Exception ex) { throw new IllegalStateException("Failed to start Jetty WebSocketClient", ex); } }
@Override public void connect(String target) { try { socket = new WSClientSocket(this); client.start(); client.connect(socket, new URI(target)); } catch (Exception e) { e.printStackTrace(); } }
public LeoSocket() { client = new WebSocketClient(); String destUri = "ws://localhost:5000"; try { System.out.println("start client"); client.start(); URI echoUri = new URI(destUri); ClientUpgradeRequest request = new ClientUpgradeRequest(); System.out.println("connect client"); client.connect(this, echoUri, request); System.out.println("Connecting to : "+echoUri); } catch (Throwable t) { System.out.println("failed to connect web socket"); t.printStackTrace(); } }
public void init() throws Exception { saws = new SimpleActuatorWebSocket(); ws = new WebSocketClient(); ws.start(); } }
URI serverURI = new URI("wss://domain:port/websocket"); ClassLoader classLoader = getClass().getClassLoader(); URL url = classLoader.getResource("resources/domain.jks"); SslContextFactory sslContextFactory = new SslContextFactory(); Resource keyStoreResource = Resource.newResource(url); sslContextFactory.setKeyStoreResource(keyStoreResource); sslContextFactory.setKeyStorePassword("Keystore Password"); sslContextFactory.setKeyManagerPassword("Keystore Password"); WebSocketClient webSocketClient = new WebSocketClient(sslContextFactory); ClientUpgradeRequest request = new ClientUpgradeRequest(); request.setSubProtocols("xsCrossfire"); String basicAuthHeader = HttpBasicAuthHeader.generateBasicAuthHeader("username", "password"); request.setHeader("Authorization", "Basic " + basicAuthHeader); webSocketClient.start();
@Override public Future<Session> connect(Object websocket, URI uri) { client = new WebSocketClient(); client.getPolicy().setIdleTimeout(TIMEOUT); try { client.start(); } catch (Exception e) { e.printStackTrace(); } try { return client.connect(websocket, uri); } catch (IOException e) { throw new RuntimeException(e); } }
/** * Opens the initial websocket connection with the gateway. */ void connect() { try { wsClient = new WebSocketClient(new SslContextFactory()); wsClient.getPolicy().setMaxBinaryMessageSize(Integer.MAX_VALUE); wsClient.getPolicy().setMaxTextMessageSize(Integer.MAX_VALUE); wsClient.start(); wsClient.connect(this, new URI("wss://" + endpoint), new ClientUpgradeRequest()); } catch (Exception e) { Discord4J.LOGGER.error(LogMarkers.VOICE_WEBSOCKET, "Encountered error while connecting voice websocket: ", e); } }
@Override public Connection connect( HostnamePort address ) throws Exception { URI target = URI.create( "ws://" + address.getHost() + ":" + address.getPort() ); client = new WebSocketClient(); client.start(); session = client.connect( this, target ).get( 30, TimeUnit.SECONDS ); server = session.getRemote(); return this; }
@Before public void setup() throws Exception { client.start(); URI socketUri = new URI(getAPIv2().path("socket").getUri().toString().replace("http://", "ws://")); ClientUpgradeRequest request = new ClientUpgradeRequest(); request.setSubProtocols(Lists.newArrayList(getAuthHeaderValue())); this.socket = new TestSocket(); client.connect(socket, socketUri, request); socket.awaitConnection(2); assertEquals(getAuthHeaderValue(), socket.session.getUpgradeResponse().getAcceptedSubProtocol()); }