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