Alexander Renz
68ede52336
- Introduced configuration files for Docker, Podman, and SystemD deployments. - Implemented a comprehensive test suite for HMAC validation, file uploads, and network resilience. - Added debugging scripts for live monitoring of upload issues and service status. - Created minimal configuration for testing purposes. - Developed multiple test scripts to validate HMAC calculations and response handling. - Enhanced upload tests to cover various scenarios including invalid HMAC and unsupported file extensions. - Improved logging and error analysis capabilities for better diagnostics.
674 lines
20 KiB
Bash
Executable File
674 lines
20 KiB
Bash
Executable File
#!/bin/bash
|
|
# HMAC File Server 3.2 - Universal Installation & Testing Framework
|
|
# Ensures consistent user experience across all deployment methods
|
|
|
|
set -e
|
|
|
|
# Colors for output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
CYAN='\033[0;36m'
|
|
MAGENTA='\033[0;35m'
|
|
NC='\033[0m'
|
|
|
|
# Installation methods
|
|
METHODS=("systemd" "docker" "podman" "debian" "multi-arch")
|
|
CURRENT_METHOD=""
|
|
TEST_MODE=false
|
|
VALIDATE_ONLY=false
|
|
|
|
# Helper functions
|
|
log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
|
|
log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
|
|
log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
|
|
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }
|
|
log_step() { echo -e "${CYAN}[STEP]${NC} $1"; }
|
|
|
|
# Show main menu
|
|
show_main_menu() {
|
|
clear
|
|
echo -e "${MAGENTA}╔════════════════════════════════════════════════════════════════╗${NC}"
|
|
echo -e "${MAGENTA}║${NC} ${BLUE}HMAC File Server 3.2 'Tremora del Terra'${NC} ${MAGENTA}║${NC}"
|
|
echo -e "${MAGENTA}║${NC} ${CYAN}Universal Installation Manager${NC} ${MAGENTA}║${NC}"
|
|
echo -e "${MAGENTA}╚════════════════════════════════════════════════════════════════╝${NC}"
|
|
echo ""
|
|
echo -e "${YELLOW}Choose your deployment method:${NC}"
|
|
echo ""
|
|
echo -e " ${GREEN}1)${NC} ${BLUE}Native SystemD Service${NC} - Traditional Linux service installation"
|
|
echo -e " ${GREEN}2)${NC} ${BLUE}Docker Deployment${NC} - Container with docker-compose"
|
|
echo -e " ${GREEN}3)${NC} ${BLUE}Podman Deployment${NC} - Rootless container deployment"
|
|
echo -e " ${GREEN}4)${NC} ${BLUE}Debian Package${NC} - Build and install .deb package"
|
|
echo -e " ${GREEN}5)${NC} ${BLUE}Multi-Architecture${NC} - Build for multiple platforms"
|
|
echo ""
|
|
echo -e " ${GREEN}6)${NC} ${YELLOW}Test All Methods${NC} - Validate all installation methods"
|
|
echo -e " ${GREEN}7)${NC} ${YELLOW}Validate Configuration${NC} - Check existing installations"
|
|
echo ""
|
|
echo -e " ${GREEN}0)${NC} Exit"
|
|
echo ""
|
|
}
|
|
|
|
# Detect system capabilities
|
|
detect_system() {
|
|
log_step "Detecting system capabilities..."
|
|
|
|
# Check OS
|
|
if [ -f /etc/os-release ]; then
|
|
. /etc/os-release
|
|
OS_NAME="$NAME"
|
|
OS_VERSION="$VERSION"
|
|
log_info "Operating System: $OS_NAME $OS_VERSION"
|
|
fi
|
|
|
|
# Check systemd
|
|
if systemctl --version >/dev/null 2>&1; then
|
|
SYSTEMD_AVAILABLE=true
|
|
log_success "SystemD available"
|
|
else
|
|
SYSTEMD_AVAILABLE=false
|
|
log_warning "SystemD not available"
|
|
fi
|
|
|
|
# Check Docker
|
|
if command -v docker >/dev/null 2>&1; then
|
|
DOCKER_AVAILABLE=true
|
|
DOCKER_VERSION=$(docker --version 2>/dev/null || echo "Unknown")
|
|
log_success "Docker available: $DOCKER_VERSION"
|
|
else
|
|
DOCKER_AVAILABLE=false
|
|
log_warning "Docker not available"
|
|
fi
|
|
|
|
# Check Podman
|
|
if command -v podman >/dev/null 2>&1; then
|
|
PODMAN_AVAILABLE=true
|
|
PODMAN_VERSION=$(podman --version 2>/dev/null || echo "Unknown")
|
|
log_success "Podman available: $PODMAN_VERSION"
|
|
else
|
|
PODMAN_AVAILABLE=false
|
|
log_warning "Podman not available"
|
|
fi
|
|
|
|
# Check Go
|
|
if command -v go >/dev/null 2>&1; then
|
|
GO_AVAILABLE=true
|
|
GO_VERSION=$(go version 2>/dev/null || echo "Unknown")
|
|
log_success "Go available: $GO_VERSION"
|
|
else
|
|
GO_AVAILABLE=false
|
|
log_warning "Go not available"
|
|
fi
|
|
|
|
# Check architecture
|
|
ARCH=$(uname -m)
|
|
log_info "Architecture: $ARCH"
|
|
|
|
echo ""
|
|
}
|
|
|
|
# Validate installation method availability
|
|
validate_method() {
|
|
local method=$1
|
|
|
|
case $method in
|
|
"systemd")
|
|
if [ "$SYSTEMD_AVAILABLE" != "true" ]; then
|
|
log_error "SystemD not available on this system"
|
|
return 1
|
|
fi
|
|
;;
|
|
"docker")
|
|
if [ "$DOCKER_AVAILABLE" != "true" ]; then
|
|
log_error "Docker not available on this system"
|
|
return 1
|
|
fi
|
|
;;
|
|
"podman")
|
|
if [ "$PODMAN_AVAILABLE" != "true" ]; then
|
|
log_error "Podman not available on this system"
|
|
return 1
|
|
fi
|
|
;;
|
|
"debian"|"multi-arch")
|
|
if [ "$GO_AVAILABLE" != "true" ]; then
|
|
log_error "Go compiler not available for building"
|
|
return 1
|
|
fi
|
|
;;
|
|
esac
|
|
return 0
|
|
}
|
|
|
|
# Install method: SystemD
|
|
install_systemd() {
|
|
log_step "Installing HMAC File Server with SystemD..."
|
|
|
|
if [ ! -f "./installer.sh" ]; then
|
|
log_error "installer.sh not found in current directory"
|
|
return 1
|
|
fi
|
|
|
|
# Run the main installer in native mode
|
|
log_info "Running native installation..."
|
|
echo "1" | sudo ./installer.sh
|
|
|
|
# Validate installation
|
|
validate_systemd_installation
|
|
}
|
|
|
|
# Install method: Docker
|
|
install_docker() {
|
|
log_step "Installing HMAC File Server with Docker..."
|
|
|
|
if [ ! -f "./installer.sh" ]; then
|
|
log_error "installer.sh not found in current directory"
|
|
return 1
|
|
fi
|
|
|
|
# Run the main installer in Docker mode
|
|
log_info "Running Docker installation..."
|
|
echo "2" | sudo ./installer.sh
|
|
|
|
# Validate installation
|
|
validate_docker_installation
|
|
}
|
|
|
|
# Install method: Podman
|
|
install_podman() {
|
|
log_step "Installing HMAC File Server with Podman..."
|
|
|
|
# Check for deployment scripts (prefer simple version for testing)
|
|
if [ -f "./dockerenv/podman/deploy-podman-simple.sh" ]; then
|
|
podman_script="./dockerenv/podman/deploy-podman-simple.sh"
|
|
elif [ -f "./dockerenv/podman/deploy-podman.sh" ]; then
|
|
podman_script="./dockerenv/podman/deploy-podman.sh"
|
|
else
|
|
log_error "No Podman deployment script found"
|
|
return 1
|
|
fi
|
|
|
|
# Make sure script is executable
|
|
chmod +x "$podman_script"
|
|
|
|
# Run Podman deployment
|
|
log_info "Running Podman deployment..."
|
|
cd dockerenv/podman
|
|
|
|
if [[ "$podman_script" == *"simple"* ]]; then
|
|
# Use simple script for testing
|
|
./deploy-podman-simple.sh test || {
|
|
log_warning "Podman simple deployment test completed with warnings"
|
|
}
|
|
else
|
|
# Use full script with automated answers
|
|
echo "y" | ./deploy-podman.sh || {
|
|
log_warning "Podman deployment encountered issues (may be normal for testing)"
|
|
}
|
|
fi
|
|
|
|
cd ../..
|
|
return 0
|
|
}
|
|
|
|
# Install method: Debian Package
|
|
install_debian() {
|
|
log_step "Building and installing Debian package..."
|
|
|
|
if [ ! -f "./builddebian.sh" ]; then
|
|
log_error "builddebian.sh not found in current directory"
|
|
return 1
|
|
fi
|
|
|
|
# Check Go dependency
|
|
if ! command -v go >/dev/null 2>&1; then
|
|
log_warning "Go not available - Debian build may use pre-built binary"
|
|
fi
|
|
|
|
# Build Debian package
|
|
log_info "Building Debian package..."
|
|
sudo ./builddebian.sh || {
|
|
log_warning "Debian build encountered issues (may be expected if already installed)"
|
|
return 0
|
|
}
|
|
|
|
# Validate installation
|
|
validate_debian_installation
|
|
}
|
|
|
|
# Install method: Multi-Architecture
|
|
install_multiarch() {
|
|
log_step "Building multi-architecture binaries..."
|
|
|
|
if [ ! -f "./build-multi-arch.sh" ]; then
|
|
log_error "build-multi-arch.sh not found in current directory"
|
|
return 1
|
|
fi
|
|
|
|
# Build multi-arch binaries - automatically choose option 1 (current platform)
|
|
log_info "Building for multiple architectures..."
|
|
echo "1" | ./build-multi-arch.sh || {
|
|
log_warning "Multi-arch build encountered issues"
|
|
return 1
|
|
}
|
|
|
|
# Validate builds
|
|
validate_multiarch_build
|
|
}
|
|
|
|
# Validation functions
|
|
validate_systemd_installation() {
|
|
log_step "Validating SystemD installation..."
|
|
|
|
# Check service file
|
|
if [ -f "/etc/systemd/system/hmac-file-server.service" ]; then
|
|
log_success "Service file exists"
|
|
else
|
|
log_error "Service file not found"
|
|
return 1
|
|
fi
|
|
|
|
# Check binary
|
|
if [ -f "/opt/hmac-file-server/hmac-file-server" ]; then
|
|
log_success "Binary installed"
|
|
else
|
|
log_error "Binary not found"
|
|
return 1
|
|
fi
|
|
|
|
# Check configuration
|
|
if [ -f "/opt/hmac-file-server/config.toml" ]; then
|
|
log_success "Configuration file exists"
|
|
# Validate configuration
|
|
if sudo -u hmac-file-server /opt/hmac-file-server/hmac-file-server -config /opt/hmac-file-server/config.toml --validate-config >/dev/null 2>&1; then
|
|
log_success "Configuration validation passed"
|
|
else
|
|
log_warning "Configuration has warnings"
|
|
fi
|
|
else
|
|
log_error "Configuration file not found"
|
|
return 1
|
|
fi
|
|
|
|
# Check service status
|
|
if systemctl is-enabled hmac-file-server.service >/dev/null 2>&1; then
|
|
log_success "Service is enabled"
|
|
else
|
|
log_warning "Service not enabled"
|
|
fi
|
|
|
|
log_success "SystemD installation validated successfully"
|
|
}
|
|
|
|
validate_docker_installation() {
|
|
log_info "Validating Docker installation..."
|
|
|
|
# Check if Docker Compose file exists
|
|
if [ ! -f "dockerenv/docker-compose.yml" ]; then
|
|
log_error "Docker Compose file not found"
|
|
return 1
|
|
fi
|
|
|
|
# Check if Dockerfile exists
|
|
if [ ! -f "dockerenv/dockerbuild/Dockerfile" ]; then
|
|
log_error "Dockerfile not found"
|
|
return 1
|
|
fi
|
|
|
|
# Check if configuration directory exists
|
|
if [ ! -d "dockerenv/config" ]; then
|
|
log_warning "Docker config directory not found, creating..."
|
|
mkdir -p dockerenv/config
|
|
fi
|
|
|
|
# Check if configuration file exists
|
|
if [ ! -f "dockerenv/config/config.toml" ]; then
|
|
log_warning "Docker configuration file not found, creating..."
|
|
# Create basic Docker configuration
|
|
cat > dockerenv/config/config.toml << 'EOF'
|
|
[server]
|
|
listen_address = "8080"
|
|
storage_path = "/opt/hmac-file-server/data/uploads"
|
|
max_upload_size = "10GB"
|
|
|
|
[security]
|
|
secret = "CHANGE-THIS-SECRET-KEY-MINIMUM-32-CHARACTERS"
|
|
|
|
[uploads]
|
|
allowedextensions = [".txt", ".pdf", ".jpg", ".jpeg", ".png", ".gif", ".zip", ".tar", ".gz"]
|
|
maxfilesize = "100MB"
|
|
chunkeduploadsenabled = true
|
|
networkevents = true
|
|
|
|
[logging]
|
|
level = "INFO"
|
|
file = "/opt/hmac-file-server/data/logs/hmac-file-server.log"
|
|
EOF
|
|
fi
|
|
|
|
# Check if image exists or can be built
|
|
if ! docker images | grep -q hmac-file-server; then
|
|
log_info "Docker image not found, testing build..."
|
|
if docker build -t hmac-file-server:latest -f dockerenv/dockerbuild/Dockerfile . >/dev/null 2>&1; then
|
|
log_success "Docker image can be built successfully"
|
|
else
|
|
log_error "Failed to build Docker image"
|
|
return 1
|
|
fi
|
|
else
|
|
log_success "Docker image exists"
|
|
fi
|
|
|
|
# Check if container is running
|
|
if docker ps | grep -q hmac-file-server; then
|
|
log_success "Docker container is running"
|
|
else
|
|
log_info "Docker container not running (normal for testing)"
|
|
fi
|
|
|
|
log_success "Docker installation validated"
|
|
return 0
|
|
}
|
|
|
|
validate_podman_installation() {
|
|
log_step "Validating Podman installation..."
|
|
|
|
# Check if Podman deployment scripts exist
|
|
scripts_found=0
|
|
for script in "./dockerenv/podman/deploy-podman-simple.sh" "./dockerenv/podman/deploy-podman.sh"; do
|
|
if [ -f "$script" ]; then
|
|
log_success "Podman deployment script found: $script"
|
|
((scripts_found++))
|
|
fi
|
|
done
|
|
|
|
if [ $scripts_found -eq 0 ]; then
|
|
log_error "No Podman deployment scripts found"
|
|
return 1
|
|
fi
|
|
|
|
# Check if Podman Dockerfile exists
|
|
if [ ! -f "./dockerenv/podman/Dockerfile.podman" ]; then
|
|
log_error "Podman Dockerfile not found"
|
|
return 1
|
|
fi
|
|
|
|
# Check if Podman containers exist
|
|
if podman ps -a --format "{{.Names}}" | grep -q "hmac-file-server" 2>/dev/null; then
|
|
log_success "Podman container exists"
|
|
else
|
|
log_info "Podman container not found (normal for testing)"
|
|
fi
|
|
|
|
# Check configuration locations
|
|
config_found=false
|
|
for config_path in "/opt/podman/hmac-file-server/config/config.toml" "./dockerenv/podman/config.toml.example"; do
|
|
if [ -f "$config_path" ]; then
|
|
log_success "Podman configuration found: $config_path"
|
|
config_found=true
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [ "$config_found" = false ]; then
|
|
log_info "Podman configuration will be created during deployment"
|
|
fi
|
|
|
|
# Check if Podman image exists or can be built
|
|
if podman images | grep -q hmac-file-server 2>/dev/null; then
|
|
log_success "Podman image exists"
|
|
else
|
|
log_info "Podman image not found (will be built during deployment)"
|
|
fi
|
|
|
|
log_success "Podman installation validated"
|
|
}
|
|
|
|
validate_debian_installation() {
|
|
log_step "Validating Debian package installation..."
|
|
|
|
# Check if package is installed
|
|
if dpkg -l | grep -q "hmac-file-server" 2>/dev/null; then
|
|
log_success "Debian package installed"
|
|
else
|
|
log_warning "Debian package not installed"
|
|
fi
|
|
|
|
# Check service
|
|
if systemctl status hmac-file-server.service >/dev/null 2>&1; then
|
|
log_success "Service running via Debian package"
|
|
else
|
|
log_warning "Service not running"
|
|
fi
|
|
|
|
log_success "Debian installation validated"
|
|
}
|
|
|
|
validate_multiarch_build() {
|
|
log_step "Validating multi-architecture builds..."
|
|
|
|
# Check if build directory exists
|
|
if [ -d "./builds" ]; then
|
|
log_success "Build directory exists"
|
|
|
|
# Count builds
|
|
BUILD_COUNT=$(find ./builds -name "hmac-file-server-*" -type f 2>/dev/null | wc -l)
|
|
if [ "$BUILD_COUNT" -gt 0 ]; then
|
|
log_success "Found $BUILD_COUNT architecture builds"
|
|
else
|
|
log_warning "No architecture builds found"
|
|
fi
|
|
else
|
|
log_warning "Build directory not found"
|
|
fi
|
|
|
|
log_success "Multi-architecture validation completed"
|
|
}
|
|
|
|
# Test all installation methods
|
|
test_all_methods() {
|
|
log_step "Testing all available installation methods..."
|
|
|
|
local failed_methods=()
|
|
|
|
for method in "${METHODS[@]}"; do
|
|
if validate_method "$method"; then
|
|
log_info "Testing $method method..."
|
|
|
|
# Create test directory
|
|
TEST_DIR="/tmp/hmac-test-$method"
|
|
mkdir -p "$TEST_DIR"
|
|
|
|
case $method in
|
|
"systemd")
|
|
if install_systemd; then
|
|
log_success "$method installation test passed"
|
|
else
|
|
log_error "$method installation test failed"
|
|
failed_methods+=("$method")
|
|
fi
|
|
;;
|
|
"docker")
|
|
if install_docker; then
|
|
log_success "$method installation test passed"
|
|
else
|
|
log_error "$method installation test failed"
|
|
failed_methods+=("$method")
|
|
fi
|
|
;;
|
|
"podman")
|
|
if install_podman; then
|
|
log_success "$method installation test passed"
|
|
else
|
|
log_error "$method installation test failed"
|
|
failed_methods+=("$method")
|
|
fi
|
|
;;
|
|
"debian")
|
|
if install_debian; then
|
|
log_success "$method installation test passed"
|
|
else
|
|
log_error "$method installation test failed"
|
|
failed_methods+=("$method")
|
|
fi
|
|
;;
|
|
"multi-arch")
|
|
if install_multiarch; then
|
|
log_success "$method installation test passed"
|
|
else
|
|
log_error "$method installation test failed"
|
|
failed_methods+=("$method")
|
|
fi
|
|
;;
|
|
esac
|
|
else
|
|
log_warning "Skipping $method (not available on this system)"
|
|
fi
|
|
done
|
|
|
|
# Summary
|
|
echo ""
|
|
log_step "Test Summary:"
|
|
if [ ${#failed_methods[@]} -eq 0 ]; then
|
|
log_success "All available installation methods passed!"
|
|
else
|
|
log_error "Failed methods: ${failed_methods[*]}"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Validate existing installations
|
|
validate_all_installations() {
|
|
log_step "Validating all existing installations..."
|
|
|
|
# Check SystemD
|
|
if systemctl list-unit-files | grep -q "hmac-file-server.service"; then
|
|
log_info "Found SystemD installation"
|
|
validate_systemd_installation
|
|
fi
|
|
|
|
# Check Docker
|
|
if [ -d "./hmac-docker" ]; then
|
|
log_info "Found Docker installation"
|
|
validate_docker_installation
|
|
fi
|
|
|
|
# Check Podman
|
|
if podman ps -a --format "{{.Names}}" | grep -q "hmac-file-server" 2>/dev/null; then
|
|
log_info "Found Podman installation"
|
|
validate_podman_installation
|
|
fi
|
|
|
|
# Check Debian package
|
|
if dpkg -l | grep -q "hmac-file-server" 2>/dev/null; then
|
|
log_info "Found Debian package installation"
|
|
validate_debian_installation
|
|
fi
|
|
|
|
log_success "Validation completed"
|
|
}
|
|
|
|
# Main execution
|
|
main() {
|
|
# Parse command line arguments
|
|
while [[ $# -gt 0 ]]; do
|
|
case $1 in
|
|
--test)
|
|
TEST_MODE=true
|
|
shift
|
|
;;
|
|
--validate)
|
|
VALIDATE_ONLY=true
|
|
shift
|
|
;;
|
|
--help)
|
|
echo "HMAC File Server Universal Installation Manager"
|
|
echo ""
|
|
echo "Usage: $0 [options]"
|
|
echo ""
|
|
echo "Options:"
|
|
echo " --test Test all installation methods"
|
|
echo " --validate Validate existing installations"
|
|
echo " --help Show this help"
|
|
exit 0
|
|
;;
|
|
*)
|
|
log_error "Unknown option: $1"
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Detect system first
|
|
detect_system
|
|
|
|
# Handle special modes
|
|
if [ "$TEST_MODE" = true ]; then
|
|
test_all_methods
|
|
exit $?
|
|
fi
|
|
|
|
if [ "$VALIDATE_ONLY" = true ]; then
|
|
validate_all_installations
|
|
exit $?
|
|
fi
|
|
|
|
# Interactive mode
|
|
while true; do
|
|
show_main_menu
|
|
read -p "Enter your choice [0-7]: " choice
|
|
|
|
case $choice in
|
|
1)
|
|
if validate_method "systemd"; then
|
|
install_systemd
|
|
read -p "Press Enter to continue..."
|
|
fi
|
|
;;
|
|
2)
|
|
if validate_method "docker"; then
|
|
install_docker
|
|
read -p "Press Enter to continue..."
|
|
fi
|
|
;;
|
|
3)
|
|
if validate_method "podman"; then
|
|
install_podman
|
|
read -p "Press Enter to continue..."
|
|
fi
|
|
;;
|
|
4)
|
|
if validate_method "debian"; then
|
|
install_debian
|
|
read -p "Press Enter to continue..."
|
|
fi
|
|
;;
|
|
5)
|
|
if validate_method "multi-arch"; then
|
|
install_multiarch
|
|
read -p "Press Enter to continue..."
|
|
fi
|
|
;;
|
|
6)
|
|
test_all_methods
|
|
read -p "Press Enter to continue..."
|
|
;;
|
|
7)
|
|
validate_all_installations
|
|
read -p "Press Enter to continue..."
|
|
;;
|
|
0)
|
|
log_info "Goodbye!"
|
|
exit 0
|
|
;;
|
|
*)
|
|
log_error "Invalid choice. Please try again."
|
|
sleep 2
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
# Run main function
|
|
main "$@"
|