More elegant way to unlink two tmux clients sharing a session from inside tmux

configurationdot-filestmux

This is almost a code-review question, but very *nixy and more about configuration than code. For years since I switched to tmux from screen I've had a couple of nagging issues that I could not make work the way I wanted them to. Since I setup my shell to exec into a tmux session I finally decided it was time to fix this one.

By default when you attach two tmux clients to the same session, they are locked together. Switch panes in one and both switch in sync. This is different from screen where the default behavior was a shared set of panes but the client itself was independent.

What I've wanted was a way to un-bind two tmux clients attached to the same session. This is easy enough to do if you are outside of tmux and launching a new client. Just start a new session with a reference to the parent one:

tmux new-session -t original_session -s new_session

However try do do this after you are in a client and want to unlink it from whatever other client is sharing that session and things get more complicated. I tried dozens of ways and never hit on one that worked well. The closest I got was using bind <key> prompt-command ... to prompt for both the old and new session names. For whatever reason tmux does not expand the #{session_name} variable inside arguments for a new-session or prompt-command. It does in arguments to many other commands (e.g. I use it in run below) but without that expansion this particular task becomes suddenly complicated. Even with manually entering the values, it only ever sorta worked.

Today I finally got it to work. The result, however, is uglier that I would have liked. It requires a shell function to do most of the magic. In order to contain this to just the config file without involving external scripts (for dotfile portability) I'm using a hack. The config, if you crop off the first two columns, is actually executable as a shell script. With everything wrapped in functions, you can call just the part of the script you need from any keybinding. The shell script bits are comments in the config, while in shell script made the config bit is discarded with a here-doc.

Todays solution came out something like this (my full .tmux.conf file):

# : << ENDOFCONF

# Clear the default binding
unbind C-c
# Pass the name of the current session to a function to clone it
bind C-c run "cut -c3- ~/.tmux.conf | sh -s clone #S"

# ENDOFCONF
# clone () {
#   orig=${1%-*}
#   copy="$orig-$(($( tmux list-sessions -F '#S' | sed -nE "/^${orig}-[0-9]+$/{s/[^0-9]//g;p}" | tail -n1 )+1))"
#   TMUX= tmux new-session -d -t $orig -s $copy
#   tmux switch-client -t $copy
#   tmux set -q -t $copy destroy-unattached on
# }
# $@

Mind you this works. From a running tmux client, Ctrl+B Ctrl+C creates a new session with a number appended to the name of the current one, uses the current one as a target for the panes, and switches to it.

I'm happy with this except for the nagging idea that I've just made something simple much more complex than it needs to be. Is there a simpler way to achieve this?

Best Answer

This is what I did:

alias ta='export NEW_SESSION=\$(uuidgen) ; tmux new-session -t 0 -s \$NEW_SESSION ; tmux kill-session -t \$NEW_SESSION'

What this does is create a new session from session named '0' (what the first session is named if you don't specify), named something uniquely random (using uuidgen) and then kill it when I detach.

Note that I'm using zsh. 'ta' is short for 'tmux attach'

Theory

Some init systems including systemd provide a feature to kill all processes belonging to the service. The service typically starts a single process which that creates more processes by forking and those processes can do that as well. All such processes are typically considered part of the service. In systemd this is done using cgroups.

In systemd, all processes belonging to a service are killed when the service is stopped by default. The SSH server is obviously part of the service. When you connect to the server, SSH server typically forks and the new process handles your SSH session. By forking from the SSH session process or its children, other server side processes are started, including your screen or tmux.

Killmode and socket activation

The default behavior can be changed using the KillMode directive. The upstream project doesn't AFAIK include any .service files and so those vary by distribution. There are typically two ways to enable SSH on your system. One is the classic ssh.service that maintains a long running SSH daemon listening on the network. The other is via socket activation handled by the ssh.socket that in turn starts sshd@.service which only runs for a single SSH session.

Solutions

If your processes get killed at the end of the session, it is possible that you are using socket activation and it gets killed by systemd when it notices that the SSH session process exited. In that case there are two solutions. One is to avoid using socket activation by using ssh.service instead of ssh.socket. The other is to set KillMode=process in the Service section of ssh@.service.

The KillMode=process setting may also be useful with the classic ssh.service, as it avoids killing the SSH session process or the screen or tmux processes when the server gets stopped or restarted.

Future notes

This answer apparently gained a level of popularity. While it worked for the OP it might happen that it doesn't work for someone in the future due to systemd-logind development or configuration. Please check documentation on logind sessions if you experience behavior different from the description in this answer.

Bash – tmux not colorizing PS1 prompt

Your PS1 also gives me black and white output.

However switching back to mine gives me color, so you should be able to figure out the different, I use

$ echo $PS1
\[\033[01;31m\]\t \[\033[01;32m\]durrantm \[\033[02;36m\]\h \[\033[01;34m\]`pwd | sed "s#\(/[^/]\{1,\}/[^/]\{1,\}/[^/]\{1,\}/\).*\(/[^/]\{1,\}/[^/]\{1,\}\)/\{0,1\}#\1_\2#g"` \[\033[00;33m\]$(git_branch)\[\033[00m\]\n\$

git_branch is a bash function I have which is:

git_branch () { 
  git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/'
}

Yours vs. Mine:

This works the same on OSX and Ubuntu