lockRankTestRInternal
)

// lockRankLeafRank is the rank of lock that does not have a declared rank,
// and hence is a leaf lock.
const lockRankLeafRank lockRank = 1000

// lockNames gives the names associated with each of the above ranks.
var lockNames = []string{
	lockRankSysmon:          "sysmon",
	lockRankScavenge:        "scavenge",
	lockRankForcegc:         "forcegc",
	lockRankDefer:           "defer",

// and hence is a leaf lock.
const lockRankLeafRank lockRank = 1000
`)

	// Create string table.
	fmt.Fprintf(w, `
// lockNames gives the names associated with each of the above ranks.
var lockNames = []string{
`)
	for _, rank := range topo {
		if !isPseudo(rank) {
			fmt.Fprintf(w, "\t%s: %q,\n", cname(rank), rank)
		}
	}
	fmt.Fprintf(w, `}

		return false
	}

	// Lock the upload, to prevent duplicate uploads.
	{
		lockname := newname + ".lock"
		lockfile, err := os.OpenFile(lockname, os.O_CREATE|os.O_EXCL, 0666)
		if err != nil {
			u.logger.Printf("Failed to acquire lock %s: %v", lockname, err)
			return false
		}
		_ = lockfile.Close()
		defer os.Remove(lockname)
	}

	endpoint := u.uploadServerURL + "/" + fdate
	b := bytes.NewReader(buf)

func generateDominatorMap(fut fun) map[string]string {
	blockNames := map[*Block]string{}
	for n, b := range fut.blocks {
		blockNames[b] = n
	}
	referenceDom := dominatorsSimple(fut.f)
	doms := make(map[string]string)
	for _, b := range fut.f.Blocks {
		if d := referenceDom[b.ID]; d != nil {
			doms[blockNames[b]] = blockNames[d]
		}
	}
	return doms
}

	retryInterval: time.Minute,
})

type sharedLock struct {
	lockContext chan LockContext
}

func (ld sharedLock) backgroundRoutine(ctx context.Context, objAPI ObjectLayer, lockName string) {
	for {
		locker := objAPI.NewNSLock(minioMetaBucket, lockName)
		lkctx, err := locker.GetLock(ctx, sharedLockTimeout)
		if err != nil {
			continue
		}

	keepLock:
		for {
			select {
			case <-ctx.Done():
				return

    return policy == Policies.DISABLED
        ? new ReentrantLock(fair)
        : new CycleDetectingReentrantLock(new LockGraphNode(lockName), fair);
  }

  /** Equivalent to {@code newReentrantReadWriteLock(lockName, false)}. */
  public ReentrantReadWriteLock newReentrantReadWriteLock(String lockName) {
    return newReentrantReadWriteLock(lockName, false);
  }

  /**

    return policy == Policies.DISABLED
        ? new ReentrantLock(fair)
        : new CycleDetectingReentrantLock(new LockGraphNode(lockName), fair);
  }

  /** Equivalent to {@code newReentrantReadWriteLock(lockName, false)}. */
  public ReentrantReadWriteLock newReentrantReadWriteLock(String lockName) {
    return newReentrantReadWriteLock(lockName, false);
  }

  /**

	expectLeader bool,
	client kubernetes.Interface, fns ...func(stop <-chan struct{}),
) (*LeaderElection, chan struct{}) {
	t.Helper()
	lockName := testLock
	if perRevision {
		lockName += "-" + revision
	}
	l := &LeaderElection{
		namespace:      "ns",
		name:           name,
		electionID:     lockName,
		client:         client,
		revision:       revision,
		remote:         remote,
		defaultWatcher: watcher,

	//
	// The lock file is never deleted, to avoid concurrent locks on distinct
	// files with the same path.
	lockName := filepath.Join(os.TempDir(), "go_ios_exec-"+deviceID+".lock")
	lock, err = os.OpenFile(lockName, os.O_CREATE|os.O_RDONLY, 0666)
	if err != nil {
		return 1, err
	}
	if err := syscall.Flock(int(lock.Fd()), syscall.LOCK_EX); err != nil {
		return 1, err
	}