comparing bf1a93fca96a7d38d781aef58fe98e01c9a49d29 and hailey/tidy on hailey.at/cocoon

+2 -10

.github/workflows/docker-image.yml

···

       5
       5
        
         push:

     

       6
       6
        
           branches:

     

       7
       7
        
             - main

     

       8
       8
       -
           tags:

     

       9
       9
       -
             - 'v*'

     

       10
       8
        
       

     

       11
       9
        
       env:

     

       12
       10
        
         REGISTRY: ghcr.io

     
···

       25
       23
        
           steps:

     

       26
       24
        
             - name: Checkout repository

     

       27
       25
        
               uses: actions/checkout@v4

     

       28
       28
       -
       

     

       29
       26
        
             # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.

     

       30
       27
        
             - name: Log in to the Container registry

     

       31
       31
       -
               uses: docker/login-action@v3

     

       28
       28
       +
               uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1

     

       32
       29
        
               with:

     

       33
       30
        
                 registry: ${{ env.REGISTRY }}

     

       34
       31
        
                 username: ${{ github.actor }}

     

       35
       32
        
                 password: ${{ secrets.GITHUB_TOKEN }}

     

       36
       36
       -
       

     

       37
       33
        
             # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.

     

       38
       34
        
             - name: Extract metadata (tags, labels) for Docker

     

       39
       35
        
               id: meta

     
···

       41
       37
        
               with:

     

       42
       38
        
                 images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

     

       43
       39
        
                 tags: |

     

       44
       44
       -
                   type=raw,value=latest,enable={{is_default_branch}}

     

       45
       40
        
                   type=sha

     

       46
       41
        
                   type=sha,format=long

     

       47
       47
       -
                   type=semver,pattern={{version}}

     

       48
       48
       -
                   type=semver,pattern={{major}}.{{minor}}

     

       49
       49
       -
       

     

       50
       42
        
             # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.

     

       51
       43
        
             # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.

     

       52
       44
        
             # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.

     

       53
       45
        
             - name: Build and push Docker image

     

       54
       46
        
               id: push

     

       55
       55
       -
               uses: docker/build-push-action@v6

     

       47
       47
       +
               uses: docker/build-push-action@v5

     

       56
       48
        
               with:

     

       57
       49
        
                 context: .

     

       58
       50
        
                 push: true

-10

Caddyfile.postgres

···

       1
       1
       -
       {$COCOON_HOSTNAME} {

     

       2
       2
       -
       	reverse_proxy cocoon:8080

     

       3
       3
       -
       

     

       4
       4
       -
       	encode gzip

     

       5
       5
       -
       

     

       6
       6
       -
       	log {

     

       7
       7
       -
       		output file /data/access.log

     

       8
       8
       -
       		format json

     

       9
       9
       -
       	}

     

       10
       10
       -
       }

+1 -44

README.md

···

       55
       55
        
          docker-compose up -d

     

       56
       56
        
          ```

     

       57
       57
        
       

     

       58
       58
       -
          **For PostgreSQL deployment:**

     

       59
       59
       -
          ```bash

     

       60
       60
       -
          # Add POSTGRES_PASSWORD to your .env file first!

     

       61
       61
       -
          docker-compose -f docker-compose.postgres.yaml up -d

     

       62
       62
       -
          ```

     

       63
       63
       -
       

     

       64
       58
        
       5. **Get your invite code**

     

       65
       59
        
       

     

       66
       60
        
          On first run, an invite code is automatically created. View it with:

     
···

       102
       96
        
       

     

       103
       97
        
       ### Optional Configuration

     

       104
       98
        
       

     

       105
       105
       -
       #### Database Configuration

     

       106
       106
       -
       

     

       107
       107
       -
       By default, Cocoon uses SQLite which requires no additional setup. For production deployments with higher traffic, you can use PostgreSQL:

     

       108
       108
       -
       

     

       109
       109
       -
       ```bash

     

       110
       110
       -
       # Database type: sqlite (default) or postgres

     

       111
       111
       -
       COCOON_DB_TYPE="postgres"

     

       112
       112
       -
       

     

       113
       113
       -
       # PostgreSQL connection string (required if db-type is postgres)

     

       114
       114
       -
       # Format: postgres://user:password@host:port/database?sslmode=disable

     

       115
       115
       -
       COCOON_DATABASE_URL="postgres://cocoon:password@localhost:5432/cocoon?sslmode=disable"

     

       116
       116
       -
       

     

       117
       117
       -
       # Or use the standard DATABASE_URL environment variable

     

       118
       118
       -
       DATABASE_URL="postgres://cocoon:password@localhost:5432/cocoon?sslmode=disable"

     

       119
       119
       -
       ```

     

       120
       120
       -
       

     

       121
       121
       -
       For SQLite (default):

     

       122
       122
       -
       ```bash

     

       123
       123
       -
       COCOON_DB_TYPE="sqlite"

     

       124
       124
       -
       COCOON_DB_NAME="/data/cocoon/cocoon.db"

     

       125
       125
       -
       ```

     

       126
       126
       -
       

     

       127
       127
       -
       > **Note**: When using PostgreSQL, database backups to S3 are not handled by Cocoon. Use `pg_dump` or your database provider's backup solution instead.

     

       128
       128
       -
       

     

       129
       99
        
       #### SMTP Email Settings

     

       130
       100
        
       ```bash

     

       131
       101
        
       COCOON_SMTP_USER="your-smtp-username"

     
···

       137
       107
        
       ```

     

       138
       108
        
       

     

       139
       109
        
       #### S3 Storage

     

       140
       140
       -
       

     

       141
       141
       -
       Cocoon supports S3-compatible storage for both database backups (SQLite only) and blob storage (images, videos, etc.):

     

       142
       142
       -
       

     

       143
       110
        
       ```bash

     

       144
       144
       -
       # Enable S3 backups (SQLite databases only - hourly backups)

     

       145
       111
        
       COCOON_S3_BACKUPS_ENABLED=true

     

       146
       146
       -
       

     

       147
       147
       -
       # Enable S3 for blob storage (images, videos, etc.)

     

       148
       148
       -
       # When enabled, blobs are stored in S3 instead of the database

     

       149
       112
        
       COCOON_S3_BLOBSTORE_ENABLED=true

     

       150
       150
       -
       

     

       151
       151
       -
       # S3 configuration (works with AWS S3, MinIO, Cloudflare R2, etc.)

     

       152
       113
        
       COCOON_S3_REGION="us-east-1"

     

       153
       114
        
       COCOON_S3_BUCKET="your-bucket"

     

       154
       115
        
       COCOON_S3_ENDPOINT="https://s3.amazonaws.com"

     

       155
       116
        
       COCOON_S3_ACCESS_KEY="your-access-key"

     

       156
       117
        
       COCOON_S3_SECRET_KEY="your-secret-key"

     

       157
       118
        
       ```

     

       158
       158
       -
       

     

       159
       159
       -
       **Blob Storage Options:**

     

       160
       160
       -
       - `COCOON_S3_BLOBSTORE_ENABLED=false` (default): Blobs stored in the database

     

       161
       161
       -
       - `COCOON_S3_BLOBSTORE_ENABLED=true`: Blobs stored in S3 bucket under `blobs/{did}/{cid}`

     

       162
       119
        
       

     

       163
       120
        
       ### Management Commands

     

       164
       121
        
       

     
···

       203
       160
        
       - [x] `com.atproto.repo.getRecord`

     

       204
       161
        
       - [x] `com.atproto.repo.importRepo` (Works "okay". Use with extreme caution.)

     

       205
       162
        
       - [x] `com.atproto.repo.listRecords`

     

       206
       206
       -
       - [x] `com.atproto.repo.listMissingBlobs` (Not actually functional, but will return a response as if no blobs were missing)

     

       163
       163
       +
       - [ ] `com.atproto.repo.listMissingBlobs`

     

       207
       164
        
       

     

       208
       165
        
       ### Server

     

       209
       166

+1 -36

cmd/cocoon/main.go

···

       17
       17
        
       	"github.com/lestrrat-go/jwx/v2/jwk"

     

       18
       18
        
       	"github.com/urfave/cli/v2"

     

       19
       19
        
       	"golang.org/x/crypto/bcrypt"

     

       20
       20
       -
       	"gorm.io/driver/postgres"

     

       21
       20
        
       	"gorm.io/driver/sqlite"

     

       22
       21
        
       	"gorm.io/gorm"

     

       23
       22
        
       )

     
···

       38
       37
        
       				Name:    "db-name",

     

       39
       38
        
       				Value:   "cocoon.db",

     

       40
       39
        
       				EnvVars: []string{"COCOON_DB_NAME"},

     

       41
       41
       -
       			},

     

       42
       42
       -
       			&cli.StringFlag{

     

       43
       43
       -
       				Name:    "db-type",

     

       44
       44
       -
       				Value:   "sqlite",

     

       45
       45
       -
       				Usage:   "Database type: sqlite or postgres",

     

       46
       46
       -
       				EnvVars: []string{"COCOON_DB_TYPE"},

     

       47
       47
       -
       			},

     

       48
       48
       -
       			&cli.StringFlag{

     

       49
       49
       -
       				Name:    "database-url",

     

       50
       50
       -
       				Usage:   "PostgreSQL connection string (required if db-type is postgres)",

     

       51
       51
       -
       				EnvVars: []string{"COCOON_DATABASE_URL", "DATABASE_URL"},

     

       52
       40
        
       			},

     

       53
       41
        
       			&cli.StringFlag{

     

       54
       42
        
       				Name:    "did",

     
···

       169
       157
        
       		s, err := server.New(&server.Args{

     

       170
       158
        
       			Addr:            cmd.String("addr"),

     

       171
       159
        
       			DbName:          cmd.String("db-name"),

     

       172
       172
       -
       			DbType:          cmd.String("db-type"),

     

       173
       173
       -
       			DatabaseURL:     cmd.String("database-url"),

     

       174
       160
        
       			Did:             cmd.String("did"),

     

       175
       161
        
       			Hostname:        cmd.String("hostname"),

     

       176
       162
        
       			RotationKeyPath: cmd.String("rotation-key-path"),

     
···

       360
       346
        
       }

     

       361
       347
        
       

     

       362
       348
        
       func newDb() (*gorm.DB, error) {

     

       363
       363
       -
       	dbType := os.Getenv("COCOON_DB_TYPE")

     

       364
       364
       -
       	if dbType == "" {

     

       365
       365
       -
       		dbType = "sqlite"

     

       366
       366
       -
       	}

     

       367
       367
       -
       

     

       368
       368
       -
       	switch dbType {

     

       369
       369
       -
       	case "postgres":

     

       370
       370
       -
       		databaseURL := os.Getenv("COCOON_DATABASE_URL")

     

       371
       371
       -
       		if databaseURL == "" {

     

       372
       372
       -
       			databaseURL = os.Getenv("DATABASE_URL")

     

       373
       373
       -
       		}

     

       374
       374
       -
       		if databaseURL == "" {

     

       375
       375
       -
       			return nil, fmt.Errorf("COCOON_DATABASE_URL or DATABASE_URL must be set when using postgres")

     

       376
       376
       -
       		}

     

       377
       377
       -
       		return gorm.Open(postgres.Open(databaseURL), &gorm.Config{})

     

       378
       378
       -
       	default:

     

       379
       379
       -
       		dbName := os.Getenv("COCOON_DB_NAME")

     

       380
       380
       -
       		if dbName == "" {

     

       381
       381
       -
       			dbName = "cocoon.db"

     

       382
       382
       -
       		}

     

       383
       383
       -
       		return gorm.Open(sqlite.Open(dbName), &gorm.Config{})

     

       384
       384
       -
       	}

     

       349
       349
       +
       	return gorm.Open(sqlite.Open("cocoon.db"), &gorm.Config{})

     

       385
       350
        
       }

-158

docker-compose.postgres.yaml

···

       1
       1
       -
       # Docker Compose with PostgreSQL

     

       2
       2
       -
       # 

     

       3
       3
       -
       # Usage:

     

       4
       4
       -
       #   docker-compose -f docker-compose.postgres.yaml up -d

     

       5
       5
       -
       #

     

       6
       6
       -
       # This file extends the base docker-compose.yaml with a PostgreSQL database.

     

       7
       7
       -
       # Set the following in your .env file:

     

       8
       8
       -
       #   COCOON_DB_TYPE=postgres

     

       9
       9
       -
       #   POSTGRES_PASSWORD=your-secure-password

     

       10
       10
       -
       

     

       11
       11
       -
       version: '3.8'

     

       12
       12
       -
       

     

       13
       13
       -
       services:

     

       14
       14
       -
         postgres:

     

       15
       15
       -
           image: postgres:16-alpine

     

       16
       16
       -
           container_name: cocoon-postgres

     

       17
       17
       -
           environment:

     

       18
       18
       -
             POSTGRES_USER: cocoon

     

       19
       19
       -
             POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}

     

       20
       20
       -
             POSTGRES_DB: cocoon

     

       21
       21
       -
           volumes:

     

       22
       22
       -
             - postgres_data:/var/lib/postgresql/data

     

       23
       23
       -
           healthcheck:

     

       24
       24
       -
             test: ["CMD-SHELL", "pg_isready -U cocoon -d cocoon"]

     

       25
       25
       -
             interval: 10s

     

       26
       26
       -
             timeout: 5s

     

       27
       27
       -
             retries: 5

     

       28
       28
       -
           restart: unless-stopped

     

       29
       29
       -
       

     

       30
       30
       -
         init-keys:

     

       31
       31
       -
           build:

     

       32
       32
       -
             context: .

     

       33
       33
       -
             dockerfile: Dockerfile

     

       34
       34
       -
           image: ghcr.io/haileyok/cocoon:latest

     

       35
       35
       -
           container_name: cocoon-init-keys

     

       36
       36
       -
           volumes:

     

       37
       37
       -
             - ./keys:/keys

     

       38
       38
       -
             - ./data:/data/cocoon

     

       39
       39
       -
             - ./init-keys.sh:/init-keys.sh:ro

     

       40
       40
       -
           environment:

     

       41
       41
       -
             COCOON_DID: ${COCOON_DID}

     

       42
       42
       -
             COCOON_HOSTNAME: ${COCOON_HOSTNAME}

     

       43
       43
       -
             COCOON_ROTATION_KEY_PATH: /keys/rotation.key

     

       44
       44
       -
             COCOON_JWK_PATH: /keys/jwk.key

     

       45
       45
       -
             COCOON_CONTACT_EMAIL: ${COCOON_CONTACT_EMAIL}

     

       46
       46
       -
             COCOON_RELAYS: ${COCOON_RELAYS:-https://bsky.network}

     

       47
       47
       -
             COCOON_ADMIN_PASSWORD: ${COCOON_ADMIN_PASSWORD}

     

       48
       48
       -
           entrypoint: ["/bin/sh", "/init-keys.sh"]

     

       49
       49
       -
           restart: "no"

     

       50
       50
       -
       

     

       51
       51
       -
         cocoon:

     

       52
       52
       -
           build:

     

       53
       53
       -
             context: .

     

       54
       54
       -
             dockerfile: Dockerfile

     

       55
       55
       -
           image: ghcr.io/haileyok/cocoon:latest

     

       56
       56
       -
           container_name: cocoon-pds

     

       57
       57
       -
           depends_on:

     

       58
       58
       -
             init-keys:

     

       59
       59
       -
               condition: service_completed_successfully

     

       60
       60
       -
             postgres:

     

       61
       61
       -
               condition: service_healthy

     

       62
       62
       -
           ports:

     

       63
       63
       -
             - "8080:8080"

     

       64
       64
       -
           volumes:

     

       65
       65
       -
             - ./data:/data/cocoon

     

       66
       66
       -
             - ./keys/rotation.key:/keys/rotation.key:ro

     

       67
       67
       -
             - ./keys/jwk.key:/keys/jwk.key:ro

     

       68
       68
       -
           environment:

     

       69
       69
       -
             # Required settings

     

       70
       70
       -
             COCOON_DID: ${COCOON_DID}

     

       71
       71
       -
             COCOON_HOSTNAME: ${COCOON_HOSTNAME}

     

       72
       72
       -
             COCOON_ROTATION_KEY_PATH: /keys/rotation.key

     

       73
       73
       -
             COCOON_JWK_PATH: /keys/jwk.key

     

       74
       74
       -
             COCOON_CONTACT_EMAIL: ${COCOON_CONTACT_EMAIL}

     

       75
       75
       -
             COCOON_RELAYS: ${COCOON_RELAYS:-https://bsky.network}

     

       76
       76
       -
             COCOON_ADMIN_PASSWORD: ${COCOON_ADMIN_PASSWORD}

     

       77
       77
       -
             COCOON_SESSION_SECRET: ${COCOON_SESSION_SECRET}

     

       78
       78
       -
       

     

       79
       79
       -
             # Database configuration - PostgreSQL

     

       80
       80
       -
             COCOON_ADDR: ":8080"

     

       81
       81
       -
             COCOON_DB_TYPE: postgres

     

       82
       82
       -
             COCOON_DATABASE_URL: postgres://cocoon:${POSTGRES_PASSWORD}@postgres:5432/cocoon?sslmode=disable

     

       83
       83
       -
             COCOON_BLOCKSTORE_VARIANT: ${COCOON_BLOCKSTORE_VARIANT:-sqlite}

     

       84
       84
       -
       

     

       85
       85
       -
             # Optional: SMTP settings for email

     

       86
       86
       -
             COCOON_SMTP_USER: ${COCOON_SMTP_USER:-}

     

       87
       87
       -
             COCOON_SMTP_PASS: ${COCOON_SMTP_PASS:-}

     

       88
       88
       -
             COCOON_SMTP_HOST: ${COCOON_SMTP_HOST:-}

     

       89
       89
       -
             COCOON_SMTP_PORT: ${COCOON_SMTP_PORT:-}

     

       90
       90
       -
             COCOON_SMTP_EMAIL: ${COCOON_SMTP_EMAIL:-}

     

       91
       91
       -
             COCOON_SMTP_NAME: ${COCOON_SMTP_NAME:-}

     

       92
       92
       -
       

     

       93
       93
       -
             # Optional: S3 configuration

     

       94
       94
       -
             COCOON_S3_BACKUPS_ENABLED: ${COCOON_S3_BACKUPS_ENABLED:-false}

     

       95
       95
       -
             COCOON_S3_BLOBSTORE_ENABLED: ${COCOON_S3_BLOBSTORE_ENABLED:-false}

     

       96
       96
       -
             COCOON_S3_REGION: ${COCOON_S3_REGION:-}

     

       97
       97
       -
             COCOON_S3_BUCKET: ${COCOON_S3_BUCKET:-}

     

       98
       98
       -
             COCOON_S3_ENDPOINT: ${COCOON_S3_ENDPOINT:-}

     

       99
       99
       -
             COCOON_S3_ACCESS_KEY: ${COCOON_S3_ACCESS_KEY:-}

     

       100
       100
       -
             COCOON_S3_SECRET_KEY: ${COCOON_S3_SECRET_KEY:-}

     

       101
       101
       -
       

     

       102
       102
       -
             # Optional: Fallback proxy

     

       103
       103
       -
             COCOON_FALLBACK_PROXY: ${COCOON_FALLBACK_PROXY:-}

     

       104
       104
       -
           restart: unless-stopped

     

       105
       105
       -
           healthcheck:

     

       106
       106
       -
             test: ["CMD", "curl", "-f", "http://localhost:8080/xrpc/_health"]

     

       107
       107
       -
             interval: 30s

     

       108
       108
       -
             timeout: 10s

     

       109
       109
       -
             retries: 3

     

       110
       110
       -
             start_period: 40s

     

       111
       111
       -
       

     

       112
       112
       -
         create-invite:

     

       113
       113
       -
           build:

     

       114
       114
       -
             context: .

     

       115
       115
       -
             dockerfile: Dockerfile

     

       116
       116
       -
           image: ghcr.io/haileyok/cocoon:latest

     

       117
       117
       -
           container_name: cocoon-create-invite

     

       118
       118
       -
           volumes:

     

       119
       119
       -
             - ./keys:/keys

     

       120
       120
       -
             - ./create-initial-invite.sh:/create-initial-invite.sh:ro

     

       121
       121
       -
           environment:

     

       122
       122
       -
             COCOON_DID: ${COCOON_DID}

     

       123
       123
       -
             COCOON_HOSTNAME: ${COCOON_HOSTNAME}

     

       124
       124
       -
             COCOON_ROTATION_KEY_PATH: /keys/rotation.key

     

       125
       125
       -
             COCOON_JWK_PATH: /keys/jwk.key

     

       126
       126
       -
             COCOON_CONTACT_EMAIL: ${COCOON_CONTACT_EMAIL}

     

       127
       127
       -
             COCOON_RELAYS: ${COCOON_RELAYS:-https://bsky.network}

     

       128
       128
       -
             COCOON_ADMIN_PASSWORD: ${COCOON_ADMIN_PASSWORD}

     

       129
       129
       -
             COCOON_DB_TYPE: postgres

     

       130
       130
       -
             COCOON_DATABASE_URL: postgres://cocoon:${POSTGRES_PASSWORD}@postgres:5432/cocoon?sslmode=disable

     

       131
       131
       -
           depends_on:

     

       132
       132
       -
             cocoon:

     

       133
       133
       -
               condition: service_healthy

     

       134
       134
       -
           entrypoint: ["/bin/sh", "/create-initial-invite.sh"]

     

       135
       135
       -
           restart: "no"

     

       136
       136
       -
       

     

       137
       137
       -
         caddy:

     

       138
       138
       -
           image: caddy:2-alpine

     

       139
       139
       -
           container_name: cocoon-caddy

     

       140
       140
       -
           ports:

     

       141
       141
       -
             - "80:80"

     

       142
       142
       -
             - "443:443"

     

       143
       143
       -
           volumes:

     

       144
       144
       -
             - ./Caddyfile.postgres:/etc/caddy/Caddyfile:ro

     

       145
       145
       -
             - caddy_data:/data

     

       146
       146
       -
             - caddy_config:/config

     

       147
       147
       -
           restart: unless-stopped

     

       148
       148
       -
           environment:

     

       149
       149
       -
             COCOON_HOSTNAME: ${COCOON_HOSTNAME}

     

       150
       150
       -
             CADDY_ACME_EMAIL: ${COCOON_CONTACT_EMAIL:-}

     

       151
       151
       -
       

     

       152
       152
       -
       volumes:

     

       153
       153
       -
         postgres_data:

     

       154
       154
       -
           driver: local

     

       155
       155
       -
         caddy_data:

     

       156
       156
       -
           driver: local

     

       157
       157
       -
         caddy_config:

     

       158
       158
       -
           driver: local

+2 -6

docker-compose.yaml

···

       49
       49
        
       

     

       50
       50
        
             # Server configuration

     

       51
       51
        
             COCOON_ADDR: ":8080"

     

       52
       52
       -
             COCOON_DB_TYPE: ${COCOON_DB_TYPE:-sqlite}

     

       53
       53
       -
             COCOON_DB_NAME: ${COCOON_DB_NAME:-/data/cocoon/cocoon.db}

     

       54
       54
       -
             COCOON_DATABASE_URL: ${COCOON_DATABASE_URL:-}

     

       52
       52
       +
             COCOON_DB_NAME: /data/cocoon/cocoon.db

     

       55
       53
        
             COCOON_BLOCKSTORE_VARIANT: ${COCOON_BLOCKSTORE_VARIANT:-sqlite}

     

       56
       54
        
       

     

       57
       55
        
             # Optional: SMTP settings for email

     
···

       99
       97
        
             COCOON_CONTACT_EMAIL: ${COCOON_CONTACT_EMAIL}

     

       100
       98
        
             COCOON_RELAYS: ${COCOON_RELAYS:-https://bsky.network}

     

       101
       99
        
             COCOON_ADMIN_PASSWORD: ${COCOON_ADMIN_PASSWORD}

     

       102
       102
       -
             COCOON_DB_TYPE: ${COCOON_DB_TYPE:-sqlite}

     

       103
       103
       -
             COCOON_DB_NAME: ${COCOON_DB_NAME:-/data/cocoon/cocoon.db}

     

       104
       104
       -
             COCOON_DATABASE_URL: ${COCOON_DATABASE_URL:-}

     

       100
       100
       +
             COCOON_DB_NAME: /data/cocoon/cocoon.db

     

       105
       101
        
           depends_on:

     

       106
       102
        
             - init-keys

     

       107
       103
        
           entrypoint: ["/bin/sh", "/create-initial-invite.sh"]

server/handle_account.go

···

       12
       12
        
       

     

       13
       13
        
       func (s *Server) handleAccount(e echo.Context) error {

     

       14
       14
        
       	ctx := e.Request().Context()

     

       15
       15
       +
       

     

       15
       16
        
       	repo, sess, err := s.getSessionRepoOrErr(e)

     

       16
       17
        
       	if err != nil {

     

       17
       18
        
       		return e.Redirect(303, "/account/signin")

server/handle_identity_get_recommended_did_credentials.go

···

       9
       9
        
       

     

       10
       10
        
       func (s *Server) handleGetRecommendedDidCredentials(e echo.Context) error {

     

       11
       11
        
       	repo := e.Get("repo").(*models.RepoActor)

     

       12
       12
       +
       

     

       12
       13
        
       	k, err := atcrypto.ParsePrivateBytesK256(repo.SigningKey)

     

       13
       14
        
       	if err != nil {

     

       14
       15
        
       		s.logger.Error("error parsing key", "error", err)

     

       15
       16
        
       		return helpers.ServerError(e, nil)

     

       16
       17
        
       	}

     

       18
       18
       +
       

     

       17
       19
        
       	creds, err := s.plcClient.CreateDidCredentials(k, "", repo.Actor.Handle)

     

       18
       20
        
       	if err != nil {

     

       19
       21
        
       		s.logger.Error("error crating did credentials", "error", err)

+8 -7

server/handle_import_repo.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"bytes"

     

       5
       5
       -
       	"context"

     

       6
       5
        
       	"io"

     

       7
       6
        
       	"slices"

     

       8
       7
        
       	"strings"

     
···

       18
       17
        
       )

     

       19
       18
        
       

     

       20
       19
        
       func (s *Server) handleRepoImportRepo(e echo.Context) error {

     

       20
       20
       +
       	ctx := e.Request().Context()

     

       21
       21
       +
       

     

       21
       22
        
       	urepo := e.Get("repo").(*models.RepoActor)

     

       22
       23
        
       

     

       23
       24
        
       	b, err := io.ReadAll(e.Request().Body)

     
···

       52
       53
        
       

     

       53
       54
        
       	slices.Reverse(orderedBlocks)

     

       54
       55
        
       

     

       55
       55
       -
       	if err := bs.PutMany(context.TODO(), orderedBlocks); err != nil {

     

       56
       56
       +
       	if err := bs.PutMany(ctx, orderedBlocks); err != nil {

     

       56
       57
        
       		s.logger.Error("could not insert blocks", "error", err)

     

       57
       58
        
       		return helpers.ServerError(e, nil)

     

       58
       59
        
       	}

     

       59
       60
        
       

     

       60
       60
       -
       	r, err := repo.OpenRepo(context.TODO(), bs, cs.Header.Roots[0])

     

       61
       61
       +
       	r, err := repo.OpenRepo(ctx, bs, cs.Header.Roots[0])

     

       61
       62
        
       	if err != nil {

     

       62
       63
        
       		s.logger.Error("could not open repo", "error", err)

     

       63
       64
        
       		return helpers.ServerError(e, nil)

     
···

       67
       68
        
       

     

       68
       69
        
       	clock := syntax.NewTIDClock(0)

     

       69
       70
        
       

     

       70
       70
       -
       	if err := r.ForEach(context.TODO(), "", func(key string, cid cid.Cid) error {

     

       71
       71
       +
       	if err := r.ForEach(ctx, "", func(key string, cid cid.Cid) error {

     

       71
       72
        
       		pts := strings.Split(key, "/")

     

       72
       73
        
       		nsid := pts[0]

     

       73
       74
        
       		rkey := pts[1]

     

       74
       75
        
       		cidStr := cid.String()

     

       75
       75
       -
       		b, err := bs.Get(context.TODO(), cid)

     

       76
       76
       +
       		b, err := bs.Get(ctx, cid)

     

       76
       77
        
       		if err != nil {

     

       77
       78
        
       			s.logger.Error("record bytes don't exist in blockstore", "error", err)

     

       78
       79
        
       			return helpers.ServerError(e, nil)

     
···

       100
       101
        
       

     

       101
       102
        
       	tx.Commit()

     

       102
       103
        
       

     

       103
       103
       -
       	root, rev, err := r.Commit(context.TODO(), urepo.SignFor)

     

       104
       104
       +
       	root, rev, err := r.Commit(ctx, urepo.SignFor)

     

       104
       105
        
       	if err != nil {

     

       105
       106
        
       		s.logger.Error("error committing", "error", err)

     

       106
       107
        
       		return helpers.ServerError(e, nil)

     

       107
       108
        
       	}

     

       108
       109
        
       

     

       109
       109
       -
       	if err := s.UpdateRepo(context.TODO(), urepo.Repo.Did, root, rev); err != nil {

     

       110
       110
       +
       	if err := s.UpdateRepo(ctx, urepo.Repo.Did, root, rev); err != nil {

     

       110
       111
        
       		s.logger.Error("error updating repo after commit", "error", err)

     

       111
       112
        
       		return helpers.ServerError(e, nil)

     

       112
       113
        
       	}

+3 -1

server/handle_repo_apply_writes.go

···

       26
       26
        
       }

     

       27
       27
        
       

     

       28
       28
        
       func (s *Server) handleApplyWrites(e echo.Context) error {

     

       29
       29
       +
       	ctx := e.Request().Context()

     

       30
       30
       +
       

     

       29
       31
        
       	repo := e.Get("repo").(*models.RepoActor)

     

       30
       32
        
       

     

       31
       33
        
       	var req ComAtprotoRepoApplyWritesRequest

     
···

       54
       56
        
       		})

     

       55
       57
        
       	}

     

       56
       58
        
       

     

       57
       57
       -
       	results, err := s.repoman.applyWrites(repo.Repo, ops, req.SwapCommit)

     

       59
       59
       +
       	results, err := s.repoman.applyWrites(ctx, repo.Repo, ops, req.SwapCommit)

     

       58
       60
        
       	if err != nil {

     

       59
       61
        
       		s.logger.Error("error applying writes", "error", err)

     

       60
       62
        
       		return helpers.ServerError(e, nil)

+3 -1

server/handle_repo_create_record.go

···

       17
       17
        
       }

     

       18
       18
        
       

     

       19
       19
        
       func (s *Server) handleCreateRecord(e echo.Context) error {

     

       20
       20
       +
       	ctx := e.Request().Context()

     

       21
       21
       +
       

     

       20
       22
        
       	repo := e.Get("repo").(*models.RepoActor)

     

       21
       23
        
       

     

       22
       24
        
       	var req ComAtprotoRepoCreateRecordRequest

     
···

       40
       42
        
       		optype = OpTypeUpdate

     

       41
       43
        
       	}

     

       42
       44
        
       

     

       43
       43
       -
       	results, err := s.repoman.applyWrites(repo.Repo, []Op{

     

       45
       45
       +
       	results, err := s.repoman.applyWrites(ctx, repo.Repo, []Op{

     

       44
       46
        
       		{

     

       45
       47
        
       			Type:       optype,

     

       46
       48
        
       			Collection: req.Collection,

+3 -1

server/handle_repo_delete_record.go

···

       15
       15
        
       }

     

       16
       16
        
       

     

       17
       17
        
       func (s *Server) handleDeleteRecord(e echo.Context) error {

     

       18
       18
       +
       	ctx := e.Request().Context()

     

       19
       19
       +
       

     

       18
       20
        
       	repo := e.Get("repo").(*models.RepoActor)

     

       19
       21
        
       

     

       20
       22
        
       	var req ComAtprotoRepoDeleteRecordRequest

     
···

       33
       35
        
       		return helpers.InputError(e, nil)

     

       34
       36
        
       	}

     

       35
       37
        
       

     

       36
       36
       -
       	results, err := s.repoman.applyWrites(repo.Repo, []Op{

     

       38
       38
       +
       	results, err := s.repoman.applyWrites(ctx, repo.Repo, []Op{

     

       37
       39
        
       		{

     

       38
       40
        
       			Type:       OpTypeDelete,

     

       39
       41
        
       			Collection: req.Collection,

-21

server/handle_repo_list_missing_blobs.go

···

       1
       1
       -
       package server

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"github.com/labstack/echo/v4"

     

       5
       5
       -
       )

     

       6
       6
       -
       

     

       7
       7
       -
       type ComAtprotoRepoListMissingBlobsResponse struct {

     

       8
       8
       -
       	Cursor *string                                    `json:"cursor,omitempty"`

     

       9
       9
       -
       	Blobs  []ComAtprotoRepoListMissingBlobsRecordBlob `json:"blobs"`

     

       10
       10
       -
       }

     

       11
       11
       -
       

     

       12
       12
       -
       type ComAtprotoRepoListMissingBlobsRecordBlob struct {

     

       13
       13
       -
       	Cid        string `json:"cid"`

     

       14
       14
       -
       	RecordUri  string `json:"recordUri"`

     

       15
       15
       -
       }

     

       16
       16
       -
       

     

       17
       17
       -
       func (s *Server) handleListMissingBlobs(e echo.Context) error {

     

       18
       18
       -
       	return e.JSON(200, ComAtprotoRepoListMissingBlobsResponse{

     

       19
       19
       -
       		Blobs: []ComAtprotoRepoListMissingBlobsRecordBlob{},

     

       20
       20
       -
       	})

     

       21
       21
       -
       }

+3 -1

server/handle_repo_put_record.go

···

       17
       17
        
       }

     

       18
       18
        
       

     

       19
       19
        
       func (s *Server) handlePutRecord(e echo.Context) error {

     

       20
       20
       +
       	ctx := e.Request().Context()

     

       21
       21
       +
       

     

       20
       22
        
       	repo := e.Get("repo").(*models.RepoActor)

     

       21
       23
        
       

     

       22
       24
        
       	var req ComAtprotoRepoPutRecordRequest

     
···

       40
       42
        
       		optype = OpTypeUpdate

     

       41
       43
        
       	}

     

       42
       44
        
       

     

       43
       43
       -
       	results, err := s.repoman.applyWrites(repo.Repo, []Op{

     

       45
       45
       +
       	results, err := s.repoman.applyWrites(ctx, repo.Repo, []Op{

     

       44
       46
        
       		{

     

       45
       47
        
       			Type:       optype,

     

       46
       48
        
       			Collection: req.Collection,

+46 -15

server/handle_server_check_account_status.go

···

       1
       1
        
       package server

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"errors"

     

       5
       5
       +
       	"sync"

     

       6
       6
       +
       

     

       7
       7
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       4
       8
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       5
       9
        
       	"github.com/haileyok/cocoon/models"

     

       6
       10
        
       	"github.com/ipfs/go-cid"

     
···

       22
       26
        
       func (s *Server) handleServerCheckAccountStatus(e echo.Context) error {

     

       23
       27
        
       	urepo := e.Get("repo").(*models.RepoActor)

     

       24
       28
        
       

     

       29
       29
       +
       	_, didErr := syntax.ParseDID(urepo.Repo.Did)

     

       30
       30
       +
       	if didErr != nil {

     

       31
       31
       +
       		s.logger.Error("error validating did", "err", didErr)

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       25
       34
        
       	resp := ComAtprotoServerCheckAccountStatusResponse{

     

       26
       35
        
       		Activated:     true, // TODO: should allow for deactivation etc.

     

       27
       27
       -
       		ValidDid:      true, // TODO: should probably verify?

     

       36
       36
       +
       		ValidDid:      didErr == nil,

     

       28
       37
        
       		RepoRev:       urepo.Rev,

     

       29
       38
        
       		ImportedBlobs: 0, // TODO: ???

     

       30
       39
        
       	}

     
···

       34
       43
        
       		s.logger.Error("error casting cid", "error", err)

     

       35
       44
        
       		return helpers.ServerError(e, nil)

     

       36
       45
        
       	}

     

       46
       46
       +
       

     

       37
       47
        
       	resp.RepoCommit = rootcid.String()

     

       38
       48
        
       

     

       39
       49
        
       	type CountResp struct {

     
···

       41
       51
        
       	}

     

       42
       52
        
       

     

       43
       53
        
       	var blockCtResp CountResp

     

       44
       44
       -
       	if err := s.db.Raw("SELECT COUNT(*) AS ct FROM blocks WHERE did = ?", nil, urepo.Repo.Did).Scan(&blockCtResp).Error; err != nil {

     

       45
       45
       -
       		s.logger.Error("error getting block count", "error", err)

     

       46
       46
       -
       		return helpers.ServerError(e, nil)

     

       47
       47
       -
       	}

     

       48
       48
       -
       	resp.RepoBlocks = blockCtResp.Ct

     

       54
       54
       +
       	var recCtResp CountResp

     

       55
       55
       +
       	var blobCtResp CountResp

     

       56
       56
       +
       

     

       57
       57
       +
       	var wg sync.WaitGroup

     

       58
       58
       +
       	var procErr error

     

       59
       59
       +
       

     

       60
       60
       +
       	wg.Add(1)

     

       61
       61
       +
       	go func() {

     

       62
       62
       +
       		defer wg.Done()

     

       63
       63
       +
       		if err := s.db.Raw("SELECT COUNT(*) AS ct FROM blocks WHERE did = ?", nil, urepo.Repo.Did).Scan(&blockCtResp).Error; err != nil {

     

       64
       64
       +
       			s.logger.Error("error getting block count", "error", err)

     

       65
       65
       +
       			procErr = errors.Join(procErr, err)

     

       66
       66
       +
       		}

     

       67
       67
       +
       	}()

     

       68
       68
       +
       

     

       69
       69
       +
       	wg.Add(1)

     

       70
       70
       +
       	go func() {

     

       71
       71
       +
       		defer wg.Done()

     

       72
       72
       +
       		if err := s.db.Raw("SELECT COUNT(*) AS ct FROM records WHERE did = ?", nil, urepo.Repo.Did).Scan(&recCtResp).Error; err != nil {

     

       73
       73
       +
       			s.logger.Error("error getting record count", "error", err)

     

       74
       74
       +
       			procErr = errors.Join(procErr, err)

     

       75
       75
       +
       		}

     

       76
       76
       +
       	}()

     

       49
       77
        
       

     

       50
       50
       -
       	var recCtResp CountResp

     

       51
       51
       -
       	if err := s.db.Raw("SELECT COUNT(*) AS ct FROM records WHERE did = ?", nil, urepo.Repo.Did).Scan(&recCtResp).Error; err != nil {

     

       52
       52
       -
       		s.logger.Error("error getting record count", "error", err)

     

       53
       53
       -
       		return helpers.ServerError(e, nil)

     

       54
       54
       -
       	}

     

       55
       55
       -
       	resp.IndexedRecords = recCtResp.Ct

     

       78
       78
       +
       	wg.Add(1)

     

       79
       79
       +
       	go func() {

     

       80
       80
       +
       		if err := s.db.Raw("SELECT COUNT(*) AS ct FROM blobs WHERE did = ?", nil, urepo.Repo.Did).Scan(&blobCtResp).Error; err != nil {

     

       81
       81
       +
       			s.logger.Error("error getting expected blobs count", "error", err)

     

       82
       82
       +
       			procErr = errors.Join(procErr, err)

     

       83
       83
       +
       		}

     

       84
       84
       +
       	}()

     

       56
       85
        
       

     

       57
       57
       -
       	var blobCtResp CountResp

     

       58
       58
       -
       	if err := s.db.Raw("SELECT COUNT(*) AS ct FROM blobs WHERE did = ?", nil, urepo.Repo.Did).Scan(&blobCtResp).Error; err != nil {

     

       59
       59
       -
       		s.logger.Error("error getting record count", "error", err)

     

       86
       86
       +
       	wg.Wait()

     

       87
       87
       +
       	if procErr != nil {

     

       60
       88
        
       		return helpers.ServerError(e, nil)

     

       61
       89
        
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	resp.RepoBlocks = blockCtResp.Ct

     

       92
       92
       +
       	resp.IndexedRecords = recCtResp.Ct

     

       62
       93
        
       	resp.ExpectedBlobs = blobCtResp.Ct

     

       63
       94
        
       

     

       64
       95
        
       	return e.JSON(200, resp)

+3 -1

server/handle_sync_get_record.go

···

       13
       13
        
       )

     

       14
       14
        
       

     

       15
       15
        
       func (s *Server) handleSyncGetRecord(e echo.Context) error {

     

       16
       16
       +
       	ctx := e.Request().Context()

     

       17
       17
       +
       

     

       16
       18
        
       	did := e.QueryParam("did")

     

       17
       19
        
       	collection := e.QueryParam("collection")

     

       18
       20
        
       	rkey := e.QueryParam("rkey")

     
···

       23
       25
        
       		return helpers.ServerError(e, nil)

     

       24
       26
        
       	}

     

       25
       27
        
       

     

       26
       26
       -
       	root, blocks, err := s.repoman.getRecordProof(urepo, collection, rkey)

     

       28
       28
       +
       	root, blocks, err := s.repoman.getRecordProof(ctx, urepo, collection, rkey)

     

       27
       29
        
       	if err != nil {

     

       28
       30
        
       		return err

     

       29
       31
        
       	}

+19 -16

server/repo.go

···

       96
       96
        
       }

     

       97
       97
        
       

     

       98
       98
        
       // TODO make use of swap commit

     

       99
       99
       -
       func (rm *RepoMan) applyWrites(urepo models.Repo, writes []Op, swapCommit *string) ([]ApplyWriteResult, error) {

     

       99
       99
       +
       func (rm *RepoMan) applyWrites(ctx context.Context, urepo models.Repo, writes []Op, swapCommit *string) ([]ApplyWriteResult, error) {

     

       100
       100
        
       	rootcid, err := cid.Cast(urepo.Root)

     

       101
       101
        
       	if err != nil {

     

       102
       102
        
       		return nil, err

     
···

       104
       104
        
       

     

       105
       105
        
       	dbs := rm.s.getBlockstore(urepo.Did)

     

       106
       106
        
       	bs := recording_blockstore.New(dbs)

     

       107
       107
       -
       	r, err := repo.OpenRepo(context.TODO(), bs, rootcid)

     

       107
       107
       +
       	r, err := repo.OpenRepo(ctx, bs, rootcid)

     

       108
       108
        
       

     

       109
       109
       -
       	entries := []models.Record{}

     

       110
       110
       -
       	var results []ApplyWriteResult

     

       109
       109
       +
       	entries := make([]models.Record, 0, len(writes))

     

       110
       110
       +
       	results := make([]ApplyWriteResult, 0, len(writes))

     

       111
       111
        
       

     

       112
       112
        
       	for i, op := range writes {

     

       113
       113
        
       		if op.Type != OpTypeCreate && op.Rkey == nil {

     

       114
       114
        
       			return nil, fmt.Errorf("invalid rkey")

     

       115
       115
        
       		} else if op.Type == OpTypeCreate && op.Rkey != nil {

     

       116
       116
       -
       			_, _, err := r.GetRecord(context.TODO(), op.Collection+"/"+*op.Rkey)

     

       116
       116
       +
       			_, _, err := r.GetRecord(ctx, op.Collection+"/"+*op.Rkey)

     

       117
       117
        
       			if err == nil {

     

       118
       118
        
       				op.Type = OpTypeUpdate

     

       119
       119
        
       			}

     
···

       144
       144
        
       				mm["$type"] = op.Collection

     

       145
       145
        
       			}

     

       146
       146
        
       

     

       147
       147
       -
       			nc, err := r.PutRecord(context.TODO(), op.Collection+"/"+*op.Rkey, &mm)

     

       147
       147
       +
       			nc, err := r.PutRecord(ctx, op.Collection+"/"+*op.Rkey, &mm)

     

       148
       148
        
       			if err != nil {

     

       149
       149
        
       				return nil, err

     

       150
       150
        
       			}

     
···

       177
       177
        
       				Rkey:  *op.Rkey,

     

       178
       178
        
       				Value: old.Value,

     

       179
       179
        
       			})

     

       180
       180
       -
       			err := r.DeleteRecord(context.TODO(), op.Collection+"/"+*op.Rkey)

     

       180
       180
       +
       			err := r.DeleteRecord(ctx, op.Collection+"/"+*op.Rkey)

     

       181
       181
        
       			if err != nil {

     

       182
       182
        
       				return nil, err

     

       183
       183
        
       			}

     
···

       194
       194
        
       				return nil, err

     

       195
       195
        
       			}

     

       196
       196
        
       			mm := MarshalableMap(out)

     

       197
       197
       -
       			nc, err := r.UpdateRecord(context.TODO(), op.Collection+"/"+*op.Rkey, &mm)

     

       197
       197
       +
       			nc, err := r.UpdateRecord(ctx, op.Collection+"/"+*op.Rkey, &mm)

     

       198
       198
        
       			if err != nil {

     

       199
       199
        
       				return nil, err

     

       200
       200
        
       			}

     
···

       219
       219
        
       		}

     

       220
       220
        
       	}

     

       221
       221
        
       

     

       222
       222
       -
       	newroot, rev, err := r.Commit(context.TODO(), urepo.SignFor)

     

       222
       222
       +
       	newroot, rev, err := r.Commit(ctx, urepo.SignFor)

     

       223
       223
        
       	if err != nil {

     

       224
       224
        
       		return nil, err

     

       225
       225
        
       	}

     
···

       230
       230
        
       		Roots:   []cid.Cid{newroot},

     

       231
       231
        
       		Version: 1,

     

       232
       232
        
       	})

     

       233
       233
       +
       	if err != nil {

     

       234
       234
       +
       		return nil, err

     

       235
       235
       +
       	}

     

       233
       236
        
       

     

       234
       237
        
       	if _, err := carstore.LdWrite(buf, hb); err != nil {

     

       235
       238
        
       		return nil, err

     

       236
       239
        
       	}

     

       237
       240
        
       

     

       238
       238
       -
       	diffops, err := r.DiffSince(context.TODO(), rootcid)

     

       241
       241
       +
       	diffops, err := r.DiffSince(ctx, rootcid)

     

       239
       242
        
       	if err != nil {

     

       240
       243
        
       		return nil, err

     

       241
       244
        
       	}

     
···

       270
       273
        
       			})

     

       271
       274
        
       		}

     

       272
       275
        
       

     

       273
       273
       -
       		blk, err := dbs.Get(context.TODO(), c)

     

       276
       276
       +
       		blk, err := dbs.Get(ctx, c)

     

       274
       277
        
       		if err != nil {

     

       275
       278
        
       			return nil, err

     

       276
       279
        
       		}

     
···

       316
       319
        
       		}

     

       317
       320
        
       	}

     

       318
       321
        
       

     

       319
       319
       -
       	rm.s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{

     

       322
       322
       +
       	rm.s.evtman.AddEvent(ctx, &events.XRPCStreamEvent{

     

       320
       323
        
       		RepoCommit: &atproto.SyncSubscribeRepos_Commit{

     

       321
       324
        
       			Repo:   urepo.Did,

     

       322
       325
        
       			Blocks: buf.Bytes(),

     
···

       330
       333
        
       		},

     

       331
       334
        
       	})

     

       332
       335
        
       

     

       333
       333
       -
       	if err := rm.s.UpdateRepo(context.TODO(), urepo.Did, newroot, rev); err != nil {

     

       336
       336
       +
       	if err := rm.s.UpdateRepo(ctx, urepo.Did, newroot, rev); err != nil {

     

       334
       337
        
       		return nil, err

     

       335
       338
        
       	}

     

       336
       339
        
       

     
···

       345
       348
        
       	return results, nil

     

       346
       349
        
       }

     

       347
       350
        
       

     

       348
       348
       -
       func (rm *RepoMan) getRecordProof(urepo models.Repo, collection, rkey string) (cid.Cid, []blocks.Block, error) {

     

       351
       351
       +
       func (rm *RepoMan) getRecordProof(ctx context.Context, urepo models.Repo, collection, rkey string) (cid.Cid, []blocks.Block, error) {

     

       349
       352
        
       	c, err := cid.Cast(urepo.Root)

     

       350
       353
        
       	if err != nil {

     

       351
       354
        
       		return cid.Undef, nil, err

     
···

       354
       357
        
       	dbs := rm.s.getBlockstore(urepo.Did)

     

       355
       358
        
       	bs := recording_blockstore.New(dbs)

     

       356
       359
        
       

     

       357
       357
       -
       	r, err := repo.OpenRepo(context.TODO(), bs, c)

     

       360
       360
       +
       	r, err := repo.OpenRepo(ctx, bs, c)

     

       358
       361
        
       	if err != nil {

     

       359
       362
        
       		return cid.Undef, nil, err

     

       360
       363
        
       	}

     

       361
       364
        
       

     

       362
       362
       -
       	_, _, err = r.GetRecordBytes(context.TODO(), collection+"/"+rkey)

     

       365
       365
       +
       	_, _, err = r.GetRecordBytes(ctx, collection+"/"+rkey)

     

       363
       366
        
       	if err != nil {

     

       364
       367
        
       		return cid.Undef, nil, err

     

       365
       368
        
       	}

+3 -34

server/server.go

···

       43
       43
        
       	"github.com/labstack/echo/v4"

     

       44
       44
        
       	"github.com/labstack/echo/v4/middleware"

     

       45
       45
        
       	slogecho "github.com/samber/slog-echo"

     

       46
       46
       -
       	"gorm.io/driver/postgres"

     

       47
       46
        
       	"gorm.io/driver/sqlite"

     

       48
       47
        
       	"gorm.io/gorm"

     

       49
       48
        
       )

     
···

       83
       82
        
       	requestCrawlMu   sync.Mutex

     

       84
       83
        
       

     

       85
       84
        
       	dbName   string

     

       86
       86
       -
       	dbType   string

     

       87
       85
        
       	s3Config *S3Config

     

       88
       86
        
       }

     

       89
       87
        
       

     

       90
       88
        
       type Args struct {

     

       91
       89
        
       	Addr            string

     

       92
       90
        
       	DbName          string

     

       93
       93
       -
       	DbType          string

     

       94
       94
       -
       	DatabaseURL     string

     

       95
       91
        
       	Logger          *slog.Logger

     

       96
       92
        
       	Version         string

     

       97
       93
        
       	Did             string

     
···

       292
       288
        
       		IdleTimeout:  5 * time.Minute,

     

       293
       289
        
       	}

     

       294
       290
        
       

     

       295
       295
       -
       	dbType := args.DbType

     

       296
       296
       -
       	if dbType == "" {

     

       297
       297
       -
       		dbType = "sqlite"

     

       298
       298
       -
       	}

     

       299
       299
       -
       

     

       300
       300
       -
       	var gdb *gorm.DB

     

       301
       301
       -
       	var err error

     

       302
       302
       -
       	switch dbType {

     

       303
       303
       -
       	case "postgres":

     

       304
       304
       -
       		if args.DatabaseURL == "" {

     

       305
       305
       -
       			return nil, fmt.Errorf("database-url must be set when using postgres")

     

       306
       306
       -
       		}

     

       307
       307
       -
       		gdb, err = gorm.Open(postgres.Open(args.DatabaseURL), &gorm.Config{})

     

       308
       308
       -
       		if err != nil {

     

       309
       309
       -
       			return nil, fmt.Errorf("failed to connect to postgres: %w", err)

     

       310
       310
       -
       		}

     

       311
       311
       -
       		args.Logger.Info("connected to PostgreSQL database")

     

       312
       312
       -
       	default:

     

       313
       313
       -
       		gdb, err = gorm.Open(sqlite.Open(args.DbName), &gorm.Config{})

     

       314
       314
       -
       		if err != nil {

     

       315
       315
       -
       			return nil, fmt.Errorf("failed to open sqlite database: %w", err)

     

       316
       316
       -
       		}

     

       317
       317
       -
       		args.Logger.Info("connected to SQLite database", "path", args.DbName)

     

       291
       291
       +
       	gdb, err := gorm.Open(sqlite.Open(args.DbName), &gorm.Config{})

     

       292
       292
       +
       	if err != nil {

     

       293
       293
       +
       		return nil, err

     

       318
       294
        
       	}

     

       319
       295
        
       	dbw := db.NewDB(gdb)

     

       320
       296
        
       

     
···

       387
       363
        
       		passport: identity.NewPassport(h, identity.NewMemCache(10_000)),

     

       388
       364
        
       

     

       389
       365
        
       		dbName:   args.DbName,

     

       390
       390
       -
       		dbType:   dbType,

     

       391
       366
        
       		s3Config: args.S3Config,

     

       392
       367
        
       

     

       393
       368
        
       		oauthProvider: provider.NewProvider(provider.Args{

     
···

       454
       429
        
       	s.echo.GET("/xrpc/com.atproto.repo.describeRepo", s.handleDescribeRepo)

     

       455
       430
        
       	s.echo.GET("/xrpc/com.atproto.sync.listRepos", s.handleListRepos)

     

       456
       431
        
       	s.echo.GET("/xrpc/com.atproto.repo.listRecords", s.handleListRecords)

     

       457
       457
       -
       	s.echo.GET("/xrpc/com.atproto.repo.listMissingBlobs", s.handleListMissingBlobs)

     

       458
       432
        
       	s.echo.GET("/xrpc/com.atproto.repo.getRecord", s.handleRepoGetRecord)

     

       459
       433
        
       	s.echo.GET("/xrpc/com.atproto.sync.getRecord", s.handleSyncGetRecord)

     

       460
       434
        
       	s.echo.GET("/xrpc/com.atproto.sync.getBlocks", s.handleGetBlocks)

     
···

       595
       569
        
       }

     

       596
       570
        
       

     

       597
       571
        
       func (s *Server) doBackup() {

     

       598
       598
       -
       	if s.dbType == "postgres" {

     

       599
       599
       -
       		s.logger.Info("skipping S3 backup - PostgreSQL backups should be handled externally (pg_dump, managed database backups, etc.)")

     

       600
       600
       -
       		return

     

       601
       601
       -
       	}

     

       602
       602
       -
       

     

       603
       572
        
       	start := time.Now()

     

       604
       573
        
       

     

       605
       574
        
       	s.logger.Info("beginning backup to s3...")

Compare changes