The other role an init process can provide is to install signal handlers so signals sent from the host can be passed onto the container process. PID 1 is a bit special as it requires the process to listen for a signal for it to be received.

It ensures that the default signal handlers work for the software you run in your Docker image. For example, with Tini, SIGTERM properly terminates your process even if you didn't explicitly install a signal handler for it.

performing signal forwarding

design forms through the iterative readings and responses to interrelational conditions, with the intention of producing environments synchronous with their cultural settings.

‘convolution’ (as in, each of the folds of the brain)

Spanish carrion Crews

Black and trans users, and those from other marginalized communities, often use algospeak to discuss the oppression they face, swapping out words for “white” or “racist.” Some are too nervous to utter the word “white” at all and simply hold their palm toward the camera to signify White people.

A long alphanumeric ID is an immediate indicator that a train of thought has been developing.

Signal relationships are (usually) symmetric: if knowledge of X tells you about Y, then knowledge of Y tells you about X.

Signal  When a fact X is a signal of a fact Y, we mean simply that knowing X tells us something, or reduces our uncertainty about, Y. This usage contrasts a little with the standard use, where a signal often indicates some kind of intentionality (X is about Y), or agency (a person uses X deliberately to inform you about Y), or causality (X signals Y only if, for example, X preceeds Y in time).

just wanted to have an overview of these categories to get people thinking and doing in this level. And the challenge of course is the cornucopias and the Vikings are distracting us from what really needs to be done. And so this whole conversation, we're thinking two or three steps ahead from something that 00:51:27 our culture is not giving us the status, reward, and emotional signals of yet.

For both of these concerns we recommend tini. It is incredibly small, has minimal external dependencies, fills each of these roles, and does only the necessary parts of reaping and signal forwarding.

The first being signal handling. If the process launched does not handle SIGTERM by exiting, it will not be killed since it is PID 1 in the container

Is whatever process you exec in your entrypoint registering signal handlers? A good way to figure this out might be to check whether your process responds properly to e.g. docker stop (or if it waits for 10 seconds before exiting)

Tini does install explicit signal handlers (to forward them, incidentally), so those signals no longer get dropped. Instead, they're sent to Jenkins, which is not running as PID 1 (Tini is), and therefore has default signal handlers

First, if Jenkins runs as PID 1, then it's difficult to differentiate between process that were re-parented to Jenkins (which should be reaped), and processes that were spawned by Jenkins (which shouldn't, because there's other code that's already expecting to wait them).

Tini fixes by "forwarding signals": if you send a signal to Tini, then it sends that same signal to your child process (Jenkins in your case).

Unfortunately most init systems don't do this correctly within Docker since they're built for hardware shutdowns instead. This causes processes to be hard killed with SIGKILL, which doesn't give them a chance to correctly deinitialize things.

SIGTSTP is like SIGSTOP except that it can be caught and handled.

SIGSTOP and SIGKILL are two signals that cannot be caught and handled by a process.

four building blocks and 14 signals for improving and inspiring the design of better digital public spaces

sig_handler() { exit_status=$? # Eg 130 for SIGINT, 128 + (2 == SIGINT) echo "Doing signal-specific up" exit "$exit_status" }

In any case signal handling in shells is one of the least reliable and portable aspects. You'll find behaviours vary greatly between shells and often between different versions of a same shell. Be prepared for some serious hair pulling and head scratching if you're going to try to do anything non-trivial.

Both kill with a job specifier and terminal signals send to the entire process group, so both the shell and sleep.

I am trying to understand how CTRL+C terminates a child but not a parent process. I see this behavior in some script shells like bash where you can start some long-running process and then terminate it by entering CTRL-C and the control returns to the shell. Could you explain how does it work and in particular why isn't the parent (shell) process terminated? Does the shell have to do some special handling of CTRL+C event and if yes what exactly does it do?

Quit the program by sending a different signal to both processes, e.g. SIGQUIT with Ctrl + \.

The CTRL-\ key sends a kill signal to the foreground job which, under normal circumstances, is guaranteed to terminate it. This signal cannot be captured by a process. However, this means the process cannot cleanup and is just summarily stopped. In some cases, a process can be stuck in a kernel wait state so this signal never reaches it. In that case, the process is unusable but cannot be killed.

Remove your last "just in case" trap, and the script should work fine also with the EXIT traps. INT in the trap calling the cleanup should be the correct way to deal with the interrupts, however

You need a trap in loop.sh. Traps are cleared for every subshell started unless they are explicitly trap ''SIG ignored by the parent.

Personally, I prefer signalling an error for invalid values

Your hardware modular rig is completely integrated,

all signals are interchangeable so any out port can be connected to any in port

The opening section also lays out come key concepts for the book, including social movement capacities (“social movements’ abilities”) and signals (“their repertoire of protest, like marches, rallies, and occupations as signals of those capacities”) (xi), as well as the problem of tactical freeze (“the inability of these movements to adjust tactics, negotiate demands, and push for

Citation signals The citation signal appearing next to a case name indicates whether the decision has received positive, negative, cautionary or neutral treatment in subsequent judgments. The signal is a summary of the annotation information available from the list of appeal proceedings and cases referring to this case. Clicking on these signals will take you to the citation entry for these decisions. Hover your mouse over the symbol for a description.