Python Systemd Service Manager

This challenge focuses on creating a Python program that can interact with systemd, the system and service manager for Linux operating systems. You will build a tool that allows you to manage systemd services programmatically from Python, enabling automated deployment, monitoring, and control of background processes.

Problem Description

The goal is to create a Python class, SystemdManager, that encapsulates common systemd service management operations. This class should provide methods to:

Check Service Status: Determine if a given systemd service is active, inactive, or in another state.
Start a Service: Initiate the startup of a specified systemd service.
Stop a Service: Terminate a running systemd service.
Restart a Service: Stop and then start a systemd service.
Enable a Service: Configure a service to start automatically on boot.
Disable a Service: Prevent a service from starting automatically on boot.
Get Service Logs: Retrieve the journal logs for a specific systemd service.

The SystemdManager class should handle interactions with the systemctl command-line utility. It should parse the output of systemctl commands and present this information in a user-friendly Pythonic way.

Key Requirements:

The SystemdManager class should be instantiated with the name of the service to manage.
Methods should return meaningful data (e.g., boolean for status, strings for logs) or raise specific exceptions for errors.
Error handling for invalid service names or command execution failures is crucial.
The solution should be cross-platform compatible where systemd is available (primarily Linux).

Expected Behavior:

Calling status() should return a string representing the service's current state (e.g., "active", "inactive", "failed").
Calling start(), stop(), restart(), enable(), or disable() should execute the corresponding systemctl command. These methods can return True on success and False on failure, or raise an exception.
Calling get_logs() should return a string containing the recent journal logs for the service.

Edge Cases:

Service not found.
Permissions issues when trying to manage systemd services (requires root privileges for some operations).
systemctl command not found in the system's PATH.
Service is in a transitional state (e.g., "activating", "deactivating").

Examples

Example 1: Basic Service Management

Let's assume a service named nginx.service is installed and managed by systemd.

from systemd_manager import SystemdManager # Assuming your class is in this module

# For demonstration, let's assume we are managing a hypothetical 'my_app.service'
# In a real scenario, you'd use a service that exists on your system, like 'ssh.service' or 'nginx.service'

# --- Scenario: Service is active ---
# Assume 'my_app.service' is running
manager = SystemdManager("my_app.service")

# Check status
current_status = manager.status()
print(f"Current status of my_app.service: {current_status}")
# Expected Output: Current status of my_app.service: active

# Stop the service
if manager.stop():
    print("my_app.service stopped successfully.")
else:
    print("Failed to stop my_app.service.")
# Expected Output: my_app.service stopped successfully.

# Check status again
current_status = manager.status()
print(f"Current status of my_app.service: {current_status}")
# Expected Output: Current status of my_app.service: inactive

# Start the service
if manager.start():
    print("my_app.service started successfully.")
else:
    print("Failed to start my_app.service.")
# Expected Output: my_app.service started successfully.

# --- Scenario: Service is inactive ---
# Assume 'my_app.service' is not running
manager_inactive = SystemdManager("my_app.service")
print(f"Current status: {manager_inactive.status()}")
# Expected Output: Current status: inactive

# Attempt to stop an inactive service (should ideally not raise an error but report success or no-op)
if manager_inactive.stop():
    print("Attempt to stop inactive service completed.")
else:
    print("Failed to stop inactive service.")
# Expected Output: Attempt to stop inactive service completed.

Example 2: Enabling and Disabling Services

# Assuming 'my_app.service' is a service that can be enabled/disabled

manager = SystemdManager("my_app.service")

# Disable the service (if it was enabled)
if manager.disable():
    print("my_app.service disabled successfully.")
else:
    print("Failed to disable my_app.service.")
# Expected Output: my_app.service disabled successfully.

# Enable the service
if manager.enable():
    print("my_app.service enabled successfully.")
else:
    print("Failed to enable my_app.service.")
# Expected Output: my_app.service enabled successfully.

Example 3: Retrieving Logs

# Assuming 'my_app.service' has generated some logs

manager = SystemdManager("my_app.service")
logs = manager.get_logs(lines=5) # Get last 5 lines of logs
print("Recent logs for my_app.service:")
print(logs)
# Expected Output:
# Recent logs for my_app.service:
# <output of last 5 log lines, e.g.,>
# Jan 15 10:30:00 myhost my_app[1234]: Application started.
# Jan 15 10:30:05 myhost my_app[1234]: Processing request...
# ... (more log lines)

Constraints

The Python code must be executable on a Linux system with systemd installed and the systemctl command available in the PATH.
The program should use the subprocess module to execute systemctl commands.
Parsing of systemctl output should be robust.
For methods like start, stop, enable, disable, the Python script itself might need to be run with elevated privileges (e.g., sudo python your_script.py) if managing services that require them. The challenge itself doesn't require implementing privilege escalation, but the user running the script should be aware.
The get_logs method should accept an optional lines argument to specify the number of log lines to retrieve.

Notes

You can use subprocess.run() with capture_output=True and text=True to capture the output of systemctl commands.
Pay close attention to the exit codes of subprocess.run() to determine command success or failure.
Consider using try-except blocks to handle potential FileNotFoundError if systemctl is not found, or CalledProcessError if a command fails.
The systemctl status command output can vary slightly. Focus on identifying the primary state (active, inactive, failed, etc.).
For enabling/disabling, systemctl enable --now can be used to enable and start immediately, but for this challenge, separate enable() and start() calls are preferred to test individual functionalities.
The systemctl --user flag could be explored for user-specific services, but the primary focus of this challenge is system-wide services.