Refine search
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(); } }
@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; } }
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 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); }
private void connect() throws Exception { wsSession = null; client = new WebSocketClient(); client.start(); client.setAsyncWriteTimeout(5000); client.setConnectTimeout(2000); client.setStopTimeout(5000); ClientUpgradeRequest request = new ClientUpgradeRequest(); request.setHeader("Authorization", SSHUtil.getPublicKeyAuthorization(username)); Future<Session> future = client.connect(this, uri, request); logger.info(String.format("Connecting to : %s", uri)); try { wsSession = future.get(); } catch (Exception e) { logger.log(Level.INFO, "Exception while trying to connect", e); try { client.stop(); client.destroy(); } catch (Exception e1) { logger.log(Level.INFO, "Exception while trying to disconnect", e1); } } } @OnWebSocketClose
@Override protected void connectNativeClient() throws TimeoutException, Exception { if (jettyClient == null || jettyClient.isStopped() || jettyClient.isStopping()) { jettyClient = new WebSocketClient(sslContextFactory); jettyClient.setConnectTimeout(this.connectionTimeout); WebSocketPolicy policy = jettyClient.getPolicy(); jettyClient.connect(new WebSocketClientSocket(), uri, new ClientUpgradeRequest()) .get(this.connectionTimeout, TimeUnit.MILLISECONDS);
@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); } }
@Override public void connect(final Channel channel, final TransportMessage transportMessage) { try { ClientUpgradeRequest request = new ClientUpgradeRequest(); request.setRequestURI(channel.getUri()); String protocol = "org.granite.gravity." + transportMessage.getContentType().substring("application/x-".length()); request.setSubProtocols(protocol); if (transportMessage.getSessionId() != null) webSocketClient.getCookieStore().add(channel.getUri(), new HttpCookie("JSESSIONID", transportMessage.getSessionId())); request.setCookiesFrom(webSocketClient.getCookieStore()); request.setHeader("connectId", transportMessage.getId()); request.setHeader("GDSClientType", transportMessage.getClientType().toString()); String clientId = transportMessage.getClientId() != null ? transportMessage.getClientId() : channel.getClientId(); if (clientId != null) request.setHeader("GDSClientId", clientId); log.info("Connecting to websocket %s protocol %s sessionId %s clientId %s", channel.getUri(), protocol, transportMessage.getSessionId(), clientId); webSocketClient.connect(new WebSocketHandler(channel), channel.getUri(), request); } 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)); } }
@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()); }
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); }
client.setConnectTimeout(conTimeout * 1000); if (client.isStarted() == false) { client.start(); request.setSubProtocols(subProtocol); final Future<Session> future = client.connect(this, uri, request);
ClientUpgradeRequest proxyReq = new ClientUpgradeRequest(); proxyReq.setMethod(req.getMethod()); Map<String, List<String>> headers = new LinkedHashMap<>(); copyRequestHeaders(req, (key, value) -> headers.computeIfAbsent(key, k -> new ArrayList<>()).add(value)); proxyReq.setHeaders(headers); wsClient.connect(client, uri, proxyReq, new UpgradeListener() { @Override public void onHandshakeRequest(UpgradeRequest request) {
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(); } }
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();
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); }
logger.debug("Opening websocket session to {}", uri); _webSocketClient.setConnectTimeout(getConnectTimeout()); _webSocketClient.getPolicy().setIdleTimeout(getIdleTimeout()); ClientUpgradeRequest request = new ClientUpgradeRequest(); String protocol = getProtocol(); if (protocol != null) { request.setSubProtocols(protocol);
/** * A factory method for {@link ClientUpgradeRequest} class * * @return */ protected ClientUpgradeRequest createClientUpgradeRequest() { final ClientUpgradeRequest request = new ClientUpgradeRequest(); // you can manipulate the request by overriding this method. return request; }
WebSocketClientConnection connection = new WebSocketClientConnection(endp,wsClient.getExecutor(),wsClient.getScheduler(),localEndpoint.getPolicy(), wsClient.getBufferPool()); session.setUpgradeRequest(new ClientUpgradeRequest(this)); session.setUpgradeResponse(new ClientUpgradeResponse(response)); connection.addListener(session);
public Future<Session> connect(Object websocket, URI toUri, ClientUpgradeRequest request) throws IOException if (!isStarted()) request.setRequestURI(toUri); request.setCookiesFrom(this.cookieStore); for (ExtensionConfig reqExt : request.getExtensions()) ConnectionManager manager = getConnectionManager();
this.setCookies(wsRequest.getCookies()); setSubProtocols(subProtocol); addExtensions(ext); setHttpVersion(wsRequest.getVersion().toString()); setMethod(wsRequest.getMethod());