Add daemon mode for automatic daily backups with Docker support

.env.example

@@ -0,0 +1,7 @@
+# GitHub Personal Access Token (optional but recommended for higher API rate limits)
+# Get one from: https://github.com/settings/tokens
+GITHUB_TOKEN=your_github_token_here
+
+# Comma-separated list of GitHub users/organizations to backup
+# Example: SCHEDULED_USERS=octocat,github,spring-projects
+SCHEDULED_USERS=octocat

Dockerfile

@@ -0,0 +1,34 @@
+# Build stage
+FROM maven:3.9-eclipse-temurin-17 AS build
+WORKDIR /app
+COPY pom.xml .
+COPY src ./src
+RUN mvn clean package -DskipTests
+
+# Runtime stage
+FROM eclipse-temurin:17-jre-alpine
+WORKDIR /app
+
+# Install git (required for cloning repositories)
+RUN apk add --no-cache git
+
+# Copy the built jar from build stage
+COPY --from=build /app/target/gh-backup-1.0.0.jar gh-backup.jar
+
+# Create backup directory
+RUN mkdir -p /backups
+
+# Set default environment variables
+ENV BACKUP_DIRECTORY=/backups
+ENV GITHUB_TOKEN=""
+ENV SCHEDULED_USERS=""
+
+# Expose port for web mode (optional)
+EXPOSE 8080
+
+# Create entrypoint script
+COPY docker-entrypoint.sh /app/
+RUN chmod +x /app/docker-entrypoint.sh
+
+# Default to daemon mode with scheduled backups
+ENTRYPOINT ["/app/docker-entrypoint.sh"]

README.md

@@ -5,6 +5,7 @@ A tool built with Spring Boot to backup public GitHub repositories for specified
 ## Features
 
 - **Web UI** for easy backup management through your browser
+- **Daemon Mode** with Docker support for automatic daily backups
 - Backup all public repositories from one or more GitHub users/organizations
 - Clone new repositories or update existing ones
 - **Interactive mode** for easier management and status viewing
@@ -32,6 +33,71 @@ The executable JAR will be created at `target/gh-backup-1.0.0.jar`
 
 ## Usage
 
+### Daemon Mode with Docker (Automatic Daily Backups)
+
+The easiest way to run automatic daily backups is using Docker. This will spin up a background service that backs up your configured repositories every 24 hours.
+
+#### Quick Start with Docker Compose
+
+1. Create a `.env` file (or copy from `.env.example`):
+```bash
+cp .env.example .env
+```
+
+2. Edit `.env` to configure your backups:
+```bash
+GITHUB_TOKEN=your_github_token_here
+SCHEDULED_USERS=octocat,github,spring-projects
+```
+
+3. Start the daemon service:
+```bash
+docker-compose up -d
+```
+
+The service will:
+- Run the first backup immediately
+- Continue running in the background
+- Automatically backup every 24 hours
+- Persist backups to the `./backups` directory on your host machine
+
+4. View logs:
+```bash
+docker-compose logs -f
+```
+
+5. Stop the service:
+```bash
+docker-compose down
+```
+
+#### Using Docker directly
+
+Build the image:
+```bash
+docker build -t gh-backup .
+```
+
+Run the daemon:
+```bash
+docker run -d \
+  -e GITHUB_TOKEN=your_token \
+  -e SCHEDULED_USERS=octocat,github \
+  -v $(pwd)/backups:/backups \
+  --name gh-backup-daemon \
+  gh-backup
+```
+
+#### Running without Docker
+
+You can also run daemon mode directly with Java:
+```bash
+java -Dspring.profiles.active=daemon \
+     -Dbackup.scheduled.users=octocat,github \
+     -Dbackup.directory=/path/to/backups \
+     -jar target/gh-backup-1.0.0.jar
+```
+
 ### Web UI Mode (Recommended)
 
 Start the web server:

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  gh-backup-daemon:
+    build: .
+    container_name: gh-backup-daemon
+    restart: unless-stopped
+    environment:
+      # Set your GitHub personal access token here for higher API rate limits
+      - GITHUB_TOKEN=${GITHUB_TOKEN:-}
+
+      # Comma-separated list of GitHub users/organizations to backup
+      # Example: SCHEDULED_USERS=octocat,github,spring-projects
+      - SCHEDULED_USERS=${SCHEDULED_USERS:-}
+
+      # Optional: Custom backup directory inside container
+      - BACKUP_DIRECTORY=/backups
+    volumes:
+      # Mount a local directory to persist backups
+      - ./backups:/backups
+    # Keep container running
+    stdin_open: true
+    tty: true

docker-entrypoint.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+set -e
+
+# Build Java command with environment variables
+JAVA_OPTS="-Dspring.profiles.active=daemon"
+JAVA_OPTS="$JAVA_OPTS -Dbackup.directory=\"${BACKUP_DIRECTORY}\""
+
+if [ -n "$SCHEDULED_USERS" ]; then
+    JAVA_OPTS="$JAVA_OPTS -Dbackup.scheduled.users=\"${SCHEDULED_USERS}\""
+fi
+
+# Execute the application
+exec java $JAVA_OPTS -jar gh-backup.jar "$@"

src/main/java/com/github/backup/GhBackupApplication.java

@@ -2,8 +2,10 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @SpringBootApplication
+@EnableScheduling
 public class GhBackupApplication {
 
     public static void main(String[] args) {

src/main/java/com/github/backup/ScheduledBackupService.java

@@ -0,0 +1,87 @@
+package com.github.backup;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+
+import jakarta.annotation.PostConstruct;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Service that runs scheduled backups at configured intervals.
+ * Enabled when backup.mode=daemon.
+ */
+@Service
+@ConditionalOnProperty(name = "backup.mode", havingValue = "daemon")
+public class ScheduledBackupService {
+
+    private static final long BACKUP_INTERVAL_MS = 86400000; // 24 hours in milliseconds
+    private static final int SEPARATOR_LENGTH = 80;
+
+    private final BackupService backupService;
+    private final List<String> scheduledUsers;
+    private final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    public ScheduledBackupService(BackupService backupService,
+                                   @Value("${backup.scheduled.users:}") String scheduledUsersConfig) {
+        this.backupService = backupService;
+        // Parse comma-separated list of users/orgs
+        this.scheduledUsers = scheduledUsersConfig.isBlank() 
+            ? List.of() 
+            : Arrays.stream(scheduledUsersConfig.split(","))
+                .map(String::trim)
+                .filter(s -> !s.isEmpty())
+                .toList();
+    }
+
+    @PostConstruct
+    public void init() {
+        if (scheduledUsers.isEmpty()) {
+            System.out.println("⚠ Warning: No users/organizations configured for scheduled backups.");
+            System.out.println("Set the 'backup.scheduled.users' property with a comma-separated list.");
+            System.out.println("Example: backup.scheduled.users=octocat,github");
+        } else {
+            System.out.println("GitHub Backup Daemon Mode");
+            System.out.println("========================");
+            System.out.println("Scheduled backups enabled for: " + String.join(", ", scheduledUsers));
+            System.out.println("Backup interval: Every 24 hours");
+            System.out.println("First backup will run immediately, then every 24 hours.");
+            System.out.println();
+        }
+    }
+
+    /**
+     * Runs backup for all configured users/organizations.
+     * Executes on startup and then every 24 hours.
+     */
+    @Scheduled(fixedRate = BACKUP_INTERVAL_MS, initialDelay = 0)
+    public void runScheduledBackup() {
+        if (scheduledUsers.isEmpty()) {
+            return;
+        }
+
+        String timestamp = LocalDateTime.now().format(dateTimeFormatter);
+        System.out.println("\n" + "=".repeat(SEPARATOR_LENGTH));
+        System.out.println("Starting scheduled backup at " + timestamp);
+        System.out.println("=".repeat(SEPARATOR_LENGTH));
+
+        for (String userOrOrg : scheduledUsers) {
+            try {
+                backupService.backupUserRepositories(userOrOrg);
+            } catch (IOException e) {
+                System.err.println("Error backing up " + userOrOrg + ": " + e.getMessage());
+            }
+        }
+
+        timestamp = LocalDateTime.now().format(dateTimeFormatter);
+        System.out.println("\n" + "=".repeat(SEPARATOR_LENGTH));
+        System.out.println("Scheduled backup completed at " + timestamp);
+        System.out.println("Next backup will run in 24 hours.");
+        System.out.println("=".repeat(SEPARATOR_LENGTH) + "\n");
+    }
+}

src/main/resources/application-daemon.properties

@@ -0,0 +1,7 @@
+# Daemon mode configuration
+spring.main.web-application-type=none
+backup.mode=daemon
+
+# Comma-separated list of GitHub users/organizations to backup automatically
+# Example: backup.scheduled.users=octocat,github,spring-projects
+backup.scheduled.users=

src/test/java/com/github/backup/ScheduledBackupServiceTest.java

@@ -0,0 +1,104 @@
+package com.github.backup;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class ScheduledBackupServiceTest {
+
+    @Mock
+    private BackupService backupService;
+
+    private ScheduledBackupService scheduledBackupService;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testScheduledBackupService_WithNoUsers() {
+        scheduledBackupService = new ScheduledBackupService(backupService, "");
+
+        // Should not throw exception with empty users list
+        assertDoesNotThrow(() -> scheduledBackupService.runScheduledBackup());
+
+        // Should not call backup service when no users configured
+        verifyNoInteractions(backupService);
+    }
+
+    @Test
+    void testScheduledBackupService_WithSingleUser() throws IOException {
+        scheduledBackupService = new ScheduledBackupService(backupService, "octocat");
+
+        scheduledBackupService.runScheduledBackup();
+
+        // Should call backup service once for the configured user
+        verify(backupService, times(1)).backupUserRepositories("octocat");
+    }
+
+    @Test
+    void testScheduledBackupService_WithMultipleUsers() throws IOException {
+        scheduledBackupService = new ScheduledBackupService(backupService, "octocat,github,spring-projects");
+
+        scheduledBackupService.runScheduledBackup();
+
+        // Should call backup service for each configured user
+        verify(backupService, times(1)).backupUserRepositories("octocat");
+        verify(backupService, times(1)).backupUserRepositories("github");
+        verify(backupService, times(1)).backupUserRepositories("spring-projects");
+    }
+
+    @Test
+    void testScheduledBackupService_WithWhitespace() throws IOException {
+        scheduledBackupService = new ScheduledBackupService(backupService, " octocat , github , spring-projects ");
+
+        scheduledBackupService.runScheduledBackup();
+
+        // Should trim whitespace from user names
+        verify(backupService, times(1)).backupUserRepositories("octocat");
+        verify(backupService, times(1)).backupUserRepositories("github");
+        verify(backupService, times(1)).backupUserRepositories("spring-projects");
+    }
+
+    @Test
+    void testScheduledBackupService_HandlesException() throws IOException {
+        scheduledBackupService = new ScheduledBackupService(backupService, "octocat,github");
+
+        doThrow(new IOException("Test exception")).when(backupService).backupUserRepositories("octocat");
+
+        // Should continue to next user even if one fails
+        assertDoesNotThrow(() -> scheduledBackupService.runScheduledBackup());
+
+        verify(backupService, times(1)).backupUserRepositories("octocat");
+        verify(backupService, times(1)).backupUserRepositories("github");
+    }
+
+    @Test
+    void testScheduledBackupService_WithEmptyStrings() throws IOException {
+        scheduledBackupService = new ScheduledBackupService(backupService, "octocat,,github");
+
+        scheduledBackupService.runScheduledBackup();
+
+        // Should filter out empty strings and only call for valid users
+        verify(backupService, times(1)).backupUserRepositories("octocat");
+        verify(backupService, times(1)).backupUserRepositories("github");
+        verifyNoMoreInteractions(backupService);
+    }
+
+    @Test
+    void testScheduledBackupService_WithBlankString() {
+        scheduledBackupService = new ScheduledBackupService(backupService, "   ");
+
+        assertDoesNotThrow(() -> scheduledBackupService.runScheduledBackup());
+
+        // Should not call backup service with blank configuration
+        verifyNoInteractions(backupService);
+    }
+}