Most crucial changes in `init/main.go`: on shutdown now Talos tries
to stop gracefully all the services. All the shutdown paths are unified,
including poweroff, reboot and panic handling on startup.
While I was at it, I also fixed bug with containers failing to start
when old snapshot is still around.
Service lifecycle is wrapped with `ServiceRunner` object now which
handles state transitions and captures events related to state changes.
Every change goes to the log as well.
There's no way to capture service state yet, but that is planned to be
implemented as RPC API for `init` which is exposed via `osd` to `osctl`.
Future steps:
1. Implement service dependencies for correct startup order and
shutdown order.
2. Implement service health, so that we can say "start trustd when
containerd is up and healthy".
3. Implement gRPC API for init, expose via osd (service status, restart,
poweroff, ...)
4. Impement 'String()' for conditions, so that we can see what service
is waiting on right now.
Signed-off-by: Andrey Smirnov <smirnov.andrey@gmail.com>
This changes `runner.Runner` API to support more methods to allow for
containerd runner to create container object only once, and start/stop
tasks to implement restarts.
New API: `Open()` (initialize), `Run()` (run once until exits), `Stop()`
(stop running instance), `Close()` (free resource, no longer available
for new `Run()`).
So the sequence might be: `Open`, `Run`, `Stop`, `Run`, `Stop`, `Close`.
Process and containerd runners were updated for the new API, and
'restart' part was removed, now both runners only run the task once.
Restart piece was implemented in an abstract way for any wrapped
`runner.Runner` in the `runner/restart` package. Restart supports three
restart policies: `Once`, `UntilSuccess` and `Forever`.
Service API was changed slightly to return the `runner.Runner`
interface, and `system.Services` now handles running the service.
For all the services, code was adjusted to either return runner (run
once), or was wrapped with `restart` runner to provide restart policy.
Signed-off-by: Andrey Smirnov <smirnov.andrey@gmail.com>
This is just first step towards better control of the services. Service
eventually uses either Process or Containerd runners to launch the
program. We don't have a way to control the service (stop it, figure out
whether it's actually running) unless we can pass back Runner instance
from the Service.
The idea is to return interface `runner.Runner` from the `Service` so
that controller (`init`) can figure out current state of the running
services and stop them on shutdown.
I haven't touched containerd runner yet (and as interface is not
enforced, code compiles fine). Only process runner is updated to allow
process to be stopped (either when it's running or while waiting to be
restarted).
For the sake of unit-tests, some additional runner options were exposed:
log path, restart interval, etc.
Signed-off-by: Andrey Smirnov <smirnov.andrey@gmail.com>
