org.eclipse.jetty.websocket.api.StatusCode Java Examples

@Test
public void testWebsocketConnection() throws Exception{
  URI uri = URI.create(
      AbstractSubmarineServerTest.getWebsocketApiUrlToTest());
  WebSocketClient client = new WebSocketClient();
  try {
    client.start();
    // The socket that receives events
    EventSocket socket = new EventSocket();
    // Attempt Connect
    Future<Session> fut = client.connect(socket, uri);
    // Wait for Connect
    Session session = fut.get();
    // Send a message
    session.getRemote().sendString("Hello");
    // Close session
    //session.close();
    session.close(StatusCode.NORMAL, "I'm done");
  } finally {
    client.stop();
  }
}
 

@OnWebSocketMessage
public void onMessage(String msg) {
    synchronized (parent) {
        log.debug("Received message: " + msg);
        String length = " (" + msg.length() + " bytes)";
        logMessage.append(" - Received message #").append(messageCounter).append(length);
        addResponseMessage("[Message " + (messageCounter++) + "]\n" + msg + "\n\n");

        if (responseExpression == null || responseExpression.matcher(msg).find()) {
            logMessage.append("; matched response pattern").append("\n");
            closeLatch.countDown();
        } else if (!disconnectPattern.isEmpty() && disconnectExpression.matcher(msg).find()) {
            logMessage.append("; matched connection close pattern").append("\n");
            closeLatch.countDown();
            close(StatusCode.NORMAL, "JMeter closed session.");
        } else {
            logMessage.append("; didn't match any pattern").append("\n");
        }
    }
}
 

/**
 * Cleanup sessions
 */
private void cleanupOnError(final Throwable t) {

  LOG.onError(t.toString());
  if (t.toString().contains("exceeds maximum size")) {
    if(frontendSession != null && !frontendSession.isOpen()) {
      frontendSession.close(StatusCode.MESSAGE_TOO_LARGE, t.getMessage());
    }
  }

  else {
    if(frontendSession != null && !frontendSession.isOpen()) {
      frontendSession.close(StatusCode.SERVER_ERROR, t.getMessage());
    }
    cleanup();
  }
}
 

@Override
public final void onWebSocketClose(final int statusCode, final String reason) {
  if (statusCode != StatusCode.NORMAL) {
    LOG.warn("WebSocket session closed abnormally: {} - {}.", statusCode, reason);
  }
  MetricBroadcaster.getInstance().removeSession(session);
}
 

@OnWebSocketError
public void onError(Throwable error) {
    LOGGER.error("{} closing session because an error was thrown", sessionName(), error);
    try {
        close(StatusCode.SERVER_ERROR, error.getMessage());
    } finally {
        socketHealthService.deregister(this);
    }
}
 

@Override
public void onWebSocketError(Throwable e) {
    logger.debug("{}: Error during websocket communication: {}", getDeviceName(), e.getMessage(), e);
    updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
    if (commandExecutor != null) {
        commandExecutor.postOperationMode(OperationModeType.OFFLINE);
        commandExecutor = null;
    }
    if (session != null) {
        session.close(StatusCode.SERVER_ERROR, getDeviceName() + ": Failure: " + e.getMessage());
        session = null;
    }
}
 

public boolean awaitClose(int duration, TimeUnit unit) throws InterruptedException {
    logMessage.append(" - Waiting for messages for ").append(duration).append(" ").append(unit.toString()).append("\n");
    boolean res = this.closeLatch.await(duration, unit);

    if (!parent.isStreamingConnection()) {
        close(StatusCode.NORMAL, "JMeter closed session.");
    } else {
        logMessage.append(" - Leaving streaming connection open").append("\n");
    }

    return res;
}
 

@OnWebSocketFrame
public void onFrame(Frame frame) {
	synchronized (parent) {
		log.debug("Received frame: " + frame.getPayload() + " "
				+ frame.getType().name());
		String length = " (" + frame.getPayloadLength() + " bytes)";
		logMessage.append(" - Received frame #").append(messageCounter)
				.append(length);
		String frameTxt = new String(frame.getPayload().array());
		addResponseMessage("[Frame " + (messageCounter++) + "]\n"
				+ frameTxt + "\n\n");

		if (responseExpression == null
				|| responseExpression.matcher(frameTxt).find()) {
			logMessage.append("; matched response pattern").append("\n");
			closeLatch.countDown();
		} else if (!disconnectPattern.isEmpty()
				&& disconnectExpression.matcher(frameTxt).find()) {
			logMessage.append("; matched connection close pattern").append(
					"\n");
			closeLatch.countDown();
			close(StatusCode.NORMAL, "JMeter closed session.");
		} else {
			logMessage.append("; didn't match any pattern").append("\n");
		}
	}
}
 

@OnWebSocketConnect
public void onConnect(Session session) {
	System.out.printf("Got connect: %s%n", session);
	this.session = session;
	try {
		Future<Void> fut;
		fut = session.getRemote().sendStringByFuture("Hello");
		fut.get(2, TimeUnit.SECONDS);
		fut = session.getRemote().sendStringByFuture("Thanks for the conversation.");
		fut.get(2, TimeUnit.SECONDS);
		session.close(StatusCode.NORMAL, "I'm done");
	} catch (Throwable t) {
		t.printStackTrace();
	}
}
 

@OnWebSocketConnect
public void onConnect(Session session) {
  System.out.printf("Got connect: %s%n",session);
  try {
    Future<Void> fut = session.getRemote().sendStringByFuture("{\"field1\" : \"value\"}");
    fut.get(2, TimeUnit.SECONDS); // wait for send to complete.

    session.close(StatusCode.NORMAL,"I'm done");
  } catch (Throwable t) {
    t.printStackTrace();
  }
}
 

@OnWebSocketClose
public void onClose(int statusCode, String reason) {
  if (statusCode != StatusCode.NORMAL) {
    LOG.error(Utils.format("WebSocket Connection closed: {} - {}", statusCode, reason));
  }
  this.closeLatch.countDown();
}
 

@OnWebSocketClose
public void onClose(int statusCode, String reason) {
  if (statusCode != StatusCode.NORMAL) {
    LOG.error(Utils.format("WebSocket Connection closed: {} - {}", statusCode, reason));
    try {
      connectToWebSocket();
    } catch (Exception e) {
      LOG.error(Errors.WEB_SOCKET_01.getMessage(), e.toString(), e);
    }
  }
}
 

public void stopServer() {
    try {
        if (server.isStarted()) {
            HarCompareHandler.closeAll(StatusCode.SHUTDOWN, "EXIT");
            server.stop();
            server.join();
        }
    } catch (Exception ex) {
        LOG.log(Level.SEVERE, ex.getMessage(), ex);
    }
}
 

@OnWebSocketClose
public void onClose(int statusCode, String reason) {
	if (statusCode != StatusCode.NORMAL)
		log.error("Disconnect " + statusCode + ": " + reason);
	else
		log.debug("Disconnect " + statusCode + ": " + reason);
    openLatch.countDown();
    closeLatch.countDown();
    connected = false;
}
 

@OnWebSocketClose
public void onClose(int statusCode, String reason) {
    session.close(StatusCode.NORMAL, "I'm done");
    this.session = null;
    this.closeLatch.countDown();
}
 

public void close() {
    close(StatusCode.NORMAL, "JMeter closed session.");
}
 

private boolean confirmClose(int statusCode, String reason) {
    return statusCode == StatusCode.NORMAL
            || SDKConstants.WEBSOCKET_STATUS_MESSAGE_SHUTDOWN.equalsIgnoreCase(reason);
}
 

public void close() {
    close(StatusCode.NORMAL, "JMeter closed session.");
}
 

public void close() {
    if (session != null) {
        this.session.close(StatusCode.NORMAL, "Closing");
    }
}
 

@Override
public void close(final String reason) throws IOException {
    session.close(StatusCode.NORMAL, reason);
}
 

@Override
public void close(final String reason) throws IOException {
    session.close(StatusCode.NORMAL, reason);
}
 

@Override
public void close() {
    close(StatusCode.NORMAL, null);
}