/**
  * Read content
  *
  * @return content
  */
 protected byte[] read() {
   ByteArrayOutputStream content = new ByteArrayOutputStream();
   final byte[] buffer = new byte[8196];
   int read;
   try {
     InputStream input = request.getInputStream();
     while ((read = input.read(buffer)) != -1) content.write(buffer, 0, read);
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
   return content.toByteArray();
 }
  private void putMessage(final Request jettyRequest, final HttpServletResponse response)
      throws IOException {
    final String topic = jettyRequest.getParameter("topic");
    try {
      // Validation should be done on client side already
      final int partition = Integer.parseInt(jettyRequest.getParameter("partition"));
      final int flag = Integer.parseInt(jettyRequest.getParameter("flag"));
      int checkSum = -1;
      if (StringUtils.isNotBlank(jettyRequest.getParameter("checksum"))) {
        checkSum = Integer.parseInt(jettyRequest.getParameter("checksum"));
      }
      // This stream should be handle by Jetty server and therefore it is
      // out of scope here without care close
      final InputStream inputStream = jettyRequest.getInputStream();
      final int dataLength = Integer.parseInt(jettyRequest.getParameter("length"));
      final byte[] data = new byte[dataLength];

      inputStream.read(data);
      this.doResponseHeaders(response, "text/plain");
      final PutCommand putCommand = this.convert2PutCommand(topic, partition, data, flag, checkSum);
      this.commandProcessor.processPutCommand(
          putCommand,
          null,
          new PutCallback() {

            @Override
            public void putComplete(final ResponseCommand resp) {
              final BooleanCommand responseCommand = (BooleanCommand) resp;
              response.setStatus(responseCommand.getCode());
              try {
                response.getWriter().write(responseCommand.getErrorMsg());
              } catch (final IOException e) {
                logger.error("Write response failed", e);
              }
            }
          });

    } catch (final Exception e) {
      logger.error("Put message failed", e);
      response.setStatus(HttpStatus.InternalServerError);
      response.getWriter().write(e.getMessage());
    }
  }
Example #3
0
  private int handlePut(Request baseRequest, HttpServletResponse response) throws IOException {
    if (!artifactCache.isPresent()) {
      response.getWriter().write("Serving local cache is disabled for this instance.");
      return HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
    }

    Path temp = null;
    try {
      projectFilesystem.mkdirs(projectFilesystem.getBuckPaths().getScratchDir());
      temp =
          projectFilesystem.createTempFile(
              projectFilesystem.getBuckPaths().getScratchDir(), "incoming_upload", ".tmp");

      StoreResponseReadResult storeRequest;
      try (DataInputStream requestInputData = new DataInputStream(baseRequest.getInputStream());
          OutputStream tempFileOutputStream = projectFilesystem.newFileOutputStream(temp)) {
        storeRequest =
            HttpArtifactCacheBinaryProtocol.readStoreRequest(
                requestInputData, tempFileOutputStream);
      }

      if (!storeRequest.getActualHashCode().equals(storeRequest.getExpectedHashCode())) {
        response.getWriter().write("Checksum mismatch.");
        return HttpServletResponse.SC_NOT_ACCEPTABLE;
      }

      artifactCache
          .get()
          .store(
              ArtifactInfo.builder()
                  .setRuleKeys(storeRequest.getRuleKeys())
                  .setMetadata(storeRequest.getMetadata())
                  .build(),
              BorrowablePath.notBorrowablePath(temp));
      return HttpServletResponse.SC_ACCEPTED;
    } finally {
      if (temp != null) {
        projectFilesystem.deleteFileAtPathIfExists(temp);
      }
    }
  }
    /**
     * The handler for the HTTP requesst
     *
     * @param target target
     * @param baseRequest request
     * @param httpRequest request
     * @param httpResponse response
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void handle(
        String target,
        Request baseRequest,
        HttpServletRequest httpRequest,
        HttpServletResponse httpResponse)
        throws IOException, ServletException {

      Onem2mRequestPrimitiveClientBuilder clientBuilder = new Onem2mRequestPrimitiveClientBuilder();
      String headerValue;

      clientBuilder.setProtocol(Onem2m.Protocol.HTTP);

      Onem2mStats.getInstance().endpointInc(baseRequest.getRemoteAddr());
      Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS);

      String contentType = httpRequest.getContentType();
      if (contentType == null) contentType = "json";
      contentType = contentType.toLowerCase();
      if (contentType.contains("json")) {
        clientBuilder.setContentFormat(Onem2m.ContentFormat.JSON);
      } else if (contentType.contains("xml")) {
        clientBuilder.setContentFormat(Onem2m.ContentFormat.XML);
      } else {
        httpResponse.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
        httpResponse.getWriter().println("Unsupported media type: " + contentType);
        httpResponse.setContentType("text/json;charset=utf-8");
        baseRequest.setHandled(true);
        Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_ERROR);
        return;
      }

      clientBuilder.setTo(httpRequest.getRequestURI());

      // pull fields out of the headers
      headerValue = httpRequest.getHeader(Onem2m.HttpHeaders.X_M2M_ORIGIN);
      if (headerValue != null) {
        clientBuilder.setFrom(headerValue);
      }
      headerValue = httpRequest.getHeader(Onem2m.HttpHeaders.X_M2M_RI);
      if (headerValue != null) {
        clientBuilder.setRequestIdentifier(headerValue);
      }
      headerValue = httpRequest.getHeader(Onem2m.HttpHeaders.X_M2M_NM);
      if (headerValue != null) {
        clientBuilder.setName(headerValue);
      }
      headerValue = httpRequest.getHeader(Onem2m.HttpHeaders.X_M2M_GID);
      if (headerValue != null) {
        clientBuilder.setGroupRequestIdentifier(headerValue);
      }
      headerValue = httpRequest.getHeader(Onem2m.HttpHeaders.X_M2M_RTU);
      if (headerValue != null) {
        clientBuilder.setResponseType(headerValue);
      }
      headerValue = httpRequest.getHeader(Onem2m.HttpHeaders.X_M2M_OT);
      if (headerValue != null) {
        clientBuilder.setOriginatingTimestamp(headerValue);
      }

      // the contentType string can have ty=val attached to it so we should handle this case
      Boolean resourceTypePresent = false;
      String contentTypeResourceString = parseContentTypeForResourceType(contentType);
      if (contentTypeResourceString != null) {
        resourceTypePresent =
            clientBuilder.parseQueryStringIntoPrimitives(contentTypeResourceString);
      }
      String method = httpRequest.getMethod().toLowerCase();
      // look in query string if didnt find it in contentType header
      if (!resourceTypePresent) {
        resourceTypePresent =
            clientBuilder.parseQueryStringIntoPrimitives(httpRequest.getQueryString());
      } else {
        clientBuilder.parseQueryStringIntoPrimitives(httpRequest.getQueryString());
      }
      if (resourceTypePresent && !method.contentEquals("post")) {
        httpResponse.setStatus(HttpServletResponse.SC_BAD_REQUEST);
        httpResponse.getWriter().println("Specifying resource type not permitted.");
        Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_ERROR);
        return;
      }

      // take the entire payload text and put it in the CONTENT field; it is the representation of
      // the resource
      String cn = IOUtils.toString(baseRequest.getInputStream()).trim();
      if (cn != null && !cn.contentEquals("")) {
        clientBuilder.setPrimitiveContent(cn);
      }

      switch (method) {
        case "get":
          clientBuilder.setOperationRetrieve();
          Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_RETRIEVE);
          break;
        case "post":
          if (resourceTypePresent) {
            clientBuilder.setOperationCreate();
            Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_CREATE);
          } else {
            clientBuilder.setOperationNotify();
            Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_NOTIFY);
          }
          break;
        case "put":
          clientBuilder.setOperationUpdate();
          Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_UPDATE);
          break;
        case "delete":
          clientBuilder.setOperationDelete();
          Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_DELETE);
          break;
        default:
          httpResponse.setStatus(HttpServletResponse.SC_NOT_IMPLEMENTED);
          httpResponse.getWriter().println("Unsupported method type: " + method);
          httpResponse.setContentType("text/json;charset=utf-8");
          baseRequest.setHandled(true);
          Onem2mStats.getInstance().inc(Onem2mStats.HTTP_REQUESTS_ERROR);
          return;
      }

      // invoke the service request
      Onem2mRequestPrimitiveClient onem2mRequest = clientBuilder.build();
      ResponsePrimitive onem2mResponse = Onem2m.serviceOnenm2mRequest(onem2mRequest, onem2mService);

      // now place the fields from the onem2m result response back in the http fields, and send
      sendHttpResponseFromOnem2mResponse(httpResponse, onem2mResponse);

      httpResponse.addHeader("Access-Control-Allow-Origin", "*");
      httpResponse.addHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT, OPTIONS");

      baseRequest.setHandled(true);
    }