Centerpiece should run as a singleton

[mweinelt]

When bound to a key, pressing the key multiple times should not stack multiple centerpiece instances above each other. That's just annoying when it happens and probably never intentional.

I checked rofi, and it does only ever have one instance, which makes it much nicer to use.

[friedow]

This would be a good improvement. I've ran into that problem myself a bunch of times.

What would be a good way to implement this? I've seen other applications writing text files with the current PID to the ~/.cache directory. Centerpiece would then check on startup if such a file exists, if so it would terminate the old instance and start the new one.

This would especially solve the edge case of old centerpiece instances being in places where you currently can't see them. e.g. a centerpiece instance being on a different workspace.

Any other implementation suggestions?

[a-kenji]

Usually locks will be held in /run, or /run/lock IIRC, but I am not 100% sure which solution is the most portable.

[VTimofeenko]

One way to do this (adapting this SO post):

        centerpiece-locking-wrapper = pkgs.writeShellApplication {
          name = cfg.package.meta.mainProgram;

          runtimeInputs = [
            cfg.package
            pkgs.util-linux # flock here
          ];

          # Source:
          # https://stackoverflow.com/posts/1985512/revisions
          text = # bash
            ''
              LOCKFILE="$XDG_RUNTIME_DIR/centerpiece.lock"
              LOCKFD=99

              _lock()             { flock -"$1" $LOCKFD; }
              _no_more_locking()  { _lock u; _lock xn && rm -f "$LOCKFILE"; }
              _prepare_locking()  { eval "exec $LOCKFD>\"$LOCKFILE\""; trap _no_more_locking EXIT; }


              # ON START
              _prepare_locking

              # PUBLIC
              exlock_now()        { _lock xn; }  # obtain an exclusive lock immediately or fail
              exlock()            { _lock x; }   # obtain an exclusive lock
              shlock()            { _lock s; }   # obtain a shared lock
              unlock()            { _lock u; }   # drop a lock

              ### BEGIN OF SCRIPT ###

              # Simplest example is avoiding running multiple instances of script.
              exlock_now || exit 1

              centerpiece "$@"
            '';
        };

cfg.package is pretty much pkgs.centerpiece, but coming from my small HM module's settings (link to modue for context).

I made a couple of minor changes:

• fixed shellcheck nags
• moved lockfile to XDG_RUNTIME_DIR. This may be made more portable(in the sense of "having a default if XDG_RUNTIME_DIR is not set") by bash's fallback syntax: FOO="${BAR:-defaultVal}" means "Set FOO to value of BAR or 'defaultVal' if BAR is not set or null"

[friedow]

FYI: there is a WIP PR by @a-kenji open for this over here #182.