Refine search
@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(); } }
private int getMessageBufferSize() { return webSocketClient.getPolicy().getMaxBinaryMessageBufferSize(); } }
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(); }
@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 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); } }
@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()); }
uri = new URI(sb.toString()); } catch (URISyntaxException e) { throw new RuntimeException(e); 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) {
methodName, "252", new Object[] { uri.toString(), Integer.valueOf(uri.getPort()), Long.valueOf(conTimeout * 1000) }); client.setConnectTimeout(conTimeout * 1000); if (client.isStarted() == false) { client.start(); request.setSubProtocols(subProtocol); final Future<Session> future = client.connect(this, uri, request);
sslContextFactory = createSslFactory(sslService, false, false); client = new WebSocketClient(sslContextFactory); configurePolicy(context, client.getPolicy()); final String userName = context.getProperty(USER_NAME).evaluateAttributeExpressions().getValue(); final String userPassword = context.getProperty(USER_PASSWORD).evaluateAttributeExpressions().getValue(); client.start(); activeSessions.clear(); webSocketUri = new URI(context.getProperty(WS_URI).evaluateAttributeExpressions().getValue()); connectionTimeoutMillis = context.getProperty(CONNECTION_TIMEOUT).evaluateAttributeExpressions().asTimePeriod(TimeUnit.MILLISECONDS);
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();
protected Delegate connect(WebSocketClient client, ClientUpgradeRequest request, String uri) throws IOException, InterruptedException { try { Delegate delegate = newDelegate(); client.connect(delegate, new URI(uri), request, this).get(); return delegate; } catch (ExecutionException x) { Throwable cause = x.getCause(); if (cause instanceof RuntimeException) { throw (RuntimeException)cause; } if (cause instanceof IOException) { throw (IOException)cause; } throw new IOException(cause); } catch (URISyntaxException x) { throw new IOException(x); } }
public Future<Session> connect(Object websocket, URI toUri, ClientUpgradeRequest request) throws IOException if (!isStarted()) if (!toUri.isAbsolute()) if (StringUtil.isBlank(toUri.getScheme())) String scheme = toUri.getScheme().toLowerCase(Locale.ENGLISH); if (("ws".equals(scheme) == false) && ("wss".equals(scheme) == false)) request.setRequestURI(toUri); request.setCookiesFrom(this.cookieStore); for (ExtensionConfig reqExt : request.getExtensions()) ConnectionManager manager = getConnectionManager();
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); } }
if (!isStarted()) throw new IllegalStateException(WebSocketClient.class.getSimpleName() + "@" + this.hashCode() + " is not started"); if (!toUri.isAbsolute()) if (StringUtil.isBlank(toUri.getScheme())) String scheme = toUri.getScheme().toLowerCase(Locale.ENGLISH); if (("ws".equals(scheme) == false) && ("wss".equals(scheme) == false)) request.setRequestURI(toUri); request.setLocalEndpoint(websocket); for (ExtensionConfig reqExt : request.getExtensions()) LOG.debug("connect websocket {} to {}",websocket,toUri); init();
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(); policy.setMaxBinaryMessageBufferSize(maxPacketSize); policy.setMaxTextMessageBufferSize(maxPacketSize); policy.setMaxTextMessageSize(maxPacketSize); jettyClient.start(); jettyClient.connect(new WebSocketClientSocket(), uri, new ClientUpgradeRequest()) .get(this.connectionTimeout, TimeUnit.MILLISECONDS);
@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); } }
@Override public void stop() { if (!this.externallyManaged) { try { this.jettyClient.stop(); } catch (Exception ex) { throw new IllegalStateException("Error stopping Jetty WebSocketClient", ex); } } }