docker-build-test.sh

#!/bin/bash

# Configuration
IMAGE_NAME="calculator-app"
CONTAINER_NAME="calculator-container"
HOST_PORT="8080"
CONTAINER_PORT="80"

# Docker Hub configuration
# Set your Docker Hub username here, or it will be prompted
DOCKER_HUB_USERNAME="${DOCKER_HUB_USERNAME:-}"
DOCKER_HUB_REPO="calculator-app"
PUBLISH_TO_DOCKERHUB="${PUBLISH_TO_DOCKERHUB:-true}"

# GitHub configuration
PUSH_TO_GITHUB="${PUSH_TO_GITHUB:-true}"

# Ansible configuration
RUN_ANSIBLE="${RUN_ANSIBLE:-true}"
ANSIBLE_PLAYBOOK="deploy.yml"
ANSIBLE_INVENTORY="inventory.ini"

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

echo -e "${YELLOW}=== Docker Build and Test Script ===${NC}\n"

# Check if Docker is installed and available
echo -e "${YELLOW}Checking Docker installation...${NC}"

# Add common Docker paths to PATH if not already there
if [[ "$OSTYPE" == "darwin"* ]]; then
    # macOS - Docker Desktop locations
    export PATH="/usr/local/bin:/opt/homebrew/bin:$PATH"
fi

if ! command -v docker &> /dev/null; then
    echo -e "${RED}Error: Docker is not installed or not in PATH!${NC}"
    if [[ "$OSTYPE" == "darwin"* ]]; then
        echo -e "${YELLOW}Please install Docker Desktop from https://www.docker.com/products/docker-desktop${NC}"
        echo -e "${YELLOW}Make sure Docker Desktop is running before executing this script.${NC}"
    else
        echo -e "${YELLOW}Please install Docker and ensure it's in your PATH.${NC}"
    fi
    exit 1
fi

# Check if Docker daemon is running
if ! docker info &> /dev/null; then
    echo -e "${RED}Error: Docker daemon is not running!${NC}"
    echo -e "${YELLOW}Please start Docker Desktop and try again.${NC}"
    exit 1
fi

DOCKER_VERSION=$(docker --version)
echo -e "${GREEN}✓ Docker is available: $DOCKER_VERSION${NC}\n"

# Step 1: Build the Docker image
echo -e "${YELLOW}Step 1: Building Docker image...${NC}"
docker build -t $IMAGE_NAME .
if [ $? -ne 0 ]; then
    echo -e "${RED}Error: Docker build failed!${NC}"
    exit 1
fi
echo -e "${GREEN}✓ Docker image built successfully${NC}\n"

# Step 2: Stop and remove existing container if it exists
echo -e "${YELLOW}Step 2: Cleaning up existing container (if any)...${NC}"
docker stop $CONTAINER_NAME 2>/dev/null
docker rm $CONTAINER_NAME 2>/dev/null
echo -e "${GREEN}✓ Cleanup complete${NC}\n"

# Step 3: Run the container
echo -e "${YELLOW}Step 3: Running Docker container...${NC}"
docker run -d -p $HOST_PORT:$CONTAINER_PORT --name $CONTAINER_NAME $IMAGE_NAME
if [ $? -ne 0 ]; then
    echo -e "${RED}Error: Failed to run container!${NC}"
    exit 1
fi
echo -e "${GREEN}✓ Container is running on port $HOST_PORT${NC}\n"

# Wait a moment for the container to fully start
echo -e "${YELLOW}Waiting for container to start...${NC}"
sleep 3

# Step 4: Test the container with curl
echo -e "${YELLOW}Step 4: Testing container with curl...${NC}"
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:$HOST_PORT)

if [ $HTTP_CODE -eq 200 ]; then
    echo -e "${GREEN}✓ HTTP Status: $HTTP_CODE (Success)${NC}"
    
    # Also check if the HTML content is returned
    if curl -s http://localhost:$HOST_PORT | grep -q "calculator\|Calculator\|display"; then
        echo -e "${GREEN}✓ HTML content verified${NC}"
    else
        echo -e "${YELLOW}⚠ Warning: HTML content may not be as expected${NC}"
    fi
else
    echo -e "${RED}✗ HTTP Status: $HTTP_CODE (Failed)${NC}"
    echo -e "${YELLOW}Container logs:${NC}"
    docker logs $CONTAINER_NAME
    docker stop $CONTAINER_NAME
    docker rm $CONTAINER_NAME
    exit 1
fi

echo ""

# Step 5: Stop the container
echo -e "${YELLOW}Step 5: Stopping container...${NC}"
docker stop $CONTAINER_NAME
if [ $? -ne 0 ]; then
    echo -e "${RED}Error: Failed to stop container!${NC}"
    exit 1
fi
echo -e "${GREEN}✓ Container stopped${NC}\n"

# Cleanup: Remove the container
echo -e "${YELLOW}Cleaning up: Removing container...${NC}"
docker rm $CONTAINER_NAME
echo -e "${GREEN}✓ Container removed${NC}\n"

# Step 6: Push to GitHub (if enabled)
COMMIT_HASH=""
GITHUB_PUSH_SUCCESS=false

if [ "$PUSH_TO_GITHUB" = "true" ]; then
    echo -e "${YELLOW}Step 6: Pushing to GitHub...${NC}"
    
    # Check if git repository exists
    if [ ! -d .git ]; then
        echo -e "${RED}Error: Not a git repository!${NC}"
        exit 1
    fi
    
    # Check for uncommitted changes
    if ! git diff-index --quiet HEAD -- 2>/dev/null; then
        echo -e "${YELLOW}Warning: You have uncommitted changes.${NC}"
        echo -e "${YELLOW}Do you want to commit them? (y/n)${NC}"
        read -r response
        if [ "$response" = "y" ] || [ "$response" = "Y" ]; then
            echo -e "${YELLOW}Enter commit message (or press Enter for default):${NC}"
            read -r commit_msg
            if [ -z "$commit_msg" ]; then
                commit_msg="Update calculator app"
            fi
            git add .
            git commit -m "$commit_msg"
            if [ $? -ne 0 ]; then
                echo -e "${RED}Error: Failed to commit changes!${NC}"
                exit 1
            fi
            echo -e "${GREEN}✓ Changes committed${NC}\n"
        else
            echo -e "${YELLOW}Skipping commit. Using current HEAD commit hash.${NC}\n"
        fi
    fi
    
    # Get current commit hash before push
    COMMIT_HASH=$(git rev-parse --short HEAD)
    if [ $? -ne 0 ]; then
        echo -e "${RED}Error: Failed to get commit hash!${NC}"
        exit 1
    fi
    echo -e "${GREEN}Current commit hash: $COMMIT_HASH${NC}\n"
    
    # Push to GitHub
    echo -e "${YELLOW}Pushing to GitHub...${NC}"
    git push origin $(git branch --show-current)
    if [ $? -ne 0 ]; then
        echo -e "${RED}Error: Failed to push to GitHub!${NC}"
        echo -e "${RED}Aborting Docker Hub push.${NC}"
        exit 1
    fi
    echo -e "${GREEN}✓ Pushed to GitHub successfully${NC}\n"
    GITHUB_PUSH_SUCCESS=true
    
    # Get the latest commit hash after push (in case a new commit was created)
    COMMIT_HASH=$(git rev-parse --short HEAD)
    echo -e "${GREEN}Using commit hash for Docker tag: $COMMIT_HASH${NC}\n"
else
    # Still get commit hash even if not pushing to GitHub
    if [ -d .git ]; then
        COMMIT_HASH=$(git rev-parse --short HEAD 2>/dev/null)
        if [ $? -eq 0 ]; then
            echo -e "${GREEN}Using commit hash for Docker tag: $COMMIT_HASH${NC}\n"
        else
            COMMIT_HASH="latest"
            echo -e "${YELLOW}Could not get commit hash, using 'latest' as tag${NC}\n"
        fi
    else
        COMMIT_HASH="latest"
        echo -e "${YELLOW}Not a git repository, using 'latest' as tag${NC}\n"
    fi
    # If GitHub push is disabled, we can still proceed to Docker Hub
    GITHUB_PUSH_SUCCESS=true
fi

# Step 7: Publish to Docker Hub (if enabled and GitHub push was successful or skipped)
if [ "$PUBLISH_TO_DOCKERHUB" = "true" ] && [ "$GITHUB_PUSH_SUCCESS" = "true" ]; then
    echo -e "${YELLOW}Step 7: Publishing to Docker Hub...${NC}"
    
    # Get Docker Hub username if not set
    if [ -z "$DOCKER_HUB_USERNAME" ]; then
        echo -e "${YELLOW}Enter your Docker Hub username:${NC}"
        read -r DOCKER_HUB_USERNAME
        if [ -z "$DOCKER_HUB_USERNAME" ]; then
            echo -e "${RED}Error: Docker Hub username is required!${NC}"
            exit 1
        fi
    fi
    
    # Use commit hash as tag, fallback to 'latest' if not available
    if [ -z "$COMMIT_HASH" ]; then
        COMMIT_HASH="latest"
    fi
    
    # Tag the image for Docker Hub using commit hash
    DOCKER_HUB_IMAGE="$DOCKER_HUB_USERNAME/$DOCKER_HUB_REPO:$COMMIT_HASH"
    DOCKER_HUB_IMAGE_LATEST="$DOCKER_HUB_USERNAME/$DOCKER_HUB_REPO:latest"
    
    echo -e "${YELLOW}Tagging image as $DOCKER_HUB_IMAGE...${NC}"
    docker tag $IMAGE_NAME $DOCKER_HUB_IMAGE
    if [ $? -ne 0 ]; then
        echo -e "${RED}Error: Failed to tag image!${NC}"
        exit 1
    fi
    echo -e "${GREEN}✓ Image tagged with commit hash${NC}"
    
    # Also tag as 'latest'
    echo -e "${YELLOW}Tagging image as $DOCKER_HUB_IMAGE_LATEST...${NC}"
    docker tag $IMAGE_NAME $DOCKER_HUB_IMAGE_LATEST
    if [ $? -ne 0 ]; then
        echo -e "${RED}Error: Failed to tag image as latest!${NC}"
        exit 1
    fi
    echo -e "${GREEN}✓ Image tagged as latest${NC}\n"
    
    # Check if already logged in to Docker Hub
    echo -e "${YELLOW}Checking Docker Hub login status...${NC}"
    # Check if Docker config exists and has auth for docker.io
    if [ ! -f ~/.docker/config.json ] || ! grep -q "docker.io" ~/.docker/config.json 2>/dev/null; then
        echo -e "${YELLOW}Please login to Docker Hub:${NC}"
        docker login
        if [ $? -ne 0 ]; then
            echo -e "${RED}Error: Docker Hub login failed!${NC}"
            exit 1
        fi
    else
        echo -e "${GREEN}✓ Already logged in to Docker Hub${NC}\n"
    fi
    
    # Push the image to Docker Hub (both tags)
    echo -e "${YELLOW}Pushing image to Docker Hub...${NC}"
    docker push $DOCKER_HUB_IMAGE
    if [ $? -ne 0 ]; then
        echo -e "${RED}Error: Failed to push image to Docker Hub!${NC}"
        exit 1
    fi
    echo -e "${GREEN}✓ Image pushed with commit hash tag${NC}"
    
    docker push $DOCKER_HUB_IMAGE_LATEST
    if [ $? -ne 0 ]; then
        echo -e "${RED}Error: Failed to push 'latest' tag to Docker Hub!${NC}"
        exit 1
    fi
    echo -e "${GREEN}✓ Image pushed with 'latest' tag${NC}"
    echo -e "${GREEN}  Images:${NC}"
    echo -e "${GREEN}    - $DOCKER_HUB_IMAGE${NC}"
    echo -e "${GREEN}    - $DOCKER_HUB_IMAGE_LATEST${NC}\n"
elif [ "$PUBLISH_TO_DOCKERHUB" = "true" ] && [ "$GITHUB_PUSH_SUCCESS" = "false" ]; then
    echo -e "${RED}Skipping Docker Hub publish: GitHub push failed!${NC}\n"
else
    echo -e "${YELLOW}Skipping Docker Hub publish (PUBLISH_TO_DOCKERHUB=false)${NC}\n"
fi

# Step 8: Run Ansible playbook (if enabled and Docker Hub push was successful)
if [ "$RUN_ANSIBLE" = "true" ] && [ "$PUBLISH_TO_DOCKERHUB" = "true" ] && [ "$GITHUB_PUSH_SUCCESS" = "true" ]; then
    echo -e "${YELLOW}Step 8: Running Ansible playbook...${NC}"
    
    # Check if Ansible is installed
    if ! command -v ansible-playbook &> /dev/null; then
        echo -e "${RED}Error: Ansible is not installed!${NC}"
        echo -e "${YELLOW}Skipping Ansible deployment.${NC}\n"
    else
        # Check if playbook and inventory files exist
        if [ ! -f "$ANSIBLE_PLAYBOOK" ]; then
            echo -e "${RED}Error: Ansible playbook '$ANSIBLE_PLAYBOOK' not found!${NC}"
            exit 1
        fi
        
        if [ ! -f "$ANSIBLE_INVENTORY" ]; then
            echo -e "${RED}Error: Ansible inventory file '$ANSIBLE_INVENTORY' not found!${NC}"
            exit 1
        fi
        
        # Update Docker Hub username in playbook if it was set
        if [ -n "$DOCKER_HUB_USERNAME" ]; then
            echo -e "${YELLOW}Running Ansible playbook with Docker Hub username: $DOCKER_HUB_USERNAME${NC}"
            ansible-playbook -i $ANSIBLE_INVENTORY $ANSIBLE_PLAYBOOK -e "docker_hub_username=$DOCKER_HUB_USERNAME"
        else
            echo -e "${YELLOW}Running Ansible playbook...${NC}"
            ansible-playbook -i $ANSIBLE_INVENTORY $ANSIBLE_PLAYBOOK
        fi
        
        if [ $? -ne 0 ]; then
            echo -e "${RED}Error: Ansible playbook failed!${NC}"
            exit 1
        fi
        echo -e "${GREEN}✓ Ansible deployment completed successfully${NC}\n"
    fi
elif [ "$RUN_ANSIBLE" = "true" ] && [ "$PUBLISH_TO_DOCKERHUB" != "true" ]; then
    echo -e "${YELLOW}Skipping Ansible deployment: Docker Hub push was not performed${NC}\n"
elif [ "$RUN_ANSIBLE" = "true" ] && [ "$GITHUB_PUSH_SUCCESS" = "false" ]; then
    echo -e "${YELLOW}Skipping Ansible deployment: GitHub push failed${NC}\n"
elif [ "$RUN_ANSIBLE" = "false" ]; then
    echo -e "${YELLOW}Skipping Ansible deployment (RUN_ANSIBLE=false)${NC}\n"
fi

echo -e "${GREEN}=== All steps completed successfully! ===${NC}"