How to use

LockingManager

in

org.geotools.data

  public void lockFeatureID(
      String typeName, String authID, Transaction transaction, FeatureLock featureLock)
      throws IOException {
    DataStore store = cache.getDataStore(typeName, false);

    if ((store != null) && (store.getLockingManager() != null)) {
      store.getLockingManager().lockFeatureID(typeName, authID, transaction, featureLock);
    }
  }
}

public void unLockFeatureID(
    String typeName, String authID, Transaction transaction, FeatureLock featureLock)
    throws IOException {
  DataStore store = cache.getDataStore(typeName, false);
  if ((store != null) && (store.getLockingManager() != null)) {
    store.getLockingManager().unLockFeatureID(typeName, authID, transaction, featureLock);
  }
}

public boolean release(String authID, Transaction transaction) throws IOException {
  List<DataStore> stores = cache.getDataStores();
  for (DataStore store : stores) {
    if ((store.getLockingManager() != null) && store.getLockingManager().exists(authID)) {
      return store.getLockingManager().release(authID, transaction);
    }
  }
  return false;
}

public boolean refresh(String authID, Transaction transaction) throws IOException {
  List<DataStore> stores = cache.getDataStores();
  for (DataStore store : stores) {
    if ((store.getLockingManager() != null) && store.getLockingManager().exists(authID)) {
      return store.getLockingManager().refresh(authID, transaction);
    }
  }
  return false;
}

/**
 * Check if a lock exists in any of the DataStores.
 *
 * @param lockID
 */
public boolean lockExists(String lockID) {
  if (lockID == null) {
    return false;
  }
  LockingManager lockManager;
  for (DataAccess<?, ?> access : repository.values()) {
    DataStore store = (DataStore) access;
    lockManager = store.getLockingManager();
    if (lockManager == null) {
      continue; // did not support locking
    }
    if (lockManager.exists(lockID)) {
      return true;
    }
  }
  return false;
}

if (lockManager == null) continue; // did not support locking
if (lockManager.release(lockID, transaction)) {
  release = true;

t.addAuthorization(lockId);
if (lockingManager.refresh(lockId, t)) {
  refresh = true;

/**
 * @see org.geotools.data.LockingManager#refresh(java.lang.String,
 *      org.geotools.data.Transaction)
 */
public boolean refresh(String authID, Transaction transaction)
  throws IOException {
  Iterator i = dataStores.values().iterator();
  while (i.hasNext()) {
    AbstractFileDataStore afds = (AbstractFileDataStore) i.next();
    if ((afds.getLockingManager() != null)
        && afds.getLockingManager().exists(authID)) {
      return afds.getLockingManager().refresh(authID, transaction);
    }
  }
  return false;
}

public boolean exists(String authID) {
  List<DataStore> stores = cache.getDataStores();
  for (DataStore store : stores) {
    if ((store.getLockingManager() != null) && store.getLockingManager().exists(authID)) {
      return true;
    }
  }
  return false;
}

  continue; // did not support locking
if (lockManager.release(lockID, transaction)) {
  refresh = true;

  t.addAuthorization(fLock.getAuthorization());
  DataStore dataStore = (DataStore) source.getDataStore();
  dataStore.getLockingManager().refresh(fLock.getAuthorization(), t);
} finally {
  t.commit();

private void createManyLocks() throws IOException {
  for (int count = 0; count < JDBCDataStore.MAX_IDS_IN_FILTER + 1; count++) {
    dataStore
        .getLockingManager()
        .lockFeatureID(
            SAMPLE_FEATURE_NAME,
            count + "",
            tx,
            new FeatureLock(count + "", 10000000L));
  }
}

/** Unlocks features specified by a filter. */
public final void unLockFeatures(Filter filter) throws IOException {
  filter = resolvePropertyNames(filter);
  String typeName = getSchema().getTypeName();
  FeatureReader<SimpleFeatureType, SimpleFeature> reader = getReader(filter);
  try {
    while (reader.hasNext()) {
      SimpleFeature feature = reader.next();
      //
      // Use native locking?
      //
      if (canLock()) {
        doUnlockInternal(typeName, feature);
      } else {
        getDataStore()
            .getLockingManager()
            .unLockFeatureID(typeName, feature.getID(), transaction, lock);
      }
    }
  } finally {
    reader.close();
  }
}

/**
 * @see org.geotools.data.LockingManager#release(java.lang.String,
 *      org.geotools.data.Transaction)
 */
public boolean release(String authID, Transaction transaction)
  throws IOException {
  Iterator i = dataStores.values().iterator();
  while (i.hasNext()) {
    AbstractFileDataStore afds = (AbstractFileDataStore) i.next();
    if ((afds.getLockingManager() != null)
        && afds.getLockingManager().exists(authID)) {
      return afds.getLockingManager().release(authID, transaction);
    }
  }
  return false;
}

public boolean refresh(String authID, Transaction transaction)
  throws IOException {
  List<DataStore> stores = cache.getDataStores();
  for (DataStore store : stores) {
    if ((store.getLockingManager() != null)
        && store.getLockingManager().exists(authID)) {
      return store.getLockingManager().refresh(authID, transaction);
    }
  }
  return false;
}

/**
 * Check if a lock exists in any of the DataStores.
 * 
 * @param lockID
 */
public boolean lockExists(String lockID) {
  if (lockID == null){
    return false;
  }
  LockingManager lockManager;
  for ( DataAccess<?,?> access : repository.values() ){
    DataStore store = (DataStore) access;
    lockManager = store.getLockingManager();
    if (lockManager == null){
      continue; // did not support locking
    }
    if (lockManager.exists(lockID)) {
      return true;
    }
  }
  return false;
}

if( lockManager == null ) continue; // did not support locking
if( lockManager.release( lockID, transaction )){
  release = true;    

private void createLock() throws IOException {
  dataStore
      .getLockingManager()
      .lockFeatureID(
          SAMPLE_FEATURE_NAME,
          SAMPLE_FEATURE_ID,
          tx,
          new FeatureLock(SAMPLE_FEATURE_ID, 10000000L));
}

/**
 * @see org.geotools.data.LockingManager#unLockFeatureID(java.lang.String,
 *      java.lang.String, org.geotools.data.Transaction,
 *      org.geotools.data.FeatureLock)
 */
public void unLockFeatureID(String typeName, String authID,
  Transaction transaction, FeatureLock featureLock)
  throws IOException {
  AbstractFileDataStore afds = (AbstractFileDataStore) dataStores.get(typeName);
  if ((afds != null) && (afds.getLockingManager() != null)) {
    afds.getLockingManager().unLockFeatureID(typeName, authID,
      transaction, featureLock);
  }
}

public boolean release(String authID, Transaction transaction)
  throws IOException {
  List<DataStore> stores = cache.getDataStores();
  for (DataStore store : stores) {
    if ((store.getLockingManager() != null)
        && store.getLockingManager().exists(authID)) {
      return store.getLockingManager().release(authID, transaction);
    }
  }
  return false;
}