import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
/** Broadcast text to all connected clients. */
void broadcast(String message, Session sourceSession) {
	String sourceName = null;
	synchronized(sessionToName) {
		sourceName = sessionToName.get(sourceSession);
	}
	if (sourceName != null && !sourceName.isEmpty()) {
		message = "<strong>" + sourceName + "</strong>: " + message;
	}
	synchronized(sessionToName) {
		for (Session s : sessionToName.keySet()) {
			try {
				if (s.isOpen()) {
					s.getRemote().sendStringByFuture(message);
				}
			} catch (WebSocketException e) {
				System.out.println("The error " + e.getLocalizedMessage() + " occurred. This " 
						+ "can happen if the player dies before a broadcast arrives.");
			}
		}
	}
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
void sendJson(Json json) throws WebSocketException, IOException {
    try {
        executor.submit(() -> {
            try {
                session.getRemote().sendString(json.toString());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }).get();
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } catch (ExecutionException e) {
        Throwable inner = e.getCause();
        Throwable cause = inner.getCause();
        if (cause instanceof IOException) {
            throw (IOException) cause;
        } else {
            assert inner instanceof RuntimeException; // We know the runnable never throws a checked exception
            throw (RuntimeException) inner;
        }
    }
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
/** Send text to a single client */
void unicast(String message, Session session) {
	try {
		if (session.isOpen()) {
			session.getRemote().sendStringByFuture(message);
		}
	} catch (WebSocketException e) {
		System.out.println("The error " + e.getLocalizedMessage() + " occurred. This " 
				+ "can happen if the player dies before a unicast arrives.");
	}
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@Override
public void onWebSocketText(String message)
{
    for (Session sess: sockets.values()){
        if (!sess.isOpen()) {
            sockets.remove(sess.getRemoteAddress().toString());
        } else {
            try {
                sess.getRemote().sendString(message);
            } catch (IOException | WebSocketException | IllegalStateException e) {
                // continue it may be closing / blocking etc..
                sockets.remove(sess.getRemoteAddress().toString());
            }
        }
    }
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@Override
public void write(String message, Object writeLock) throws IOException {
    // The explicit connnectionClosed check is because the session is null until the connection is initially established
    if (connectionClosed) {
        throw new EOFException("WebSocket is closed.");
    }

    if (queuedMessageCount.get() > MAX_QUEUED_MESSAGES.get()) {
        throw new IOException("Reached max queued messages [" + MAX_QUEUED_MESSAGES.get() + "].");
    }

    if (session != null && session.isOpen()) {
        try {
            session.getRemote().sendString(message, new WebSocketWriteCallback(this));
            queuedMessageCount.incrementAndGet();
        } catch (WebSocketException e) {
            // Thrown if getRemote() determines the connection was closed by the client. No need to log.
            close();
        }
    }
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
public synchronized void broadcast(JSONObject message){
	if(message == null)
		return;
	
	for(ClientWebSocket subscriber : subscribers){
		try{
			subscriber.session.getRemote().sendStringByFuture(message.toString());
		}catch(WebSocketException e){
			subscribers.remove(subscriber);
			log.error(e);
		}
	}
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@Test
public void whenWebSocketFailsThenPingShouldThrowException() throws IOException {
    JsonSession session = mock(JsonSession.class);

    when(session.isOpen()).thenReturn(true);
    doThrow(new WebSocketException()).when(session).sendJson(any());

    exception.expect(RuntimeException.class);

    WebSocketPing.ping(session);
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@Test
public void whenWebSocketClosesThenPingShouldNotThrowException() throws IOException {
    JsonSession session = mock(JsonSession.class);

    when(session.isOpen()).thenReturn(false);
    doThrow(new WebSocketException()).when(session).sendJson(any());

    WebSocketPing.ping(session);
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
/**
 * Send POST response
 *
 * This method is used by the connection acceptor to return the POST response
 *
 * @param   requestId           Request identifier
 * @param   response            Response message
 * @throws  IOException         I/O error occurred
 */
public void sendResponse(long requestId, String response) throws IOException {
    lock.lock();
    try {
        if (session != null && session.isOpen()) {
            byte[] responseBytes = response.getBytes("UTF-8");
            int responseLength = responseBytes.length;
            int flags = 0;
            if (isGzipEnabled && responseLength>=MIN_COMPRESS_SIZE) {
                flags |= FLAG_COMPRESSED;
                ByteArrayOutputStream outStream = new ByteArrayOutputStream(responseLength);
                try (GZIPOutputStream gzipStream = new GZIPOutputStream(outStream)) {
                    gzipStream.write(responseBytes);
                }
                responseBytes = outStream.toByteArray();
            }
            ByteBuffer buf = ByteBuffer.allocate(responseBytes.length + 20);
            buf.putInt(version)
               .putLong(requestId)
               .putInt(flags)
               .putInt(responseLength)
               .put(responseBytes)
               .flip();
            if (buf.limit() > MAX_MESSAGE_SIZE) {
                throw new ProtocolException("POST response length exceeds max message size");
            }
            session.getRemote().sendBytes(buf);
        }
    } catch (WebSocketException exc) {
        throw new SocketException(exc.getMessage());
    } finally {
        lock.unlock();
    }
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@FailedTest
public static void retrieveGstreamerDots() {
  if (kurentoClient != null) {
    try {
      List<MediaPipeline> pipelines = kurentoClient.getServerManager().getPipelines();
      log.debug("Retrieving GStreamerDots for all pipelines in KMS ({})", pipelines.size());

      for (MediaPipeline pipeline : pipelines) {

        String pipelineName = pipeline.getName();
        log.debug("Saving GstreamerDot for pipeline {}", pipelineName);

        String gstreamerDotFile = KurentoTest.getDefaultOutputFile("-" + pipelineName);

        try {
          FileUtils.writeStringToFile(new File(gstreamerDotFile), pipeline.getGstreamerDot());

        } catch (IOException ioe) {
          log.error("Exception writing GstreamerDot file", ioe);
        }
      }
    } catch (WebSocketException e) {
      log.warn("WebSocket exception while reading existing pipelines. Maybe KMS is closed: {}:{}",
          e.getClass().getName(), e.getMessage());
    }
  }
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@Override
public synchronized void writeBytes(Address toAddress,
                                    byte[] message,
                                    long timeout,
                                    TimeUnit unit,
                                    final SuccessAction successAction,
                                    final FailureAction failureAction) {
    if (!(toAddress instanceof WebSocketClientAddress)) {
        throw new JoynrIllegalStateException("Web Socket Server can only send to WebSocketClientAddresses");
    }

    WebSocketClientAddress toClientAddress = (WebSocketClientAddress) toAddress;
    Session session = sessionMap.get(toClientAddress.getId());
    if (session == null) {
        //TODO We need a delay with invalidation of the stub
        throw new JoynrDelayMessageException("no active session for WebSocketClientAddress: "
                + toClientAddress.getId());
    }
    try {
        session.getRemote().sendBytes(ByteBuffer.wrap(message), new WriteCallback() {
            @Override
            public void writeSuccess() {
                successAction.execute();
            }

            @Override
            public void writeFailed(Throwable error) {
                if (shutdown) {
                    return;
                }
                failureAction.execute(error);
            }
        });
    } catch (WebSocketException e) {
        // Jetty throws WebSocketException when expecting [OPEN or CONNECTED] but found a different state
        // The client must reconnect, but the message can be queued in the mean time.
        sessionMap.remove(toClientAddress.getId());
        //TODO We need a delay with invalidation of the stub
        throw new JoynrDelayMessageException(e.getMessage(), e);
    }
}
 

import org.eclipse.jetty.websocket.api.WebSocketException; //导入依赖的package包/类
@Test
public void whenSendJsonSeesAWebSocketExceptionThenItShouldThrowItBack() throws IOException {
    doThrow(WebSocketException.class).when(remote).sendString(any());

    JsonSession jsonSession = new JsonSession(client, uri);

    exception.expect(WebSocketException.class);

    jsonSession.sendJson(Json.object(ACTION, ACTION_END));
}