summary refs log tree commit diff
path: root/Completion/Unix/Command/_systemd
blob: d2a7895e1b33a4c39dded0dd2ba83b8e310c5c03 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
#compdef systemctl systemd-loginctl

# Copyright (c) 2011 Foudil Bre'tel <foudil.newbie+zshsystemctl@gmail.com>
#
# This file is released under the GPLv3.
#
# inspired from _yum and systemctl-bash-completion.sh (shipped with systemctl)
#
# TODO: enable options after commands. Ex: systemctl list-units --all --full

# Main dispatcher
_systemd()
{
  local curcontext="$curcontext" state lstate line

  case "$service" in
    systemctl)
      # -s for aggregated options like -aP
      _arguments -s \
        {-h,--help}'[Show help]' \
        '--version[Show package version]' \
        {-t,--type=}'[List only units of a particular type]:unit type:(automount device mount path service snapshot socket swap target timer)' \
        \*{-p,--property=}'[Show only properties by specific name]:unit property:()' \
        {-a,--all}'[Show all units/properties, including dead/empty ones]' \
        '--failed[Show only failed units]' \
        "--full[Don't ellipsize unit names on output]" \
        '--fail[When queueing a new job, fail if conflicting jobs are pending]' \
        '--ignore-dependencies[When queueing a new job, ignore all its dependencies]' \
        '--kill-mode=[How to send signal]:killmode:(control-group process)' \
        '--kill-who=[Who to send signal to]:killwho:(main control all)' \
        {-s,--signal=}'[Which signal to send]:signal:_signals' \
        {-H,--host=}'[Show information for remote host]:userathost:_hosts_or_user_at_host' \
        {-P,--privileged}'[Acquire privileges before execution]' \
        {-q,--quiet}'[Suppress output]' \
        '--no-block[Do not wait until operation finished]' \
        "--no-wall[Don't send wall message before halt/power-off/reboot]" \
        "--no-reload[When enabling/disabling unit files, don't reload daemon configuration]" \
        '--no-legend[Do not print a legend, i.e. the column headers and the footer with hints]' \
        '--no-pager[Do not pipe output into a pager]' \
        '--no-ask-password[Do not ask for system passwords]' \
        '--order[When generating graph for dot, show only order]' \
        '--require[When generating graph for dot, show only requirement]' \
        '--system[Connect to system manager]' \
        '--user[Connect to user service manager]' \
        '--global[Enable/disable unit files globally]' \
        {-f,--force}'[When enabling unit files, override existing symlinks. When shutting down, execute action immediately]' \
        '--root=[Enable unit files in the specified root directory]:directory:_directories' \
        '--runtime[Enable unit files only temporarily until next reboot]' \
        '*::systemctl command:_systemctl_command'
      ;;

    systemd-loginctl)
      _arguments -s \
        {-h,--help}'[Show help]' \
        '--version[Show package version]' \
        \*{-p,--property=}'[Show only properties by this name]:unit property:' \
        {-a,--all}'[Show all properties, including empty ones]' \
        '--failed[Show only failed units]' \
        '--kill-who=[Who to send signal to]:killwho:(main control all)' \
        {-s,--signal=}'[Which signal to send]:signal:_signals' \
        {-H,--host=}'[Show information for remote host]:userathost:_hosts_or_user_at_host' \
        {-P,--privileged}'[Acquire privileges before execution]' \
        '--no-pager[Do not pipe output into a pager]' \
        '*::systemd-loginctl command:_systemd_loginctl_command'
      ;;

    *) _message 'eh?' ;;
  esac

}

_hosts_or_user_at_host()
{
  _alternative \
    'users-hosts:: _user_at_host' \
    'hosts:: _hosts'
}

(( $+functions[_systemctl_command] )) || _systemctl_command()
{
  local -a _systemctl_cmds
  _systemctl_cmds=(
    "list-units:List units"
    "start:Start (activate) one or more units"
    "stop:Stop (deactivate) one or more units"
    "reload:Reload one or more units"
    "restart:Start or restart one or more units"
    "condrestart:Restart one or more units if active"
    "try-restart:Restart one or more units if active"
    "reload-or-restart:Reload one or more units is possible, otherwise start or restart"
    "force-reload:Reload one or more units is possible, otherwise restart if active"
    "reload-or-try-restart:Reload one or more units is possible, otherwise restart if active"
    "isolate:Start one unit and stop all others"
    "kill:Send signal to processes of a unit"
    "is-active:Check whether units are active"
    "status:Show runtime status of one or more units"
    "show:Show properties of one or more units/jobs or the manager"
    "reset-failed:Reset failed state for all, one, or more units"
    "load:Load one or more units"
    "list-unit-files:List installed unit files"
    "enable:Enable one or more unit files"
    "disable:Disable one or more unit files"
    "reenable:Reenable one or more unit files"
    "preset:Enable/disable one or more unit files based on preset configuration"
    "mask:Mask one or more units"
    "unmask:Unmask one or more units"
    "link:Link one or more units files into the search path"
    "is-enabled:Check whether unit files are enabled"
    "list-jobs:List jobs"
    "cancel:Cancel all, one, or more jobs"
    "dump:Dump server status"
    "dot:Dump dependency graph for dot(1)"
    "snapshot:Create a snapshot"
    "delete:Remove one or more snapshots"
    "show-environment:Dump environment"
    "set-environment:Set one or more environment variables"
    "unset-environment:Unset one or more environment variables"
    "daemon-reload:Reload systemd manager configuration"
    "daemon-reexec:Reexecute systemd manager"
    "default:Enter system default mode"
    "rescue:Enter system rescue mode"
    "emergency:Enter system emergency mode"
    "halt:Shut down and halt the system"
    "poweroff:Shut down and power-off the system"
    "reboot:Shut down and reboot the system"
    "kexec:Shut down and reboot the system with kexec"
    "exit:Ask for user instance termination"
    "switch-root:Change to a different root file system"
    "suspend:Suspend the system"
    "hibernate:Hibernate the system"
    "hibernate-sleep:Hibernate and suspend the system"
  )

  if (( CURRENT == 1 )); then
    _describe -t commands 'systemctl command' _systemctl_cmds || compadd "$@"
  else
    local curcontext="$curcontext"

    cmd="${${_systemctl_cmds[(r)$words[1]:*]%%:*}}"
    # Deal with any aliases
    case $cmd in
      condrestart) cmd="try-restart";;
      force-reload) cmd="reload-or-try-restart";;
    esac

    if (( $#cmd )); then
      curcontext="${curcontext%:*:*}:systemctl-${cmd}:"

      local update_policy
      zstyle -s ":completion:${curcontext}:" cache-policy update_policy
      if [[ -z "$update_policy" ]]; then
        zstyle ":completion:${curcontext}:" cache-policy _systemctl_caching_policy
      fi

      _call_function ret _systemctl_$cmd || _message 'no more arguments'
    else
      _message "unknown systemctl command: $words[1]"
    fi
    return ret
  fi
}

__systemctl()
{
  systemctl --full --no-legend --no-pager "$@"
}


# Fills the unit list
_systemctl_all_units()
{
  if ( [[ ${+_sys_all_units} -eq 0 ]] || _cache_invalid SYS_ALL_UNITS ) &&
    ! _retrieve_cache SYS_ALL_UNITS;
  then
    _sys_all_units=( $(__systemctl list-units --all | { while read a b; do echo "$a"; done; }) )
    _store_cache SYS_ALL_UNITS _sys_all_units
  fi
}

# Fills the unit list including all file units
_systemctl_really_all_units()
{
  local -a all_unit_files;
  local -a really_all_units;
  if ( [[ ${+_sys_really_all_units} -eq 0 ]] || _cache_invalid SYS_REALLY_ALL_UNITS ) &&
    ! _retrieve_cache SYS_REALLY_ALL_UNITS;
  then
    all_unit_files=( $(__systemctl list-unit-files | { while read a b; do echo "$a"; done; }) )
    _systemctl_all_units
    really_all_units=($_sys_all_units $all_unit_files)
    _sys_really_all_units=(${(u)really_all_units})
    _store_cache SYS_REALLY_ALL_UNITS _sys_really_all_units
  fi
}

_filter_units_by_property() {
  local property=$1 value=$2 ; shift ; shift
  local -a units ; units=($*)
  local prop unit
  for ((i=1; $i <= ${#units[*]}; i++)); do
    # FIXME: "Failed to issue method call: Unknown unit" errors are ignored for
    # now (related to DBUS_ERROR_UNKNOWN_OBJECT). in the future, we need to
    # revert to calling 'systemctl show' once for all units, which is way
    # faster
    unit=${units[i]}
    prop=$(systemctl show --no-pager --property="$property" ${unit} 2>/dev/null)
    if [[ "${prop}" = "$property=$value" ]]; then
      echo "${unit}"
    fi
  done
}

_systemctl_active_units()  {_sys_active_units=(  $(__systemctl list-units          | { while read a b; do echo "$a"; done; }) )}
_systemctl_inactive_units(){_sys_inactive_units=($(__systemctl list-units --all    | { while read a b c d; do [[ $c == "inactive" ]] && echo "$a"; done; }) )}
_systemctl_failed_units()  {_sys_failed_units=(  $(__systemctl list-units --failed | { while read a b; do echo "$a"; done; }) )}
_systemctl_enabled_units() {_sys_enabled_units=( $(__systemctl list-unit-files     | { while read a b; do [[ $b == "enabled" ]] && echo "$a"; done; }) )}
_systemctl_disabled_units(){_sys_disabled_units=($(__systemctl list-unit-files     | { while read a b; do [[ $b == "disabled" ]] && echo "$a"; done; }) )}
_systemctl_masked_units()  {_sys_masked_units=(  $(__systemctl list-unit-files     | { while read a b; do [[ $b == "masked" ]] && echo "$a"; done; }) )}

# Completion functions for ALL_UNITS
for fun in is-active is-enabled status show mask preset ; do
  (( $+functions[_systemctl_$fun] )) || _systemctl_$fun()
  {
    _systemctl_really_all_units
    compadd "$@" -a - _sys_really_all_units
  }
done

# Completion functions for ENABLED_UNITS
for fun in disable reenable ; do
  (( $+functions[_systemctl_$fun] )) || _systemctl_$fun()
  {
    _systemctl_enabled_units
    compadd "$@" -a - _sys_enabled_units
  }
done

# Completion functions for DISABLED_UNITS
(( $+functions[_systemctl_enable] )) || _systemctl_enable()
{
  _systemctl_disabled_units
  compadd "$@" -a - _sys_disabled_units
}

# Completion functions for FAILED_UNITS
(( $+functions[_systemctl_reset-failed] )) || _systemctl_reset-failed()
{
  _systemctl_failed_units
  compadd "$@" -a - _sys_failed_units || _message "no failed unit found"
}

# Completion functions for STARTABLE_UNITS
(( $+functions[_systemctl_start] )) || _systemctl_start()
{
  _systemctl_inactive_units
  compadd "$@" -a - _sys_inactive_units
}

# Completion functions for STOPPABLE_UNITS
for fun in stop kill try-restart condrestart ; do
  (( $+functions[_systemctl_$fun] )) || _systemctl_$fun()
  {
    _systemctl_active_units
    compadd "$@" - $( _filter_units_by_property CanStop yes \
      ${_sys_active_units[*]} )
  }
done

# Completion functions for ISOLATABLE_UNITS
(( $+functions[_systemctl_isolate] )) || _systemctl_isolate()
{
  _systemctl_all_units
  compadd "$@" - $( _filter_units_by_property AllowIsolate yes \
    ${_sys_all_units[*]} )
}

# Completion functions for RELOADABLE_UNITS
for fun in reload reload-or-try-restart force-reload ; do
  (( $+functions[_systemctl_$fun] )) || _systemctl_$fun()
  {
    _systemctl_active_units
    compadd "$@" - $( _filter_units_by_property CanReload yes \
      ${_sys_active_units[*]} )
  }
done

# Completion functions for RESTARTABLE_UNITS
for fun in restart reload-or-restart ; do
  (( $+functions[_systemctl_$fun] )) || _systemctl_$fun()
  {
    _systemctl_all_units
    compadd "$@" - $( _filter_units_by_property CanStart yes \
      ${_sys_all_units[*]} | while read line; do \
      [[ "$line" =~ \.(device|snapshot|socket|timer)$ ]] || echo "$line"; \
      done )
  }
done

# Completion functions for MASKED_UNITS
(( $+functions[_systemctl_unmask] )) || _systemctl_unmask()
{
  _systemctl_masked_units
  compadd "$@" -a - _sys_masked_units || _message "no masked unit found"
}

# Completion functions for JOBS
(( $+functions[_systemctl_cancel] )) || _systemctl_cancel()
{
  compadd "$@" - $(__systemctl list-jobs \
    | cut -d' ' -f1  2>/dev/null ) || _message "no job found"
}

# Completion functions for SNAPSHOTS
(( $+functions[_systemctl_delete] )) || _systemctl_delete()
{
  compadd "$@" - $(__systemctl list-units --type snapshot --all \
    | cut -d' ' -f1  2>/dev/null ) || _message "no snampshot found"
}

# Completion functions for ENVS
for fun in set-environment unset-environment ; do
  (( $+functions[_systemctl_$fun] )) || _systemctl_$fun()
  {
    local fun=$0 ; fun=${fun##_systemctl_}
    local suf
    if [[ "${fun}" = "set-environment" ]]; then
      suf='-S='
    fi

    compadd "$@" ${suf} - $(systemctl show-environment \
      | while read line; do echo "${line%%\=}";done )
  }
done

(( $+functions[_systemctl_link] )) || _systemctl_link() { _files }

(( $+functions[_systemctl_switch-root] )) || _systemctl_switch-root()
{
  if (( CURRENT == 2 )); then
    _directories
  fi
}

# no systemctl completion for:
#    [STANDALONE]='daemon-reexec daemon-reload default dot dump
#                  emergency exit halt kexec list-jobs list-units
#                  list-unit-files poweroff reboot rescue show-environment'
#         [NAME]='snapshot load'

_systemctl_caching_policy()
{
  local _sysunits
  local -a oldcache

  # rebuild if cache is more than a day old
  oldcache=( "$1"(mh+1) )
  (( $#oldcache )) && return 0

  _sysunits=($(__systemctl --all | cut -d' ' -f1))

  if (( $#_sysunits )); then
    for unit in $_sysunits; do
      [[ "$unit" -nt "$1" ]] && return 0
    done
  fi

  return 1
}



_systemd_loginctl_all_sessions(){_sys_all_sessions=($(systemd-loginctl list-sessions | { while read a b; do echo "$a"; done; }) )}
_systemd_loginctl_all_users()   {_sys_all_users=(   $(systemd-loginctl list-users    | { while read a b; do echo "$a"; done; }) )}
_systemd_loginctl_all_seats()   {_sys_all_seats=(   $(systemd-loginctl list-seats    | { while read a b; do echo "$a"; done; }) )}

# Completion functions for SESSIONS
for fun in session-status show-session activate lock-session unlock-session terminate-session kill-session ; do
  (( $+functions[_systemd_loginctl_$fun] )) || _systemd_loginctl_$fun()
  {
    _systemd_loginctl_all_sessions
    compadd "$@" -a - _sys_all_sessions
  }
done

# Completion functions for USERS
for fun in user-status show-user enable-linger disable-linger terminate-user kill-user ; do
  (( $+functions[_systemd_loginctl_$fun] )) || _systemd_loginctl_$fun()
  {
    _systemd_loginctl_all_users
    compadd "$@" -a - _sys_all_users
  }
done

# Completion functions for SEATS
(( $+functions[_systemd_loginctl_seats] )) || _systemd_loginctl_seats()
{
  _systemd_loginctl_all_seats
  compadd "$@" -a - _sys_all_seats
}
for fun in seat-status show-seat terminate-seat ; do
  (( $+functions[_systemd_loginctl_$fun] )) || _systemd_loginctl_$fun()
  { _systemd_loginctl_seats }
done

# Completion functions for ATTACH
(( $+functions[_systemd_loginctl_attach] )) || _systemd_loginctl_attach()
{
  _systemd_loginctl_all_seats

  _arguments -w -C -S -s \
    ':seat:_systemd_loginctl_seats' \
    '*:device:_files'
}

# no systemd-loginctl completion for:
# [STANDALONE]='list-sessions list-users list-seats flush-devices'

(( $+functions[_systemd_loginctl_command] )) || _systemd_loginctl_command()
{
  local -a _systemd_loginctl_cmds
  _systemd_loginctl_cmds=(
    "list-sessions:List sessions"
    "session-status:Show session status"
    "show-session:Show properties of one or more sessions"
    "activate:Activate a session"
    "lock-session:Screen lock one or more sessions"
    "unlock-session:Screen unlock one or more sessions"
    "terminate-session:Terminate one or more sessions"
    "kill-session:Send signal to processes of a session"
    "list-users:List users"
    "user-status:Show user status"
    "show-user:Show properties of one or more users"
    "enable-linger:Enable linger state of one or more users"
    "disable-linger:Disable linger state of one or more users"
    "terminate-user:Terminate all sessions of one or more users"
    "kill-user:Send signal to processes of a user"
    "list-seats:List seats"
    "seat-status:Show seat status"
    "show-seat:Show properties of one or more seats"
    "attach:Attach one or more devices to a seat"
    "flush-devices:Flush all device associations"
    "terminate-seat:Terminate all sessions on one or more seats"
  )

  if (( CURRENT == 1 )); then
    _describe -t commands 'systemd-loginctl command' _systemd_loginctl_cmds || compadd "$@"
  else
    local curcontext="$curcontext"

    cmd="${${_systemd_loginctl_cmds[(r)$words[1]:*]%%:*}}"

    if (( $#cmd )); then
      curcontext="${curcontext%:*:*}:systemd_loginctl-${cmd}:"

      _call_function ret _systemd_loginctl_$cmd || _message 'no more arguments'
    else
      _message "unknown systemd-loginctl command: $words[1]"
    fi
    return ret
  fi
}

_systemd "$@"

# Local Variables:
# mode: sh
# sh-indentation: 2
# indent-tabs-mode: nil
# sh-basic-offset: 2
# End: