FIX (dependencies): Run extra dependencies via go mod tidy

FEATURE (readme): Move badges under the description [skip-release]

.github/workflows/ci-release.yml

@@ -3,6 +3,8 @@ name: CI and Release
 on:
   push:
     branches: [main]
+  pull_request:
+    branches: [main]
   workflow_dispatch:
 
 jobs:
@@ -23,7 +25,7 @@ jobs:
           path: |
             ~/go/pkg/mod
             ~/.cache/go-build
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          key: ${{ runner.os }}-go-${{ hashFiles('backend/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-go-
 
@@ -80,10 +82,108 @@ jobs:
           cd frontend
           npm run lint
 
+  test-backend:
+    runs-on: ubuntu-latest
+    needs: [lint-backend]
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.23.3"
+
+      - name: Cache Go modules
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('backend/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Create .env file for testing
+        run: |
+          cd backend
+          cat > .env << EOF
+          # docker-compose.yml
+          DEV_DB_NAME=postgresus
+          DEV_DB_USERNAME=postgres
+          DEV_DB_PASSWORD=Q1234567
+          #app
+          ENV_MODE=development
+          # db
+          DATABASE_DSN=host=localhost user=postgres password=Q1234567 dbname=postgresus port=5437 sslmode=disable
+          DATABASE_URL=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
+          # migrations
+          GOOSE_DRIVER=postgres
+          GOOSE_DBSTRING=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
+          GOOSE_MIGRATION_DIR=./migrations
+          # testing
+          # to get Google Drive env variables: add storage in UI and copy data from added storage here 
+          TEST_GOOGLE_DRIVE_CLIENT_ID=${{ secrets.TEST_GOOGLE_DRIVE_CLIENT_ID }}
+          TEST_GOOGLE_DRIVE_CLIENT_SECRET=${{ secrets.TEST_GOOGLE_DRIVE_CLIENT_SECRET }}
+          TEST_GOOGLE_DRIVE_TOKEN_JSON=${{ secrets.TEST_GOOGLE_DRIVE_TOKEN_JSON }}
+          # testing DBs
+          TEST_POSTGRES_13_PORT=5001
+          TEST_POSTGRES_14_PORT=5002
+          TEST_POSTGRES_15_PORT=5003
+          TEST_POSTGRES_16_PORT=5004
+          TEST_POSTGRES_17_PORT=5005
+          # testing S3
+          TEST_MINIO_PORT=9000
+          TEST_MINIO_CONSOLE_PORT=9001
+          EOF
+
+      - name: Start test containers
+        run: |
+          cd backend
+          docker compose -f docker-compose.yml.example up -d
+
+      - name: Wait for containers to be ready
+        run: |
+          # Wait for main dev database
+          timeout 60 bash -c 'until docker exec dev-db pg_isready -h localhost -p 5437 -U postgres; do sleep 2; done'
+
+          # Wait for test databases
+          timeout 60 bash -c 'until nc -z localhost 5001; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5002; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5003; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5004; do sleep 2; done'
+          timeout 60 bash -c 'until nc -z localhost 5005; do sleep 2; done'
+
+          # Wait for MinIO
+          timeout 60 bash -c 'until nc -z localhost 9000; do sleep 2; done'
+
+      - name: Install PostgreSQL client tools
+        run: |
+          chmod +x backend/tools/download_linux.sh
+          cd backend/tools
+          ./download_linux.sh
+
+      - name: Run database migrations
+        run: |
+          cd backend
+          go install github.com/pressly/goose/v3/cmd/goose@latest
+          goose up
+
+      - name: Run Go tests
+        run: |
+          cd backend
+          go test ./internal/...
+
+      - name: Stop test containers
+        if: always()
+        run: |
+          cd backend
+          docker compose -f docker-compose.yml.example down -v
+
   determine-version:
     runs-on: ubuntu-latest
-    needs: [lint-backend, lint-frontend]
-    if: ${{ !contains(github.event.head_commit.message, '[skip-release]') }}
+    needs: [test-backend, lint-frontend]
+    if: ${{ github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, '[skip-release]') }}
     outputs:
       should_release: ${{ steps.version_bump.outputs.should_release }}
       new_version: ${{ steps.version_bump.outputs.new_version }}
@@ -175,8 +275,8 @@ jobs:
 
   build-only:
     runs-on: ubuntu-latest
-    needs: [lint-backend, lint-frontend]
-    if: ${{ contains(github.event.head_commit.message, '[skip-release]') }}
+    needs: [test-backend, lint-frontend]
+    if: ${{ github.ref == 'refs/heads/main' && contains(github.event.head_commit.message, '[skip-release]') }}
     steps:
       - name: Check out code
         uses: actions/checkout@v4
@@ -236,16 +336,6 @@ jobs:
             rostislavdugin/postgresus:v${{ needs.determine-version.outputs.new_version }}
             rostislavdugin/postgresus:${{ github.sha }}
 
-      - name: Update Docker Hub description
-        uses: peter-evans/dockerhub-description@v4
-        continue-on-error: true
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-          repository: rostislavdugin/postgresus
-          short-description: "Free PostgreSQL monitoring & backup solution with multi-storage support"
-          readme-filepath: ./README.md
-
   release:
     runs-on: ubuntu-latest
     needs: [determine-version, build-and-push]

CHANGELOG.md

@@ -1,10 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-<!-- This file is automatically updated by the release workflow -->

Dockerfile

@@ -53,18 +53,23 @@ RUN CGO_ENABLED=0 \
 # ========= RUNTIME =========
 FROM --platform=$TARGETPLATFORM debian:bookworm-slim
 
-# Install PostgreSQL client tools (versions 13-17)
+# Install PostgreSQL server and client tools (versions 13-17)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-       wget ca-certificates gnupg lsb-release && \
+       wget ca-certificates gnupg lsb-release sudo gosu && \
     wget -qO- https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add - && \
     echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" \
       > /etc/apt/sources.list.d/pgdg.list && \
     apt-get update && \
     apt-get install -y --no-install-recommends \
-       postgresql-client-13 postgresql-client-14 postgresql-client-15 \
+       postgresql-17 postgresql-client-13 postgresql-client-14 postgresql-client-15 \
        postgresql-client-16 postgresql-client-17 && \
     rm -rf /var/lib/apt/lists/*
 
+# Create postgres user and set up directories
+RUN useradd -m -s /bin/bash postgres || true && \
+    mkdir -p /postgresus-data/pgdata && \
+    chown -R postgres:postgres /postgresus-data/pgdata
+
 WORKDIR /app
 
 # Copy Goose from build stage
@@ -87,7 +92,71 @@ RUN if [ ! -f /app/.env ]; then \
       fi; \
     fi
 
+# Create startup script
+COPY <<EOF /app/start.sh
+#!/bin/bash
+set -e
+
+# PostgreSQL 17 binary paths
+PG_BIN="/usr/lib/postgresql/17/bin"
+
+# Ensure proper ownership of data directory
+echo "Setting up data directory permissions..."
+mkdir -p /postgresus-data/pgdata
+chown -R postgres:postgres /postgresus-data
+
+# Initialize PostgreSQL if not already initialized
+if [ ! -s "/postgresus-data/pgdata/PG_VERSION" ]; then
+    echo "Initializing PostgreSQL database..."
+    gosu postgres \$PG_BIN/initdb -D /postgresus-data/pgdata --encoding=UTF8 --locale=C.UTF-8
+    
+    # Configure PostgreSQL
+    echo "host all all 127.0.0.1/32 md5" >> /postgresus-data/pgdata/pg_hba.conf
+    echo "local all all trust" >> /postgresus-data/pgdata/pg_hba.conf
+    echo "port = 5437" >> /postgresus-data/pgdata/postgresql.conf
+    echo "listen_addresses = 'localhost'" >> /postgresus-data/pgdata/postgresql.conf
+    echo "shared_buffers = 256MB" >> /postgresus-data/pgdata/postgresql.conf
+    echo "max_connections = 100" >> /postgresus-data/pgdata/postgresql.conf
+fi
+
+# Start PostgreSQL in background
+echo "Starting PostgreSQL..."
+gosu postgres \$PG_BIN/postgres -D /postgresus-data/pgdata -p 5437 &
+POSTGRES_PID=\$!
+
+# Wait for PostgreSQL to be ready
+echo "Waiting for PostgreSQL to be ready..."
+for i in {1..30}; do
+    if gosu postgres \$PG_BIN/pg_isready -p 5437 -h localhost >/dev/null 2>&1; then
+        echo "PostgreSQL is ready!"
+        break
+    fi
+    if [ \$i -eq 30 ]; then
+        echo "PostgreSQL failed to start"
+        exit 1
+    fi
+    sleep 1
+done
+
+# Create database and set password for postgres user
+echo "Setting up database and user..."
+gosu postgres \$PG_BIN/psql -p 5437 -h localhost -d postgres << 'SQL'
+ALTER USER postgres WITH PASSWORD 'Q1234567';
+CREATE DATABASE "postgresus" OWNER postgres;
+\q
+SQL
+
+# Start the main application
+echo "Starting Postgresus application..."
+exec ./main
+EOF
+
+RUN chmod +x /app/start.sh
+
 EXPOSE 4005
 
-ENTRYPOINT ["./main"]
+# Volume for PostgreSQL data
+VOLUME ["/postgresus-data"]
+
+ENTRYPOINT ["/app/start.sh"]
 CMD []

README.md

@@ -1,9 +1,18 @@
 <div align="center">
-  <img src="assets/logo.svg" alt="Postgresus Logo" width="250"/>
-  
+  <img src="assets/logo.svg" style="margin-bottom: 20px;" alt="Postgresus Logo" width="250"/>
+
   <h3>PostgreSQL monitoring and backup</h3>
   <p>Free, open source and self-hosted solution for automated PostgreSQL monitoring and backups. With multiple storage options and notifications</p>
   
+  <!-- Badges -->
+  [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+  [![Docker Pulls](https://img.shields.io/docker/pulls/rostislavdugin/postgresus?color=brightgreen)](https://hub.docker.com/r/rostislavdugin/postgresus)
+  [![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/RostislavDugin/postgresus)
+  
+  [![PostgreSQL](https://img.shields.io/badge/PostgreSQL-13%20%7C%2014%20%7C%2015%20%7C%2016%20%7C%2017-336791?logo=postgresql&logoColor=white)](https://www.postgresql.org/)
+  [![Self Hosted](https://img.shields.io/badge/self--hosted-yes-brightgreen)](https://github.com/RostislavDugin/postgresus)
+  [![Open Source](https://img.shields.io/badge/open%20source-❤️-red)](https://github.com/RostislavDugin/postgresus)
+  
   <p>
     <a href="#-features">Features</a> •
     <a href="#-installation">Installation</a> •
@@ -55,21 +64,29 @@
 - **Historical data**: View trends and patterns over time
 - **Alert system**: Get notified when issues are detected
 
+### 📦 Installation
+
+You have three ways to install Postgresus:
+
+- Script (recommended)
+- Simple Docker run
+- Docker Compose setup
+
 <img src="assets/healthchecks.svg" alt="Postgresus Dashboard" width="800"/>
 
 ---
 
 ## 📦 Installation
 
-You have two ways to install Postgresus: via automated script (recommended) or manual Docker Compose setup.
+You have three ways to install Postgresus: automated script (recommended), simple Docker run, or Docker Compose setup.
 
 ### Option 1: Automated Installation Script (Recommended, Linux only)
 
 The installation script will:
 
-- ✅ Install Docker with Docker Compose (if not already installed)
-- ✅ Create optimized `docker-compose.yml` configuration
-- ✅ Set up automatic startup on system reboot via cron
+- ✅ Install Docker with Docker Compose(if not already installed)
+- ✅ Set up Postgresus
+- ✅ Configure automatic startup on system reboot
 
 ```bash
 sudo apt-get install -y curl && \
@@ -77,7 +94,26 @@ sudo curl -sSL https://raw.githubusercontent.com/RostislavDugin/postgresus/refs/
 | sudo bash
 ```
 
-### Option 2: Manual Docker Compose Setup
+### Option 2: Simple Docker Run
+
+The easiest way to run Postgresus with embedded PostgreSQL:
+
+```bash
+docker run -d \
+  --name postgresus \
+  -p 4005:4005 \
+  -v ./postgresus-data:/postgresus-data \
+  --restart unless-stopped \
+  rostislavdugin/postgresus:latest
+```
+
+This single command will:
+
+- ✅ Start Postgresus
+- ✅ Store all data in `./postgresus-data` directory
+- ✅ Automatically restart on system reboot
+
+### Option 3: Docker Compose Setup
 
 Create a `docker-compose.yml` file with the following configuration:
 
@@ -92,29 +128,6 @@ services:
       - "4005:4005"
     volumes:
       - ./postgresus-data:/postgresus-data
-    depends_on:
-      postgresus-db:
-        condition: service_healthy
-    restart: unless-stopped
-
-  postgresus-db:
-    container_name: postgresus-db
-    image: postgres:17
-    # we use default values, but do not expose
-    # PostgreSQL ports so it is safe
-    environment:
-      - POSTGRES_DB=postgresus
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=Q1234567
-    volumes:
-      - ./pgdata:/var/lib/postgresql/data
-    command: -p 5437
-    shm_size: 10gb
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d postgresus -p 5437"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
     restart: unless-stopped
 ```
 

backend/.env.production.example

@@ -5,9 +5,9 @@ DEV_DB_PASSWORD=Q1234567
 #app
 ENV_MODE=production
 # db
-DATABASE_DSN=host=postgresus-db user=postgres password=Q1234567 dbname=postgresus port=5437 sslmode=disable
-DATABASE_URL=postgres://postgres:Q1234567@postgresus-db:5437/postgresus?sslmode=disable
+DATABASE_DSN=host=localhost user=postgres password=Q1234567 dbname=postgresus port=5437 sslmode=disable
+DATABASE_URL=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
 # migrations
 GOOSE_DRIVER=postgres
-GOOSE_DBSTRING=postgres://postgres:Q1234567@postgresus-db:5437/postgresus?sslmode=disable
+GOOSE_DBSTRING=postgres://postgres:Q1234567@localhost:5437/postgresus?sslmode=disable
 GOOSE_MIGRATION_DIR=./migrations

backend/.pre-commit-config.yaml

@@ -1,15 +0,0 @@
-repos:
-  - repo: local
-    hooks:
-      - id: golangci-lint-fmt
-        name: Format Go Code using golangci-lint fmt
-        entry: golangci-lint fmt ./...
-        language: system
-        types: [go]
-
-      - id: golangci-lint-run
-        name: Run golangci-lint for static analysis
-        entry: golangci-lint run
-        language: system
-        types: [go]
-        pass_filenames: false

backend/cmd/main.go

@@ -31,6 +31,7 @@ import (
 	_ "postgresus-backend/swagger" // swagger docs
 
 	"github.com/gin-contrib/cors"
+	"github.com/gin-contrib/gzip"
 	"github.com/gin-gonic/gin"
 	swaggerFiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
@@ -61,6 +62,15 @@ func main() {
 	gin.SetMode(gin.ReleaseMode)
 	ginApp := gin.Default()
 
+	// Add GZIP compression middleware
+	ginApp.Use(gzip.Gzip(
+		gzip.DefaultCompression,
+		// Don't compress already compressed files
+		gzip.WithExcludedExtensions(
+			[]string{".png", ".gif", ".jpeg", ".jpg", ".ico", ".svg", ".pdf", ".mp4"},
+		),
+	))
+
 	enableCors(ginApp)
 	setUpRoutes(ginApp)
 	setUpDependencies()

backend/go.mod

@@ -4,6 +4,7 @@ go 1.23.3
 
 require (
 	github.com/gin-contrib/cors v1.7.5
+	github.com/gin-contrib/gzip v1.2.3
 	github.com/gin-gonic/gin v1.10.0
 	github.com/golang-jwt/jwt/v4 v4.5.2
 	github.com/google/uuid v1.6.0
@@ -19,6 +20,7 @@ require (
 	github.com/swaggo/gin-swagger v1.6.0
 	github.com/swaggo/swag v1.16.4
 	golang.org/x/crypto v0.39.0
+	golang.org/x/time v0.12.0
 	gorm.io/driver/postgres v1.5.11
 	gorm.io/gorm v1.26.1
 )

backend/go.sum

@@ -37,8 +37,8 @@ github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBv
 github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
 github.com/gin-contrib/cors v1.7.5 h1:cXC9SmofOrRg0w9PigwGlHG3ztswH6bqq4vJVXnvYMk=
 github.com/gin-contrib/cors v1.7.5/go.mod h1:4q3yi7xBEDDWKapjT2o1V7mScKDDr8k+jZ0fSquGoy0=
-github.com/gin-contrib/gzip v0.0.6 h1:NjcunTcGAj5CO1gn4N8jHOSIeRFHIbn51z6K+xaN4d4=
-github.com/gin-contrib/gzip v0.0.6/go.mod h1:QOJlmV2xmayAjkNS2Y8NQsMneuRShOU/kjovCXNuzzk=
+github.com/gin-contrib/gzip v1.2.3 h1:dAhT722RuEG330ce2agAs75z7yB+NKvX/ZM1r8w0u2U=
+github.com/gin-contrib/gzip v1.2.3/go.mod h1:ad72i4Bzmaypk8M762gNXa2wkxxjbz0icRNnuLJ9a/c=
 github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
 github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
@@ -252,6 +252,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
 golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go

@@ -255,10 +255,10 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(
 		copyResultCh <- err
 	}()
 
-	// Wait for the dump and copy to finish
-	waitErr := cmd.Wait()
+	// Wait for the copy to finish first, then the dump process
 	copyErr := <-copyResultCh
 	bytesWritten := <-bytesWrittenCh
+	waitErr := cmd.Wait()
 
 	// Check for shutdown before finalizing
 	if config.IsShouldShutdown() {

backend/internal/features/healthcheck/attempt/check_pg_health_uc.go

@@ -224,7 +224,7 @@ func (uc *CheckPgHealthUseCase) sendDbStatusNotification(
 	messageBody := ""
 
 	if newHealthStatus == databases.HealthStatusAvailable {
-		messageTitle = fmt.Sprintf("✅ [%s] DB is back online", database.Name)
+		messageTitle = fmt.Sprintf("✅ [%s] DB is online", database.Name)
 		messageBody = fmt.Sprintf("✅ [%s] DB is back online", database.Name)
 	} else {
 		messageTitle = fmt.Sprintf("❌ [%s] DB is unavailable", database.Name)

backend/internal/features/healthcheck/attempt/check_pg_health_uc_test.go

@@ -303,7 +303,7 @@ func Test_CheckPgHealthUseCase(t *testing.T) {
 			t,
 			"SendNotification",
 			mock.Anything,
-			fmt.Sprintf("✅ [%s] DB is back online", database.Name),
+			fmt.Sprintf("✅ [%s] DB is online", database.Name),
 			fmt.Sprintf("✅ [%s] DB is back online", database.Name),
 		)
 	})

backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go

@@ -222,11 +222,8 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
 		return "", nil, fmt.Errorf("failed to write backup to temporary file: %w", err)
 	}
 
-	// Close the temp file to ensure all data is written
-	if err := tempFile.Close(); err != nil {
-		cleanupFunc()
-		return "", nil, fmt.Errorf("failed to close temporary backup file: %w", err)
-	}
+	// Close the temp file to ensure all data is written - this is handled by defer
+	// Removing explicit close to avoid double-close error
 
 	uc.logger.Info("Backup file written to temporary location", "tempFile", tempBackupFile)
 	return tempBackupFile, cleanupFunc, nil

backend/internal/features/storages/models/local/model.go

@@ -62,8 +62,8 @@ func (l *LocalStorage) SaveFile(logger *slog.Logger, fileID uuid.UUID, file io.R
 		return fmt.Errorf("failed to sync temp file: %w", err)
 	}
 
-	err = tempFile.Close()
-	if err != nil {
+	// Close the temp file explicitly before moving it (required on Windows)
+	if err = tempFile.Close(); err != nil {
 		logger.Error("Failed to close temp file", "fileId", fileID.String(), "error", err)
 		return fmt.Errorf("failed to close temp file: %w", err)
 	}

backend/internal/features/tests/postgresql_backup_restore_test.go

@@ -222,10 +222,14 @@ func verifyDataIntegrity(t *testing.T, originalDB *sqlx.DB, restoredDB *sqlx.DB)
 	assert.NoError(t, err)
 
 	assert.Equal(t, len(originalData), len(restoredData), "Should have same number of rows")
-	for i := range originalData {
-		assert.Equal(t, originalData[i].ID, restoredData[i].ID, "ID should match")
-		assert.Equal(t, originalData[i].Name, restoredData[i].Name, "Name should match")
-		assert.Equal(t, originalData[i].Value, restoredData[i].Value, "Value should match")
+
+	// Only compare data if both slices have elements (to avoid panic)
+	if len(originalData) > 0 && len(restoredData) > 0 {
+		for i := range originalData {
+			assert.Equal(t, originalData[i].ID, restoredData[i].ID, "ID should match")
+			assert.Equal(t, originalData[i].Name, restoredData[i].Name, "Name should match")
+			assert.Equal(t, originalData[i].Value, restoredData[i].Value, "Value should match")
+		}
 	}
 }
 

backend/internal/features/users/controller.go

@@ -4,10 +4,12 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"golang.org/x/time/rate"
 )
 
 type UserController struct {
-	userService *UserService
+	userService   *UserService
+	signinLimiter *rate.Limiter
 }
 
 func (c *UserController) RegisterRoutes(router *gin.RouterGroup) {
@@ -51,8 +53,18 @@ func (c *UserController) SignUp(ctx *gin.Context) {
 // @Param request body SignInRequest true "User signin data"
 // @Success 200 {object} SignInResponse
 // @Failure 400
+// @Failure 429 {object} map[string]string "Rate limit exceeded"
 // @Router /users/signin [post]
 func (c *UserController) SignIn(ctx *gin.Context) {
+	// We use rate limiter to prevent brute force attacks
+	if !c.signinLimiter.Allow() {
+		ctx.JSON(
+			http.StatusTooManyRequests,
+			gin.H{"error": "Rate limit exceeded. Please try again later."},
+		)
+		return
+	}
+
 	var request SignInRequest
 	if err := ctx.ShouldBindJSON(&request); err != nil {
 		ctx.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request format"})

backend/internal/features/users/di.go

@@ -2,6 +2,8 @@ package users
 
 import (
 	user_repositories "postgresus-backend/internal/features/users/repositories"
+
+	"golang.org/x/time/rate"
 )
 
 var secretKeyRepository = &user_repositories.SecretKeyRepository{}
@@ -12,6 +14,7 @@ var userService = &UserService{
 }
 var userController = &UserController{
 	userService,
+	rate.NewLimiter(rate.Limit(3), 3), // 3 RPS with burst of 3
 }
 
 func GetUserService() *UserService {

backend/tools/download_linux.sh

@@ -2,6 +2,9 @@
 
 set -e  # Exit on any error
 
+# Ensure non-interactive mode for apt
+export DEBIAN_FRONTEND=noninteractive
+
 echo "Installing PostgreSQL client tools versions 13-17 for Linux (Debian/Ubuntu)..."
 echo
 
@@ -30,18 +33,18 @@ echo
 
 # Add PostgreSQL official APT repository
 echo "Adding PostgreSQL official APT repository..."
-$SUDO apt-get update -qq
-$SUDO apt-get install -y wget ca-certificates
+$SUDO apt-get update -qq -y
+$SUDO apt-get install -y -qq wget ca-certificates
 
 # Add GPG key
-wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | $SUDO apt-key add -
+wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | $SUDO apt-key add - 2>/dev/null
 
 # Add repository
-echo "deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main" | $SUDO tee /etc/apt/sources.list.d/pgdg.list
+echo "deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main" | $SUDO tee /etc/apt/sources.list.d/pgdg.list >/dev/null
 
 # Update package list
 echo "Updating package list..."
-$SUDO apt-get update -qq
+$SUDO apt-get update -qq -y
 
 # Install client tools for each version
 versions="13 14 15 16 17"
@@ -50,35 +53,34 @@ for version in $versions; do
     echo "Installing PostgreSQL $version client tools..."
     
     # Install client tools only
-    $SUDO apt-get install -y postgresql-client-$version
+    $SUDO apt-get install -y -qq postgresql-client-$version
     
     # Create version-specific directory and symlinks
     version_dir="$POSTGRES_DIR/postgresql-$version"
     mkdir -p "$version_dir/bin"
     
-    # Create symlinks to the installed binaries
-    if [ -f "/usr/bin/pg_dump" ]; then
-        # If multiple versions, binaries are usually named with version suffix
-        if [ -f "/usr/bin/pg_dump-$version" ]; then
-            ln -sf "/usr/bin/pg_dump-$version" "$version_dir/bin/pg_dump"
-            ln -sf "/usr/bin/pg_dumpall-$version" "$version_dir/bin/pg_dumpall"
-            ln -sf "/usr/bin/psql-$version" "$version_dir/bin/psql"
-            ln -sf "/usr/bin/pg_restore-$version" "$version_dir/bin/pg_restore"
-            ln -sf "/usr/bin/createdb-$version" "$version_dir/bin/createdb"
-            ln -sf "/usr/bin/dropdb-$version" "$version_dir/bin/dropdb"
-        else
-            # Fallback to non-versioned names (latest version)
-            ln -sf "/usr/bin/pg_dump" "$version_dir/bin/pg_dump"
-            ln -sf "/usr/bin/pg_dumpall" "$version_dir/bin/pg_dumpall"
-            ln -sf "/usr/bin/psql" "$version_dir/bin/psql"
-            ln -sf "/usr/bin/pg_restore" "$version_dir/bin/pg_restore"
-            ln -sf "/usr/bin/createdb" "$version_dir/bin/createdb"
-            ln -sf "/usr/bin/dropdb" "$version_dir/bin/dropdb"
-        fi
+    # On Debian/Ubuntu, PostgreSQL binaries are located in /usr/lib/postgresql/{version}/bin/
+    pg_bin_dir="/usr/lib/postgresql/$version/bin"
+    
+    if [ -d "$pg_bin_dir" ] && [ -f "$pg_bin_dir/pg_dump" ]; then
+        # Create symlinks to the version-specific binaries
+        ln -sf "$pg_bin_dir/pg_dump" "$version_dir/bin/pg_dump"
+        ln -sf "$pg_bin_dir/pg_dumpall" "$version_dir/bin/pg_dumpall"
+        ln -sf "$pg_bin_dir/psql" "$version_dir/bin/psql"
+        ln -sf "$pg_bin_dir/pg_restore" "$version_dir/bin/pg_restore"
+        ln -sf "$pg_bin_dir/createdb" "$version_dir/bin/createdb"
+        ln -sf "$pg_bin_dir/dropdb" "$version_dir/bin/dropdb"
         
         echo "PostgreSQL $version client tools installed successfully"
     else
-        echo "Warning: PostgreSQL $version client tools may not have installed correctly"
+        echo "Error: PostgreSQL $version binaries not found in expected location: $pg_bin_dir"
+        echo "Available PostgreSQL directories:"
+        ls -la /usr/lib/postgresql/ 2>/dev/null || echo "No PostgreSQL directories found in /usr/lib/postgresql/"
+        if [ -d "$pg_bin_dir" ]; then
+            echo "Contents of $pg_bin_dir:"
+            ls -la "$pg_bin_dir" 2>/dev/null || echo "Directory exists but cannot list contents"
+        fi
+        exit 1
     fi
     echo
 done
@@ -93,6 +95,9 @@ for version in $versions; do
     version_dir="$POSTGRES_DIR/postgresql-$version"
     if [ -f "$version_dir/bin/pg_dump" ]; then
         echo "  postgresql-$version: $version_dir/bin/"
+        # Verify the correct version
+        version_output=$("$version_dir/bin/pg_dump" --version 2>/dev/null | grep -o "pg_dump (PostgreSQL) [0-9]\+\.[0-9]\+")
+        echo "    Version check: $version_output"
     fi
 done
 

backend/tools/readme.md

@@ -1,4 +1,4 @@
-This directory is needed only for development.
+This directory is needed only for development and CI\CD.
 
 We have to download and install all the PostgreSQL versions from 13 to 17 locally.
 This is needed so we can call pg_dump, pg_dumpall, etc. on each version of the PostgreSQL database.

contribute/README.md

@@ -86,17 +86,14 @@ Notifications flow:
 
 Extra:
 
-- add tests running on each PR (in progress by Rostislav Dugin)
-- add prettier labels to GitHub README
-- create pretty website like rybbit.io with demo
 - add HTTPS for Postgresus
 - add simple SQL queries via UI
-- add brute force protection on auth (via local RPS limiter)
 - add support of Kubernetes Helm
+- create pretty website like rybbit.io with demo
 
 Monitoring flow:
 
-- add system metrics (CPU, RAM, disk, IO)
+- add system metrics (CPU, RAM, disk, IO) (in progress by Rostislav Dugin)
 - add queries stats (slowest, most frequent, etc. via pg_stat_statements)
 - add alerting for slow queries (listen for slow query and if they reach >100ms - send message)
 - add alerting for high resource usage (listen for high resource usage and if they reach >90% - send message)

docker-compose.yml.example

@@ -16,27 +16,4 @@ services:
     volumes:
       - ./postgresus-data:/postgresus-data
     container_name: postgresus-local
-    depends_on:
-      postgresus-db:
-        condition: service_healthy
-    restart: unless-stopped
-
-  postgresus-db:
-    image: postgres:17
-    # we use default values, but do not expose
-    # PostgreSQL ports so it is safe
-    environment:
-      - POSTGRES_DB=postgresus
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=Q1234567
-    volumes:
-      - ./pgdata:/var/lib/postgresql/data
-    container_name: postgresus-db
-    command: -p 5437
-    shm_size: 10gb
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d postgresus -p 5437"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-    restart: unless-stopped
+    restart: unless-stopped

frontend/src/features/backups/ui/EditBackupConfigComponent.tsx

@@ -341,7 +341,7 @@ export const EditBackupConfigComponent = ({
 
             <Tooltip
               className="cursor-pointer"
-              title="Number of CPU cores to use for backup processing. Higher values may speed up backups but use more resources."
+              title="Number of CPU cores to use for restore processing. Higher values may speed up restores, but use more resources."
             >
               <InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
             </Tooltip>

install-postgresus.sh

@@ -68,29 +68,6 @@ services:
       - "4005:4005"
     volumes:
       - ./postgresus-data:/postgresus-data
-    depends_on:
-      postgresus-db:
-        condition: service_healthy
-    restart: unless-stopped
-
-  postgresus-db:
-    container_name: postgresus-db
-    image: postgres:17
-    # we use default values, but do not expose
-    # PostgreSQL ports so it is safe
-    environment:
-      - POSTGRES_DB=postgresus
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=Q1234567
-    volumes:
-      - ./pgdata:/var/lib/postgresql/data
-    command: -p 5437
-    shm_size: 10gb
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres -d postgresus -p 5437"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
     restart: unless-stopped
 EOF
 log "docker-compose.yml created successfully"