# Simplify Linux Service Management with Python and Tkinter

## Introduction

Managing essential services in a Linux system can often be a complex task. To simplify this process, we can develop a Python application using the Tkinter library, which provides a user-friendly interface for starting, stopping, and restarting services like SSH, network, Apache, MySQL, Nginx, and Cron. This blog post will guide you through building such an application, highlighting its advantages and providing a line-by-line code walkthrough.

### Advantages

1. **Ease of Use**: The Tkinter-based GUI makes service management intuitive and accessible, eliminating the need for complex terminal commands.
    
2. **Secure Authentication**: The application prompts the user for their password, ensuring only authorized individuals can manage the services.
    
3. **Efficiency**: With a simple click of a button, users can start, stop, or restart services, saving time and effort.
    
4. **Visual Feedback**: The application displays the output of the service management commands, indicating success or failure, and providing real-time feedback.
    

<mark>Source Code - </mark> [**<mark>Here</mark>**](https://github.com/kartikmehta8/systemctl-gui-client)

## Code Walkthrough

Here's a line-by-line code walkthrough of the script:

```python
import tkinter as tk
import subprocess
```

The `tkinter` library is imported for creating the GUI, and the `subprocess` module is imported to execute terminal commands.

```python
def start_service():
    service = selected_service.get()
    command = f"sudo systemctl start {service}"
    execute_command(command)
```

The `start_service()` function is called when the "START" button is clicked. It retrieves the selected service from the dropdown menu, constructs the `systemctl start` command, and calls the `execute_command()` function with the command as an argument.

```python
def stop_service():
    service = selected_service.get()
    command = f"sudo systemctl stop {service}"
    execute_command(command
```

The `stop_service()` function is similar to the `start_service()` function but constructs the `systemctl stop` command.

```python
def restart_service():
    service = selected_service.get()
    command = f"sudo systemctl restart {service}"
    execute_command(command)
```

The `restart_service()` function constructs the `systemctl restart` command and calls the `execute_command()` function.

```python
def execute_command(command):
    password = password_entry.get()
    full_command = f"echo {password} | {command} 2>&1"
    process = subprocess.Popen(full_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    output, error = process.communicate()
    if process.returncode == 0:
        output_text.config(text=f"\nSUCCESS\n\n{output.decode()}")
    else:
        output_text.config(text=f"\nFAILURE\n\n{error.decode()}")
```

The `execute_command()` function is responsible for executing the provided command. It retrieves the password from the password entry field, constructs the full command with the password using the `echo` command, and uses `subprocess.Popen` to execute the command. The output and error are captured and displayed in the GUI based on the return code of the process.

```python
window = tk.Tk()
window.title("Service Control Panel")
```

A Tkinter window is created with the title "Service Control Panel".

```python
bg_color = "#262626"
fg_color = "#FFFFFF"
entry_bg_color = "#000000"
entry_fg_color = "#FFFFFF"
window.configure(bg=bg_color)
```

Variables are assigned with colour codes for the background and foreground colours of the GUI elements. The window background colour is set using `window.configure()`.

```python
password_label = tk.Label(window, text="Password:", bg=bg_color, fg=fg_color)
password_label.grid(row=0, column=0, sticky="w")
password_entry = tk.Entry(window, show="*", bg=entry_bg_color, fg=entry_fg_color)
password_entry.grid(row=0, column=1, sticky="w")
```

Labels and an entry field for the password are created and placed in the window using the `grid()` method.

```python
service_label = tk.Label(window, text="Service:", bg=bg_color, fg=fg_color)
service_label.grid(row=1, column=0, sticky="w")
services = ["ssh", "network", "apache2", "mysql", "nginx", "cron"]
selected_service = tk.StringVar()
selected_service.set(services[0])
service_dropdown = tk.OptionMenu(window, selected_service, *services)
service_dropdown.config(bg=entry_bg_color, fg=entry_fg_color)
service_dropdown.grid(row=1, column=1, sticky="w")

start_button = tk.Button(window, text="START", command=start_service, bg=bg_color, fg=fg_color)
start_button.grid(row=2, column=0, pady=10)
stop_button = tk.Button(window, text="STOP", command=stop_service, bg=bg_color, fg=fg_color)
stop_button.grid(row=2, column=1, pady=10)
restart_button = tk.Button(window, text="RESTART", command=restart_service, bg=bg_color, fg=fg_color)
restart_button.grid(row=2, column=2, pady=10)
```

Buttons for starting, stopping, and restarting the selected service are created. Each button is assigned a command to execute when clicked and styled with the provided background and foreground colours. They are placed in the window using the `grid()` method.

```python
output_label = tk.Label(window, text="Output:", bg=bg_color, fg=fg_color)
output_label.grid(row=3, column=0, sticky="w")
output_text = tk.Label(window, text="", bg=entry_bg_color, fg=entry_fg_color, justify="left", anchor="nw")
output_text.grid(row=3, column=1, columnspan=2, sticky="w")
```

A label for the output section is created, along with a label widget to display the output text. The output text label is styled with the provided background and foreground colours, and its justification is set to the left. The labels are placed in the window using the `grid()` method.

```python
window.grid_columnconfigure(0, weight=1)
window.grid_columnconfigure(1, weight=1)
window.grid_columnconfigure(2, weight=1)
window.grid_rowconfigure(3, weight=1)
```

The grid layout of the window is configured to distribute the column and row weights, ensuring that the elements expand properly.

```python
window.mainloop()
```

The main event loop of the Tkinter window is started, which handles user interactions and keeps the window open until closed.

## Conclusion

With the Python and Tkinter application demonstrated in this blog post, managing essential services in a Linux system becomes more accessible and user-friendly. The GUI interface simplifies the process by offering intuitive buttons for starting, stopping, and restarting services, while password authentication ensures secure access. By providing real-time feedback on the success or failure of the commands, administrators can efficiently monitor and control their system services. This application streamlines service management, enhancing productivity and easing the administration of Linux systems.