SHELL Shell script

AI-powered detection and analysis of Shell script files.

📂 Code

🏷️ .sh

🎯 text/x-shellscript

🔍

Instant SHELL File Detection

Use our advanced AI-powered tool to instantly detect and analyze Shell script files with precision and speed.

File Information

File Description

Shell script

Shell Script

What is a Shell script file?

A Shell script (.sh) file is a text file containing a series of commands that can be executed by a Unix shell interpreter. Shell scripts automate repetitive tasks, system administration operations, and complex command sequences by combining shell commands, variables, control structures, and functions into executable programs. These scripts are fundamental to Unix-like operating systems including Linux, macOS, and various Unix distributions.

More Information

Shell scripting has its roots in the early days of Unix, developed at Bell Labs in the 1970s. The original Bourne shell (sh) was created by Stephen Bourne in 1979, providing the foundation for shell scripting as we know it today. Over the decades, various shells have been developed including the C shell (csh), Korn shell (ksh), and the widely popular Bash (Bourne Again Shell), which combines features from multiple shells.

Shell scripts serve as the backbone of system administration, automation, and DevOps practices in Unix-like environments. They enable system administrators and developers to automate complex workflows, manage system configurations, deploy applications, and perform batch operations efficiently. The power of shell scripting lies in its ability to orchestrate existing command-line tools and system utilities into sophisticated automation solutions.

Shell Script Format

Shell scripts follow specific syntax rules and conventions:

Basic Structure

Shebang line - #!/bin/bash or #!/bin/sh specifies interpreter
Comments - Lines starting with # for documentation
Variables - Store and manipulate data
Commands - System commands and utilities
Control structures - if/else, loops, case statements
Functions - Reusable code blocks

Key Features

Command execution - Run system commands and programs
Variable manipulation - String and numeric operations
File operations - Read, write, and manipulate files
Process control - Background jobs and signal handling
Input/output - Redirection and piping
Error handling - Exit codes and error checking

Variables and Data Types

String variables - TEXT="Hello World"
Numeric variables - NUMBER=42
Arrays - ARRAY=(item1 item2 item3)
Environment variables - $PATH, $HOME, $USER
Special variables - $0, $1, $?, $$, $#
Command substitution - $(command) or command

Example Shell Script

#!/bin/bash

# Script: system_backup.sh
# Purpose: Automated system backup with logging
# Author: System Administrator
# Date: $(date)

set -euo pipefail  # Exit on error, undefined variables, pipe failures

# Configuration variables
BACKUP_DIR="/backup"
SOURCE_DIRS=("/home" "/etc" "/var/log")
LOG_FILE="/var/log/backup.log"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_NAME="system_backup_${TIMESTAMP}"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Logging function
log_message() {
    local level=$1
    shift
    local message="$@"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $message" | tee -a "$LOG_FILE"
}

# Error handling function
error_exit() {
    log_message "ERROR" "$1"
    exit 1
}

# Check if running as root
check_permissions() {
    if [[ $EUID -ne 0 ]]; then
        error_exit "This script must be run as root"
    fi
}

# Create backup directory
create_backup_dir() {
    local backup_path="${BACKUP_DIR}/${BACKUP_NAME}"
    
    if [[ ! -d "$BACKUP_DIR" ]]; then
        mkdir -p "$BACKUP_DIR" || error_exit "Failed to create backup directory"
    fi
    
    mkdir -p "$backup_path" || error_exit "Failed to create backup subdirectory"
    echo "$backup_path"
}

# Backup function
perform_backup() {
    local backup_path=$1
    local total_size=0
    
    log_message "INFO" "Starting backup to $backup_path"
    
    for source_dir in "${SOURCE_DIRS[@]}"; do
        if [[ -d "$source_dir" ]]; then
            log_message "INFO" "Backing up $source_dir"
            
            # Create archive with compression
            local archive_name=$(basename "$source_dir").tar.gz
            
            if tar -czf "${backup_path}/${archive_name}" -C "$(dirname "$source_dir")" "$(basename "$source_dir")" 2>/dev/null; then
                local size=$(du -sh "${backup_path}/${archive_name}" | cut -f1)
                log_message "SUCCESS" "Backup of $source_dir completed (Size: $size)"
                total_size=$((total_size + $(stat -c%s "${backup_path}/${archive_name}")))
            else
                log_message "WARNING" "Failed to backup $source_dir"
            fi
        else
            log_message "WARNING" "Source directory $source_dir does not exist"
        fi
    done
    
    # Convert bytes to human readable format
    local human_size=$(numfmt --to=iec --suffix=B $total_size)
    log_message "INFO" "Total backup size: $human_size"
}

# Cleanup old backups (keep last 7 days)
cleanup_old_backups() {
    log_message "INFO" "Cleaning up old backups"
    find "$BACKUP_DIR" -name "system_backup_*" -type d -mtime +7 -exec rm -rf {} \; 2>/dev/null || true
}

# System health check
system_health_check() {
    log_message "INFO" "Performing system health check"
    
    # Check disk space
    local disk_usage=$(df / | awk 'NR==2 {print $5}' | sed 's/%//')
    if [[ $disk_usage -gt 90 ]]; then
        log_message "WARNING" "Disk usage is at ${disk_usage}%"
    fi
    
    # Check memory usage
    local mem_usage=$(free | awk 'NR==2{printf "%.2f", $3*100/$2}')
    log_message "INFO" "Memory usage: ${mem_usage}%"
    
    # Check system load
    local load_avg=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    log_message "INFO" "System load: $load_avg"
}

# Main execution
main() {
    echo -e "${GREEN}Starting System Backup Script${NC}"
    
    # Perform checks
    check_permissions
    system_health_check
    
    # Create backup
    local backup_path=$(create_backup_dir)
    perform_backup "$backup_path"
    
    # Cleanup
    cleanup_old_backups
    
    log_message "SUCCESS" "Backup completed successfully"
    echo -e "${GREEN}Backup completed! Check $LOG_FILE for details${NC}"
}

# Script execution with error handling
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    trap 'error_exit "Script interrupted"' INT TERM
    main "$@"
fi