Ergonomic, hermetic, user-friendly software build system for Python, Go, Java, Kotlin, Protobuf, Scala, Shell. Pants lets you fearlessly scale up your codebase!

Pants

a solution that acquires it once would be preferable. perhaps by trying a non-blocking lock first and actually using it.

Yeah I was thinking about that earlier and decided not to, but that's a good point

```@contextmanager
def owner_printing_file_lock(path, blocking=True, timeout=None):
  lock = InterProcessLock(path)

  @contextmanager
  def pid_message():
    with open(lock.path, 'wb') as f:
      current_process = psutil.Process()
      message = '{} ({})'.format(current_process.pid, ' '.join(current_process.cmdline()))
      f.write(message.encode('utf-8'))
    yield
    with open(lock.path, 'w'): pass

  if not lock.acquire(blocking=False):
    with open(lock.path, 'rb') as f:
      lockfile_contents = f.read().decode('utf-8', 'replace')
      print('Waiting on pants process to complete: {}'.format(lockfile_contents), file=sys.stderr)
    with lock.acquire(blocking=blocking, timeout=timeout):
      with pid_message():
        yield lock
  else:
    with pid_message():
      yield lock
```

I couldn't think of an especially elegant way to do this

But in the common case, that only acquires the lock once

bah this is buggy and needs cleaning up, I'll work on that.  Mostly I just wanted to make sure that the general idea was okay with people

i.e. is it okay to just write the message into the lockfile

```@contextmanager
def owner_printing_file_lock(path, blocking=True, timeout=None):
  lock = InterProcessLock(path)
  deadline = time.time() + (timeout or 0)

  @contextmanager
  def attempt(attempt_blocking):
    with lock.acquire(blocking=attempt_blocking, timeout=(deadline - time.time())) as lock:
      if lock:
        yield lock
      else:
        ... print a message then retry ...
        yield attempt(blocking=blocking)
  
  yield attempt(attempt_blocking=False)```

it switches to blocking after the first attempt.

I'm going to let the underlying library take care of the timeout/deadline stuff

Also we should only act as a context manager when blocking is True

At least, that's what the underlying does

would suggest splitting into two methods then

I'm just going to make a blocking and a non-blocking