コード例 #1
0
  /**
   * Refresh locks held by the authorization <code>authID</code>.
   *
   * <p>(remember that the lock may have expired)
   *
   * @param authID Authorization identifing Lock to refresh
   * @param transaction Transaction with authorization for lockID
   * @return <code>true</code> if lock was found and refreshed
   * @throws IOException If transaction not authorized to refresh authID
   * @throws IllegalArgumentException If authID or transaction not provided
   */
  public synchronized boolean refresh(String authID, Transaction transaction) throws IOException {
    if (authID == null) {
      throw new IllegalArgumentException("lockID required");
    }

    if ((transaction == null) || (transaction == Transaction.AUTO_COMMIT)) {
      throw new IllegalArgumentException(
          "Tansaction required (with authorization for " + authID + ")");
    }

    Lock lock;
    boolean refresh = false;

    for (Iterator i = allLocks().iterator(); i.hasNext(); ) {
      lock = (Lock) i.next();

      if (lock.isExpired()) {
        i.remove();
      } else if (lock.isMatch(authID)) {
        if (lock.isAuthorized(transaction)) {
          lock.refresh();
          refresh = true;
        } else {
          throw new IOException("Not authorized to refresh " + lock);
        }
      }
    }

    return refresh;
  }
コード例 #2
0
  /**
   * Release locks held by the authorization <code>authID</code>.
   *
   * <p>(remember that the lock may have expired)
   *
   * @param authID Authorization identifing Lock to release
   * @param transaction Transaction with authorization for lockID
   * @return <code>true</code> if lock was found and released
   * @throws IOException If transaction not authorized to release authID
   * @throws IllegalArgumentException If authID or transaction not provided
   */
  public boolean release(String authID, Transaction transaction) throws IOException {
    // LOGGER.info("release called on lock: " + authID + ", trans: "
    //  + transaction);

    if (authID == null) {
      throw new IllegalArgumentException("lockID required");
    }

    if ((transaction == null) || (transaction == Transaction.AUTO_COMMIT)) {
      throw new IllegalArgumentException(
          "Tansaction required (with authorization for " + authID + ")");
    }

    Lock lock;
    boolean release = false;

    // This could be done more efficiently, and perhaps cleaner,
    // but these maps within a map are just nasty.  The previous way of
    // calling iterator.remove() didn't actually remove anything, as it
    // was only iterating through the values of a map, which I believe
    // java just copies, so it's immutable.  Or perhaps we just moved
    // through too many iterator layers...
    for (Iterator i = lockTables.values().iterator(); i.hasNext(); ) {
      Map fidMap = (Map) i.next();
      Set unLockedFids = new HashSet();

      for (Iterator j = fidMap.keySet().iterator(); j.hasNext(); ) {
        String fid = (String) j.next();
        lock = (Lock) fidMap.get(fid);
        // LOGGER.info("checking lock " + lock + ", is match "
        //    + lock.isMatch(authID));

        if (lock.isExpired()) {
          unLockedFids.add(fid);

          // fidMap.remove(fid); concurrent modification error.
        } else if (lock.isMatch(authID)) {
          // LOGGER.info("matches, is authorized: "
          //    + lock.isAuthorized(transaction));

          if (lock.isAuthorized(transaction)) {
            unLockedFids.add(fid);

            // fidMap.remove(fid);
            release = true;
          } else {
            throw new IOException("Not authorized to release " + lock);
          }
        }
      }

      for (Iterator k = unLockedFids.iterator(); k.hasNext(); ) {
        fidMap.remove(k.next());
      }
    }

    return release;
  }
コード例 #3
0
  /**
   * Checks mutability of featureID for this transaction.
   *
   * <p>Two behaviors are defined by FeatureLocking:
   *
   * <ul>
   *   <li>TransactionLock (Blocking): lock held by a Transaction<br>
   *       Authorization is granted to the Transaction holding the Lock. Conflict will result in a
   *       block until the Transaction holding the lock completes. (This behavior is equivalent to a
   *       Database row-lock, or a java synchronized statement)
   *   <li>FeatureLock (Error): lock held by a FeatureLock<br>
   *       Authorization is based on the set of Authorization IDs held by the provided Transaction.
   *       Conflict will result in an error. (This behavior is equivalent to the WFS locking
   *       specification)
   * </ul>
   *
   * <p>Right now we are just going to error out with an exception
   *
   * @param typeName Feature type to check against
   * @param featureID FeatureID to check
   * @param transaction Provides Authorization
   * @throws FeatureLockException If transaction does not have sufficient authroization
   */
  public void assertAccess(String typeName, String featureID, Transaction transaction)
      throws FeatureLockException {
    Lock lock = getLock(typeName, featureID);

    // LOGGER.info("asserting access on lock for " + typeName + ", fid: "
    //  + featureID + ", transaction: " + transaction + ", lock " + lock);

    if ((lock != null) && !lock.isAuthorized(transaction)) {
      throw new FeatureLockException(
          "Transaction does not have authorization for " + typeName + ":" + featureID);
    }
  }