Java Code Examples for org.eclipse.jetty.websocket.servlet.ServletUpgradeResponse#sendError()

@Override
public PlayerSocket createWebSocket(ServletUpgradeRequest servletRequest, ServletUpgradeResponse response) {
    HttpServletRequest request = servletRequest.getHttpServletRequest();
    String authId = authenticationService.authenticate(request);
    PlayerSocket socket = new PlayerSocket(authId, waitForClient);
    if (authId == null) {
        log.warn("Unauthorized access [{}] from {}", getParameters(request), request.getRemoteAddr());
        try {
            response.sendError(401, UNAUTHORIZED_ACCESS);
        } catch (IOException e) {
            log.warn("Error sending status {}", e.getMessage());
        }
        return null;
    }
    socket.onClose(() -> transport.unregisterPlayerSocket(socket));
    transport.registerPlayerSocket(authId, socket);
    return socket;
}
 

public ProducerHandler(WebSocketService service, HttpServletRequest request, ServletUpgradeResponse response) {
    super(service, request, response);
    this.numMsgsSent = new LongAdder();
    this.numBytesSent = new LongAdder();
    this.numMsgsFailed = new LongAdder();
    this.publishLatencyStatsUSec = new StatsBuckets(ENTRY_LATENCY_BUCKETS_USEC);

    if (!checkAuth(response)) {
        return;
    }

    try {
        this.producer = getProducerBuilder(service.getPulsarClient()).topic(topic.toString()).create();
        if (!this.service.addProducer(this)) {
            log.warn("[{}:{}] Failed to add producer handler for topic {}", request.getRemoteAddr(),
                    request.getRemotePort(), topic);
        }
    } catch (Exception e) {
        log.warn("[{}:{}] Failed in creating producer on topic {}: {}", request.getRemoteAddr(),
                request.getRemotePort(), topic, e.getMessage());

        try {
            response.sendError(getErrorCode(e), getErrorMessage(e));
        } catch (IOException e1) {
            log.warn("[{}:{}] Failed to send error: {}", request.getRemoteAddr(), request.getRemotePort(),
                    e1.getMessage(), e1);
        }
    }
}
 

@Override
public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse res) {
  String requester = req.getRemoteAddress() + ":" + req.getRemotePort();
  if (isShuttingDown()) {
    LOG.debug("Shutting down, discarding incoming request from '{}'", requester);
    res.setStatusCode(HttpServletResponse.SC_GONE);
    return null;
  }

  try {
    if (validateRequest(req, res)) {
      LOG.debug("Request accepted from '{}'", requester);
      return new WebSocketReceiverSocket(
          requester,
          receiver,
          errorQueue,
          requestMeter,
          invalidRequestMeter,
          errorRequestMeter,
          requestTimer
      );
    }
  } catch (Exception ex) {
    errorQueue.offer(ex);
    errorRequestMeter.mark();
    LOG.warn("Error while processing request payload from '{}': {}", requester, ex.toString(), ex);
    try {
      res.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex.toString());
    } catch (IOException e) {
      LOG.warn("Error while sending WebSocket error message: {}", ex.toString(), ex);
    }
  }
  invalidRequestMeter.mark();
  return null;
}
 

public ReaderHandler(WebSocketService service, HttpServletRequest request, ServletUpgradeResponse response) {
    super(service, request, response);

    final int receiverQueueSize = getReceiverQueueSize();

    this.maxPendingMessages = (receiverQueueSize == 0) ? 1 : receiverQueueSize;
    this.numMsgsDelivered = new LongAdder();
    this.numBytesDelivered = new LongAdder();

    if (!checkAuth(response)) {
        return;
    }

    try {
        ReaderBuilder<byte[]> builder = service.getPulsarClient().newReader()
                .topic(topic.toString())
                .startMessageId(getMessageId())
                .receiverQueueSize(receiverQueueSize);
        if (queryParams.containsKey("readerName")) {
            builder.readerName(queryParams.get("readerName"));
        }

        this.reader = builder.create();

        this.subscription = ((ReaderImpl<?>) this.reader).getConsumer().getSubscription();
        if (!this.service.addReader(this)) {
            log.warn("[{}:{}] Failed to add reader handler for topic {}", request.getRemoteAddr(),
                    request.getRemotePort(), topic);
        }
    } catch (Exception e) {
        log.warn("[{}:{}] Failed in creating reader {} on topic {}", request.getRemoteAddr(),
                request.getRemotePort(), subscription, topic, e);
        try {
            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                    "Failed to create reader: " + e.getMessage());
        } catch (IOException e1) {
            log.warn("[{}:{}] Failed to send error: {}", request.getRemoteAddr(), request.getRemotePort(),
                    e1.getMessage(), e1);
        }
    }
}
 

public ConsumerHandler(WebSocketService service, HttpServletRequest request, ServletUpgradeResponse response) {
    super(service, request, response);

    ConsumerBuilderImpl<byte[]> builder;

    this.numMsgsDelivered = new LongAdder();
    this.numBytesDelivered = new LongAdder();
    this.numMsgsAcked = new LongAdder();
    this.pullMode = Boolean.valueOf(queryParams.get("pullMode"));

    try {
        // checkAuth() and getConsumerConfiguration() should be called after assigning a value to this.subscription
        this.subscription = extractSubscription(request);
        builder = (ConsumerBuilderImpl<byte[]>) getConsumerConfiguration(service.getPulsarClient());

        if (!this.pullMode) {
            this.maxPendingMessages = (builder.getConf().getReceiverQueueSize() == 0) ? 1
                    : builder.getConf().getReceiverQueueSize();
        }
        this.subscriptionType = builder.getConf().getSubscriptionType();

        if (!checkAuth(response)) {
            return;
        }

        this.consumer = builder.topic(topic.toString()).subscriptionName(subscription).subscribe();
        if (!this.service.addConsumer(this)) {
            log.warn("[{}:{}] Failed to add consumer handler for topic {}", request.getRemoteAddr(),
                    request.getRemotePort(), topic);
        }
    } catch (Exception e) {
        log.warn("[{}:{}] Failed in creating subscription {} on topic {}", request.getRemoteAddr(),
                request.getRemotePort(), subscription, topic, e);

        try {
            response.sendError(getErrorCode(e), getErrorMessage(e));
        } catch (IOException e1) {
            log.warn("[{}:{}] Failed to send error: {}", request.getRemoteAddr(), request.getRemotePort(),
                    e1.getMessage(), e1);
        }
    }
}
 

private boolean validateAppId(ServletUpgradeRequest req, ServletUpgradeResponse res) throws ServletException, IOException {
  boolean valid = false;
  String ourAppId = null;
  try {
    ourAppId = getReceiver().getAppId().get();
  } catch (StageException e) {
    throw new IOException("Cant resolve credential value", e);
  }

  String requester = req.getRemoteAddress() + ":" + req.getRemotePort();
  String reqAppId = req.getHeader(HttpConstants.X_SDC_APPLICATION_ID_HEADER);

  if (reqAppId == null && receiver.isAppIdViaQueryParamAllowed()) {
    Map<String,List<String>> parameterMap = req.getParameterMap();
    if (parameterMap != null && parameterMap.containsKey(HttpConstants.SDC_APPLICATION_ID_QUERY_PARAM)) {
      List<String> values = parameterMap.get(HttpConstants.SDC_APPLICATION_ID_QUERY_PARAM);
      if (values != null && values.size() > 0) {
        reqAppId = values.get(0);
      }
    }
  }

  if (reqAppId == null) {
    // Since it is not possible to pass headers in some of the WebSockets client (example: browser WebSocket API)
    // http://stackoverflow.com/questions/4361173/http-headers-in-websockets-client-api
    // check sub-protocol header for APP ID
    List<String> subProtocols = req.getSubProtocols();
    if (subProtocols != null && subProtocols.contains(ourAppId)) {
      reqAppId = ourAppId;
      res.setAcceptedSubProtocol(reqAppId);
    }
  }

  if (reqAppId == null) {
    LOG.warn("Request from '{}' missing appId, rejected", requester);
    res.sendError(HttpServletResponse.SC_FORBIDDEN, "Missing 'appId'");
  } if (reqAppId != null && !ourAppId.equals(reqAppId)) {
    LOG.warn("Request from '{}' invalid appId '{}', rejected", requester, reqAppId);
    res.sendError(HttpServletResponse.SC_FORBIDDEN, "Invalid 'appId'");
  } else {
    valid = true;
  }
  return valid;
}