immortal/immortal

⭕ A *nix cross-platform (OS agnostic) supervisor

⭕ immortal

A *nix cross-platform (OS agnostic) supervisor

https://immortal.run/

Linux precompiled binaries

run on behalf other system user

If services need to run on behalf other system user www, nobody, www-data, not root, immortal should be compiled from source for the desired target/architecture, otherwise, this error may be returned:

Error looking up user: "www". user: Lookup requires cgo

See more: https://golang.org/cmd/cgo/

If using FreeBSD or macOS you can install using pkg/ports or homebrew, for other platforms work is in progress, any help for making the port/package for other systems would be appreciated.

Compile from source

Setup go environment https://golang.org/doc/install

go >= 1.12 is required

For example using $HOME/go for your workspace

$ export GOPATH=$HOME/go

Create the directory:

$ mkdir -p $HOME/go/src/github.com/immortal

Clone project into that directory:

$ git clone [email protected]:immortal/immortal.git $HOME/go/src/github.com/immortal/immortal

Build by just typing make:

$ cd $HOME/go/src/github.com/immortal/immortal
$ make

To install/uninstall:

$ make install
$ make uninstall

configuration example

Content of file /usr/local/etc/immortal/www.yml:

# pkg install go-www
cmd: www
cwd: /usr/ports
log:
    file: /var/log/www.log
    age: 10  # seconds
    num: 7   # int
    size: 1  # MegaBytes
wait: 1
require:
  - foo
  - bar

If foo and bar are not running, the service www will not be started. Skip age, num & size options to avoid log-rotation completely.

foo and bar are the names for the services defined on the same path www.yaml is located, foo.yml & bar.yml

Paths

When using immortaldir:

/usr/local/etc/immortal
|--foo.yml
|--bar.yml
`--www.yml

The name of the file.yml will be used to reference the service to be daemonized excluding the extension .yml.:

foo
bar
www

/var/run/immortal/

/var/run/immortal
|--foo
|  |-lock
|  `-immortal.sock
|--bar
|  |-lock
|  `-immortal.sock
`--www
   |-lock
   `-immortal.sock

immortal like non-root user

Any service launched like not using using immortaldir will follow this structure:

~/.immortal
|--(pid)
|  |--lock
|  `--immortal.sock
|--(pid)
|  |--lock
|  `--immortal.sock
`--(pid)
   |--lock
   `--immortal.sock

The -name argument takes a non-path (e.g., "myservice"), and the argument will be used instead of the pid in the directory structure. For example, immortal -ctl myservice sleep 1000 will be:

~/.immortal
|--myservice
|  |--lock
|  `--immortal.sock

The -ctl argument takes precedence over the -name argument.

immortalctl

Will print current status and allow to manage the services

debug

pgrep -fl "immortal -ctl"  | awk '{print $1}' | xargs watch -n .1 pstree -p

Test status using curl & jq

status:

curl --unix-socket immortal.sock http:/status -s | jq

note the single '/' https://superuser.com/a/925610/284722

down:

curl --unix-socket immortal.sock http://im/signal/d -s | jq

up:

curl --unix-socket immortal.sock http://im/signal/u -s | jq

immortal's Issues

-o stdout.log -e stderr.log

make optionally how to log

• combine stdout/stderr
• stdout
• stderr

Lack of orthogonality: cmd vs require_cmd

The cmd configuration value is parsed using strings.Fields(), and executed with: exec.Command(p.command[0], p.command[1:]...)

The require_cmd configuration value is not parsed and is executed with exec.Command(shell, "-c", cfg.RequireCmd).Run()

This means that you cannot use a command in cmd that does any sort of globbing, pipes, quoting, escaping or uses environment variables, and you cannot pass an argument to the command that contains whitespace.

I suppose the issue is that using "sh -c" creates an extra (shell) child process layer, which maybe you want to avoid.

So, for example, I could not run this:

cmd: curl -S -H"X-Custom:Value with spaces" http://example.com/RestService

In other similar tools I've done something like this:

cmd_exec: /bin/curl
cmd_args:
  - -S
  - -HX-Custom:Value with spaces
  - http://example.com/RestService

This still does not allow for globbing, env var expansion or pipes.

Perhaps there should be an alternate way to specify a full "command line" where quoting, interpolation and globbing can work:

cmd_line: echo "Searching for new foo files";date;ls -l $HOME/subdir/*/foo*

stderr log file

Be available to specify a file only for writing logs related only to stderr, probably something like this:

    log:
        file: /var/log/app/access.log
        age: 86400
        num: 3
        size: 1
    stderr:
        file: /var/log/app/error.log
        age: 86400
        num: 3
        size: 1

The complexity of this is the creation of another pair of pipes only for the stderr and another logger that both file/err should be rotated on the defined period

Is it possible to make immortal load environment variables from the actual environment?

It seems if i don't supply the env: dictionary in the yaml file, then the environment variables from the OS are not available to the process. Is it possible to have them pass through?

Immortal on Raspberry

Hi !
I'm using immortal with Linux Mint and the SSTV software since this program is buggy and exit itself whenever while it must receive SSTV pictures from ISS. So in order to avoid missing pictures from the International Space Station, Immortal is a must have software.
I've just installed QSSTV on my raspberry and I didn't find any package for Raspbian and ARM device working for my Raspbian under Raspberry. I've passed many hours to try to compile the software but I never succeed.

So can someone help me to get a working package or un very good tutorial about how to compile this software for my raspberry ? New pictures are being sent this week-end from ISS...

Many thanks to all people who will help me.

David.

immortaldir the restart process is not terminating the process

immortaldir is sending an exit instead of a term therefore, only the supervisor exist but the process continues to be up and running as expected.

To do a restart when something changes on the run.yml, a term, start should be performed.

How do you stop a process?

Hi :). Sorry for opening up a GitHub issue. I just can't predictably stop an immortal service with immortalctl.

The service doesn't appear without sudo.

So I always try the following
immortalctl stop
immortalctl stop
sudo immortalctl stop
sudo immortalctl stop
sudo immortalctl -k
sudo immortalctl -k
immortalctl -k
immortalctl -k
set IMMORTAL_EXIT=exit sudo immortalctl exit run
sudo IMMORTAL_EXIT=exit immortalctl exit run (Where run is the process name - see pictures).
sudo immortalctl halt "" And it comes back to life in about 5 seconds.
sdo immortalctl exit
sudo IMMORTAL_EXIT=exit immortalctl exit ""

And nada.

https://askubuntu.com/a/1088357/806019

The question is... how do I stop a service?

Unable to run immortal with yml config in docker

I am trying to create long-running services with .net core and Docker, and i want them supervised with immortal.

Here's my dockerfile:

FROM microsoft/dotnet:2.0-runtime
    ARG source
    WORKDIR /app
    COPY ${source:-obj/Docker/publish} .
    WORKDIR /immortal
    RUN  apt-get update \
      && apt-get install -y wget \
      && rm -rf /var/lib/apt/lists/*
    RUN wget https://github.com/immortal/immortal/releases/download/0.16.0/immortal_0.16.0_linux_amd64.tar.gz
    RUN tar -xzvf immortal_0.16.0_linux_amd64.tar.gz
    WORKDIR /app
    ENTRYPOINT ["/immortal/immortal_0.16.0_linux_amd64/immortal", "-c /app/coresandbox.yml"]

(i am using VS Docker tools, so the publishing to /obj/Docker/publish is handled outside of this docker file)

If i do docker run coresandbox i get this output:

flag provided but not defined: -c /app/coresandbox.yml
  Usage: /immortal/immortal_0.16.0_linux_amd64/immortal [-v] [-ctl dir] [-d dir] [-e dir] [-f pidfile] [-l logfile] [-logger logger] [-p child_pidfile] [-P supervisor_pidfile] [-u use
  
     command
          The command with arguments if any, to supervise
  
    -c run.yml
          run.yml configuration file
    -ctl /var/run/immortal/<service>
          Create supervise directory /var/run/immortal/<service>
    -d dir
          Change to dir before starting the command
    -e dir
          Set environment variables specified by files in the dir
    -f pidfile
          Follow PID in pidfile
    -l logfile
          Write stdout/stderr to logfile
    -logger command
          A command to pipe stdout/stderr to stdin
    -P pidfile
          Path to write the supervisor pidfile
    -p pidfile
          Path to write the child pidfile
    -s seconds
          seconds to wait before starting
    -u user
          Execute command on behalf user
    -v    Print version

However, if i use bash interactively in the image, i can start immortal:

docker run --entrypoint /bin/bash -i -t coresandbox

/immortal/immortal_0.16.0_linux_amd64/immortal -c /app/coresandbox.yml

 2017/09/13 04:47:02 PID 90 terminated, exit status 0 [100ms user  50ms sys  156.8319ms up]
 2017/09/13 04:47:03 PID 103 terminated, exit status 0 [110ms user  40ms sys  154.0168ms up]

The contents of my coresandbox.yml are correct yaml, and correct config for immortal

improve mutex

improve the RWmutex implementation and tests using TestMain

improve PurgeServices to avoid accidents

PurgeServices will remove the parent directory of the listen socket immortal.sock but when using a custom path by defining IMMORTAL_SDIR, if accidentally a wrong path is used, for example:

export IMMORTAL_SDIR=/

that may delete full root directory (rm -rf /)

So better find a way of only cleaning the sockets instead of the full directories.

Tests not passing using travis Go:tip under mac os

Find out why tests are not passing on Travis (develop branch) only when OS is mac os and go version is tip https://travis-ci.org/immortal/immortal/jobs/283863933

Are packagecloud immortal packages still maintained?

Hello, sorry if a GitHub issue is not the correct place to raise this.

I was following the installation instructions for immortal and noticed two issues:

1. The latest version available on packagecloud is 0.23.1 while it seems from the GitHub releases, that the latest stable release is 0.24.3
2. There are no packages for Ubuntu 20.04 (focal). The installation script on packagecloud attempts to generate an immortal_immortal.list for focal, and this fails as no package for this release has been created on packagecloud.

It is not possible to install immortal on Ubuntu Focal:

Ign:6 https://packagecloud.io/immortal/immortal/ubuntu focal InRelease
Err:7 https://packagecloud.io/immortal/immortal/ubuntu focal Release
  404  Not Found [IP: 2600:1f1c:2e5:6900:5df8:6a7b:6fb7:c697 443]
Reading package lists... Done
E: The repository 'https://packagecloud.io/immortal/immortal/ubuntu focal Release' does not have a Release file.

I did a bit of searching, but I cannot find any other source of immortal deb packages.

Thank you

Does immortal daemonize itself?

When running immortal, how does it daemonize itself?

immortaldir not starting services

immortaldir does not start services when running immortal entirely from a user $HOME -- with no access to root directories.

Setup

$HOME/local/bin/immortal
$HOME/local/bin/immortaldir
$HOME/local/bin/immortalctl
$HOME/local/var/run/immortal
$HOME/local/etc/immortal/app.yml

Success with immortal

cd $HOME/local
./bin/immortal -c etc/immortal/app.yml

This works; bin/immortalctl status shows the service started & app is running. I can stop, restart, and otherwise control app through immortalctl as expected. However...

Failure with immortaldir

cd $HOME/local
IMMORTAL_SDIR=$HOME/local/var/run/immortal ./bin/immortaldir etc/immortal

results in

2018/04/17 22:28:36 immortal scandir: /home/uzr/local/etc/immortal
2018/04/17 22:28:36 Starting: app
2018/04/17 22:28:36
2018/04/17 22:28:41 Starting: app
2018/04/17 22:28:41

and so on, repeatedly. No errors, no logging, no way to figure out what's going wrong. app is not started nor is running.

Expected behavior

An app that can be successfully started with immortal should work when started with immortaldir.

validate config file

is there a way to validate config file?

STOP & CONTINUE os: process already finished

When sending -s for stop and -c for continue I get os: process already finished

sending the signals to the pid directly it works.

$ ./immortalctl -c 8457                                                                                                                                                        │BUGS
  PID       Up   Down   Name   CMD                                                                                                                                             │     A replacement for the command ``kill 0'' for csh(1) users should be provided.
12646   1m8.9s          8457   /Users/nbari/tmp/stdout - os: process already finished  

conflict when using -l and logger with watchpid

When logging to a file using -l or -logger

The watchpid line is not printed but seems to be working, the expected logs should be somethign like:

Mar 17 01:48:46 nbari-mini immortal[82586]: PID 82591 terminated, exit status 0 [314.523ms user  72.499ms sys  37.000382188s up]
Mar 17 01:48:46 nbari-mini immortal[82586]: Watching pid 83737 on file: ./unicorn.pid

Also, the process remains up "green", but can't send signals to it

improve tests for scandir (kqueue)

Need to improve tests/code for properly testing scandir currently having only this:

https://github.com/immortal/immortal/blob/master/scandir_test.go

keep it up when sending signal "DOWN", "D"

When sending signal down or d the supervisor exists therefore the socket stops listening further requests.

In case the supervisor dir where enable, possible this will cause a loop since the required status is down and could became up

immortal 0.24.0/0.24.1 upgrade issue

Relates to

• Homebrew/homebrew-core#45928
• Homebrew/homebrew-core#47622

It looks like we cannot build immortal from the source code (I just tried on my local machine, I wonder if you can provide some instructions to keep the formula up to date). Thanks!

cc @nbari

option to keep trying and only stop when exit 0

In some cases, for example along rsync process would be nice to keep trying until X program exit 0:

immortal -l /tmp/rsync.log rsync -avz your-server.tld::maildirs /vmail/

once program exist successfully, immortal could exit

Stopping a process

I have a similar problem to a previous question: #44 (comment)

I installed immortal.run and immortalized a process on WSL2 Ubuntu to try it. But I didn't set up immortalctrl or immortaldir. Now, I cannot find the way to kill this process. When I run "immortalctrl" or "sudo immortalctrl" there are no processes listed. But I can see that they are running from htop. I have also not found any run.yml file anywhere or even an /.immortal directory anywhere in the file system.

Maybe the developers went too far in their search for immortality?

I would really appreciate any recommendations on how to kill this process. I guess it would not be helpful to uninstall and purge immortal since at this stage the process has been daemonized?

Log files reopening

Is there any way to reopen log files managed by immortal?
What do you think about implementing a such feature (by catching SIGUSR2 like supervisord do) to avoid dependency on any external log manager?

abstract functions on an interface to better handle tests

to better test immortalctl and immortaldir create an interface to test mock SendSignal

Custom 'cleanup' action

Hi,

Would it be possible to integrate some kind of custom cleanup action after the process from “cmd” finishes? Something to be executed with the exit code as a parameter, that could perform some extra actions before the main process is restarted (or just after it is shut down.)

I have a 'cmd' script that uses “exec” to start the main service so that it can be managed properly, but when it stops I'm left with a few ifconfig commands to run to ensure the proper teardown sequence 😅

immortaldir crashes with a high number of processes

What did you do?

I would like to start/manage about 1500 processes via immortal. But unfortunately after about 100-200 processes immortaldir crashes. As soon as I create more than 200 yml files in the immortaldir directory, immortaldir crashes.

yml file content is always the same:
cmd: sleep 3600

What did you expect to see?

It should be possible to manage 1500 processes

What did you see instead?

immortal crashed.
Jan 07 21:54:49 immortaldir[3501265]: 2020/01/07 21:54:49 runtime: failed to create new OS thread (have 6 already; errno=11)
Jan 07 21:54:49 immortaldir[3501265]: runtime: may need to increase max user processes (ulimit -u)
Jan 07 21:54:49 immortaldir[3501265]: fatal error: newosproc
Jan 07 21:54:49 immortaldir[3501265]: runtime stack:
Jan 07 21:54:49 immortaldir[3501265]: runtime.throw(0x7b2dc0, 0x9)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/panic.go:774 +0x72
Jan 07 21:54:49 immortaldir[3501265]: runtime.newosproc(0xc000080000)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/os_linux.go:153 +0x1ba
Jan 07 21:54:49 immortaldir[3501265]: runtime.newm1(0xc000080000)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:1853 +0xdc
Jan 07 21:54:49 immortaldir[3501265]: runtime.newm(0x7cce20, 0xc000029400)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:1832 +0x8f
Jan 07 21:54:49 immortaldir[3501265]: runtime.startm(0x0, 0xc000026f01)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:1969 +0x12a
Jan 07 21:54:49 immortaldir[3501265]: runtime.wakep(...)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:2050
Jan 07 21:54:49 immortaldir[3501265]: runtime.resetspinning()
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:2430 +0x93
Jan 07 21:54:49 immortaldir[3501265]: runtime.schedule()
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:2531 +0x2a0
Jan 07 21:54:49 immortaldir[3501265]: runtime.park_m(0xc000000600)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:2610 +0x9d
Jan 07 21:54:49 immortaldir[3501265]: runtime.mcall(0x0)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/asm_amd64.s:318 +0x5b
Jan 07 21:54:49 immortaldir[3501265]: goroutine 1 [chan receive, locked to thread]:
Jan 07 21:54:49 immortaldir[3501265]: runtime.gopark(0x7cce70, 0xc000060058, 0x170e, 0x3)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:304 +0xe0
Jan 07 21:54:49 immortaldir[3501265]: runtime.goparkunlock(...)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:310
Jan 07 21:54:49 immortaldir[3501265]: runtime.chanrecv(0xc000060000, 0x0, 0xc000000101, 0x410101)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/chan.go:524 +0x2e8
Jan 07 21:54:49 immortaldir[3501265]: runtime.chanrecv1(0xc000060000, 0x0)
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/chan.go:406 +0x2b
Jan 07 21:54:49 immortaldir[3501265]: runtime.gcenable()
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/mgc.go:213 +0xac
Jan 07 21:54:49 immortaldir[3501265]: runtime.main()
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/proc.go:166 +0x121
Jan 07 21:54:49 immortaldir[3501265]: runtime.goexit()
Jan 07 21:54:49 immortaldir[3501265]: /usr/local/go/src/runtime/asm_amd64.s:1357 +0x1

Is it possible to reproduce?

Yes on Ubuntu and SLES distributions

Hardware

8 Cores
8 GB RAM

uname -a
Linux 4.12.14-95.29-default #1 SMP Thu Aug 1 15:34:33 UTC 2019 (47e48a4) x86_64 x86_64 x86_64 GNU/Linux

ulimit -a
core file size (blocks, -c) unlimited
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 0
file size (blocks, -f) unlimited
pending signals (-i) 31295
max locked memory (kbytes, -l) 64
max memory size (kbytes, -m) unlimited
open files (-n) 1042101
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 0
stack size (kbytes, -s) unlimited
cpu time (seconds, -t) unlimited
max user processes (-u) 2097151
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited

Question - log throughput

When i run my app via immortal with yml config, if i don't specify the log option, i don't see any logs in my console, apart from process starts and exists.
Is it possible to have the logs sent to the console from a running process?

Improve web docs

Improve the web docs: for example https://github.com/immortal/docs/edit/master/post/immortal.md

Command dependencies

Hi,

the following is an idea to allow dependence of processes on unix commands: instead of the keyword "require" to list a number of immortal processes as dependencies one could introduce a keyword "require_cmd", which specifies a list of unix commands that are executed and have to return without errors (exit code 0) in order for the immortal process to start. Immortal would then automatically check this periodically, and as soon as these dynamic conditions are fulfilled, the process would be spawned.

Use case: spawn a process when a certain file exists/does not exist anymore.

Thank you!

Flag to name jobs without using `immortaldir`

For lightweight or temporary usage of immortal, it's still useful to be able to refer to jobs by name. I'm thinking it could work something like this:

$ immortal -n datelog -l out.txt /bin/sh -c "date && sleep 5"
$ immortalctl status
  PID      Up   Down   Name    CMD
92315   4.3s          datelog   /bin/sh -c date && sleep 5
$ immortalctl exit datelog
PID   Up   Down   Name   CMD

I think this should be fairly straightforward to implement. If it's a feature that you agree would be useful, I would be happy to look into implementing it myself.

improve tests for scandir.go

improve tests for scandir.go and watchdir.go mainly the onew using kqueue (freebsd netbsd openbsd dragonfly darwin)

func (s *ScanDir) Start(ctl Control) {}

and

func (s *ScanDir) Scandir(ctl Control) error {}

Implement require

The idea of the require in the configuration file, is to avoid starting services that depend on others, so this will allow to chain services, example:

require:
    - service1
    - service2

option to send logs to syslog ( centralized logging)

Have an option to send logs directly to syslog.

The idea behind is to simplify the log collection in systems that are already sending logs to a remote server.

Error looking up user: "www". user: Lookup requires cgo

When downloading the precompiled binaries, this error may appear:

 Error looking up user: "www". user: Lookup requires cgo

Seems that is not currently possible to cross compile using cgo, therefore need to way to create the binaries on the native platforms.

Compiling from sources solves this problem.

https://golang.org/cmd/cgo/

retries implementation

http://disq.us/p/1nvwxkm

define in the run.yml the number of retries before exiting, like the once but within the configuration file.

immortaldir should stop all services on exit

maybe it's my bias, but it looks like more predictable behaviour (or at least it would be nice to have such option).

make immortalctl work when following pid

when following a pid, all the signals reply with a no such process

$ immortalctl -2 93301 
  PID       Up   Down   Name    CMD
93306   2m5.8s          93301   bundle exec unicorn -c unicorn.rb - no such process

Find a way to send signals to the master pid on file

distinguish when a Pid is been followed

When followign a pid, instead of printing the pid in red, probably yellow could be used:

$ immortalctl status
  PID   Up      Down   Name    CMD
37760        1m17.1s   37199   bundle exec unicorn -c unicorn.rb

restart alias for "halt"

When having immortaldir up and running and sending signal halt basically a "restart" is performed, services are stopped and started again, therefore could be handy to also have an alias for halt named restart something like:

immortalctl restart service 

implement restart

I'm missing a restart command that would restart my process without having to run two commands (halt and up). I mainly require this for reloading application-specific configuration files.

I guess a restart command would basically mean calling immortalctl halt xxx and then start the process again. it would probably only work when using immortaldir.

would be nice to expose the sequence of commands for restart as part of the configuration (pretty much like Monit does it?!), in case sending the TERM signal is not my way of restarting a process.

wdyt? 🍍

improve documentation

Improve the overall documentation, for the example in the run.yml there is no explanation about how to avoid rotating logs, something that could be done by just omitting the options age, num, size etc.

Be more clear, add more examples (avoid assumptions)

add option to avoid logger add current time

The default logger writes to file using the current time as a prefix, for example:

2017-07-30T02:27:33.285542198Z 2017/07/30 02:27:33  [http://sign-io.appspot.com/] 200 946 806.40384ms 

But when the app add its own format it may be desired to just write to the log exactly that the app is sending.

probably add a timestamp bool option:

log:
    file: /var/log/app-1.log
    age: 86400 # seconds
    num: 7     # int
    size: 1    # MegaBytes
    timestamp: false

create linux package for common distros

Create a package for common Linux distros to simplify the install process so it can be used by default package managers like apt, yum, pacman etc.

as Docker container process manager

1. Documentation needed for using immortal as non-dependency binary file as container entry point multi services container.
   See supervisord as python process manager.
   https://docs.docker.com/config/containers/multi-service_container/

2. And how to healtheck for container will work?
   https://docs.docker.com/engine/reference/builder/#healthcheck

3. and some example to open nginx or pm2 or phpfpm or another application for immortal subprocess and immortal lead them all and report docker engine that container is healthy or not.

It's will be awesome.

usr.HomeDir, verify that HOME environment variable is not ignored

test/double check that daemon.go respects the $HOME environment variable, to prevent something like this: Homebrew/homebrew-core#18238 (comment)

give preference to$HOME environment variable

Releases do not contain man pages?

It seems the pre-built binary releases do not contain the man pages. Is there a reason for this?

Kqueue for immortaldir

Implement Kqueue per configuration file or directory to better track changes on demand.

Similar to what watchpid is using when using the -f follow PID option, but in this case for the configuration files.

help to review the code

Help reviewing the code mainly in the https://github.com/immortal/immortal/blob/master/logger.go and interfaces

Have a lot of Defunct process when running immortal in a docker container

I had some missing libraries in my container so my process kept dying, but this seemed to create a lot of defunct process when I log into the container.

I run my command as
immortal -l /dev/null /usr/bin/python3

in the container immortal has pid 1. Is there something I need to do to avoid these defunct entries in the container (and presumably host) pid table?

Question - can we do one retry using `retries`

We use immortal to configure some code insider our docker containers.
Depending on some external configuration, we may want our service to always be restarted, or to run just once.

I tried setting retries to 0 in immortal configuration but that didn't seem to do it.

Any way i can use immortal so that supervisor exits if service exits, using run.yml approach?