861 lines
23 KiB
Bash
Executable File
861 lines
23 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# mailhog_manager.sh - Comprehensive MailHog server management utility
|
|
# Usage: ./mailhog_manager.sh [COMMAND] [OPTIONS]
|
|
|
|
set -e
|
|
|
|
# Default configuration
|
|
DEFAULT_SMTP_PORT=1025
|
|
DEFAULT_UI_PORT=8025
|
|
DEFAULT_API_PORT=8025
|
|
DEFAULT_HOSTNAME="mailhog.local"
|
|
DEFAULT_STORAGE="memory"
|
|
PID_FILE="/tmp/mailhog.pid"
|
|
LOG_FILE="/tmp/mailhog.log"
|
|
CONFIG_FILE="$HOME/.mailhog_config"
|
|
|
|
# Colors for output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
CYAN='\033[0;36m'
|
|
NC='\033[0m' # No Color
|
|
|
|
# Print colored output
|
|
print_info() {
|
|
echo -e "${BLUE}[INFO]${NC} $1"
|
|
}
|
|
|
|
print_success() {
|
|
echo -e "${GREEN}[SUCCESS]${NC} $1"
|
|
}
|
|
|
|
print_warning() {
|
|
echo -e "${YELLOW}[WARNING]${NC} $1"
|
|
}
|
|
|
|
print_error() {
|
|
echo -e "${RED}[ERROR]${NC} $1"
|
|
}
|
|
|
|
print_header() {
|
|
echo -e "${CYAN}=== $1 ===${NC}"
|
|
}
|
|
|
|
# Show usage information
|
|
show_usage() {
|
|
cat << EOF
|
|
MailHog Server Manager
|
|
|
|
Usage: $0 COMMAND [OPTIONS]
|
|
|
|
COMMANDS:
|
|
start Start MailHog server
|
|
stop Stop MailHog server
|
|
restart Restart MailHog server
|
|
status Show MailHog server status
|
|
logs Show MailHog server logs
|
|
config Show current configuration
|
|
test Test MailHog functionality
|
|
cleanup Clean up MailHog data
|
|
install Install MailHog (if not installed)
|
|
update Update MailHog to latest version
|
|
|
|
START OPTIONS:
|
|
-p, --smtp-port PORT SMTP port (default: $DEFAULT_SMTP_PORT)
|
|
-u, --ui-port PORT UI/API port (default: $DEFAULT_UI_PORT)
|
|
-h, --hostname HOST Hostname (default: $DEFAULT_HOSTNAME)
|
|
-s, --storage TYPE Storage type: memory, mongodb, maildir (default: $DEFAULT_STORAGE)
|
|
--mongo-uri URI MongoDB connection URI (for MongoDB storage)
|
|
--mongo-db DB MongoDB database name (default: mailhog)
|
|
--mongo-coll COLL MongoDB collection name (default: messages)
|
|
--maildir-path PATH Maildir storage path
|
|
--auth-file FILE Authentication file path
|
|
--outgoing-smtp FILE Outgoing SMTP configuration file
|
|
--cors-origin ORIGIN CORS origin
|
|
--invite-jim Enable Jim network simulation
|
|
-d, --daemon Run in daemon mode
|
|
-v, --verbose Enable verbose logging
|
|
|
|
CONFIGURATION:
|
|
--save Save current configuration as default
|
|
--load Load saved configuration
|
|
--reset Reset configuration to defaults
|
|
|
|
TESTING OPTIONS:
|
|
--send-email Send test email
|
|
--check-connection Check SMTP connection
|
|
--check-api Check API connection
|
|
--cleanup-test Clean up test emails
|
|
|
|
EXAMPLES:
|
|
# Start MailHog with default settings
|
|
$0 start
|
|
|
|
# Start with custom ports and MongoDB storage
|
|
$0 start --smtp-port 1026 --ui-port 8026 --storage mongodb --mongo-uri mongodb://localhost:27017
|
|
|
|
# Start in daemon mode with authentication
|
|
$0 start --auth-file /path/to/auth.txt --daemon
|
|
|
|
# Check server status
|
|
$0 status
|
|
|
|
# Send test email
|
|
$0 test --send-email --to test@recipient.local
|
|
|
|
# View logs
|
|
$0 logs
|
|
|
|
# Save current configuration
|
|
$0 config --save
|
|
|
|
INSTALLATION:
|
|
# Install MailHog (Linux/macOS)
|
|
$0 install
|
|
|
|
# Update to latest version
|
|
$0 update
|
|
|
|
EOF
|
|
}
|
|
|
|
# Load configuration from file
|
|
load_config() {
|
|
if [[ -f "$CONFIG_FILE" ]]; then
|
|
print_info "Loading configuration from $CONFIG_FILE"
|
|
# Source the configuration file
|
|
source "$CONFIG_FILE"
|
|
fi
|
|
}
|
|
|
|
# Save current configuration
|
|
save_config() {
|
|
cat > "$CONFIG_FILE" << EOF
|
|
# MailHog Configuration
|
|
SMTP_PORT="$SMTP_PORT"
|
|
UI_PORT="$UI_PORT"
|
|
API_PORT="$API_PORT"
|
|
HOSTNAME="$HOSTNAME"
|
|
STORAGE="$STORAGE"
|
|
MONGO_URI="$MONGO_URI"
|
|
MONGO_DB="$MONGO_DB"
|
|
MONGO_COLL="$MONGO_COLL"
|
|
MAILDIR_PATH="$MAILDIR_PATH"
|
|
AUTH_FILE="$AUTH_FILE"
|
|
OUTGOING_SMTP="$OUTGOING_SMTP"
|
|
CORS_ORIGIN="$CORS_ORIGIN"
|
|
INVITE_JIM="$INVITE_JIM"
|
|
EOF
|
|
|
|
print_success "Configuration saved to $CONFIG_FILE"
|
|
}
|
|
|
|
# Reset configuration to defaults
|
|
reset_config() {
|
|
SMTP_PORT="$DEFAULT_SMTP_PORT"
|
|
UI_PORT="$DEFAULT_UI_PORT"
|
|
API_PORT="$DEFAULT_API_PORT"
|
|
HOSTNAME="$DEFAULT_HOSTNAME"
|
|
STORAGE="$DEFAULT_STORAGE"
|
|
MONGO_URI=""
|
|
MONGO_DB="mailhog"
|
|
MONGO_COLL="messages"
|
|
MAILDIR_PATH=""
|
|
AUTH_FILE=""
|
|
OUTGOING_SMTP=""
|
|
CORS_ORIGIN=""
|
|
INVITE_JIM=""
|
|
|
|
print_success "Configuration reset to defaults"
|
|
}
|
|
|
|
# Check if MailHog is installed
|
|
check_mailhog_installed() {
|
|
if command -v mailhog >/dev/null 2>&1; then
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Install MailHog
|
|
install_mailhog() {
|
|
print_header "Installing MailHog"
|
|
|
|
if check_mailhog_installed; then
|
|
print_warning "MailHog is already installed"
|
|
return 0
|
|
fi
|
|
|
|
local os=$(uname -s | tr '[:upper:]' '[:lower:]')
|
|
local arch=$(uname -m)
|
|
|
|
# Determine architecture
|
|
case "$arch" in
|
|
x86_64)
|
|
arch="amd64"
|
|
;;
|
|
aarch64|arm64)
|
|
arch="arm64"
|
|
;;
|
|
armv7l)
|
|
arch="arm7"
|
|
;;
|
|
*)
|
|
print_error "Unsupported architecture: $arch"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
# Get latest version
|
|
local latest_version=$(curl -s "https://api.github.com/repos/mailhog/MailHog/releases/latest" | grep -o '"tag_name": "[^"]*' | cut -d'"' -f2 | sed 's/v//')
|
|
|
|
if [[ -z "$latest_version" ]]; then
|
|
print_error "Failed to fetch latest MailHog version"
|
|
return 1
|
|
fi
|
|
|
|
local download_url="https://github.com/mailhog/MailHog/releases/download/v${latest_version}/MailHog_${os}_${arch}.zip"
|
|
|
|
print_info "Downloading MailHog v${latest_version} for ${os}/${arch}..."
|
|
|
|
# Download and extract
|
|
local temp_dir=$(mktemp -d)
|
|
cd "$temp_dir"
|
|
|
|
if curl -L -o mailhog.zip "$download_url"; then
|
|
unzip mailhog.zip
|
|
chmod +x MailHog
|
|
|
|
# Move to binary directory
|
|
if [[ -w "/usr/local/bin" ]]; then
|
|
sudo mv MailHog /usr/local/bin/
|
|
elif [[ -w "$HOME/.local/bin" ]]; then
|
|
mkdir -p "$HOME/.local/bin"
|
|
mv MailHog "$HOME/.local/bin/"
|
|
# Add to PATH if not already there
|
|
if ! echo "$PATH" | grep -q "$HOME/.local/bin"; then
|
|
echo 'export PATH="$PATH:$HOME/.local/bin"' >> "$HOME/.bashrc"
|
|
export PATH="$PATH:$HOME/.local/bin"
|
|
fi
|
|
else
|
|
print_error "No writable binary directory found. Please install manually."
|
|
cd /
|
|
rm -rf "$temp_dir"
|
|
return 1
|
|
fi
|
|
|
|
cd /
|
|
rm -rf "$temp_dir"
|
|
|
|
print_success "MailHog v${latest_version} installed successfully"
|
|
return 0
|
|
else
|
|
print_error "Failed to download MailHog"
|
|
cd /
|
|
rm -rf "$temp_dir"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Update MailHog
|
|
update_mailhog() {
|
|
print_header "Updating MailHog"
|
|
|
|
if ! check_mailhog_installed; then
|
|
print_warning "MailHog not installed. Installing..."
|
|
install_mailhog
|
|
return $?
|
|
fi
|
|
|
|
# Stop MailHog if running
|
|
if is_mailhog_running; then
|
|
stop_mailhog
|
|
fi
|
|
|
|
# Install latest version
|
|
install_mailhog
|
|
}
|
|
|
|
# Check if MailHog is running
|
|
is_mailhog_running() {
|
|
if [[ -f "$PID_FILE" ]]; then
|
|
local pid=$(cat "$PID_FILE")
|
|
if ps -p "$pid" > /dev/null 2>&1; then
|
|
return 0
|
|
else
|
|
# PID file exists but process is not running
|
|
rm -f "$PID_FILE"
|
|
return 1
|
|
fi
|
|
fi
|
|
|
|
# Check by looking for mailhog process
|
|
if pgrep -f "mailhog" > /dev/null; then
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
# Build MailHog command with current configuration
|
|
build_mailhog_command() {
|
|
local cmd="mailhog"
|
|
|
|
# Basic configuration
|
|
cmd+=" -hostname $HOSTNAME"
|
|
cmd+=" -smtp-bind-addr 0.0.0.0:$SMTP_PORT"
|
|
cmd+=" -ui-bind-addr 0.0.0.0:$UI_PORT"
|
|
cmd+=" -api-bind-addr 0.0.0.0:$API_PORT"
|
|
|
|
# Storage configuration
|
|
case "$STORAGE" in
|
|
"mongodb")
|
|
if [[ -n "$MONGO_URI" ]]; then
|
|
cmd+=" -storage mongodb -mongo-uri $MONGO_URI"
|
|
else
|
|
cmd+=" -storage mongodb -mongo-uri 127.0.0.1:27017"
|
|
fi
|
|
if [[ -n "$MONGO_DB" ]]; then
|
|
cmd+=" -mongo-db $MONGO_DB"
|
|
fi
|
|
if [[ -n "$MONGO_COLL" ]]; then
|
|
cmd+=" -mongo-coll $MONGO_COLL"
|
|
fi
|
|
;;
|
|
"maildir")
|
|
if [[ -n "$MAILDIR_PATH" ]]; then
|
|
cmd+=" -storage maildir -maildir-path $MAILDIR_PATH"
|
|
else
|
|
cmd+=" -storage maildir -maildir-path ./maildir"
|
|
fi
|
|
;;
|
|
*)
|
|
cmd+=" -storage memory"
|
|
;;
|
|
esac
|
|
|
|
# Optional configurations
|
|
if [[ -n "$AUTH_FILE" ]]; then
|
|
cmd+=" -auth-file $AUTH_FILE"
|
|
fi
|
|
|
|
if [[ -n "$OUTGOING_SMTP" ]]; then
|
|
cmd+=" -outgoing-smtp $OUTGOING_SMTP"
|
|
fi
|
|
|
|
if [[ -n "$CORS_ORIGIN" ]]; then
|
|
cmd+=" -cors-origin \"$CORS_ORIGIN\""
|
|
fi
|
|
|
|
if [[ "$INVITE_JIM" == "true" ]]; then
|
|
cmd+=" -invite-jim"
|
|
fi
|
|
|
|
echo "$cmd"
|
|
}
|
|
|
|
# Start MailHog
|
|
start_mailhog() {
|
|
print_header "Starting MailHog"
|
|
|
|
if is_mailhog_running; then
|
|
print_warning "MailHog is already running"
|
|
return 0
|
|
fi
|
|
|
|
if ! check_mailhog_installed; then
|
|
print_error "MailHog is not installed. Run '$0 install' first."
|
|
return 1
|
|
fi
|
|
|
|
# Check if ports are available
|
|
if netstat -tlnp 2>/dev/null | grep -q ":$SMTP_PORT "; then
|
|
print_error "Port $SMTP_PORT is already in use"
|
|
return 1
|
|
fi
|
|
|
|
if netstat -tlnp 2>/dev/null | grep -q ":$UI_PORT "; then
|
|
print_error "Port $UI_PORT is already in use"
|
|
return 1
|
|
fi
|
|
|
|
local mailhog_cmd=$(build_mailhog_command)
|
|
|
|
print_info "Starting MailHog with the following command:"
|
|
print_info "$mailhog_cmd"
|
|
|
|
if [[ "$DAEMON_MODE" == true ]]; then
|
|
# Start in daemon mode
|
|
nohup $mailhog_cmd > "$LOG_FILE" 2>&1 &
|
|
local pid=$!
|
|
echo "$pid" > "$PID_FILE"
|
|
print_success "MailHog started in daemon mode (PID: $pid)"
|
|
print_info "Logs are being written to: $LOG_FILE"
|
|
else
|
|
# Start in foreground
|
|
$mailhog_cmd 2>&1 | tee "$LOG_FILE" &
|
|
local pid=$!
|
|
echo "$pid" > "$PID_FILE"
|
|
print_success "MailHog started (PID: $pid)"
|
|
fi
|
|
|
|
# Wait a moment and check if it started successfully
|
|
sleep 2
|
|
if is_mailhog_running; then
|
|
print_success "MailHog started successfully"
|
|
print_info "SMTP server: localhost:$SMTP_PORT"
|
|
print_info "Web UI: http://localhost:$UI_PORT"
|
|
print_info "API: http://localhost:$API_PORT/api/v1"
|
|
else
|
|
print_error "MailHog failed to start"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Stop MailHog
|
|
stop_mailhog() {
|
|
print_header "Stopping MailHog"
|
|
|
|
if ! is_mailhog_running; then
|
|
print_warning "MailHog is not running"
|
|
return 0
|
|
fi
|
|
|
|
local pid=""
|
|
if [[ -f "$PID_FILE" ]]; then
|
|
pid=$(cat "$PID_FILE")
|
|
else
|
|
# Try to find PID by process name
|
|
pid=$(pgrep -f "mailhog" | head -1)
|
|
fi
|
|
|
|
if [[ -n "$pid" ]]; then
|
|
print_info "Stopping MailHog (PID: $pid)"
|
|
kill "$pid"
|
|
|
|
# Wait for process to stop
|
|
local count=0
|
|
while ps -p "$pid" > /dev/null 2>&1 && [[ $count -lt 10 ]]; do
|
|
sleep 1
|
|
((count++))
|
|
done
|
|
|
|
# Force kill if still running
|
|
if ps -p "$pid" > /dev/null 2>&1; then
|
|
print_warning "Force killing MailHog process"
|
|
kill -9 "$pid"
|
|
fi
|
|
|
|
rm -f "$PID_FILE"
|
|
print_success "MailHog stopped"
|
|
else
|
|
print_warning "Could not find MailHog process to stop"
|
|
fi
|
|
}
|
|
|
|
# Restart MailHog
|
|
restart_mailhog() {
|
|
print_header "Restarting MailHog"
|
|
stop_mailhog
|
|
sleep 2
|
|
start_mailhog
|
|
}
|
|
|
|
# Show MailHog status
|
|
show_status() {
|
|
print_header "MailHog Status"
|
|
|
|
if is_mailhog_running; then
|
|
print_success "MailHog is running"
|
|
|
|
# Show process information
|
|
if [[ -f "$PID_FILE" ]]; then
|
|
local pid=$(cat "$PID_FILE")
|
|
print_info "PID: $pid"
|
|
print_info "Command: $(ps -p "$pid" -o cmd=)"
|
|
fi
|
|
|
|
# Show configuration
|
|
echo ""
|
|
print_info "Configuration:"
|
|
print_info " SMTP Port: $SMTP_PORT"
|
|
print_info " UI Port: $UI_PORT"
|
|
print_info " API Port: $API_PORT"
|
|
print_info " Hostname: $HOSTNAME"
|
|
print_info " Storage: $STORAGE"
|
|
|
|
# Test API connection
|
|
echo ""
|
|
print_info "Testing API connection..."
|
|
if curl -s --max-time 3 "http://localhost:$API_PORT/api/v1/status" > /dev/null 2>&1; then
|
|
print_success "API is accessible"
|
|
local messages=$(curl -s "http://localhost:$API_PORT/api/v1/messages" 2>/dev/null | jq -r '.total // 0' 2>/dev/null || echo "unknown")
|
|
print_info "Messages stored: $messages"
|
|
else
|
|
print_error "API is not accessible"
|
|
fi
|
|
|
|
# Show URLs
|
|
echo ""
|
|
print_info "Access URLs:"
|
|
print_info " Web UI: http://localhost:$UI_PORT"
|
|
print_info " API: http://localhost:$API_PORT/api/v1"
|
|
print_info " SMTP: localhost:$SMTP_PORT"
|
|
else
|
|
print_error "MailHog is not running"
|
|
fi
|
|
}
|
|
|
|
# Show logs
|
|
show_logs() {
|
|
print_header "MailHog Logs"
|
|
|
|
if [[ -f "$LOG_FILE" ]]; then
|
|
tail -f "$LOG_FILE"
|
|
else
|
|
print_warning "Log file not found: $LOG_FILE"
|
|
fi
|
|
}
|
|
|
|
# Show configuration
|
|
show_config() {
|
|
print_header "Current Configuration"
|
|
|
|
echo "SMTP Port: $SMTP_PORT"
|
|
echo "UI Port: $UI_PORT"
|
|
echo "API Port: $API_PORT"
|
|
echo "Hostname: $HOSTNAME"
|
|
echo "Storage: $STORAGE"
|
|
|
|
if [[ "$STORAGE" == "mongodb" ]]; then
|
|
echo "MongoDB URI: ${MONGO_URI:-"127.0.0.1:27017"}"
|
|
echo "MongoDB DB: $MONGO_DB"
|
|
echo "MongoDB Collection: $MONGO_COLL"
|
|
fi
|
|
|
|
if [[ "$STORAGE" == "maildir" ]]; then
|
|
echo "Maildir Path: ${MAILDIR_PATH:-"./maildir"}"
|
|
fi
|
|
|
|
echo "Auth File: ${AUTH_FILE:-"none"}"
|
|
echo "Outgoing SMTP: ${OUTGOING_SMTP:-"none"}"
|
|
echo "CORS Origin: ${CORS_ORIGIN:-"none"}"
|
|
echo "Jim Simulation: ${INVITE_JIM:-"false"}"
|
|
|
|
echo ""
|
|
echo "MailHog Command:"
|
|
echo "$(build_mailhog_command)"
|
|
}
|
|
|
|
# Test MailHog functionality
|
|
test_mailhog() {
|
|
print_header "Testing MailHog"
|
|
|
|
if ! is_mailhog_running; then
|
|
print_error "MailHog is not running"
|
|
return 1
|
|
fi
|
|
|
|
# Test API connection
|
|
if [[ "$CHECK_API" == true ]]; then
|
|
print_info "Testing API connection..."
|
|
local response=$(curl -s "http://localhost:$API_PORT/api/v1/status" 2>/dev/null)
|
|
|
|
if [[ $? -eq 0 ]]; then
|
|
print_success "API connection successful"
|
|
echo "$response" | jq . 2>/dev/null || echo "$response"
|
|
else
|
|
print_error "API connection failed"
|
|
fi
|
|
fi
|
|
|
|
# Test SMTP connection
|
|
if [[ "$CHECK_CONNECTION" == true ]]; then
|
|
print_info "Testing SMTP connection..."
|
|
if echo "" | nc -w 3 localhost "$SMTP_PORT" 2>/dev/null | grep -q "220"; then
|
|
print_success "SMTP connection successful"
|
|
else
|
|
print_error "SMTP connection failed"
|
|
fi
|
|
fi
|
|
|
|
# Send test email
|
|
if [[ "$SEND_EMAIL" == true ]]; then
|
|
print_info "Sending test email..."
|
|
|
|
local test_to="${TEST_TO:-test@recipient.local}"
|
|
local test_from="${TEST_FROM:-test@sender.local}"
|
|
local test_subject="MailHog Test Email $(date +%s)"
|
|
local test_body="This is a test email sent at $(date)"
|
|
|
|
# Send email using netcat
|
|
(
|
|
echo "EHLO localhost"
|
|
echo "MAIL FROM:<$test_from>"
|
|
echo "RCPT TO:<$test_to>"
|
|
echo "DATA"
|
|
echo "From: $test_from"
|
|
echo "To: $test_to"
|
|
echo "Subject: $test_subject"
|
|
echo "Date: $(date -R)"
|
|
echo ""
|
|
echo "$test_body"
|
|
echo "."
|
|
echo "QUIT"
|
|
) | nc localhost "$SMTP_PORT" 2>/dev/null
|
|
|
|
if [[ $? -eq 0 ]]; then
|
|
print_success "Test email sent to $test_to"
|
|
|
|
# Wait and check if received
|
|
sleep 2
|
|
local messages=$(curl -s "http://localhost:$API_PORT/api/v1/messages" 2>/dev/null | jq -r '.total // 0' 2>/dev/null)
|
|
|
|
if [[ "$messages" -gt 0 ]]; then
|
|
print_success "Test email received by MailHog ($messages total messages)"
|
|
else
|
|
print_warning "Test email not found in MailHog (may need more time)"
|
|
fi
|
|
else
|
|
print_error "Failed to send test email"
|
|
fi
|
|
fi
|
|
|
|
# Clean up test emails
|
|
if [[ "$CLEANUP_TEST" == true ]]; then
|
|
print_info "Cleaning up test emails..."
|
|
local response=$(curl -s -X DELETE "http://localhost:$API_PORT/api/v1/messages" 2>/dev/null)
|
|
|
|
if [[ $? -eq 0 ]]; then
|
|
print_success "Test emails cleaned up"
|
|
else
|
|
print_warning "Failed to clean up test emails"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Clean up MailHog data
|
|
cleanup_mailhog() {
|
|
print_header "Cleaning up MailHog"
|
|
|
|
if is_mailhog_running; then
|
|
print_info "Clearing all messages..."
|
|
local response=$(curl -s -X DELETE "http://localhost:$API_PORT/api/v1/messages" 2>/dev/null)
|
|
|
|
if [[ $? -eq 0 ]]; then
|
|
print_success "All messages cleared"
|
|
else
|
|
print_warning "Failed to clear messages"
|
|
fi
|
|
else
|
|
print_warning "MailHog is not running"
|
|
fi
|
|
|
|
# Clean up temporary files
|
|
print_info "Cleaning up temporary files..."
|
|
rm -f "$PID_FILE" "$LOG_FILE"
|
|
|
|
# Optional: Clean up maildir if used
|
|
if [[ "$STORAGE" == "maildir" ]] && [[ -n "$MAILDIR_PATH" ]]; then
|
|
if [[ -d "$MAILDIR_PATH" ]]; then
|
|
print_info "Cleaning up Maildir storage..."
|
|
rm -rf "$MAILDIR_PATH"/{cur,new,tmp}/*
|
|
print_success "Maildir storage cleaned"
|
|
fi
|
|
fi
|
|
|
|
print_success "Cleanup completed"
|
|
}
|
|
|
|
# Main function
|
|
main() {
|
|
# Load default configuration
|
|
load_config
|
|
|
|
# Set defaults if not loaded
|
|
SMTP_PORT="${SMTP_PORT:-$DEFAULT_SMTP_PORT}"
|
|
UI_PORT="${UI_PORT:-$DEFAULT_UI_PORT}"
|
|
API_PORT="${API_PORT:-$DEFAULT_API_PORT}"
|
|
HOSTNAME="${HOSTNAME:-$DEFAULT_HOSTNAME}"
|
|
STORAGE="${STORAGE:-$DEFAULT_STORAGE}"
|
|
MONGO_DB="${MONGO_DB:-mailhog}"
|
|
MONGO_COLL="${MONGO_COLL:-messages}"
|
|
DAEMON_MODE=false
|
|
|
|
# Parse command line arguments
|
|
case "${1:-}" in
|
|
"start")
|
|
shift
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
-p|--smtp-port)
|
|
SMTP_PORT="$2"
|
|
shift 2
|
|
;;
|
|
-u|--ui-port)
|
|
UI_PORT="$2"
|
|
API_PORT="$2"
|
|
shift 2
|
|
;;
|
|
-h|--hostname)
|
|
HOSTNAME="$2"
|
|
shift 2
|
|
;;
|
|
-s|--storage)
|
|
STORAGE="$2"
|
|
shift 2
|
|
;;
|
|
--mongo-uri)
|
|
MONGO_URI="$2"
|
|
shift 2
|
|
;;
|
|
--mongo-db)
|
|
MONGO_DB="$2"
|
|
shift 2
|
|
;;
|
|
--mongo-coll)
|
|
MONGO_COLL="$2"
|
|
shift 2
|
|
;;
|
|
--maildir-path)
|
|
MAILDIR_PATH="$2"
|
|
shift 2
|
|
;;
|
|
--auth-file)
|
|
AUTH_FILE="$2"
|
|
shift 2
|
|
;;
|
|
--outgoing-smtp)
|
|
OUTGOING_SMTP="$2"
|
|
shift 2
|
|
;;
|
|
--cors-origin)
|
|
CORS_ORIGIN="$2"
|
|
shift 2
|
|
;;
|
|
--invite-jim)
|
|
INVITE_JIM="true"
|
|
shift
|
|
;;
|
|
-d|--daemon)
|
|
DAEMON_MODE=true
|
|
shift
|
|
;;
|
|
-v|--verbose)
|
|
VERBOSE=true
|
|
shift
|
|
;;
|
|
--save)
|
|
save_config
|
|
exit 0
|
|
;;
|
|
*)
|
|
print_error "Unknown option: $1"
|
|
show_usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
start_mailhog
|
|
;;
|
|
"stop")
|
|
stop_mailhog
|
|
;;
|
|
"restart")
|
|
restart_mailhog
|
|
;;
|
|
"status")
|
|
show_status
|
|
;;
|
|
"logs")
|
|
show_logs
|
|
;;
|
|
"config")
|
|
case "${2:-}" in
|
|
"--save")
|
|
save_config
|
|
;;
|
|
"--load")
|
|
load_config
|
|
print_success "Configuration loaded"
|
|
;;
|
|
"--reset")
|
|
reset_config
|
|
;;
|
|
*)
|
|
show_config
|
|
;;
|
|
esac
|
|
;;
|
|
"test")
|
|
shift
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
--send-email)
|
|
SEND_EMAIL=true
|
|
shift
|
|
;;
|
|
--check-connection)
|
|
CHECK_CONNECTION=true
|
|
shift
|
|
;;
|
|
--check-api)
|
|
CHECK_API=true
|
|
shift
|
|
;;
|
|
--cleanup-test)
|
|
CLEANUP_TEST=true
|
|
shift
|
|
;;
|
|
--to)
|
|
TEST_TO="$2"
|
|
shift 2
|
|
;;
|
|
--from)
|
|
TEST_FROM="$2"
|
|
shift 2
|
|
;;
|
|
*)
|
|
print_error "Unknown test option: $1"
|
|
show_usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# If no specific test options, run all tests
|
|
if [[ -z "$SEND_EMAIL" && -z "$CHECK_CONNECTION" && -z "$CHECK_API" && -z "$CLEANUP_TEST" ]]; then
|
|
SEND_EMAIL=true
|
|
CHECK_CONNECTION=true
|
|
CHECK_API=true
|
|
CLEANUP_TEST=true
|
|
fi
|
|
|
|
test_mailhog
|
|
;;
|
|
"cleanup")
|
|
cleanup_mailhog
|
|
;;
|
|
"install")
|
|
install_mailhog
|
|
;;
|
|
"update")
|
|
update_mailhog
|
|
;;
|
|
"help"|"-h"|"--help")
|
|
show_usage
|
|
;;
|
|
*)
|
|
print_error "Unknown command: ${1:-}"
|
|
show_usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Run main function
|
|
main "$@" |