· 7 years ago · Sep 17, 2018, 02:12 PM
1#!/usr/bin/env python3
2
3"""
4This is a helper script that semi-automates the process
5of configuring/editing systemd services.
6
7Examples --
8Create a service using a short preset configuration:
9sudo ./service-config.py --short some_service_name
10
11Create a service using a custom preset configuration template:
12sudo ./service-config.py -c some_schema some_service_name
13
14Edit an existing service:
15sudo ./service-config.py --edit some_service_name
16
17# To do list:
181. Document the script.
192. Fix permission issues with some of the arguments.
203. Add a configuration file for the script for
21 some of the default values and options. (?)
224. Allow the user to choose an editor.
23
24NOTES:
251. This script requires root privileges for most use-cases.
262. Skipping a configuration option (just pressing enter) without
27 supplying any value will just tell the script to skip that option.
28"""
29
30# IMPORTS:
31
32import argparse
33import configparser
34import datetime
35import os
36import subprocess
37import sys
38import time
39
40from collections import OrderedDict
41
42# DEFINING CONSTANTS:
43
44VERSION = "0.4"
45MAINTAINER_NICK = "..."
46MAINTAINER_EMAIL = "...@gmail.com"
47TRACE = True
48SCHEMA = "schemas/service-config"
49SCHEMA_SHORT = "schemas/short_service-config"
50SCHEMA_EXTENDED = "schemas/extended_service-config"
51CONFIG = None # for future uses
52OUTPUT_DIR = "/etc/systemd/system"
53
54# ERRORS:
55
56USER_ABORT = 5
57ARGPARSE_ERR = 6
58CONFIGURATION_ERR = 7
59GLOBAL_ERR = 8
60SCHEMA_ERR = 9
61SYSTEMD_ERR = 10
62UID_ERROR = 11
63FINISH_ERROR = 12
64
65# DEFAULTS:
66
67DEFAULT_EDITOR = "vim"
68DEFAULT_BUILD_SCHEMA = "schemas/default-schema"
69
70DEFAULT_DESCRIPTION = "Example"
71DEFAULT_AFTER = "network.target"
72DEFAULT_TYPE = "simple"
73DEFAULT_USER = "root"
74DEFAULT_GROUP = "root"
75DEFAULT_EXEC_START = "/bin/true"
76DEFAULT_EXEC_STOP = "/bin/true"
77DEFAULT_KILL_MODE = "control-group"
78DEFAULT_KILL_SIGNAL = "SIGTERM"
79DEFAULT_PID_FILE = "/run/service.pid"
80DEFAULT_RESTART = "on-failure"
81DEFAULT_RESTART_SEC = "2"
82DEFAULT_TIMEOUT_STOP_SEC = "5"
83DEFAULT_DYNAMIC_USER = "no"
84DEFAULT_ENVIRONMENT_FILE = "/etc/service/env"
85DEFAULT_STANDARD_OUTPUT = "journal"
86DEFAULT_STANDARD_ERROR = "journal"
87DEFAULT_WANTED_BY = "multi-user.target"
88
89# COLORS AND Formatting:
90
91def tty_supports_ansi():
92 """Checks whether the terminal used supports ANSI codes."""
93
94 for handle in [sys.stdout, sys.stderr]:
95 if ((hasattr(handle, "isatty") and handle.isatty()) or
96 ('TERM' in os.environ and os.environ['TERM'] == "ANSI")):
97 return True
98 else:
99 return False
100
101class Formatting:
102 """
103 A class containing constants with most Formatting/basic colors
104 for Unix-based terminals and vtys.
105 Does NOT work on Windows cmd, PowerShell, and their varieties!
106 """
107
108 RESET = " 33[0m"
109 BOLD = " 33[1m"
110 DIM = " 33[2m"
111 ITALIC = " 33[3m"
112 UNDERLINE = " 33[4m"
113 BLINK = " 33[5m" # Doesn't work on some terminals.
114 INVERT = " 33[7m"
115 HIDDEN = " 33[8m"
116 FG_DEFAULT = " 33[39m"
117 FG_BLACK = " 33[30m"
118 FG_RED = " 33[31m"
119 FG_GREEN = " 33[32m"
120 FG_YELLOW = " 33[33m"
121 FG_BLUE = " 33[34m"
122 FG_MAGENTA = " 33[35m"
123 FG_CYAN = " 33[36m"
124 FG_LIGHT_GRAY = " 33[37m"
125 FG_DARK_GRAY = " 33[90m"
126 FG_LIGHT_RED = " 33[91m"
127 FG_LIGHT_GREEN = " 33[92m"
128 FG_LIGHT_YELLOW = " 33[93m"
129 FG_LIGHT_BLUE = " 33[94m"
130 FG_LIGHT_MAGENTA = " 33[95m"
131 FG_LIGHT_CYAN = " 33[96m"
132 FG_WHITE = " 33[97m"
133 BG_DEFAULT = " 33[49m"
134 BG_BLACK = " 33[40m"
135 BG_RED = " 33[41m"
136 BG_GREEN = " 33[42m"
137 BG_YELLOW = " 33[43m"
138 BG_BLUE = " 33[44m"
139 BG_MAGENTA = " 33[45m"
140 BG_CYAN = " 33[46m"
141 BG_LIGHT_GRAY = " 33[47m"
142 BG_DARK_GRAY = " 33[100m"
143 BG_LIGHT_RED = " 33[101m"
144 BG_LIGHT_GREEN = " 33[102m"
145 BG_LIGHT_YELLOW = " 33[103m"
146 BG_LIGHT_BLUE = " 33[104m"
147 BG_LIGHT_MAGENTA = " 33[105m"
148 BG_LIGHT_CYAN = " 33[106m"
149 BG_WHITE = " 33[107m"
150
151 def __init__(self):
152 self.is_supported = tty_supports_ansi()
153
154 def ansi(self, ansi_key):
155 """
156 The format method for this class. Returns the proper
157 chosen formatting if it is supported, else does nothing.
158 Takes ansi_key as argument, where ansi_key is one of the
159 defined constants in the class.
160 """
161 if self.is_supported:
162 return getattr(self, ansi_key)
163 else:
164 return ""
165
166# The formatting/color class handler variable
167
168FTY = Formatting()
169
170# Code starts from here:
171
172def printf(text, f="RESET", **kwargs):
173 """
174 A print function with formatting.
175 Always prints on stdout.
176 As arguments takes:
177 1. string (text to print)
178 2. formatting type (bold, italic, etc.)
179 3+. kwargs passed to the print function.
180 """
181
182 f = FTY.ansi(f.upper())
183
184 print("{}{}".format(f, text), file=sys.stdout, **kwargs)
185
186
187def print_info():
188 """Print information about the script."""
189
190 printf("This is a helper script for configuring systemd services.", f="bold")
191 printf("{}Maintainer: {}{}".format(FTY.ansi("FG_GREEN"), FTY.ansi("RESET"), MAINTAINER_NICK))
192 printf("{}Email: {}{}".format(FTY.ansi("FG_GREEN"), FTY.ansi("RESET"), MAINTAINER_EMAIL))
193
194 sys.exit(0)
195
196def parse_arg():
197 """Get user arguments and configure them."""
198
199 parser = argparse.ArgumentParser(description="Systemd services configuration script")
200 no_pos = parser.add_mutually_exclusive_group()
201 schema = parser.add_mutually_exclusive_group()
202 exclus = parser.add_mutually_exclusive_group()
203 exclus.add_argument("-c",
204 "--schema",
205 help="Choose a custom schema and load defaults from it.",
206 type=str,
207 default=SCHEMA)
208 exclus.add_argument("--edit",
209 help="Directly edit a systemd unit file.",
210 action="store_true",
211 default=False)
212 no_pos.add_argument("--info",
213 help="Show information about the script.",
214 action="store_true",
215 default=False)
216 no_pos.add_argument("-b",
217 "--build",
218 help="Builds a default schema in schemas/default-schema",
219 action="store_true",
220 default=False)
221 schema.add_argument("-s",
222 "--short",
223 help="Use a short configuration schema.",
224 action="store_true",
225 default=False)
226 schema.add_argument("-x",
227 "--extended",
228 help="Use a long configuration schema.",
229 action="store_true",
230 default=False)
231 exclus.add_argument("-d",
232 "--directory",
233 help="Output directory for the service unit file.",
234 type=str,
235 default=OUTPUT_DIR)
236 exclus.add_argument("--delete",
237 help="Delete the specified service's configuration file.",
238 action="store_true",
239 default=False)
240 no_pos.add_argument("service_name",
241 help="The name of the service to configure/edit.",
242 type=str,
243 nargs='?')
244
245 try:
246 args = parser.parse_args()
247 check_parser_opts(args)
248 except argparse.ArgumentError:
249 print("Error: An error occured while parsing your arguments.", file=sys.stderr)
250 sys.exit(ARGPARSE_ERR)
251
252 return args
253
254def check_parser_opts(args):
255 """
256 Check if all supplied arguments are used correctly.
257 Returns an error if the combination of
258 supplied arguments is illegal.
259 For arguments that are supposed to be
260 single checks if any other arguments
261 are used (besides directory and schema,
262 since they have default values already).
263 """
264
265 all_args = [
266 'build',
267 'service_name',
268 'info',
269 'short',
270 'extended',
271 'delete',
272 'directory',
273 'edit',
274 'schema'
275 ]
276
277 error = False
278
279 # --build is supposed to be used alone.
280 if args.build:
281 for arg in all_args:
282 if (arg is not 'build' and
283 arg is not 'directory' and
284 arg is not 'schema'):
285 value = getattr(args, arg)
286 else:
287 value = None
288 if value:
289 print("The argument -b/--build cannot be used with {}.".format(arg))
290 error = True
291
292 # --info is supposed to be used alone.
293 if args.info:
294 for arg in all_args:
295 if (arg is not 'info' and
296 arg is not 'directory' and
297 arg is not 'schema'):
298 value = getattr(args, arg)
299 else:
300 value = None
301 if value:
302 print("The argument --info cannot be used with {}.".format(arg))
303 error = True
304
305 # --delete is supposed to be used only with service_name.
306 if args.delete:
307 for arg in all_args:
308 if (arg is not 'delete' and
309 arg is not 'directory' and
310 arg is not 'schema' and
311 arg is not 'service_name'):
312 value = getattr(args, arg)
313 else:
314 value = None
315 if value:
316 print("The argument --delete cannot be used with {}.".format(arg))
317 error = True
318
319 # --edit is supposed to be used only with service_name.
320 if args.edit:
321 for arg in all_args:
322 if (arg is not 'edit' and
323 arg is not 'directory' and
324 arg is not 'schema' and
325 arg is not 'service_name'):
326 value = getattr(args, arg)
327 else:
328 value = None
329 if value:
330 print("The argument --edit cannot be used with {}.".format(arg))
331 error = True
332
333 if error:
334 printf("{}Error: wrong argument usage, aborting.".format(FTY.ansi("FG_RED")), f="bold")
335 sys.exit(ARGPARSE_ERR)
336
337def get_fragment_path(service):
338 """
339 Returns the path of the systemd service's unit configuration file.
340 """
341
342 # Extremely ugly (imo) multiline statement
343 sysctl_out = subprocess.check_output("systemctl show {} -p FragmentPath".format(service),
344 shell=True)
345 filename = sysctl_out.decode('utf-8').strip().split('=')[1]
346
347 return filename
348
349def edit(service, manual=False, finish=True):
350 """
351 Open the service's systemd service
352 unit configuration file for editing.
353 """
354
355 # Check if destination is already set to the full path.
356 if manual:
357 file = service
358 else:
359 file = get_fragment_path(service)
360
361 # Open vim to edit the configuration file. This is a TODO.
362 with subprocess.Popen(["{} {}".format(DEFAULT_EDITOR, file)], shell=True) as command:
363 subprocess.Popen.wait(command)
364
365 if finish:
366 finish(file, mode="edit")
367
368def delete(service):
369 """
370 Deletes the given service configuration file,
371 stops and disables the service.
372 """
373
374 # Get the destination of the service unit file.
375 destination = get_fragment_path(service)
376
377 # Ask the user for confirmation if it's a system service.
378 if destination.startswith("/lib/systemd/system"):
379 print("This is not a user-configured service, do you want to delete it anyway? [y/N]: ")
380 force_delete = input()
381 if not (force_delete and (force_delete.lower() == 'y' or force_delete.lower() == 'yes')):
382 print("Aborting...")
383 sys.exit(0)
384
385 # Stop, disable, and delete the service.
386 print("Deleting service...")
387 sysctl_service(service, "stop")
388 sysctl_service(service, "disable")
389 os.remove(destination)
390 service_reload()
391 print("Deleted service.")
392
393def setup(args):
394 """
395 Check systemd version available on the host to confirm compability.
396 Also checks whether we have permissions to use
397 most of the script's functionality.
398 """
399
400 # Get the systemd version to confirm compability. This is for a future update.
401 try:
402 systemd_version = subprocess.check_output('systemd --version', shell=True)
403 systemd_version = int(systemd_version.strip().split()[1])
404 except subprocess.CalledProcessError:
405 print("Systemd isn't working on your system. Why even use this script?", file=sys.stderr)
406 sys.exit(SYSTEMD_ERR)
407
408 if os.getuid() > 0 and not args.build and args.directory == OUTPUT_DIR:
409 # Extremely ugly (imo) multiline statement
410 printf("{}Insufficient permissions. "
411 "You have to run the script as root (with sudo).".format(
412 FTY.ansi("FG_LIGHT_RED")), f="bold", file=sys.stderr)
413 sys.exit(UID_ERROR)
414
415 return systemd_version
416
417def build():
418 """
419 Build a default example unit configuration schema,
420 using default constants.
421 """
422
423 if os.path.exists(DEFAULT_BUILD_SCHEMA):
424 print("Error: {} already exists.".format(DEFAULT_BUILD_SCHEMA), file=sys.stderr)
425 sys.exit(SCHEMA_ERR)
426 else:
427 schema = configparser.ConfigParser()
428 schema.optionxform = str
429 schema['Unit'] = OrderedDict(
430 Description = DEFAULT_DESCRIPTION,
431 After = DEFAULT_AFTER
432 )
433
434 schema['Service'] = OrderedDict(
435 Type = DEFAULT_TYPE,
436 ExecStart = DEFAULT_EXEC_START,
437 ExecStop = DEFAULT_EXEC_STOP,
438 Restart = DEFAULT_RESTART,
439 RestartSec = DEFAULT_RESTART_SEC,
440 User = DEFAULT_USER,
441 Group = DEFAULT_GROUP,
442 PIDFile = DEFAULT_PID_FILE,
443 EnvironmentFile = DEFAULT_ENVIRONMENT_FILE,
444 KillMode = DEFAULT_KILL_MODE,
445 KillSignal = DEFAULT_KILL_SIGNAL,
446 TimeoutStopSec = DEFAULT_TIMEOUT_STOP_SEC,
447 StandardOutput = DEFAULT_STANDARD_OUTPUT,
448 StandardError = DEFAULT_STANDARD_ERROR,
449 DynamicUser = DEFAULT_DYNAMIC_USER
450 )
451
452 schema['Install'] = OrderedDict(
453 WantedBy = DEFAULT_WANTED_BY
454 )
455
456 with open(DEFAULT_BUILD_SCHEMA, 'w+') as schemafile:
457 schema.write(schemafile)
458
459 finish(DEFAULT_BUILD_SCHEMA, mode="build")
460
461def load_schema(schema):
462 """
463 Read the service unit configuration file and load it.
464 """
465
466 config_dict = {}
467
468 config = configparser.ConfigParser()
469 config.optionxform = str
470 config.read(schema)
471
472 return config
473
474def parse_config(cfg):
475 """
476 Parse the configuration file and return it as dictionaries.
477 """
478
479 config = argparse.Namespace(**OrderedDict(cfg))
480 config.Unit = OrderedDict(config.Unit)
481 config.Service = OrderedDict(config.Service)
482 config.Install = OrderedDict(config.Install)
483
484 return config
485
486def write_config(cfg, destination):
487 """
488 Save the unit configuration file to the destination.
489 """
490
491 config = configparser.ConfigParser()
492 config.optionxform = str
493 config['Unit'] = cfg.Unit
494 config['Service'] = cfg.Service
495 if cfg.Install:
496 config['Install'] = cfg.Install
497 with open(destination, 'w') as unitfile:
498 config.write(unitfile)
499 unitfile.write("# Automatically generated by service-config.n")
500
501def user_configuration(config):
502 """
503 Let the user interactively configure the unit file.
504 """
505
506 user_config = config
507
508 # Ask for the [Unit] section's keys.
509 printf("{}[Unit] section configuration:".format(FTY.ansi("FG_YELLOW")), f="bold")
510 for key in config.Unit:
511 printf("{}{}={}".format(FTY.ansi("FG_GREEN"), key, FTY.ansi("RESET")), f="bold", end="")
512 value = input()
513 user_config.Unit[key] = value
514
515 # Ask for the [Service] section's keys.
516 print()
517 printf("{}[Service] section configuration:".format(FTY.ansi("FG_BLUE")), f="bold")
518 for key in config.Service:
519 printf("{}{}={}".format(FTY.ansi("FG_GREEN"), key, FTY.ansi("RESET")), f="bold", end="")
520 value = input()
521 user_config.Service[key] = value
522
523 # Ask for the [Install] section's keys.
524 print()
525 printf("{}[Install] section configuration:".format(FTY.ansi("FG_MAGENTA")), f="bold")
526 for key in config.Install:
527 printf("{}{}={}".format(FTY.ansi("FG_GREEN"), key, FTY.ansi("RESET")), f="bold", end="")
528 value = input()
529 user_config.Install[key] = value
530
531 # Clear the dictionaries from any empty keys.
532 user_config.Unit = {k: v for k, v in user_config.Unit.items() if v}
533 user_config.Service = {k: v for k, v in user_config.Service.items() if v}
534 user_config.Install = {k: v for k, v in user_config.Install.items() if v}
535
536 return user_config
537
538def service_reload():
539 """
540 A simple daemon-reload wrapper.
541 """
542
543 subprocess.call('systemctl daemon-reload', shell=True)
544
545def sysctl_service(service, action):
546 """
547 A simple systemctl wrapper for service management.
548 """
549
550 subprocess.call('systemctl {} {}'.format(action, service), shell=True)
551
552def finish(destination, mode="create"):
553 """
554 Checks whether the file has been saved successfully and exits.
555 """
556
557 if os.path.exists(destination):
558 if mode == "create":
559 print("{}Service created successfully.".format(FTY.ansi("FG_GREEN")))
560 elif mode == "edit":
561 print("{}Service edited successfully.".format(FTY.ansi("FG_YELLOW")))
562 elif mode == "build":
563 print("{}Default schema built successfully.".format(FTY.ansi("FG_BLUE")))
564 sys.exit(0)
565 else:
566 print("The script failed to finish successfully.")
567 sys.exit(FINISH_ERROR)
568
569def main():
570 """
571 The main function that handles the program.
572 """
573
574 # Get the parsed arguments.
575 args = parse_arg()
576
577 # Check the version of systemd and check permissions.
578 systemd_version = setup(args)
579
580 # Exit if service_name contains illegal characters.
581 if args.service_name:
582 if 'x00' in args.service_name or '/' in args.service_name:
583 print("Service name contains symbols that are not allowed.")
584 sys.exit(ARGPARSE_ERR)
585
586 if args.delete:
587 delete(args.service_name)
588 sys.exit(0)
589 if args.info:
590 print_info()
591 if args.build:
592 build()
593 if args.edit:
594 edit(args.service_name)
595 if args.short:
596 args.schema = SCHEMA_SHORT
597 print("Using short schema configuration.")
598 if args.extended:
599 args.schema = SCHEMA_EXTENDED
600 print("Using extended schema configuration.")
601
602 # Load and parse the unit configuration schema.
603 schema = load_schema(args.schema)
604 config = parse_config(schema)
605
606 # Start interactive configuration, aborts on CTRL-C/CTRL-D.
607 try:
608 user_config = user_configuration(config)
609 except (EOFError, KeyboardInterrupt):
610 print("nAborting.")
611 sys.exit(USER_ABORT)
612
613 # Check whether the supplied service name ends with .service.
614 if not args.service_name.endswith('.service'):
615 args.service_name = args.service_name + '.service'
616
617 # Save the configured unit file to the destination directory.
618 destination = os.path.join(args.directory, args.service_name)
619 write_config(user_config, destination)
620
621
622 # Interactive section:
623
624 print("Do you want to manually edit the new configuration? [y/N]: ", end="")
625 manual = input()
626
627 if manual and manual.lower() == "y":
628 print("Opening editor...")
629 edit(destination, manual=True, finish=False)
630 else:
631 print("The configuration file won't be edited.")
632
633 # Allow these options only if we have permissions for them.
634 if os.getuid() == 0:
635 print("Do you want to enable the service? [y/N]: ", end="")
636 enable = input()
637
638 if enable and enable.lower() == "y":
639 print("Enabling service...")
640 service_reload()
641 sysctl_service(args.service_name, "enable")
642 print("Service enabled.")
643 else:
644 print("Service won't be enabled.")
645
646
647 print("Do you want to start the service? [Y/n]: ", end="")
648 start = input()
649
650 if not start or (start and start.lower() == "y"):
651 print("Starting service...")
652 service_reload()
653 sysctl_service(args.service_name, "start")
654 print("Service started.")
655 else:
656 print("Service won't be started.")
657
658 elif os.getuid() > 0:
659 # Extremely ugly (imo) multiline statement
660 print("{}No permissions to enable/start service. "
661 "Need to run with root privileges.".format(FTY.ansi("FG_RED")))
662
663 finish(destination)
664
665
666# Name guard for main process.
667if __name__ == "__main__":
668 # Don't use global error handling if TRACE is set to True.
669 if TRACE:
670 main()
671 elif not TRACE:
672 try:
673 main()
674 except Exception as error:
675 print("A global exception has been caught.", file=sys.stderr)
676 print(err, file=sys.stderr)
677 sys.exit(GLOBAL_ERR)