Skip to main content

Automation & Scripting

System Administration Tasks​

Process Management​

import subprocess
import psutil
import os

# Run system commands
result = subprocess.run(['ls', '-la'], capture_output=True, text=True)
print(result.stdout)
print(result.stderr)
print(result.returncode)

# Process monitoring with psutil
for proc in psutil.process_iter(['pid', 'name', 'cpu_percent']):
    print(proc.info)

# Kill process by name
def kill_process_by_name(name):
    for proc in psutil.process_iter():
        if proc.name() == name:
            proc.kill()

# System information
print(f"CPU usage: {psutil.cpu_percent()}%")
print(f"Memory usage: {psutil.virtual_memory().percent}%")
print(f"Disk usage: {psutil.disk_usage('/').percent}%")

File System Operations​

File Operations​

import os
import shutil
from pathlib import Path
import time

# Directory operations
def create_directory_structure(base_path):
    dirs = ['logs', 'config', 'data', 'backup']
    for dir_name in dirs:
        Path(base_path / dir_name).mkdir(parents=True, exist_ok=True)

# File cleanup
def cleanup_old_files(directory, days_old=30):
    cutoff_time = time.time() - (days_old * 24 * 60 * 60)
    for file_path in Path(directory).iterdir():
        if file_path.is_file() and file_path.stat().st_mtime < cutoff_time:
            file_path.unlink()
            print(f"Deleted: {file_path}")

Scheduling and Task Automation​

Scheduling with schedule​

import schedule
import time

# Simple scheduling
schedule.every(10).minutes.do(lambda: print("Task every 10 minutes"))
schedule.every().hour.do(lambda: print("Hourly task"))
schedule.every().day.at("09:00").do(lambda: print("Daily 9 AM task"))

# Task with parameters
def backup_database(db_name):
    print(f"Backing up database: {db_name}")

schedule.every().day.at("02:00").do(backup_database, "production_db")

# Run scheduler
while True:
    schedule.run_pending()
    time.sleep(1)

Command-Line Interfaces​

Argparse for CLI​

import argparse

def create_cli():
    parser = argparse.ArgumentParser(description='System Admin Tool')

    # Subcommands
    subparsers = parser.add_subparsers(dest='command')

    # Backup command
    backup_parser = subparsers.add_parser('backup')
    backup_parser.add_argument('--source', required=True)
    backup_parser.add_argument('--destination', required=True)
    backup_parser.add_argument('--compress', action='store_true')

    return parser

def main():
    parser = create_cli()
    args = parser.parse_args()

    if args.command == 'backup':
        print(f"Backing up {args.source} to {args.destination}")
        if args.compress:
            print("Using compression")

if __name__ == "__main__":
    main()

Click for Modern CLI​

import click

@click.group()
def cli():
    """System Administration Tool"""
    pass

@cli.command()
@click.option('--source', required=True)
@click.option('--destination', required=True)
@click.option('--compress', is_flag=True)
def backup(source, destination, compress):
    """Backup operations"""
    click.echo(f"Backing up {source} to {destination}")
    if compress:
        click.echo("Using compression")

if __name__ == "__main__":
    cli()

Email Automation​

Email Operations​

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

class EmailAutomation:
    def __init__(self, smtp_server, smtp_port, username, password):
        self.smtp_server = smtp_server
        self.smtp_port = smtp_port
        self.username = username
        self.password = password

    def send_email(self, to_addresses, subject, body):
        msg = MIMEText(body)
        msg['From'] = self.username
        msg['To'] = ', '.join(to_addresses)
        msg['Subject'] = subject

        with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
            server.starttls()
            server.login(self.username, self.password)
            server.send_message(msg)

# Usage
emailer = EmailAutomation('smtp.gmail.com', 587, 'user@gmail.com', 'password')
emailer.send_email(['admin@company.com'], 'System Alert', 'High CPU usage detected')

System Monitoring​

Basic Monitoring​

import time
from collections import defaultdict

class SystemMonitor:
    def __init__(self):
        self.alerts_sent = defaultdict(int)

    def check_disk_space(self, threshold=80):
        usage = psutil.disk_usage('/')
        percent_used = (usage.used / usage.total) * 100

        if percent_used > threshold:
            self.send_alert(f"Disk usage high: {percent_used:.1f}%")

        return percent_used

    def check_memory_usage(self, threshold=85):
        memory = psutil.virtual_memory()
        if memory.percent > threshold:
            self.send_alert(f"Memory usage high: {memory.percent:.1f}%")

        return memory.percent

    def send_alert(self, message):
        print(f"ALERT: {message}")
        # Add email/webhook notification here

# Usage
monitor = SystemMonitor()
while True:
    monitor.check_disk_space()
    monitor.check_memory_usage()
    time.sleep(60)  # Check every minute

Quick Reference​

Common Patterns​

# File operations
shutil.copy2(src, dst)          # Copy with metadata
shutil.move(src, dst)           # Move file/directory
os.chmod(path, 0o755)           # Change permissions

# Process management
subprocess.run(['command'], check=True)  # Run with error checking
psutil.Process(pid).kill()              # Kill specific process

# System information
psutil.boot_time()              # System boot time
psutil.users()                  # Logged in users

# Scheduling
schedule.every().minute.do(job)         # Every minute
schedule.every(5).seconds.do(job)       # Every 5 seconds
schedule.every().hour.at(":30").do(job) # Every hour at 30 minutes

# Error handling with retry
import time
from functools import wraps

def retry(times=3, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == times - 1:
                        raise
                    time.sleep(delay)
            return None
        return wrapper
    return decorator