Personally, I'd like to see a system transparent as much as possible (ideally, with an option to boot the system with a pause after a service launched, so in tty2, it would be possible to check a brief description of the service, files created, and how to delete and start it manually if needed).

2018-01-18 08:33:55.648616500 rofs-console started
2018-01-18 08:33:55.649825500 lvm-prepare desactived
2018-01-18 08:33:55.650139500 checkfs-dmraid desactived
2018-01-18 08:33:55.650244500 checkfs-brtfs desactived
2018-01-18 08:33:55.653642500 checkfs-fsckeck started
2018-01-18 08:33:55.855397500 /dev/sda3: clean, 824654/6406144 files, 14835686/25600000 blocks
2018-01-18 08:33:55.934077500 /dev/sda1: clean, 84/38456 files, 42329/153600 blocks
2018-01-18 08:33:55.996409500 rofs-console successfully started

For most users some gui panel listing services and daemons that they could activate and deactivate like systemd on debian, with warnings for the minimum essential and the optional ones.

After S6 has shut everything down, it says the system will no be powered off/down and then it sticks there. In some other box I don't even get to see this message it is already off (so fast).

foreground {
	if { s6-test -x /usr/bin/mountstats }
	if -X { mountstats }
	if { s6-echo Umount NFS filesystem }
	umount -a -f -t nfs4 
}

# append this following line
foreground { sleep 10 }

if { s6-echo -- "***************************************************************************" }
if { s6-echo -- "** 

type=classic
description="foo service is used by foo soft"
name=foo
enabled=yes
log=yes
dependencies=( 'foobar' 'foostr' )
user=obarun
timeout-kill=2

run(){
# !/usr/bin/bash
/usr/bin/foo --nodaemon
}

finish(){
# !/usr/local/bin/execlineb -P
s6-rmrf /run/foo
}

--------------- File Syntax format with all available keys ------------

type = classic/bundle/longrun/oneshot
name = foo
description = "foo service"
contents = ( fooA fooB )
depends = ( fooA fooB fooD fooC )
options = ( logger nosetsid down data env )
notify = 3
user = ( root obarun )
pipeline = ( foo-pipe )
producer = ( logger foo )
consumer = ( foo fooA )


[run]
flags = ( auto line )
runas = root
timeout-finish = 10
timeout-kill = 10
timeout-up = 10
timoout-down = 10
exec = ( /usr/bin/foo -d )


[finish]
flags = ( auto line )
runas = root
timeout-finish = 10
timeout-kill = 10
timeout-up = 10
timoout-down = 10
exec = ( /usr/bin/foo -d )

[logger]
destination = /var/log/foo
flags = ( auto line )
timeout-finish = 10
timeout-kill = 10
runas = s6log
backup = 3
size = 1000000
timestamp = TAI64


-------------------- Explanation of each key ------------------------

key --- type ----
decription : Mandatory key. First key to find, if it's not the case the
process is stopped immediatly. This will allow to earn time to parse the file.
In function of the type some key are mandatories.
value : string format
classic -> classic servcie
bundle -> bundle service
longrun -> longrun service
oneshot -> oneshot service

key --- name ----
description : Mandatory key. Name of the service
value : string format

key --- description ----
description : Mandatory key. A short description of the service
value : string format

key --- contents ----
description : Mandatory key for bundle type. The declaration order
define the dependencies order.
value : must be found between (), space is the separator of each name

key --- depends ----
description : Optional key. The declaration order define the dependencies
order. Can be used for classic service too, it isn't so
difficult for the helper to verify the presence of an another classic/rc
service.
value : must be found between (), space is the separator of each name

key --- options ----
description : Optional key. Available options
value : must be found between (), space is the separator of each name
logger -> the helper will create automaticaly a logger for the service.
down -> creation of the empty file down
nosetsid -> creation of the empty file nosetsid
data -> verbatim copy of the data directory
env -> verbatim copy of the data directory

key --- notify ----
description : Optional key. Fd number. This will create the file notification-fd
value : int format

key --- user ----
description : Optional key. This indicate which user can handle the
service. We are not talking about process execution process here,
we talking about if the service can be started or not by the given user
If it not set only root can handle the service.If it set, root need to be
present as value, if not only the user define as value can handle the service
value : must be found between (), space is the separator of each name

key --- pipeline/consumer/producer ----
description : Optional key. Creation of the respective files
value : must be found between (), space is the separator of each name

[-------- section run -------- ]

Mandatory section


key --- flags ----
description : Mandatory key. The helper will create automaticaly the file
run or up (depending of the type of the service) or make a verbatim copy
of the value
value : must be found between (), only one of those can be set
auto -> automatic creation of the file run/up.
line -> verbatim copy of all the things found between ()

key --- timeout-{finish,kill,up,down} ----
description : Optional file. Creation of the respectives files. this will
also depends of the type e.g timeout-up doesn't exist on classic service.
value : int format

key --- runas ----
description : Optional key. Execute the program as user
value : string format or int (uid/gid)

key --- exec ----
description : Mandatory key. Which program to execute
value : must be found between ()
for auto flags : the resulting file run/up is :

# !/command/execlineb -P <--- trouble can be append here for the path
fdmove -c 2 1
fdmove 1 3 <---- only present if notify is set
s6-setuidgid user <---- only present if runas is set
exec -c
/usr/bin/foo -d <---- verbatim copy of the string found between ()

for line flags : verbatim copy of the string found between ()

[-------- section finish -------- ]

Optional section. if it set, this section is the same as the run section

[-------- section logger -------- ]

Optional section. If option logger is set the helper create the log
automaticaly. However, if the section is found, some key are mandatory.

key --- destination ----
description : Mandatory key. Destination directory
value : string format, must be an absolute path

key --- flags ----
description : Mandatory key. The helper will create automaticaly the file
run or make a verbatim copy of the value.
value : must be found between (), only one of those can be set
auto -> automatic creation of the file run/up.
line -> verbatim copy of all the things found between ()

key --- timeout-{finish,kill} ----
description : Optional file. Creation of the respectives files.
value : int format

key --- runas ----
description : Optional key. Execute the program as user
value : string format or int (uid/gid)

key --- backup ----
description : Optional key. number of the archived log files
value : int format

key --- size ----
description : Optional key. set the filesize for the log files.
value : int format

key --- timestamp ----
description : Optional key. line will be prepended with the value format.
value : string
TAI -> TAI64N timestamp format
ISO -> ISO 8601 timestamp format

key --- exec ----
description : Optional key if flags is set to auto. Mandatory key if flags
is set to line.
value : must be found between ()
for auto flags : the resulting file run is :

# !/command/execlineb -P <--- trouble can be append here for the path
fdmove -c 2 1
s6-setuidgid s6log <---- only present if runas is set
exec -c
s6-log n3 t s1000000 /var/log/foo

the n3 t and s1000000 will be replaced by the given value of the
respective key

for line flags : verbatim copy of the string found between ()


-------------------- Example ------------------------

<----------- Simple classic service ---------->

type=classic
name=foo
description="foo service"
options=( logger )

[run]
flags=( auto )
exec=( /usr/bin/foo -d )

<------- Complex classic service ------->

type=classic
name=foo
description="foo service with dependencies and personnal command"
options=( logger env )
depends=( fooA fooB )
user = ( obarun root )

[run]
flags=( line )
runas= 1000
exec=(
# !/bin/bash
exec 2>&1
source /etc/file.conf
/usr/bin/foo -d
)

[logger]
destination = /var/log/foo
flags=( auto )
runas=s6log
backup = 1

<---------- bundle service -------------->

type=bundle
name=foo
description="foo bundle service"
contents=( fooA fooB fooD fooC )


<--------- Simple longrun service ------------>

type=longrun
name=foo
description="foo longrun service"
options=( logger )

[run]
flags=( auto )
exec=( /usr/bin/foo -d )

<------- Complex longrun service ------------->

type=longrun
name=foo
description="foo longrun service with dependencies"
options=( logger )
depends=( fooA fooB )
producer=( logger fooA )
consumer=( fooB )
pipe=( foo-pipe )

[run]
flags=( auto )
exec=( /usr/bin/foo -d )

[finish]
flags=( line )
exec=(
# !/bin/bash
source /etc/script.file
/usr/bin/foo --finish
)

<---------- Oneshot service -------->

type=oneshot
name=foo
description="foo oneshot service"

[run]
flags=( auto )
exec=( /usr/bin/scripts.sh )

I think it is almost nice, because it is relatively simple. What is the difference to the former proposal? Isn't it primarily the syntax of the block separators, that is now ini-like instead of shell-like.

This is really a question: Can the 'exec' variable be multiline? This would be nice to support custom runscripts. The former format has the advantage that one could also utilise other interpreters <edit>and edit the whole structure of the file (skel file would need to be in skel service description)</edit>. On the other hand, run scripts should not contain too much logic.

----- with flags set to auto ----
valid examples :
exec=( /usr/bin/foo -d )
or 
exec=( /usr/bin/script_to_run args_of_the_scripts ) 

not valid :
exec=( /usr/bin/mkdir -p && /usr/bin/foo -d ) <----the final file will be on execlineb language, error
------- with flags set to line -----
valid examples :
exec=( # !/bin/bash
mkdir -p /run/foo
mkfifo /run/foo/fifofoo
/usr/bin/foo -d )
or
exec=( # !/usr/bin/env python
stuff in python )

not valid
exec=( mkdir -p /run/foo 
/usr/bin/foo ) <<<------- shebang not present, error

[run]
flags=( auto )
shebang=( # !/bin/bash )
.....

I think, lazy admins don't like long config files where they have to search for explanations. So, the latter should be at the location where you need them if they are really short. For the rest, what's wrong with a man page and a short hint to it in the file? Examples could also be supplied as separate files under, e.g., /usr/share/<something>/examples or something like that.

type=classic
name=foo
description="foo service"
options=( logger )

[run]
flags=( auto )
exec=( /usr/bin/foo -d )

type = 
name = 
description = ""
contents = ( )
depends = ( )
options = ( )
notify = 
user = ( )
pipeline = ( )
producer = ( )
consumer = ( )

[run]
flags = ( )
runas = 
shebang = ( )
timeout-finish = 
timeout-kill = 
timeout-up = 
timoout-down = 
exec = ( )

[finish]
flags = ( )
runas = 
shebang = ( )
timeout-finish = 
timeout-kill =
timeout-up = 
timoout-down = 
exec = ( )

[logger]
destination = 
flags = ( )
shebang = ( )
timeout-finish = 
timeout-kill = 
runas = 
backup = 
size = 
timestamp =