}
}

// Lock holds a write lock on dm.
//
// If the lock is already in use, the calling go routine
// blocks until the mutex is available.
func (dm *DRWMutex) Lock(id, source string) {
	isReadLock := false
	dm.lockBlocking(context.Background(), nil, id, source, isReadLock, Options{
		Timeout: drwMutexInfinite,
	})
}

// Options lock options.
type Options struct {

dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> 1712896733 +0000

    return lock.withLock(action)
  }

  inline fun <T> RealConnection.withLock(action: () -> T): T {
    contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
    return lock.withLock(action)
  }

  inline fun <T> RealCall.withLock(action: () -> T): T {
    contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
    return lock.withLock(action)
  }

    extra_args = ["--allow-unsafe"],
    requirements_in = REQUIREMENTS_FILE_NAME,
    requirements_txt = "requirements_lock_3_9.txt",
)

compile_pip_requirements_3_10(
    name = "requirements_3_10",
    extra_args = ["--allow-unsafe"],
    requirements_in = REQUIREMENTS_FILE_NAME,
    requirements_txt = "requirements_lock_3_10.txt",
)

compile_pip_requirements_3_11(
    name = "requirements_3_11",

func (p *podNetnsCache) UpsertPodCacheWithNetns(uid string, workload WorkloadInfo) Netns {
	// lock current snapshot pod map
	p.mu.Lock()
	defer p.mu.Unlock()
	if existing := p.currentPodCache[uid]; existing.Netns != nil {
		if existing.Netns.Inode() == workload.Netns.Inode() {
			workload.Netns.Close()

    /**
     * Get the value for the key 'mail.send.mock'. <br>
     * The value is, e.g. true <br>
     * comment: Does it send mock mail? (true: no send actually, logging only)
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */
    String getMailSendMock();

    /**
     * Is the property for the key 'mail.send.mock' true? <br>
     * The value is, e.g. true <br>

func (ahs *allHealState) setDiskHealingStatus(ep Endpoint, healing bool) {
	ahs.Lock()
	defer ahs.Unlock()

	ahs.healLocalDisks[ep] = healing
}

func (ahs *allHealState) pushHealLocalDisks(healLocalDisks ...Endpoint) {
	ahs.Lock()
	defer ahs.Unlock()

	for _, ep := range healLocalDisks {
		ahs.healLocalDisks[ep] = false
	}
}

	TimeLastRefresh time.Time // Timestamp for last lock refresh.
	Source          string    // Contains line, function and filename requesting the lock.
	Group           bool      // indicates if it was a group lock.
	Owner           string    // Owner represents the UUID of the owner who originally requested the lock.
	Quorum          int       // Quorum represents the quorum required for this lock to be active.

  outFinished: Boolean,
  inFinished: Boolean,
  headers: Headers?,
) {
  internal val lock: ReentrantLock = ReentrantLock()
  val condition: Condition = lock.newCondition()

  // Internal state is guarded by [lock]. No long-running or potentially blocking operations are
  // performed while the lock is held.

  /** The bytes consumed and acknowledged by the stream. */
  val readBytes: WindowCounter = WindowCounter(id)

		ilm       lifecycle.Lifecycle
		retention lock.Retention
		obj       ObjectInfo
		want      lifecycle.Action
	}{
		{
			// with object locking
			ilm:       *deleteAllLc,
			retention: lock.Retention{LockEnabled: true},
			obj:       obj,
			want:      lifecycle.NoneAction,
		},
		{
			// without object locking
			ilm:       *deleteAllLc,
			retention: lock.Retention{},
			obj:       obj,