Systemd Service Management with Python

This challenge focuses on creating a Python script that can interact with systemd, allowing you to start, stop, restart, and check the status of systemd services. Automating systemd service management is crucial for robust deployments, monitoring, and automated tasks, especially in server environments. You'll be using the subprocess module to execute systemd commands and parse their output.

Problem Description

You are tasked with developing a Python script named systemd_manager.py that provides a command-line interface for managing systemd services. The script should accept service names as arguments and perform the requested actions. The script must handle potential errors gracefully and provide informative output to the user.

What needs to be achieved:

The script should accept a service name and an action as command-line arguments.
The script should use systemctl commands to perform the requested action on the specified service.
The script should parse the output of systemctl to determine the success or failure of the operation.
The script should provide clear and concise feedback to the user about the outcome of the operation.

Key Requirements:

Supported Actions: The script must support the following actions: start, stop, restart, and status.
Error Handling: The script must handle cases where the service name is invalid, the action is unsupported, or the systemctl command fails.
Output Formatting: The script should provide informative output, including the service name, action performed, and the result (success or failure). For the status action, the script should extract and display the service's active state (e.g., "active (running)", "inactive (dead)").
Security: The script should avoid using shell injection vulnerabilities. Use subprocess.run with a list of arguments.

Expected Behavior:

When executed with valid arguments, the script should perform the requested action on the specified service and print a message indicating success or failure. For the status action, it should print the service's current state. When executed with invalid arguments, the script should print an error message and exit with a non-zero exit code.

Edge Cases to Consider:

Service name does not exist.
User does not have sufficient permissions to manage the service.
systemctl command fails for other reasons (e.g., systemd is not running).
The status command returns unexpected output.
Handling of spaces in service names (e.g., "my service").

Examples

Example 1:

Input: python systemd_manager.py start apache2
Output: Successfully started service apache2.
Explanation: The script executes `systemctl start apache2` and prints a success message if the command returns a zero exit code.

Example 2:

Input: python systemd_manager.py status nginx
Output: Service nginx is active (running).
Explanation: The script executes `systemctl status nginx` and parses the output to extract the active state.

Example 3:

Input: python systemd_manager.py restart postgresql
Output: Successfully restarted service postgresql.
Explanation: The script executes `systemctl restart postgresql` and prints a success message.

Example 4:

Input: python systemd_manager.py stop invalid_service
Output: Error: Service 'invalid_service' not found.
Explanation: The script executes `systemctl stop invalid_service` and, because the service doesn't exist, prints an error message.

Constraints

The script must be written in Python 3.
The script must use the subprocess module to execute systemd commands.
The script must handle errors gracefully and provide informative output.
The script must be able to manage services with names containing spaces.
The script should not require any external dependencies beyond the Python standard library.
The script should be reasonably efficient; avoid unnecessary loops or complex data structures.

Notes

Consider using subprocess.run with capture_output=True to capture both standard output and standard error.
The systemctl status command's output format can vary slightly between systemd versions. You may need to adjust the parsing logic accordingly. Focus on extracting the "Active:" line.
Think about how to handle different exit codes from systemctl to determine success or failure. A zero exit code generally indicates success.
Remember to sanitize the service name to prevent potential security vulnerabilities. While this challenge doesn't explicitly require complex sanitization, be mindful of best practices.
The script should be executable by a regular user (not just root) for services they have permission to manage.