// Ensures that reply field is non-null
 //
 private void build() throws IOException {
   Request.Action action = request.action();
   if ((action != Request.Action.GET) && (action != Request.Action.HEAD)) {
     reply = new Reply(Reply.Code.METHOD_NOT_ALLOWED, new StringContent(request.toString()));
   }
   reply = new Reply(Reply.Code.OK, new FileContent(request.uri()), action);
 }
Example #2
0
 /**
  * {@inheritDoc}
  *
  * @see java.lang.Object#toString()
  */
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   for (Request request : requests) {
     sb.append(request.toString());
     sb.append("\n");
   }
   return sb.toString();
 }
Example #3
0
  private Response doSyncUpdate(final Request request) {
    loggerContext.init(getRequestId(request.getRemoteAddress()));

    try {
      if (!sourceMatchesContext(request.getSource())) {
        return Response.status(Response.Status.BAD_REQUEST)
            .entity("Invalid source specified: " + request.getSource())
            .build();
      }

      boolean notificationsEnabled = true;
      if (request.isParam(Command.REDIRECT)) {
        if (!ipRanges.isTrusted(IpInterval.parse(request.getRemoteAddress()))) {
          return Response.status(Response.Status.FORBIDDEN)
              .entity("Not allowed to disable notifications: " + request.getRemoteAddress())
              .build();
        }

        notificationsEnabled = false;
      }

      if (!request.hasParam(Command.DATA) && request.isParam(Command.NEW)) {
        return Response.status(Response.Status.BAD_REQUEST)
            .entity("DATA parameter is missing")
            .build();
      }

      if (!request.hasParam(Command.DATA) && !request.isParam(Command.HELP)) {
        return Response.status(Response.Status.BAD_REQUEST).entity("Invalid request").build();
      }

      loggerContext.log("msg-in.txt", new SyncUpdateLogCallback(request.toString()));

      final UpdateContext updateContext = new UpdateContext(loggerContext);

      final String content = request.hasParam("DATA") ? request.getParam("DATA") : "";

      final UpdateRequest updateRequest =
          new UpdateRequest(
              new SyncUpdate(dateTimeProvider, request.getRemoteAddress()),
              getKeyword(request),
              content,
              updatesParser.parse(
                  updateContext, Lists.newArrayList(new ContentWithCredentials(content))),
              notificationsEnabled);

      final UpdateResponse updateResponse =
          updateRequestHandler.handle(updateRequest, updateContext);
      loggerContext.log("msg-out.txt", new SyncUpdateLogCallback(updateResponse.getResponse()));
      return getResponse(updateResponse);

    } finally {
      loggerContext.remove();
    }
  }
  @Override
  protected void handle(DatagramPacket datagramPacket) throws SignatureException {
    KeyManager keyManager = KeyManager.getInstance();
    RSAPublicKey clientPubKey = (RSAPublicKey) keyManager.getPublicKey(Key.CLIENT);

    byte[] reqBytes = Arrays.copyOf(datagramPacket.getData(), datagramPacket.getLength());
    Request req = new Request(new String(reqBytes), clientPubKey);

    String chainHash = null;

    LOCK.lock();
    try {
      String itemId = req.getItemId().toString();

      System.out.format(
          "received: itemId=%2d, userId=%s, price=%s\n",
          req.getItemId(), req.getUserId(), req.getPrice());

      chainHash = HASHING_CHAIN_TABLE.getLastChainHash(itemId);
      HASHING_CHAIN_TABLE.chain(itemId, Utils.digest(req.toString()));
    } finally {
      LOCK.unlock();
    }

    int currentPrice = PRICE_TABLE.getOrDefault(req.getItemId(), 0);
    int bidderPrice = Integer.decode(req.getPrice());
    boolean bidSuccess = bidderPrice > currentPrice;

    if (bidSuccess) {
      PRICE_TABLE.put(req.getItemId(), bidderPrice);
    }

    System.out.format(
        "decrypted price: %d, now highest price is %d\n",
        bidderPrice, Math.max(bidderPrice, currentPrice));

    Acknowledgement ack = new Acknowledgement(chainHash, bidSuccess, req);

    ack.sign(keyPair, keyInfo);

    try (Socket s = new Socket(datagramPacket.getAddress(), req.getPort());
        DataOutputStream out = new DataOutputStream(s.getOutputStream());
        DataInputStream in = new DataInputStream(s.getInputStream())) {
      Utils.send(out, ack.toString());
    } catch (IOException ex) {
      LOGGER.log(Level.SEVERE, null, ex);
    }
  }
  protected void process(HttpServletRequest hreq, HttpServletResponse hresp)
      throws ServletException, IOException {
    Request req = createRequest(hreq, hresp);
    if (L.isDebugEnabled()) L.debug(null, req.toString());

    Response resp = createResponse(hreq, hresp);
    try {
      fireBeforeAll(req, resp);
      if (routeSummary
          && "$"
              .equals(StringUtils.removeStart(StringUtils.trimToEmpty(hreq.getPathInfo()), "/"))) {
        resp.body(RawText.of(makeRouteSummary()));
        resp.type("text/plain");
      } else {
        invokeAllMatched(before, req, resp);
        boolean matched = invokeFirstMatched(routes, req, resp);
        invokeAllMatched(after, req, resp);
        if (!matched) TopazHelper.halt(404, "Route error");

        if (L.isDebugEnabled()) L.debug(null, "ok");
      }
      fireSuccess(req, resp);
    } catch (Throwable t) {
      fireExceptionCaught(req, resp, t);
      Throwable c =
          (t instanceof InvocationTargetException)
              ? ((InvocationTargetException) t).getTargetException()
              : t;
      if (!(c instanceof QuietHaltException)) resp.error(c);

      L.warn(null, c, "error");
    } finally {
      fireBeforeOutput(req, resp);
      resp.doOutput(Response.OutputOptions.fromRequest(req));
      fireAfterOutput(req, resp);
      req.deleteUploadedFiles();
      fireAfterAll(req, resp);
      if (L.isDebugEnabled()) L.debug(null, "complete");
    }
  }
Example #6
0
 public static void logRequest(Logger log, long mask, char rp, Request request, String header) {
   if (isTraceEnabled(log, mask)) {
     log.trace(header + ":" + rp + request.toString());
   }
 }
  /**
   * This method will be called inside the ProcessRequestThread, which is a singleton, so there will
   * be a single thread calling this code.
   *
   * @param request
   */
  @SuppressWarnings("unchecked")
  protected void pRequest(Request request) throws RequestProcessorException {
    // LOG.info("Prep>>> cxid = " + request.cxid + " type = " +
    // request.type + " id = 0x" + Long.toHexString(request.sessionId));
    TxnHeader txnHeader = null;
    Record txn = null;
    try {
      switch (request.type) {
        case OpCode.create:
          txnHeader =
              new TxnHeader(
                  request.sessionId, request.cxid, zks.getNextZxid(), zks.getTime(), OpCode.create);
          zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
          CreateRequest createRequest = new CreateRequest();
          ZooKeeperServer.byteBuffer2Record(request.request, createRequest);
          String path = createRequest.getPath();
          int lastSlash = path.lastIndexOf('/');
          if (lastSlash == -1 || path.indexOf('\0') != -1 || failCreate) {
            LOG.info(
                "Invalid path " + path + " with session 0x" + Long.toHexString(request.sessionId));
            throw new KeeperException.BadArgumentsException(path);
          }
          if (!fixupACL(request.authInfo, createRequest.getAcl())) {
            throw new KeeperException.InvalidACLException(path);
          }
          String parentPath = path.substring(0, lastSlash);
          ChangeRecord parentRecord = getRecordForPath(parentPath);

          checkACL(zks, parentRecord.acl, ZooDefs.Perms.CREATE, request.authInfo);
          int parentCVersion = parentRecord.stat.getCversion();
          CreateMode createMode = CreateMode.fromFlag(createRequest.getFlags());
          if (createMode.isSequential()) {
            path = path + String.format(Locale.ENGLISH, "%010d", parentCVersion);
          }
          try {
            PathUtils.validatePath(path);
          } catch (IllegalArgumentException ie) {
            LOG.info(
                "Invalid path " + path + " with session 0x" + Long.toHexString(request.sessionId));
            throw new KeeperException.BadArgumentsException(path);
          }
          try {
            if (getRecordForPath(path) != null) {
              throw new KeeperException.NodeExistsException(path);
            }
          } catch (KeeperException.NoNodeException e) {
            // ignore this one
          }
          boolean ephemeralParent = parentRecord.stat.getEphemeralOwner() != 0;
          if (ephemeralParent) {
            throw new KeeperException.NoChildrenForEphemeralsException(path);
          }
          txn =
              new CreateTxn(
                  path, createRequest.getData(), createRequest.getAcl(), createMode.isEphemeral());
          StatPersisted s = new StatPersisted();
          if (createMode.isEphemeral()) {
            s.setEphemeralOwner(request.sessionId);
          }
          parentRecord = parentRecord.duplicate(txnHeader.getZxid());
          parentRecord.childCount++;
          parentRecord.stat.setCversion(parentRecord.stat.getCversion() + 1);
          addChangeRecord(parentRecord);
          addChangeRecord(
              new ChangeRecord(txnHeader.getZxid(), path, s, 0, createRequest.getAcl()));

          break;
        case OpCode.delete:
          txnHeader =
              new TxnHeader(
                  request.sessionId, request.cxid, zks.getNextZxid(), zks.getTime(), OpCode.delete);
          zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
          DeleteRequest deleteRequest = new DeleteRequest();
          ZooKeeperServer.byteBuffer2Record(request.request, deleteRequest);
          path = deleteRequest.getPath();
          lastSlash = path.lastIndexOf('/');
          if (lastSlash == -1
              || path.indexOf('\0') != -1
              || zks.getZKDatabase().isSpecialPath(path)) {
            throw new KeeperException.BadArgumentsException(path);
          }
          parentPath = path.substring(0, lastSlash);
          parentRecord = getRecordForPath(parentPath);
          ChangeRecord nodeRecord = getRecordForPath(path);
          checkACL(zks, parentRecord.acl, ZooDefs.Perms.DELETE, request.authInfo);
          int version = deleteRequest.getVersion();
          if (version != -1 && nodeRecord.stat.getVersion() != version) {
            throw new KeeperException.BadVersionException(path);
          }
          if (nodeRecord.childCount > 0) {
            throw new KeeperException.NotEmptyException(path);
          }
          txn = new DeleteTxn(path);
          parentRecord = parentRecord.duplicate(txnHeader.getZxid());
          parentRecord.childCount--;
          parentRecord.stat.setCversion(parentRecord.stat.getCversion() + 1);
          addChangeRecord(parentRecord);
          addChangeRecord(new ChangeRecord(txnHeader.getZxid(), path, null, -1, null));
          break;
        case OpCode.setData:
          txnHeader =
              new TxnHeader(
                  request.sessionId,
                  request.cxid,
                  zks.getNextZxid(),
                  zks.getTime(),
                  OpCode.setData);
          zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
          SetDataRequest setDataRequest = new SetDataRequest();
          ZooKeeperServer.byteBuffer2Record(request.request, setDataRequest);
          path = setDataRequest.getPath();
          nodeRecord = getRecordForPath(path);
          checkACL(zks, nodeRecord.acl, ZooDefs.Perms.WRITE, request.authInfo);
          version = setDataRequest.getVersion();
          int currentVersion = nodeRecord.stat.getVersion();
          if (version != -1 && version != currentVersion) {
            throw new KeeperException.BadVersionException(path);
          }
          version = currentVersion + 1;
          txn = new SetDataTxn(path, setDataRequest.getData(), version);
          nodeRecord = nodeRecord.duplicate(txnHeader.getZxid());
          nodeRecord.stat.setVersion(version);
          addChangeRecord(nodeRecord);
          break;
        case OpCode.setACL:
          txnHeader =
              new TxnHeader(
                  request.sessionId, request.cxid, zks.getNextZxid(), zks.getTime(), OpCode.setACL);
          zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
          SetACLRequest setAclRequest = new SetACLRequest();
          ZooKeeperServer.byteBuffer2Record(request.request, setAclRequest);
          path = setAclRequest.getPath();
          if (!fixupACL(request.authInfo, setAclRequest.getAcl())) {
            throw new KeeperException.InvalidACLException(path);
          }
          nodeRecord = getRecordForPath(path);
          checkACL(zks, nodeRecord.acl, ZooDefs.Perms.ADMIN, request.authInfo);
          version = setAclRequest.getVersion();
          currentVersion = nodeRecord.stat.getAversion();
          if (version != -1 && version != currentVersion) {
            throw new KeeperException.BadVersionException(path);
          }
          version = currentVersion + 1;
          txn = new SetACLTxn(path, setAclRequest.getAcl(), version);
          nodeRecord = nodeRecord.duplicate(txnHeader.getZxid());
          nodeRecord.stat.setAversion(version);
          addChangeRecord(nodeRecord);
          break;
        case OpCode.createSession:
          txnHeader =
              new TxnHeader(
                  request.sessionId,
                  request.cxid,
                  zks.getNextZxid(),
                  zks.getTime(),
                  OpCode.createSession);
          request.request.rewind();
          int to = request.request.getInt();
          txn = new CreateSessionTxn(to);
          request.request.rewind();
          zks.sessionTracker.addSession(request.sessionId, to);
          zks.setOwner(request.sessionId, request.getOwner());
          break;
        case OpCode.closeSession:
          txnHeader =
              new TxnHeader(
                  request.sessionId,
                  request.cxid,
                  zks.getNextZxid(),
                  zks.getTime(),
                  OpCode.closeSession);
          // We don't want to do this check since the session expiration thread
          // queues up this operation without being the session owner.
          // this request is the last of the session so it should be ok
          // zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
          HashSet<String> es = zks.getZKDatabase().getEphemerals(request.sessionId);
          synchronized (zks.outstandingChanges) {
            for (ChangeRecord c : zks.outstandingChanges) {
              if (c.stat == null) {
                // Doing a delete
                es.remove(c.path);
              } else if (c.stat.getEphemeralOwner() == request.sessionId) {
                es.add(c.path);
              }
            }
            for (String path2Delete : es) {
              addChangeRecord(new ChangeRecord(txnHeader.getZxid(), path2Delete, null, 0, null));
            }

            zks.sessionTracker.setSessionClosing(request.sessionId);
          }

          LOG.info(
              "Processed session termination for sessionid: 0x"
                  + Long.toHexString(request.sessionId));
          break;
        case OpCode.sync:
        case OpCode.exists:
        case OpCode.getData:
        case OpCode.getACL:
        case OpCode.getChildren:
        case OpCode.getChildren2:
        case OpCode.ping:
        case OpCode.setWatches:
          zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
          break;
      }
    } catch (KeeperException e) {
      if (txnHeader != null) {
        txnHeader.setType(OpCode.error);
        txn = new ErrorTxn(e.code().intValue());
      }
      LOG.info(
          "Got user-level KeeperException when processing "
              + request.toString()
              + " Error Path:"
              + e.getPath()
              + " Error:"
              + e.getMessage());
      request.setException(e);
    } catch (Exception e) {
      // log at error level as we are returning a marshalling
      // error to the user
      LOG.error("Failed to process " + request, e);

      StringBuilder sb = new StringBuilder();
      ByteBuffer bb = request.request;
      if (bb != null) {
        bb.rewind();
        while (bb.hasRemaining()) {
          sb.append(Integer.toHexString(bb.get() & 0xff));
        }
      } else {
        sb.append("request buffer is null");
      }

      LOG.error("Dumping request buffer: 0x" + sb.toString());
      if (txnHeader != null) {
        txnHeader.setType(OpCode.error);
        txn = new ErrorTxn(Code.MARSHALLINGERROR.intValue());
      }
    }
    request.hdr = txnHeader;
    request.txn = txn;
    request.zxid = zks.getZxid();
    nextProcessor.processRequest(request);
  }
Example #8
0
    /** {@inheritDoc} */
    @Override
    public String toString() {

      return request.toString();
    }