leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);
            
            return newKey;
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public void updateLease(Smb2LeaseKey key, int grantedState) {
        LeaseEntry entry = leases.get(key);
        if (entry != null) {
            entry.updateState(grantedState);

# Heap new generation
#FESS_HEAP_NEWSIZE=

# max direct memory
#FESS_DIRECT_SIZE=

# Additional Java OPTS
#FESS_JAVA_OPTS=

# Maximum number of open files
MAX_OPEN_FILES=65535

# Maximum amount of locked memory
#MAX_LOCKED_MEMORY=

# Fess log directory
LOG_DIR=${packaging.fess.log.dir}

# Fess data directory
DATA_DIR=${packaging.fess.var.dir}

# Fess configuration directory

			if serverDebugLog {
				if obj.VersionID != "" {
					console.Debugf(applyActionsLogPrefix+" lifecycle: %s v(%s) is locked, not deleting\n", obj.Name, obj.VersionID)
				} else {
					console.Debugf(applyActionsLogPrefix+" lifecycle: %s is locked, not deleting\n", obj.Name)
				}
			}
			return lifecycle.Event{Action: lifecycle.NoneAction}
		}

  @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
  void awaitTimedWaiting(Thread thread) {
    while (true) {
      switch (thread.getState()) {
        case BLOCKED:
        case NEW:
        case RUNNABLE:
        case WAITING:
          Thread.yield();
          break;
        case TIMED_WAITING:
          return;
        case TERMINATED:

        void testExclusiveLockFlag() {
            assertEquals(0x2, Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK);
        }

        @Test
        @DisplayName("Should have correct unlock flag value")
        void testUnlockFlag() {
            assertEquals(0x4, Smb2Lock.SMB2_LOCKFLAG_UNLOCK);
        }

        @Test
        @DisplayName("Should have correct fail immediately flag value")

		if !opts.NoLock {
			ns := er.NewNSLock(bucket, object)
			lkctx, err := ns.GetLock(ctx, globalOperationTimeout)
			if err != nil {
				return nil, err
			}
			ctx = lkctx.Context()
			defer ns.Unlock(lkctx)
			opts.NoLock = true
		}

		obj, err := er.getObjectInfo(ctx, bucket, object, opts)
		if err == nil && opts.CheckPrecondFn(obj) {
			return nil, PreConditionFailed{}
		}

    /** LM compatibility level */
    int LM_COMPATIBILITY = Config.getInt("jcifs.smb1.smb.lmCompatibility", 3);

    /** No flags set */
    int FLAGS_NONE = 0x00;
    /** Lock and read write and unlock flag */
    int FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK = 0x01;
    /** Receive buffer posted flag */
    int FLAGS_RECEIVE_BUFFER_POSTED = 0x02;
    /** Path names are caseless flag */
    int FLAGS_PATH_NAMES_CASELESS = 0x08;

   * Finalizer running, and as a result, the application class loader can never be reclaimed.
   *
   * This means that dynamically loaded web applications and OSGi bundles can't be unloaded.
   *
   * If the library is loaded in an application class loader, we try to break the cycle by loading
   * Finalizer in its own independent class loader:
   *

		sys.group.Forget(bucket)
		delete(sys.metadataMap, bucket)
		globalBucketMonitor.DeleteBucket(bucket)
	}
	sys.Unlock()
}

// RemoveStaleBuckets removes all stale buckets in memory that are not on disk.
func (sys *BucketMetadataSys) RemoveStaleBuckets(diskBuckets set.StringSet) {
	sys.Lock()
	defer sys.Unlock()

	for bucket := range sys.metadataMap {
		if diskBuckets.Contains(bucket) {
			continue

  TFE_DEVICE_PLACEMENT_EXPLICIT = 0,
  // Copy the tensor to the right device but log a warning.
  TFE_DEVICE_PLACEMENT_WARN = 1,
  // Silently copy the tensor, which has a performance cost since the operation
  // will be blocked till the copy completes. This is the default placement
  // policy.
  TFE_DEVICE_PLACEMENT_SILENT = 2,
  // Placement policy which silently copies int32 tensors but not other dtypes.
  TFE_DEVICE_PLACEMENT_SILENT_FOR_INT32 = 3,