Exemple #1
0
  protected void processExistingResource(
      HttpManager manager, Request request, Response response, Resource resource)
      throws NotAuthorizedException {
    if (handlerHelper.isNotCompatible(resource, request.getMethod()) || !isCompatible(resource)) {
      responseHandler.respondMethodNotImplemented(resource, response, request);
      return;
    }
    if (!handlerHelper.checkAuthorisation(manager, resource, request)) {
      responseHandler.respondUnauthorised(resource, response, request);
      return;
    }

    handlerHelper.checkExpects(responseHandler, request, response);

    LockableResource r = (LockableResource) resource;
    LockTimeout timeout = LockTimeout.parseTimeout(request);
    String ifHeader = request.getIfHeader();
    response.setContentTypeHeader(Response.XML);
    if (ifHeader == null || ifHeader.length() == 0) {
      processNewLock(manager, request, response, r, timeout);
    } else {
      processRefresh(manager, request, response, r, timeout, ifHeader);
    }
  }
Exemple #2
0
  protected void processNewLock(
      HttpManager milton,
      Request request,
      Response response,
      LockableResource r,
      LockTimeout timeout)
      throws NotAuthorizedException {
    LockInfo lockInfo;
    try {
      lockInfo = LockInfoSaxHandler.parseLockInfo(request);
    } catch (SAXException ex) {
      throw new RuntimeException("Exception reading request body", ex);
    } catch (IOException ex) {
      throw new RuntimeException("Exception reading request body", ex);
    }

    if (handlerHelper.isLockedOut(request, r)) {
      this.responseHandler.respondLocked(request, response, r);
      return;
    }

    log.debug("locking: " + r.getName());
    LockResult result;
    try {
      result = r.lock(timeout, lockInfo);
    } catch (PreConditionFailedException ex) {
      responseHandler.respondPreconditionFailed(request, response, r);
      return;
    } catch (LockedException ex) {
      responseHandler.respondLocked(request, response, r);
      return;
    }

    if (result.isSuccessful()) {
      LockToken tok = result.getLockToken();
      log.debug("..locked ok: " + tok.tokenId);
      response.setLockTokenHeader(
          "<opaquelocktoken:" + tok.tokenId + ">"); // spec says to set response header. See 8.10.1
      respondWithToken(tok, request, response);
    } else {
      respondWithLockFailure(result, request, response);
    }
  }
Exemple #3
0
  @Override
  public void process(HttpManager manager, Request request, Response response)
      throws NotAuthorizedException, BadRequestException {
    if (!handlerHelper.checkExpects(responseHandler, request, response)) {
      return;
    }

    String host = request.getHostHeader();
    String url = HttpManager.decodeUrl(request.getAbsolutePath());

    // Find a resource if it exists
    Resource r = manager.getResourceFactory().getResource(host, url);
    if (r != null) {
      log.debug("locking existing resource: " + r.getName());
      processExistingResource(manager, request, response, r);
    } else {
      log.debug("lock target doesnt exist, attempting lock null..");
      processNonExistingResource(manager, request, response, host, url);
    }
  }
Exemple #4
0
  /**
   * (from the spec) 7.4 Write Locks and Null Resources
   *
   * <p>It is possible to assert a write lock on a null resource in order to lock the name.
   *
   * <p>A write locked null resource, referred to as a lock-null resource, MUST respond with a 404
   * (Not Found) or 405 (Method Not Allowed) to any HTTP/1.1 or DAV methods except for PUT, MKCOL,
   * OPTIONS, PROPFIND, LOCK, and UNLOCK. A lock-null resource MUST appear as a member of its parent
   * collection. Additionally the lock-null resource MUST have defined on it all mandatory DAV
   * properties. Most of these properties, such as all the get* properties, will have no value as a
   * lock-null resource does not support the GET method. Lock-Null resources MUST have defined
   * values for lockdiscovery and supportedlock properties.
   *
   * <p>Until a method such as PUT or MKCOL is successfully executed on the lock-null resource the
   * resource MUST stay in the lock-null state. However, once a PUT or MKCOL is successfully
   * executed on a lock-null resource the resource ceases to be in the lock-null state.
   *
   * <p>If the resource is unlocked, for any reason, without a PUT, MKCOL, or similar method having
   * been successfully executed upon it then the resource MUST return to the null state.
   *
   * @param manager
   * @param request
   * @param response
   * @param host
   * @param url
   */
  private void processNonExistingResource(
      HttpManager manager, Request request, Response response, String host, String url)
      throws NotAuthorizedException, BadRequestException {
    String name;

    Path parentPath = Path.path(url);
    name = parentPath.getName();
    parentPath = parentPath.getParent();
    url = parentPath.toString();

    Resource r = manager.getResourceFactory().getResource(host, url);
    if (r != null) {
      if (!handlerHelper.checkAuthorisation(manager, r, request)) {
        responseHandler.respondUnauthorised(r, response, request);
        return;
      } else {
        processCreateAndLock(manager, request, response, r, name);
      }
    } else {
      log.debug("couldnt find parent to execute lock-null, returning not found");
      // respondNotFound(response,request);
      response.setStatus(Status.SC_CONFLICT);
    }
  }