YALP

This is process manager which can manage process in linux. The basic job of this is to keep the process running in background even if crashes just like systemd.

NOTE: UUID/id refers to unique identifier assigned to process

Installation

Run make to get yapl binary in bin folder

Commands

yalp manage [-n identifier] command

Keep managing the process with identifier if specified otherwise a random idetifier assigned to process is returned
yalp list

List identifiers for processes managed by yapl
yalp logs [<id>|all]

Print last 10 lines of stdout & stderr
yalp status [<id>|all]

Print identifier, PID, state, health statisitics mentioned below
yalp start|stop|restart <id>

start|stop|restart a process identified by
yalp unmanage <id>

Stop managing the process identified by
yalp kill [signal] <id>

Send to the process identified by

Architecture

It is based on daemon-client model.

A single daemon process will handle managing, launching, stopping and restarting the processes.
- Daemon uses a SIGCHLD signal handler to keep track of terminated children
  - It is used beacuse a single parent (daemon) makes its easy to keep track of terminated childs
  - Also the processes launched using daemon will be independent of terminal session and no SIGHUP will be sent to these processes causing termination or any other action.
- Daemon uses 2 thread
  - 2 threads are required because SIGCHLD might interrupt if it is delievered while server is handling the client and may result in abnormal behaviour. * One thread runs a TCP server on port 31337 and service requests from client (SIGCHLD is blocked in this thread) * Other thread has SIGCHLD signal handler installed and it restarts the terminated processes on receiving the SIGCHLD signal. * The client program use TCP to send actions to perform to the daemon.
Choosing sockets over FIFOs or other IPC methods is just a personal preference.
- Usually in client/server communication, it is required to use a special TOKEN (like at the end of message) that confirm the end of message so that the other end won't block itself in a read call, since in this model client needs to send data once so use of use of the TOKEN can be eliminated using shutdown syscall which will terminate one half of connection and the other end won't get blocked.
Also if a process exits normally more than 10 times, it won't be started

Process

This class stores information about the process like: * UUID (unique indentifier) * Arguments and location of executable * State * Other health statistics related variables

Logging

Logs of the yapl are stored on /tmp/logs
stdout and stderr of a process are stored in /tmp/.logs (for stdout) and /tmp/.err (for stderr) Before execing a process after fork, stdout and stderr mapped to above files by closing fd 1,2 and opening above files so process automatically write to the above files. yapl logs commands gives last 10 lines of logs

Health Statistics

No of times a process is restarted by yapl with exit status != 0 and exit status for every failure
Average running time of the process
Last duration for which process is running/stopped.

Error Handling

For each command, error like invalid arguments, insufficient args, invalid identifier are checked properly
While starting the process, errors like Binary doesn't exists, insufficient permission are checked and reported to user.
Errors if starting an already running process, stopping an inactive process, unmanaging running/inactive process are handles properly.
Basically I have make sure that you won't be able to break the tool by throwing random data to it.

Data Structures

Information about a process (state, args, no of failures) are stored using a process class object.
Tow maps, one maps process_identifier to its process object and other maps pid to process_identifier

Direcrtory Tree

├── bin
│   └── yapl                                    the yapl binary will be placed here on running `make`
├── makefile
├── README.md
├── src
│   ├── globals.h
│   ├── yclient.cpp                             code to talk to daemon
│   └── ydaemon.cpp                             code to manage processes

rnehra01/YALP