diff --git a/Dockerfile b/Dockerfile index 05546cf..b53e49e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1 +1,125 @@ -FROM alpine:3.12 \ No newline at end of file +# FreeTAKServer Docker Container +# Based on the easy_install.sh script from FreeTAKTeam/FreeTAKHub-Installation +# Licensed under the Eclipse Public License 2.0 (EPL-2.0) + +FROM ubuntu:22.04 + +# Set environment variables to prevent interactive prompts +ENV DEBIAN_FRONTEND=noninteractive +ENV NEEDRESTART_SUSPEND=1 +ENV TZ=UTC + +# Set default installation parameters +ENV INSTALL_TYPE=latest +ENV PY3_VER=3.11 +ENV STABLE_FTS_VERSION=2.0.66 +ENV LEGACY_FTS_VERSION=1.9.9.6 +ENV FTS_VENV=/opt/fts.venv +ENV REPO=https://github.com/FreeTAKTeam/FreeTAKHub-Installation.git +ENV BRANCH=main +ENV CFG_RPATH=core/configuration + +# Create application directory +WORKDIR /opt/freetak + +# Update system and install base dependencies +RUN apt-get update -qq && \ + apt-get install -y --no-install-recommends \ + software-properties-common \ + curl \ + wget \ + git \ + python3-pip \ + python3-setuptools \ + python${PY3_VER}-dev \ + python${PY3_VER}-venv \ + libpython${PY3_VER}-dev \ + build-essential \ + libssl-dev \ + libffi-dev \ + libxml2-dev \ + libxslt1-dev \ + libjpeg-dev \ + libpng-dev \ + zlib1g-dev \ + sqlite3 \ + libsqlite3-dev \ + sudo \ + openssh-client \ + ca-certificates \ + gnupg \ + lsb-release && \ + # Add Ansible PPA and install + add-apt-repository -y ppa:ansible/ansible && \ + apt-get update -qq && \ + apt-get install -y --no-install-recommends ansible && \ + # Clean up apt cache + apt-get clean && \ + rm -rf /var/lib/apt/lists/* + +# Get latest FTS version from PyPI +RUN LATEST_FTS_VERSION=$(curl -s https://pypi.org/pypi/FreeTAKServer/json | python3 -c "import sys, json; print(json.load(sys.stdin)['info']['version'])") && \ + echo "export LATEST_FTS_VERSION=${LATEST_FTS_VERSION}" >> /etc/environment + +# Create Python virtual environment and install dependencies +RUN python${PY3_VER} -m venv ${FTS_VENV} && \ + . ${FTS_VENV}/bin/activate && \ + python3 -m pip install --upgrade pip && \ + python3 -m pip install --force-reinstall jinja2 pyyaml psutil + +# Clone FreeTAKHub-Installation repository +RUN git clone --branch ${BRANCH} ${REPO} /opt/FreeTAKHub-Installation + +# Set working directory to the cloned repository +WORKDIR /opt/FreeTAKHub-Installation + +# Create a non-root user for running the application +RUN useradd -m -u 1000 -s /bin/bash freetak && \ + usermod -aG sudo freetak && \ + echo "freetak ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers + +# Generate SSH key pair for the freetak user +RUN mkdir -p /home/freetak/.ssh && \ + ssh-keygen -t rsa -f /home/freetak/.ssh/id_rsa -N "" && \ + chown -R freetak:freetak /home/freetak/.ssh && \ + chmod 700 /home/freetak/.ssh && \ + chmod 600 /home/freetak/.ssh/id_rsa && \ + chmod 644 /home/freetak/.ssh/id_rsa.pub + +# Copy the virtual environment to be accessible by freetak user +RUN chown -R freetak:freetak ${FTS_VENV} + +# Copy the scripts +COPY scripts/install_freetak.sh /opt/install_freetak.sh +COPY scripts/start_freetak.sh /opt/start_freetak.sh +COPY scripts/healthcheck.sh /opt/healthcheck.sh +COPY scripts/entrypoint.sh /opt/entrypoint.sh + +# Make the scripts executable +RUN chmod +x /opt/install_freetak.sh /opt/start_freetak.sh /opt/healthcheck.sh /opt/entrypoint.sh + +# Run the installation +RUN /opt/install_freetak.sh + +# Set proper ownership +RUN chown -R freetak:freetak /opt/FreeTAKHub-Installation /opt/freetak /opt/*.sh + +# Switch to freetak user +USER freetak + +# Set the working directory +WORKDIR /opt/freetak + +# Expose the default FreeTAKServer ports +# 8087 - Main server port +# 8080 - Web UI port +# 8443 - HTTPS port +# 19023 - FTS API port +EXPOSE 8087 8080 8443 19023 + +# Add healthcheck +HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \ + CMD /opt/healthcheck.sh + +# Default command - use the entrypoint script +CMD ["/opt/entrypoint.sh"] \ No newline at end of file diff --git a/Readme.md b/Readme.md index 2904b26..2818566 100644 --- a/Readme.md +++ b/Readme.md @@ -1,36 +1,181 @@ -# README for Docker Image Build and Publish Workflows +# FreeTAKServer Docker Container -## Overview +This Docker container provides a complete FreeTAKServer installation based on the official FreeTAKTeam installation script. It includes all necessary components and dependencies to run FreeTAKServer in a containerized environment. -This repository contains two GitHub Actions workflows that automate the building and publishing of Docker images to an OCI registry. +## Features -### Workflows +- **All-in-one container**: Includes FreeTAKServer, Web UI, and Web Map +- **Multiple installation types**: Support for latest, stable, and legacy versions +- **Automated setup**: Based on the official FreeTAKHub-Installation scripts +- **Health checks**: Built-in container health monitoring +- **Persistent data**: Volume support for configuration and data persistence -1. **On Commit to Main** - - **Trigger:** Activates on commits to the `main` branch (tags are excluded). - - **Purpose:** Builds and publishes a Docker image for each commit. +## Quick Start -2. **On Tag Push** - - **Trigger:** Activates when a new tag is pushed. - - **Purpose:** Builds and publishes a Docker image for the tag and tags it as `latest`. +### Using Docker Compose (Recommended) -## Prerequisites +```bash +# Clone or navigate to the directory containing docker-compose.yml +docker-compose up -d +``` -- **Secrets Needed:** - - `OCI_TOKEN`: Your OCI registry token. - - `OCI_USER`: Your OCI registry username. +### Using the Run Script -## How to Use +```bash +# Build and run with latest version (default) +./run.sh -1. **Clone the Repository:** Get a local copy of this repository. -2. **Modify Dockerfile:** Update the `Dockerfile` for your application. -3. **Push Changes:** Push changes to the `main` branch or create a new tag. -4. **Check Workflow Status:** View the Actions tab in Forgjo to monitor workflow runs. +# Build and run with stable version +./run.sh stable -## Notes +# Build and run with legacy version +./run.sh legacy +``` -- Ensure your Docker environment is compatible with multi-platform builds if necessary. +### Manual Docker Commands + +```bash +# Build the image +docker build -t freetak-server . + +# Run the container +docker run -d \ + --name freetak-server \ + -p 8087:8087 \ + -p 8080:8080 \ + -p 8443:8443 \ + -p 19023:19023 \ + -e INSTALL_TYPE=latest \ + freetak-server +``` + +## Installation Types + +The container supports three installation types via the `INSTALL_TYPE` environment variable: + +- **`latest`** (default): Installs the most recent version from PyPI +- **`stable`**: Installs the stable version (v2.0.66) +- **`legacy`**: Installs the legacy version (v1.9.9.6) with Python 3.8 + +## Exposed Ports + +- **8087**: Main FreeTAKServer port +- **8080**: Web UI port +- **8443**: HTTPS port (if configured) +- **19023**: FTS API port + +## Access Points + +After the container is running, you can access: + +- **Web UI**: http://localhost:8080 +- **Main API**: http://localhost:8087 +- **API Endpoint**: http://localhost:19023 + +## Project Structure + +``` +/docker/services/freetak/ +├── Dockerfile # Main container definition +├── docker-compose.yml # Docker Compose configuration +├── run.sh # Quick start script +├── scripts/ # Container scripts directory +│ ├── install_freetak.sh # Installation script +│ ├── start_freetak.sh # Simple startup script +│ ├── entrypoint.sh # Main entrypoint with signal handling +│ ├── healthcheck.sh # Health check script +│ ├── dev-helper.sh # Development helper script +│ └── README.md # Scripts documentation +└── README.md # This file +``` + +## Configuration + +The container includes: + +- Python virtual environment at `/opt/fts.venv` +- FreeTAKHub-Installation repository at `/opt/FreeTAKHub-Installation` +- Configuration files based on the installation type +- Ansible playbooks for automated setup + +## Environment Variables + +- `INSTALL_TYPE`: Installation type (latest, stable, legacy) +- `TZ`: Timezone (default: UTC) +- `DEBIAN_FRONTEND`: Set to noninteractive for automated installation +- `PY3_VER`: Python version (automatically set based on install type) +- `FTS_VENV`: Virtual environment path +- `CFG_RPATH`: Configuration path (automatically set based on install type) + +## Volumes + +To persist data and configuration: + +```yaml +volumes: + - freetak_data:/opt/freetak/data + - freetak_config:/opt/FreeTAKHub-Installation +``` + +## Health Checks + +The container includes a built-in health check that monitors the FreeTAKServer process: + +```bash +# Check container health +docker ps +# Look for "healthy" status +``` + +## Troubleshooting + +### View Logs + +```bash +docker logs freetak-server +``` + +### Access Container Shell + +```bash +docker exec -it freetak-server /bin/bash +``` + +### Check Service Status + +```bash +docker exec -it freetak-server /opt/healthcheck.sh +``` + +### Restart Container + +```bash +docker restart freetak-server +``` + +## Building from Source + +The Dockerfile is based on Ubuntu 22.04 and includes: + +1. System dependencies (Python, Ansible, Git, etc.) +2. Python virtual environment setup +3. FreeTAKHub-Installation repository clone +4. Ansible playbook execution +5. Service configuration and startup scripts + +## Security Notes + +- The container runs as a non-root user (`freetak`) +- SSH keys are generated for internal use +- All dependencies are installed from official repositories +- The installation follows the official FreeTAKTeam procedures ## License -This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details. \ No newline at end of file +This Docker container is based on the FreeTAKHub-Installation scripts, which are licensed under the Eclipse Public License 2.0 (EPL-2.0). + +## Support + +For issues related to FreeTAKServer itself, please refer to the [FreeTAKTeam GitHub repository](https://github.com/FreeTAKTeam/FreeTAKServer). + +For Docker-specific issues, please check the container logs and ensure all required ports are available. \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..24c3a28 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,36 @@ +version: '3.8' + +services: + freetak: + build: + context: . + dockerfile: Dockerfile + container_name: freetak-server + ports: + - "8087:8087" # Main server port + - "8080:8080" # Web UI port + - "8443:8443" # HTTPS port + - "19023:19023" # FTS API port + environment: + - INSTALL_TYPE=latest # Options: latest, stable, legacy + - TZ=UTC + volumes: + - freetak_data:/opt/freetak/data + - freetak_config:/opt/FreeTAKHub-Installation + restart: unless-stopped + healthcheck: + test: ["CMD", "/opt/healthcheck.sh"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 60s + networks: + - freetak_network + +networks: + freetak_network: + driver: bridge + +volumes: + freetak_data: + freetak_config: diff --git a/run.sh b/run.sh new file mode 100755 index 0000000..278fcf5 --- /dev/null +++ b/run.sh @@ -0,0 +1,44 @@ +#!/bin/bash +# Build and run FreeTAKServer with different installation types + +set -e + +INSTALL_TYPE=${1:-latest} +CONTAINER_NAME="freetak-server" +IMAGE_NAME="freetak-server" + +echo "Building FreeTAKServer Docker image with install type: $INSTALL_TYPE" + +# Stop and remove existing container if it exists +if docker ps -a --format 'table {{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then + echo "Stopping and removing existing container..." + docker stop $CONTAINER_NAME || true + docker rm $CONTAINER_NAME || true +fi + +# Build the Docker image +echo "Building Docker image..." +docker build -t $IMAGE_NAME . + +# Run the container +echo "Starting FreeTAKServer container..." +docker run -d \ + --name $CONTAINER_NAME \ + -p 8087:8087 \ + -p 8080:8080 \ + -p 8443:8443 \ + -p 19023:19023 \ + -e INSTALL_TYPE=$INSTALL_TYPE \ + -e TZ=UTC \ + --restart unless-stopped \ + $IMAGE_NAME + +echo "FreeTAKServer is starting up..." +echo "Web UI will be available at: http://localhost:8080" +echo "Main server API at: http://localhost:8087" +echo "API endpoint at: http://localhost:19023" +echo "" +echo "Use 'docker logs $CONTAINER_NAME' to view the logs" +echo "Use 'docker exec -it $CONTAINER_NAME /bin/bash' to access the container" +echo "" +echo "To stop the container: docker stop $CONTAINER_NAME" diff --git a/scripts/README.md b/scripts/README.md new file mode 100644 index 0000000..cc71914 --- /dev/null +++ b/scripts/README.md @@ -0,0 +1,134 @@ +# FreeTAKServer Docker Scripts + +This directory contains the scripts used by the FreeTAKServer Docker container. These scripts have been extracted from the Dockerfile for better maintainability and easier development. + +## Scripts Overview + +### `install_freetak.sh` +- **Purpose**: Installs FreeTAKServer using Ansible playbooks +- **Usage**: Called during Docker build process +- **Environment Variables**: + - `INSTALL_TYPE`: Installation type (latest, stable, legacy) + - `FTS_VENV`: Path to Python virtual environment + - `STABLE_FTS_VERSION`: Stable version number + - `LEGACY_FTS_VERSION`: Legacy version number + - `CFG_RPATH`: Configuration path + +### `start_freetak.sh` +- **Purpose**: Simple startup script for FreeTAKServer +- **Usage**: Basic container startup (deprecated, use entrypoint.sh) +- **Environment Variables**: + - `FTS_VENV`: Path to Python virtual environment + - `CFG_RPATH`: Configuration path + +### `entrypoint.sh` +- **Purpose**: Main entrypoint script with signal handling and logging +- **Usage**: Default container entrypoint +- **Features**: + - Graceful shutdown handling + - Proper signal forwarding + - Timestamped logging + - Dynamic configuration path detection + - Environment-based configuration + +### `healthcheck.sh` +- **Purpose**: Health check script for Docker container +- **Usage**: Called by Docker healthcheck +- **Functionality**: Checks if FreeTAKServer process is running + +### `dev-helper.sh` +- **Purpose**: Development helper script for validation and testing +- **Usage**: `./scripts/dev-helper.sh [validate|test|info|help]` +- **Features**: + - Script validation + - Syntax checking + - Information display + - Development workflow support + +## Development Workflow + +1. **Validate Scripts**: Ensure all scripts exist and are executable + ```bash + ./scripts/dev-helper.sh validate + ``` + +2. **Test Syntax**: Check all scripts for syntax errors + ```bash + ./scripts/dev-helper.sh test + ``` + +3. **View Information**: Display script information + ```bash + ./scripts/dev-helper.sh info + ``` + +## Script Maintenance + +### Adding New Scripts +1. Create the script in the `scripts/` directory +2. Make it executable: `chmod +x scripts/your-script.sh` +3. Add it to the Dockerfile `COPY` instruction +4. Update the `dev-helper.sh` script to include validation + +### Modifying Existing Scripts +1. Edit the script file directly +2. Test syntax: `./scripts/dev-helper.sh test` +3. Rebuild the Docker image to apply changes + +### Best Practices +- Always include proper error handling (`set -e`) +- Use descriptive variable names +- Add comments for complex logic +- Follow consistent formatting +- Test scripts before committing + +## Environment Variables + +The scripts use these key environment variables: + +- `FTS_VENV`: Python virtual environment path (default: `/opt/fts.venv`) +- `INSTALL_TYPE`: Installation type - `latest`, `stable`, or `legacy` +- `CFG_RPATH`: Configuration path (auto-detected based on install type) +- `STABLE_FTS_VERSION`: Stable version number +- `LEGACY_FTS_VERSION`: Legacy version number + +## Troubleshooting + +### Script Not Executable +```bash +chmod +x scripts/script-name.sh +``` + +### Syntax Errors +```bash +bash -n scripts/script-name.sh +``` + +### Testing Individual Scripts +```bash +# Test in container context +docker run --rm -it freetak-server /bin/bash +# Then run: /opt/script-name.sh +``` + +### Debugging +Add `set -x` at the beginning of scripts to enable debug output. + +## Integration with Dockerfile + +The scripts are copied into the container during build: + +```dockerfile +# Copy the scripts +COPY scripts/install_freetak.sh /opt/install_freetak.sh +COPY scripts/start_freetak.sh /opt/start_freetak.sh +COPY scripts/healthcheck.sh /opt/healthcheck.sh +COPY scripts/entrypoint.sh /opt/entrypoint.sh + +# Make the scripts executable +RUN chmod +x /opt/*.sh +``` + +## License + +These scripts are part of the FreeTAKServer Docker container project and follow the same licensing as the original FreeTAKHub-Installation project (Eclipse Public License 2.0). diff --git a/scripts/dev-helper.sh b/scripts/dev-helper.sh new file mode 100755 index 0000000..88826ae --- /dev/null +++ b/scripts/dev-helper.sh @@ -0,0 +1,160 @@ +#!/bin/bash +# Development helper script for FreeTAKServer Docker container + +set -e + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Function to print colored output +print_status() { + 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" +} + +# Function to check if script exists and is executable +check_script() { + local script_path="$1" + local script_name=$(basename "$script_path") + + if [[ ! -f "$script_path" ]]; then + print_error "Script $script_name not found at $script_path" + return 1 + fi + + if [[ ! -x "$script_path" ]]; then + print_warning "Script $script_name is not executable, fixing..." + chmod +x "$script_path" + fi + + print_success "Script $script_name is ready" + return 0 +} + +# Function to validate scripts +validate_scripts() { + print_status "Validating scripts..." + + local scripts=( + "$PROJECT_DIR/scripts/install_freetak.sh" + "$PROJECT_DIR/scripts/start_freetak.sh" + "$PROJECT_DIR/scripts/healthcheck.sh" + "$PROJECT_DIR/scripts/entrypoint.sh" + ) + + local all_valid=true + + for script in "${scripts[@]}"; do + if ! check_script "$script"; then + all_valid=false + fi + done + + if [[ "$all_valid" == true ]]; then + print_success "All scripts are valid and executable" + else + print_error "Some scripts have issues" + exit 1 + fi +} + +# Function to test script syntax +test_syntax() { + print_status "Testing script syntax..." + + local scripts=( + "$PROJECT_DIR/scripts/install_freetak.sh" + "$PROJECT_DIR/scripts/start_freetak.sh" + "$PROJECT_DIR/scripts/healthcheck.sh" + "$PROJECT_DIR/scripts/entrypoint.sh" + ) + + for script in "${scripts[@]}"; do + local script_name=$(basename "$script") + if bash -n "$script"; then + print_success "Syntax check passed for $script_name" + else + print_error "Syntax check failed for $script_name" + exit 1 + fi + done +} + +# Function to show script information +show_info() { + print_status "FreeTAKServer Docker Scripts Information" + echo + echo "Scripts directory: $PROJECT_DIR/scripts/" + echo + echo "Available scripts:" + echo " install_freetak.sh - Installs FreeTAKServer using Ansible" + echo " start_freetak.sh - Simple startup script" + echo " entrypoint.sh - Main entrypoint with signal handling" + echo " healthcheck.sh - Health check script" + echo + echo "Usage in Dockerfile:" + echo " COPY scripts/ /opt/scripts/" + echo " RUN chmod +x /opt/scripts/*.sh" + echo +} + +# Function to show usage +usage() { + echo "Usage: $0 [COMMAND]" + echo + echo "Commands:" + echo " validate Validate all scripts exist and are executable" + echo " test Test script syntax" + echo " info Show information about scripts" + echo " help Show this help message" + echo + echo "If no command is provided, 'validate' is run by default." +} + +# Main script logic +main() { + case "${1:-validate}" in + validate) + validate_scripts + ;; + test) + validate_scripts + test_syntax + ;; + info) + show_info + ;; + help|--help|-h) + usage + ;; + *) + print_error "Unknown command: $1" + usage + exit 1 + ;; + esac +} + +# Change to project directory +cd "$PROJECT_DIR" + +# Run main function +main "$@" diff --git a/scripts/entrypoint.sh b/scripts/entrypoint.sh new file mode 100755 index 0000000..1f88524 --- /dev/null +++ b/scripts/entrypoint.sh @@ -0,0 +1,68 @@ +#!/bin/bash +set -e + +# Function to log messages with timestamp +log() { + echo "[$(date +'%Y-%m-%d %H:%M:%S')] $1" +} + +# Function to handle signals for graceful shutdown +cleanup() { + log "Received shutdown signal, stopping FreeTAKServer..." + if [ -n "$FTS_PID" ]; then + kill -TERM "$FTS_PID" 2>/dev/null || true + wait "$FTS_PID" 2>/dev/null || true + fi + log "FreeTAKServer stopped" + exit 0 +} + +# Set up signal handlers +trap cleanup SIGTERM SIGINT + +# Source the virtual environment +log "Activating Python virtual environment..." +source ${FTS_VENV}/bin/activate + +# Set up environment variables based on install type +case ${INSTALL_TYPE} in + legacy) + export CFG_RPATH=controllers/configuration + log "Using legacy configuration path: ${CFG_RPATH}" + ;; + *) + export CFG_RPATH=core/configuration + log "Using standard configuration path: ${CFG_RPATH}" + ;; +esac + +# Change to the configuration directory +CONFIG_DIR="/opt/FreeTAKHub-Installation/${CFG_RPATH}" +if [ -d "$CONFIG_DIR" ]; then + log "Changing to configuration directory: $CONFIG_DIR" + cd "$CONFIG_DIR" +else + log "WARNING: Configuration directory not found at $CONFIG_DIR" + log "Attempting to start from FreeTAKHub-Installation root..." + cd /opt/FreeTAKHub-Installation +fi + +# Start FreeTAKServer +log "Starting FreeTAKServer (Install Type: ${INSTALL_TYPE})..." +log "Python version: $(python3 --version)" +log "Working directory: $(pwd)" + +# Start the service in the background to allow signal handling +python3 -m FreeTAKServer.controllers.services.FTS & +FTS_PID=$! + +log "FreeTAKServer started with PID: $FTS_PID" +log "FreeTAKServer is running. Use Ctrl+C to stop." + +# Wait for the background process +wait "$FTS_PID" + +# Deactivate virtual environment +deactivate + +log "FreeTAKServer has stopped" diff --git a/scripts/healthcheck.sh b/scripts/healthcheck.sh new file mode 100755 index 0000000..2ee3b8d --- /dev/null +++ b/scripts/healthcheck.sh @@ -0,0 +1,4 @@ +#!/bin/bash +# Simple healthcheck - check if the FTS process is running +pgrep -f "FreeTAKServer" > /dev/null +exit $? diff --git a/scripts/install_freetak.sh b/scripts/install_freetak.sh new file mode 100755 index 0000000..25af185 --- /dev/null +++ b/scripts/install_freetak.sh @@ -0,0 +1,49 @@ +#!/bin/bash +set -e + +# Source the virtual environment +source ${FTS_VENV}/bin/activate + +# Set up environment variables +export CODENAME=jammy +export INSTALL_TYPE=${INSTALL_TYPE:-latest} +export FTS_VERSION=${STABLE_FTS_VERSION} +export PY3_VER=${PY3_VER} +export CFG_RPATH=${CFG_RPATH} +export FTS_VENV=${FTS_VENV} + +# Determine FTS version based on install type +case ${INSTALL_TYPE} in + latest) + export FTS_VERSION=$(curl -s https://pypi.org/pypi/FreeTAKServer/json | python3 -c "import sys, json; print(json.load(sys.stdin)[\"info\"][\"version\"])" 2>/dev/null || echo "${STABLE_FTS_VERSION}") + ;; + stable) + export FTS_VERSION=${STABLE_FTS_VERSION} + ;; + legacy) + export FTS_VERSION=${LEGACY_FTS_VERSION} + export PY3_VER=3.8 + export CFG_RPATH=controllers/configuration + ;; +esac + +# Set up Ansible variables +env_vars="python3_version=${PY3_VER} codename=${CODENAME} itype=${INSTALL_TYPE}" +env_vars="${env_vars} fts_version=${FTS_VERSION} cfg_rpath=${CFG_RPATH} fts_venv=${FTS_VENV}" +env_vars="${env_vars} webmap_force_install=true" + +# Run Ansible playbook +cd /opt/FreeTAKHub-Installation +echo "Installing FreeTAKServer with the following settings:" +echo " Version: ${FTS_VERSION}" +echo " Python: ${PY3_VER}" +echo " Install Type: ${INSTALL_TYPE}" +echo " Virtual Environment: ${FTS_VENV}" + +ansible-playbook -u root install_all.yml \ + --connection=local \ + --inventory localhost, \ + --extra-vars "${env_vars}" \ + -v + +deactivate diff --git a/scripts/start_freetak.sh b/scripts/start_freetak.sh new file mode 100755 index 0000000..754923c --- /dev/null +++ b/scripts/start_freetak.sh @@ -0,0 +1,14 @@ +#!/bin/bash +set -e + +# Source the virtual environment +source ${FTS_VENV}/bin/activate + +# Change to the configuration directory +cd /opt/FreeTAKHub-Installation/${CFG_RPATH} + +# Start FreeTAKServer +echo "Starting FreeTAKServer..." +python3 -m FreeTAKServer.controllers.services.FTS + +deactivate