This repository contains a Dockerized script to monitor changes in specified directories and automatically commit and push those changes to a git repository.

The script pulls down a repository specified by CLONE_URL and watches the directories listed in SOURCE_PATHS. It periodically checks if those directories differ from the corresponding ones in TARGET_PATHS inside the cloned repo. Any differences found are committed and pushed to the repo.

This allows keeping the repository repository in sync with changes to files/directories on the host machine or on remote instances. It can be useful for centralized logging, version control and backup of important data.

The script is packaged into a Docker image for portability. It can be configured via environment variables passed into docker run. SSH keys can be mounted into the container to enable pushing over SSH.

• Usage
• Configuration
• Usage
  • Running directly
  • Running with Docker Compose
  • Running with Docker
• Example
• Contributing
• License

Configuration of the watcher is done through environment variables. Here are the variables you can set:

Example of configuration variables setup:

  CLONE_URL=https://github.com/my_repository.git \
  SOURCE_PATHS=/home/myapp/logs,/var/logs/nginx \
  TARGET_PATHS=logs,nginx_logs \
  BRANCH_NAME=main \
  SLEEP_TIME=300 \
  SSH_KEY_PATH=/home/foo/.ssh/id_rsa \

Remember to replace these values with your specific setup. Ensure your SOURCE_PATHS and TARGET_PATHS align vertically i.e., each source path is synced to the corresponding target path based on their order in the comma-separated list. For example, in the above case, /home/myapp/logs is synced with logs in the repository root, and /var/logs/nginx is synced with nginx_logs in the repository root.

It is recommended to run the script in a Docker container, as it is much easier to manage its' configuration.

The watcher.sh script can be executed directly from the shell without using Docker. Here's how to use it:

1. Make sure you have all the required dependencies installed: Git, Bash, and SSH (if applicable).

2. Set the necessary environment variables before running the script.

3. Run the script using bash:

   bash watcher.sh

The script will continue running in the background, periodically checking for changes according to the specified sleep time. You can stop the script by pressing Ctrl + C.

Note: If you are using SSH for Git, make sure your SSH key is correctly configured and accessible to the script.

In case you prefer using Docker Compose, here is a sample docker-compose.yml configuration:

version: '3'
services:
  watcher:
    image: ghcr.io/emmorts/watcher:main
    volumes:
      - ./my_dir/one:/mnt/one
      - ./my_dir/two:/mnt/two
      - ./my_dir/three:/mnt/three
      - ~/.ssh/id_rsa:/etc/sshpk/id_rsa:ro
    environment:
      - CLONE_URL=<clone url>
      - SOURCE_PATHS=<source-paths>
      - TARGET_PATHS=<target-paths>
      - BRANCH_NAME=<branch-name>
      - SLEEP_TIME=<sleep-time>
      - SSH_KEY_PATH=<ssh-key-path>

Be aware that the value on the left of each volume entry corresponds to the host directory, and the value on the right corresponds to the respective directory in the Docker container.

To start the services, run:

docker-compose up -d

To start the directory watcher using Docker command-line interface, run:

docker run -d \
  -e CLONE_URL=<clone-url> \
  -e SOURCE_PATHS=<source-paths> \
  -e TARGET_PATHS=<target-paths> \
  -e BRANCH_NAME=<branch-name> \
  -e SLEEP_TIME=<sleep-time> \
  -e SSH_KEY_PATH=<ssh-key-path> \
  -v ./my_dir/one:/mnt/one \
  -v ./my_dir/two:/mnt/two \
  -v ./my_dir/three:/mnt/three \
  -v ~/.ssh/id_rsa:/etc/sshpk/id_rsa \
  ghcr.io/emmorts/watcher:main

Let's take the example of a repository hosted on GitHub which you want to keep in sync with three local directories.

Consider a repository stored at https://github.com/example/important-repo.git on the main branch. This repository contains the directories blog, docs, and .config.

Your source directories on your local machine are /home/example/blog, /home/example/data/docs, /home/example/.config respectively. These directories contain files that frequently change and you want to automatically back up changes to your GitHub repository.

To enable synchronization of these directories, update the environment variables in either in your system, Docker Compose or Docker command as follows:

  [email protected]:example/important-repo.git # Using SSH
  SOURCE_PATHS=/home/example/blog,/home/example/data/docs,/home/example/.config
  TARGET_PATHS=blog,docs,.config
  BRANCH_NAME=main
  SLEEP_TIME=60
  SSH_KEY_PATH=/home/example/.ssh/id_rsa

You can choose to use Docker Compose or Docker command-line interface to run the project. Refer to the Usage section for instructions on how to run the script.

Contributions are welcome! Please feel free to submit a pull request with any improvements or additional features.

This project is licensed under the MIT License.