private Mono<Void> executeInternal(URI url, HttpHeaders headers, WebSocketHandler handler) { MonoProcessor<Void> completionMono = MonoProcessor.create(); return Mono.fromCallable( () -> { if (logger.isDebugEnabled()) { logger.debug("Connecting to " + url); } Object jettyHandler = createHandler(url, handler, completionMono); ClientUpgradeRequest request = new ClientUpgradeRequest(); request.setSubProtocols(handler.getSubProtocols()); UpgradeListener upgradeListener = new DefaultUpgradeListener(headers); return this.jettyClient.connect(jettyHandler, url, request, upgradeListener); }) .then(completionMono); }
proxyReq.setHeaders(headers); wsClient.connect(client, uri, proxyReq, new UpgradeListener() { @Override public void onHandshakeRequest(UpgradeRequest request) {
@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(); }
private void connect(final String clientId, String sessionId) throws IOException { connectionLock.lock(); try { final WebSocketMessageRouter router; try { router = routers.getRouterOrFail(clientId); } catch (WebSocketConfigurationException e) { throw new IllegalStateException("Failed to get router due to: " + e, e); } final RoutingWebSocketListener listener = new RoutingWebSocketListener(router); listener.setSessionId(sessionId); final ClientUpgradeRequest request = new ClientUpgradeRequest(); if (!StringUtils.isEmpty(authorizationHeader)) { request.setHeader(HttpHeader.AUTHORIZATION.asString(), authorizationHeader); } final Future<Session> connect = client.connect(listener, webSocketUri, request); getLogger().info("Connecting to : {}", new Object[]{webSocketUri}); final Session session; try { session = connect.get(connectionTimeoutMillis, TimeUnit.MILLISECONDS); } catch (Exception e) { throw new IOException("Failed to connect " + webSocketUri + " due to: " + e, e); } getLogger().info("Connected, session={}", new Object[]{session}); activeSessions.put(clientId, listener.getSessionId()); } finally { connectionLock.unlock(); } }
@Override public ListenableFuture<WebSocketSession> doHandshakeInternal(WebSocketHandler wsHandler, HttpHeaders headers, final URI uri, List<String> protocols, List<WebSocketExtension> extensions, Map<String, Object> attributes) { final ClientUpgradeRequest request = new ClientUpgradeRequest(); request.setSubProtocols(protocols); for (WebSocketExtension e : extensions) { request.addExtensions(new WebSocketToJettyExtensionConfigAdapter(e)); } headers.forEach(request::setHeader); Principal user = getUser(); final JettyWebSocketSession wsSession = new JettyWebSocketSession(attributes, user); final JettyWebSocketHandlerAdapter listener = new JettyWebSocketHandlerAdapter(wsHandler, wsSession); Callable<WebSocketSession> connectTask = () -> { Future<Session> future = this.client.connect(listener, uri, request); future.get(); return wsSession; }; if (this.taskExecutor != null) { return this.taskExecutor.submitListenable(connectTask); } else { ListenableFutureTask<WebSocketSession> task = new ListenableFutureTask<>(connectTask); task.run(); return task; } }
@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(); } }
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 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 Future<Session> connect(Object websocket, URI toUri) throws IOException { ClientUpgradeRequest request = new ClientUpgradeRequest(toUri); request.setRequestURI(toUri); request.setCookiesFrom(this.cookieStore); return connect(websocket,toUri,request); }
public Future<Session> connect(Object websocket, URI toUri) throws IOException { ClientUpgradeRequest request = new ClientUpgradeRequest(toUri); request.setRequestURI(toUri); request.setLocalEndpoint(websocket); return connect(websocket,toUri,request); }
public Future<Session> connect(Object websocket, URI toUri) throws IOException { ClientUpgradeRequest request = new ClientUpgradeRequest(toUri); request.setRequestURI(toUri); request.setCookiesFrom(this.cookieStore); return connect(websocket,toUri,request); }
/** * 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); } }
public void byWebSocket() { try { if (session == null || !session.isOpen()) { Future<Session> fu = ws.connect(saws, URI.create(conf.get("actuator.uplink.url", "ws://127.0.0.1:8802/monitor/websocket"))); session = fu.get(5, TimeUnit.SECONDS); } NutMap re = monitorService.getMonitors(); session.getRemote().sendString(Json.toJson(re, JsonFormat.full().setCompact(true))); } catch (Throwable e) { log.info("monitor.uplink.error", 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; }
private Mono<Void> executeInternal(URI url, HttpHeaders headers, WebSocketHandler handler) { MonoProcessor<Void> completionMono = MonoProcessor.create(); return Mono.fromCallable( () -> { String[] protocols = beforeHandshake(url, headers, handler); ClientUpgradeRequest upgradeRequest = new ClientUpgradeRequest(); upgradeRequest.setSubProtocols(protocols); Object jettyHandler = createJettyHandler(url, handler, completionMono); UpgradeListener upgradeListener = new DefaultUpgradeListener(headers); return this.jettyClient.connect(jettyHandler, url, upgradeRequest, upgradeListener); }) .then(completionMono); }
@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()); }