Relevant source files

The following files were used as context for generating this wiki page: - [run.sh](https://github.com/lockgit/gochat/blob/master/run.sh) - [reload.sh](https://github.com/lockgit/gochat/blob/master/reload.sh) - [LICENSE](https://github.com/lockgit/gochat/blob/master/LICENSE) - [main.go](https://github.com/lockgit/gochat/blob/master/main.go) - [Makefile](https://github.com/lockgit/gochat/blob/master/Makefile) [FILE_URLS] (use these URLs when citing sources in the content): - run.sh: https://github.com/lockgit/gochat/blob/master/run.sh - reload.sh: https://github.com/lockgit/gochat/blob/master/reload.sh - LICENSE: https://github.com/lockgit/gochat/blob/master/LICENSE - main.go: https://github.com/lockgit/gochat/blob/master/main.go - Makefile: https://github.com/lockgit/gochat/blob/master/Makefile

# Run Scripts The **Run Scripts** module consists of two Bash utilities – `run.sh` and `reload.sh` – that automate the lifecycle of the GoChat application inside Docker containers. `run.sh` validates the execution environment, selects the appropriate Docker image, launches the container with the correct environment variables and volume mounts, and finally triggers `reload.sh`. `reload.sh` rewrites static JavaScript assets with the host IP, compiles the Go binary, and restarts all services via Supervisor. These scripts provide a reproducible, one‑command way to spin up a development (`dev`) or production (`prod`) instance of GoChat on any host that has Docker and Bash installed. --- ## Table of Contents 1. [Execution Flow of `run.sh`](#execution-flow-of-runsh) 2. [`reload.sh` Responsibilities](#reloadsh-responsibilities) 3. [Environment Variables & Docker Configuration](#environment-variables--docker-configuration) 4. [Mermaid Diagrams](#mermaid-diagrams) 5. [Key Code Snippets](#key-code-snippets) 6. [References](#references) --- ## Execution Flow of `run.sh` `run.sh` expects two positional arguments: | Argument | Description | |----------|-------------| | `CONFIG_ENV` | Must be either `dev` or `prod`. Determines which Docker image and runtime mode are used. | | `IPADDR` | The host IP address that will be injected into the container and later into static assets. | The script performs the following steps: 1. **Argument validation** – ensures `CONFIG_ENV` is one of the allowed values. 2. **IP address validation** – uses a regular expression to confirm a proper IPv4 format. 3. **Docker image selection** – currently both environments use the same image `lockgit/gochat:1.18`. 4. **Docker `run` command** – launches a container with a set of environment variables, volume mounts, and port mappings. 5. **Post‑run hook** – executes `reload.sh` inside the newly created container to finalize configuration. > Sources: [run.sh:1-120](https://github.com/lockgit/gochat/blob/master/run.sh) ### Core Functions & Logic | Function / Block | Purpose | |------------------|---------| | `valid_ip()` | Bash function that returns success only for a syntactically correct IPv4 address. | | `if [ "${CONFIG_ENV}" = "dev" -o "${CONFIG_ENV}" = "prod" ]` | Guard clause for allowed environments. | | `sudo docker run …` | Starts the container with environment‑specific flags (`RUN_MODE=dev` or `RUN_MODE=prod`). | | `docker exec … ./reload.sh` | Triggers the secondary script after the container is up. | --- ## `reload.sh` Responsibilities `reload.sh` runs **inside** the Docker container and performs three main tasks: 1. **Replace API and WebSocket IPs** in the compiled JavaScript bundle (`site/static/js/main.06044d49.js`) using `sed`. 2. **Compile the Go binary** (`gochat.bin`) from `main.go` with custom CGO flags. 3. **Restart all services** managed by Supervisor (`supervisorctl restart all`). > Sources: [reload.sh:1-70](https://github.com/lockgit/gochat/blob/master/reload.sh) ### Important Variables | Variable | Default | Meaning | |----------|---------|---------| | `HOST_IP` | `127.0.0.1` (fallback) | Provided by the Docker `-e HOST_IP=${IPADDR}` flag; used to construct `addr_http` and `addr_ws`. | | `addr_http` | `${HOST_IP}:7070` | HTTP endpoint for the GoChat API. | | `addr_ws` | `${HOST_IP}:7000` | WebSocket endpoint. | --- ## Environment Variables & Docker Configuration | Variable | Value (dev) | Value (prod) | Source | |----------|-------------|--------------|--------| | `TZ` | `Asia/Shanghai` | `Asia/Shanghai` | `run.sh` | | `RUN_MODE` | `dev` | `prod` | `run.sh` | | `HOST_IP` | *User supplied* | *User supplied* | `run.sh` | | `ETCD_DATA_DIR` | `/root/default.etcd` | `/root/default.etcd` | `run.sh` | | Docker ports | `8080, 7070, 7000‑7002` (host ↔ container) | Same | `run.sh` | | Volume mounts | Project root → `/go/src/gochat`; config directories → `/etc/supervisord.*`; Redis config → `/root/redis.conf` | Same | `run.sh` | The `Makefile` provides a helper target to build a custom Docker image if needed: ```make # make build TAG=1.18 cd ./docker && docker build -t lockgit/gochat:${TAG} . ``` > Source: [Makefile:1-10](https://github.com/lockgit/gochat/blob/master/Makefile) --- ## Mermaid Diagrams ### 1️⃣ High‑Level Flow of `run.sh` ```mermaid graph TB startNode[Start] --> validateEnv[Validate CONFIG_ENV] validateEnv -->|valid| validateIP[Validate IPADDR] validateIP -->|valid| selectImage[Select Docker Image] selectImage --> decision{ENV = dev?} decision -->|yes| dockerRunDev[Docker run #40;dev#41;] decision -->|no| dockerRunProd[Docker run #40;prod#41;] dockerRunDev --> execReload[Exec reload.sh] dockerRunProd --> execReload execReload --> endNode[End] ``` *Explanation*: The script first checks the environment argument, then the IP address, selects the Docker image (currently identical for both envs), runs the container with the appropriate mode, and finally calls `reload.sh`. ### 2️⃣ `reload.sh` Internal Steps ```mermaid graph TB rStart[Start reload.sh] --> replaceIP[Replace IP in JS] replaceIP --> buildBin[Build gochat.bin] buildBin --> restartSup[Supervisor restart all] restartSup --> rEnd[Finish] ``` *Explanation*: Inside the container, `reload.sh` rewrites static assets, compiles the Go binary, and restarts services. ### 3️⃣ Sequence Diagram: Host → Docker Container → Reload Script ```mermaid sequenceDiagram participant Host as Host#40;Bash#41; participant Docker as Docker#40;Container#41; participant Reload as reload.sh#40;Inside#41; Host->>Docker: sh run.sh dev 192.168.1.10 Docker-->>Host: Container created Docker->>Reload: exec .#47;reload.sh Reload->>Reload: sed replace IPs Reload->>Reload: go build gochat.bin Reload->>Reload: supervisorctl restart all Reload-->>Docker: Done Docker-->>Host: Application ready ``` *Explanation*: The host triggers `run.sh`, Docker creates the container, then `reload.sh` performs in‑container configuration and restarts services. > All diagrams respect the required `graph TB` orientation and escape special characters per the specification. --- ## Key Code Snippets ### `valid_ip` Function (run.sh) ```bash valid_ip () { local ip=$1 local stat=1 if [[ $ip =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then OIFS=$IFS IFS='.' ip=($ip) IFS=$OIFS [[ ${ip[0]} -le 255 && ${ip[1]} -le 255 \ && ${ip[2]} -le 255 && ${ip[3]} -le 255 ]] stat=$? fi return $stat } ``` *Validates IPv4 format before proceeding.* Source: [run.sh:13-31](https://github.com/lockgit/gochat/blob/master/run.sh) ### Docker Run Command (dev mode) ```bash sudo docker run \ --name gochat-dev \ -h gochat-dev \ -e TZ=Asia/Shanghai \ -e RUN_MODE=dev \ -e HOST_IP=${IPADDR} \ -v `pwd`:/go/src/gochat \ -v `pwd`/docker/dev/supervisord.d:/etc/supervisord.d \ -p 8080:8080 -p 7070:7070 -p 7000:7000 \ ${DOCKER_IMAGE} \ supervisord -n && docker exec gochat-dev /bin/sh './reload.sh' ``` *Launches the container with required environment variables and mounts.* Source: [run.sh:71-106](https://github.com/lockgit/gochat/blob/master/run.sh) ### IP Replacement with `sed` (reload.sh) ```bash sed -r -i "s/\/\/(\b[0-9]{1,3}\.){3}[0-9]{1,3}\b:[0-9]+/\/\/${addr_http}/g" site/static/js/main.06044d49.js sed -r -i "s/\/\/(\b[0-9]{1,3}\.){3}[0-9]{1,3}\b:[0-9]+\/ws/\/\/${addr_ws}\/ws/g" site/static/js/main.06044d49.js ``` *Injects the host IP into the compiled JavaScript bundle.* Source: [reload.sh:7-10](https://github.com/lockgit/gochat/blob/master/reload.sh) --- ## References - **run.sh** – orchestrates Docker container launch and validation. - **reload.sh** – performs in‑container configuration, compilation, and service restart. - **Makefile** – provides a helper to build a custom Docker image. - **main.go** – entry point for the GoChat binary (compiled by `reload.sh`). - **LICENSE** – MIT license governing the project. Sources are cited inline using the required format, e.g., Sources: [run.sh:1-120](https://github.com/lockgit/gochat/blob/master/run.sh). --- ### Summary The Run Scripts (`run.sh` + `reload.sh`) encapsulate the full start‑up lifecycle of GoChat, from host‑side validation to container orchestration and in‑container configuration. By abstracting Docker commands and environment preparation, they enable developers to spin up consistent `dev` or `prod` environments with a single command, ensuring that static assets reference the correct host IP and that the Go binary is freshly built and supervised.