comparing 5f0d713f460401690c1062af509d8b95a9bd5c97 and hailey/s3-blobstore on hailey.at/cocoon

+58

.github/workflows/docker-image.yml

···

       1
       1
       +
       name: Docker image

     

       2
       2
       +
       

     

       3
       3
       +
       on:

     

       4
       4
       +
         workflow_dispatch:

     

       5
       5
       +
         push:

     

       6
       6
       +
       

     

       7
       7
       +
       env:

     

       8
       8
       +
         REGISTRY: ghcr.io

     

       9
       9
       +
         IMAGE_NAME: ${{ github.repository }}

     

       10
       10
       +
       

     

       11
       11
       +
       jobs:

     

       12
       12
       +
         build-and-push-image:

     

       13
       13
       +
           runs-on: ubuntu-latest

     

       14
       14
       +
           # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.

     

       15
       15
       +
           permissions:

     

       16
       16
       +
             contents: read

     

       17
       17
       +
             packages: write

     

       18
       18
       +
             attestations: write

     

       19
       19
       +
             id-token: write

     

       20
       20
       +
             #

     

       21
       21
       +
           steps:

     

       22
       22
       +
             - name: Checkout repository

     

       23
       23
       +
               uses: actions/checkout@v4

     

       24
       24
       +
             # 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.

     

       25
       25
       +
             - name: Log in to the Container registry

     

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

     

       27
       27
       +
               with:

     

       28
       28
       +
                 registry: ${{ env.REGISTRY }}

     

       29
       29
       +
                 username: ${{ github.actor }}

     

       30
       30
       +
                 password: ${{ secrets.GITHUB_TOKEN }}

     

       31
       31
       +
             # 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.

     

       32
       32
       +
             - name: Extract metadata (tags, labels) for Docker

     

       33
       33
       +
               id: meta

     

       34
       34
       +
               uses: docker/metadata-action@v5

     

       35
       35
       +
               with:

     

       36
       36
       +
                 images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

     

       37
       37
       +
                 tags: |

     

       38
       38
       +
                   type=sha

     

       39
       39
       +
                   type=sha,format=long

     

       40
       40
       +
             # 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.

     

       41
       41
       +
             # 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.

     

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

     

       43
       43
       +
             - name: Build and push Docker image

     

       44
       44
       +
               id: push

     

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

     

       46
       46
       +
               with:

     

       47
       47
       +
                 context: .

     

       48
       48
       +
                 push: true

     

       49
       49
       +
                 tags: ${{ steps.meta.outputs.tags }}

     

       50
       50
       +
                 labels: ${{ steps.meta.outputs.labels }}

     

       51
       51
       +
       

     

       52
       52
       +
             # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)."

     

       53
       53
       +
             - name: Generate artifact attestation

     

       54
       54
       +
               uses: actions/attest-build-provenance@v1

     

       55
       55
       +
               with:

     

       56
       56
       +
                 subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}

     

       57
       57
       +
                 subject-digest: ${{ steps.push.outputs.digest }}

     

       58
       58
       +
                 push-to-registry: true

+25

Dockerfile

···

       1
       1
       +
       ### Compile stage

     

       2
       2
       +
       FROM golang:1.25.1-bookworm AS build-env

     

       3
       3
       +
       

     

       4
       4
       +
       ADD . /dockerbuild

     

       5
       5
       +
       WORKDIR /dockerbuild

     

       6
       6
       +
       

     

       7
       7
       +
       RUN GIT_VERSION=$(git describe --tags --long --always || echo "dev-local") && \

     

       8
       8
       +
           go mod tidy && \

     

       9
       9
       +
           go build -ldflags "-X main.Version=$GIT_VERSION" -o cocoon ./cmd/cocoon

     

       10
       10
       +
       

     

       11
       11
       +
       ### Run stage

     

       12
       12
       +
       FROM debian:bookworm-slim AS run

     

       13
       13
       +
       

     

       14
       14
       +
       RUN apt-get update && apt-get install -y dumb-init runit ca-certificates && rm -rf /var/lib/apt/lists/*

     

       15
       15
       +
       ENTRYPOINT ["dumb-init", "--"]

     

       16
       16
       +
       

     

       17
       17
       +
       WORKDIR /

     

       18
       18
       +
       RUN mkdir -p data/cocoon

     

       19
       19
       +
       COPY --from=build-env /dockerbuild/cocoon /

     

       20
       20
       +
       

     

       21
       21
       +
       CMD ["/cocoon", "run"]

     

       22
       22
       +
       

     

       23
       23
       +
       LABEL org.opencontainers.image.source=https://github.com/haileyok/cocoon

     

       24
       24
       +
       LABEL org.opencontainers.image.description="Cocoon ATProto PDS"

     

       25
       25
       +
       LABEL org.opencontainers.image.licenses=MIT

Makefile

···

       40
       40
        
       

     

       41
       41
        
       .env:

     

       42
       42
        
       	if [ ! -f ".env" ]; then cp example.dev.env .env; fi

     

       43
       43
       +
       

     

       44
       44
       +
       .PHONY: docker-build

     

       45
       45
       +
       docker-build:

     

       46
       46
       +
       	docker build -t cocoon .

+2 -2

README.md

···

       33
       33
        
       

     

       34
       34
        
       ### Server

     

       35
       35
        
       

     

       36
       36
       -
       - [ ] `com.atproto.server.activateAccount`

     

       36
       36
       +
       - [x] `com.atproto.server.activateAccount`

     

       37
       37
        
       - [x] `com.atproto.server.checkAccountStatus`

     

       38
       38
        
       - [x] `com.atproto.server.confirmEmail`

     

       39
       39
        
       - [x] `com.atproto.server.createAccount`

     

       40
       40
        
       - [x] `com.atproto.server.createInviteCode`

     

       41
       41
        
       - [x] `com.atproto.server.createInviteCodes`

     

       42
       42
       -
       - [ ] `com.atproto.server.deactivateAccount`

     

       42
       42
       +
       - [x] `com.atproto.server.deactivateAccount`

     

       43
       43
        
       - [ ] `com.atproto.server.deleteAccount`

     

       44
       44
        
       - [x] `com.atproto.server.deleteSession`

     

       45
       45
        
       - [x] `com.atproto.server.describeServer`

-163

blockstore/blockstore.go

···

       1
       1
       -
       package blockstore

     

       2
       2
       -
       

     

       3
       3
       -
       import (

     

       4
       4
       -
       	"context"

     

       5
       5
       -
       	"fmt"

     

       6
       6
       -
       

     

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

     

       8
       8
       -
       	"github.com/haileyok/cocoon/internal/db"

     

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

     

       10
       10
       -
       	blocks "github.com/ipfs/go-block-format"

     

       11
       11
       -
       	"github.com/ipfs/go-cid"

     

       12
       12
       -
       	"gorm.io/gorm/clause"

     

       13
       13
       -
       )

     

       14
       14
       -
       

     

       15
       15
       -
       type SqliteBlockstore struct {

     

       16
       16
       -
       	db       *db.DB

     

       17
       17
       -
       	did      string

     

       18
       18
       -
       	readonly bool

     

       19
       19
       -
       	inserts  map[cid.Cid]blocks.Block

     

       20
       20
       -
       }

     

       21
       21
       -
       

     

       22
       22
       -
       func New(did string, db *db.DB) *SqliteBlockstore {

     

       23
       23
       -
       	return &SqliteBlockstore{

     

       24
       24
       -
       		did:      did,

     

       25
       25
       -
       		db:       db,

     

       26
       26
       -
       		readonly: false,

     

       27
       27
       -
       		inserts:  map[cid.Cid]blocks.Block{},

     

       28
       28
       -
       	}

     

       29
       29
       -
       }

     

       30
       30
       -
       

     

       31
       31
       -
       func NewReadOnly(did string, db *db.DB) *SqliteBlockstore {

     

       32
       32
       -
       	return &SqliteBlockstore{

     

       33
       33
       -
       		did:      did,

     

       34
       34
       -
       		db:       db,

     

       35
       35
       -
       		readonly: true,

     

       36
       36
       -
       		inserts:  map[cid.Cid]blocks.Block{},

     

       37
       37
       -
       	}

     

       38
       38
       -
       }

     

       39
       39
       -
       

     

       40
       40
       -
       func (bs *SqliteBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {

     

       41
       41
       -
       	var block models.Block

     

       42
       42
       -
       

     

       43
       43
       -
       	maybeBlock, ok := bs.inserts[cid]

     

       44
       44
       -
       	if ok {

     

       45
       45
       -
       		return maybeBlock, nil

     

       46
       46
       -
       	}

     

       47
       47
       -
       

     

       48
       48
       -
       	if err := bs.db.Raw("SELECT * FROM blocks WHERE did = ? AND cid = ?", nil, bs.did, cid.Bytes()).Scan(&block).Error; err != nil {

     

       49
       49
       -
       		return nil, err

     

       50
       50
       -
       	}

     

       51
       51
       -
       

     

       52
       52
       -
       	b, err := blocks.NewBlockWithCid(block.Value, cid)

     

       53
       53
       -
       	if err != nil {

     

       54
       54
       -
       		return nil, err

     

       55
       55
       -
       	}

     

       56
       56
       -
       

     

       57
       57
       -
       	return b, nil

     

       58
       58
       -
       }

     

       59
       59
       -
       

     

       60
       60
       -
       func (bs *SqliteBlockstore) Put(ctx context.Context, block blocks.Block) error {

     

       61
       61
       -
       	bs.inserts[block.Cid()] = block

     

       62
       62
       -
       

     

       63
       63
       -
       	if bs.readonly {

     

       64
       64
       -
       		return nil

     

       65
       65
       -
       	}

     

       66
       66
       -
       

     

       67
       67
       -
       	b := models.Block{

     

       68
       68
       -
       		Did:   bs.did,

     

       69
       69
       -
       		Cid:   block.Cid().Bytes(),

     

       70
       70
       -
       		Rev:   syntax.NewTIDNow(0).String(), // TODO: WARN, this is bad. don't do this

     

       71
       71
       -
       		Value: block.RawData(),

     

       72
       72
       -
       	}

     

       73
       73
       -
       

     

       74
       74
       -
       	if err := bs.db.Create(&b, []clause.Expression{clause.OnConflict{

     

       75
       75
       -
       		Columns:   []clause.Column{{Name: "did"}, {Name: "cid"}},

     

       76
       76
       -
       		UpdateAll: true,

     

       77
       77
       -
       	}}).Error; err != nil {

     

       78
       78
       -
       		return err

     

       79
       79
       -
       	}

     

       80
       80
       -
       

     

       81
       81
       -
       	return nil

     

       82
       82
       -
       }

     

       83
       83
       -
       

     

       84
       84
       -
       func (bs *SqliteBlockstore) DeleteBlock(context.Context, cid.Cid) error {

     

       85
       85
       -
       	panic("not implemented")

     

       86
       86
       -
       }

     

       87
       87
       -
       

     

       88
       88
       -
       func (bs *SqliteBlockstore) Has(context.Context, cid.Cid) (bool, error) {

     

       89
       89
       -
       	panic("not implemented")

     

       90
       90
       -
       }

     

       91
       91
       -
       

     

       92
       92
       -
       func (bs *SqliteBlockstore) GetSize(context.Context, cid.Cid) (int, error) {

     

       93
       93
       -
       	panic("not implemented")

     

       94
       94
       -
       }

     

       95
       95
       -
       

     

       96
       96
       -
       func (bs *SqliteBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {

     

       97
       97
       -
       	tx := bs.db.BeginDangerously()

     

       98
       98
       -
       

     

       99
       99
       -
       	for _, block := range blocks {

     

       100
       100
       -
       		bs.inserts[block.Cid()] = block

     

       101
       101
       -
       

     

       102
       102
       -
       		if bs.readonly {

     

       103
       103
       -
       			continue

     

       104
       104
       -
       		}

     

       105
       105
       -
       

     

       106
       106
       -
       		b := models.Block{

     

       107
       107
       -
       			Did:   bs.did,

     

       108
       108
       -
       			Cid:   block.Cid().Bytes(),

     

       109
       109
       -
       			Rev:   syntax.NewTIDNow(0).String(), // TODO: WARN, this is bad. don't do this

     

       110
       110
       -
       			Value: block.RawData(),

     

       111
       111
       -
       		}

     

       112
       112
       -
       

     

       113
       113
       -
       		if err := tx.Clauses(clause.OnConflict{

     

       114
       114
       -
       			Columns:   []clause.Column{{Name: "did"}, {Name: "cid"}},

     

       115
       115
       -
       			UpdateAll: true,

     

       116
       116
       -
       		}).Create(&b).Error; err != nil {

     

       117
       117
       -
       			tx.Rollback()

     

       118
       118
       -
       			return err

     

       119
       119
       -
       		}

     

       120
       120
       -
       	}

     

       121
       121
       -
       

     

       122
       122
       -
       	if bs.readonly {

     

       123
       123
       -
       		return nil

     

       124
       124
       -
       	}

     

       125
       125
       -
       

     

       126
       126
       -
       	tx.Commit()

     

       127
       127
       -
       

     

       128
       128
       -
       	return nil

     

       129
       129
       -
       }

     

       130
       130
       -
       

     

       131
       131
       -
       func (bs *SqliteBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {

     

       132
       132
       -
       	panic("not implemented")

     

       133
       133
       -
       }

     

       134
       134
       -
       

     

       135
       135
       -
       func (bs *SqliteBlockstore) HashOnRead(enabled bool) {

     

       136
       136
       -
       	panic("not implemented")

     

       137
       137
       -
       }

     

       138
       138
       -
       

     

       139
       139
       -
       func (bs *SqliteBlockstore) UpdateRepo(ctx context.Context, root cid.Cid, rev string) error {

     

       140
       140
       -
       	if err := bs.db.Exec("UPDATE repos SET root = ?, rev = ? WHERE did = ?", nil, root.Bytes(), rev, bs.did).Error; err != nil {

     

       141
       141
       -
       		return err

     

       142
       142
       -
       	}

     

       143
       143
       -
       

     

       144
       144
       -
       	return nil

     

       145
       145
       -
       }

     

       146
       146
       -
       

     

       147
       147
       -
       func (bs *SqliteBlockstore) Execute(ctx context.Context) error {

     

       148
       148
       -
       	if !bs.readonly {

     

       149
       149
       -
       		return fmt.Errorf("blockstore was not readonly")

     

       150
       150
       -
       	}

     

       151
       151
       -
       

     

       152
       152
       -
       	bs.readonly = false

     

       153
       153
       -
       	for _, b := range bs.inserts {

     

       154
       154
       -
       		bs.Put(ctx, b)

     

       155
       155
       -
       	}

     

       156
       156
       -
       	bs.readonly = true

     

       157
       157
       -
       

     

       158
       158
       -
       	return nil

     

       159
       159
       -
       }

     

       160
       160
       -
       

     

       161
       161
       -
       func (bs *SqliteBlockstore) GetLog() map[cid.Cid]blocks.Block {

     

       162
       162
       -
       	return bs.inserts

     

       163
       163
       -
       }

+24 -13

cmd/cocoon/main.go

···

       9
       9
        
       	"os"

     

       10
       10
        
       	"time"

     

       11
       11
        
       

     

       12
       12
       -
       	"github.com/bluesky-social/indigo/atproto/crypto"

     

       12
       12
       +
       	"github.com/bluesky-social/indigo/atproto/atcrypto"

     

       13
       13
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       14
       14
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       15
       15
        
       	"github.com/haileyok/cocoon/server"

     
···

       107
       107
        
       				Name:    "s3-backups-enabled",

     

       108
       108
        
       				EnvVars: []string{"COCOON_S3_BACKUPS_ENABLED"},

     

       109
       109
        
       			},

     

       110
       110
       +
       			&cli.BoolFlag{

     

       111
       111
       +
       				Name:    "s3-blobstore-enabled",

     

       112
       112
       +
       				EnvVars: []string{"COCOON_S3_BLOBSTORE_ENABLED"},

     

       113
       113
       +
       			},

     

       110
       114
        
       			&cli.StringFlag{

     

       111
       115
        
       				Name:    "s3-region",

     

       112
       116
        
       				EnvVars: []string{"COCOON_S3_REGION"},

     
···

       132
       136
        
       				EnvVars: []string{"COCOON_SESSION_SECRET"},

     

       133
       137
        
       			},

     

       134
       138
        
       			&cli.StringFlag{

     

       135
       135
       -
       				Name:    "default-atproto-proxy",

     

       136
       136
       -
       				EnvVars: []string{"COCOON_DEFAULT_ATPROTO_PROXY"},

     

       137
       137
       -
       				Value:   "did:web:api.bsky.app#bsky_appview",

     

       139
       139
       +
       				Name:    "blockstore-variant",

     

       140
       140
       +
       				EnvVars: []string{"COCOON_BLOCKSTORE_VARIANT"},

     

       141
       141
       +
       				Value:   "sqlite",

     

       142
       142
       +
       			},

     

       143
       143
       +
       			&cli.StringFlag{

     

       144
       144
       +
       				Name:    "fallback-proxy",

     

       145
       145
       +
       				EnvVars: []string{"COCOON_FALLBACK_PROXY"},

     

       138
       146
        
       			},

     

       139
       147
        
       		},

     

       140
       148
        
       		Commands: []*cli.Command{

     
···

       158
       166
        
       	Usage: "Start the cocoon PDS",

     

       159
       167
        
       	Flags: []cli.Flag{},

     

       160
       168
        
       	Action: func(cmd *cli.Context) error {

     

       169
       169
       +
       

     

       161
       170
        
       		s, err := server.New(&server.Args{

     

       162
       171
        
       			Addr:            cmd.String("addr"),

     

       163
       172
        
       			DbName:          cmd.String("db-name"),

     
···

       176
       185
        
       			SmtpEmail:       cmd.String("smtp-email"),

     

       177
       186
        
       			SmtpName:        cmd.String("smtp-name"),

     

       178
       187
        
       			S3Config: &server.S3Config{

     

       179
       179
       -
       				BackupsEnabled: cmd.Bool("s3-backups-enabled"),

     

       180
       180
       -
       				Region:         cmd.String("s3-region"),

     

       181
       181
       -
       				Bucket:         cmd.String("s3-bucket"),

     

       182
       182
       -
       				Endpoint:       cmd.String("s3-endpoint"),

     

       183
       183
       -
       				AccessKey:      cmd.String("s3-access-key"),

     

       184
       184
       -
       				SecretKey:      cmd.String("s3-secret-key"),

     

       188
       188
       +
       				BackupsEnabled:   cmd.Bool("s3-backups-enabled"),

     

       189
       189
       +
       				BlobstoreEnabled: cmd.Bool("s3-blobstore-enabled"),

     

       190
       190
       +
       				Region:           cmd.String("s3-region"),

     

       191
       191
       +
       				Bucket:           cmd.String("s3-bucket"),

     

       192
       192
       +
       				Endpoint:         cmd.String("s3-endpoint"),

     

       193
       193
       +
       				AccessKey:        cmd.String("s3-access-key"),

     

       194
       194
       +
       				SecretKey:        cmd.String("s3-secret-key"),

     

       185
       195
        
       			},

     

       186
       186
       -
       			SessionSecret:       cmd.String("session-secret"),

     

       187
       187
       -
       			DefaultAtprotoProxy: cmd.String("default-atproto-proxy"),

     

       196
       196
       +
       			SessionSecret:     cmd.String("session-secret"),

     

       197
       197
       +
       			BlockstoreVariant: server.MustReturnBlockstoreVariant(cmd.String("blockstore-variant")),

     

       198
       198
       +
       			FallbackProxy:     cmd.String("fallback-proxy"),

     

       188
       199
        
       		})

     

       189
       200
        
       		if err != nil {

     

       190
       201
        
       			fmt.Printf("error creating cocoon: %v", err)

     
···

       211
       222
        
       		},

     

       212
       223
        
       	},

     

       213
       224
        
       	Action: func(cmd *cli.Context) error {

     

       214
       214
       -
       		key, err := crypto.GeneratePrivateKeyK256()

     

       225
       225
       +
       		key, err := atcrypto.GeneratePrivateKeyK256()

     

       215
       226
        
       		if err != nil {

     

       216
       227
        
       			return err

     

       217
       228
        
       		}

+2 -2

go.mod

···

       5
       5
        
       require (

     

       6
       6
        
       	github.com/Azure/go-autorest/autorest/to v0.4.1

     

       7
       7
        
       	github.com/aws/aws-sdk-go v1.55.7

     

       8
       8
       -
       	github.com/bluesky-social/indigo v0.0.0-20250414202759-826fcdeaa36b

     

       8
       8
       +
       	github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe

     

       9
       9
        
       	github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792

     

       10
       10
        
       	github.com/domodwyer/mailyak/v3 v3.6.2

     

       11
       11
        
       	github.com/go-pkgz/expirable-cache/v3 v3.0.0

     
···

       18
       18
        
       	github.com/hashicorp/golang-lru/v2 v2.0.7

     

       19
       19
        
       	github.com/ipfs/go-block-format v0.2.0

     

       20
       20
        
       	github.com/ipfs/go-cid v0.4.1

     

       21
       21
       +
       	github.com/ipfs/go-ipfs-blockstore v1.3.1

     

       21
       22
        
       	github.com/ipfs/go-ipld-cbor v0.1.0

     

       22
       23
        
       	github.com/ipld/go-car v0.6.1-0.20230509095817-92d28eb23ba4

     

       23
       24
        
       	github.com/joho/godotenv v1.5.1

     
···

       60
       61
        
       	github.com/ipfs/bbloom v0.0.4 // indirect

     

       61
       62
        
       	github.com/ipfs/go-blockservice v0.5.2 // indirect

     

       62
       63
        
       	github.com/ipfs/go-datastore v0.6.0 // indirect

     

       63
       63
       -
       	github.com/ipfs/go-ipfs-blockstore v1.3.1 // indirect

     

       64
       64
        
       	github.com/ipfs/go-ipfs-ds-help v1.1.1 // indirect

     

       65
       65
        
       	github.com/ipfs/go-ipfs-exchange-interface v0.2.1 // indirect

     

       66
       66
        
       	github.com/ipfs/go-ipfs-util v0.0.3 // indirect

+2 -4

go.sum

···

       16
       16
        
       github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=

     

       17
       17
        
       github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY=

     

       18
       18
        
       github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k=

     

       19
       19
       -
       github.com/bluesky-social/indigo v0.0.0-20250414202759-826fcdeaa36b h1:elwfbe+W7GkUmPKFX1h7HaeHvC/kC0XJWfiEHC62xPg=

     

       20
       20
       -
       github.com/bluesky-social/indigo v0.0.0-20250414202759-826fcdeaa36b/go.mod h1:yjdhLA1LkK8VDS/WPUoYPo25/Hq/8rX38Ftr67EsqKY=

     

       19
       19
       +
       github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe h1:VBhaqE5ewQgXbY5SfSWFZC/AwHFo7cHxZKFYi2ce9Yo=

     

       20
       20
       +
       github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe/go.mod h1:RuQVrCGm42QNsgumKaR6se+XkFKfCPNwdCiTvqKRUck=

     

       21
       21
        
       github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=

     

       22
       22
        
       github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=

     

       23
       23
        
       github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792 h1:R8vQdOQdZ9Y3SkEwmHoWBmX1DNXhXZqlTpq6s4tyJGc=

     
···

       113
       113
        
       github.com/ipfs/go-block-format v0.2.0/go.mod h1:+jpL11nFx5A/SPpsoBn6Bzkra/zaArfSmsknbPMYgzM=

     

       114
       114
        
       github.com/ipfs/go-blockservice v0.5.2 h1:in9Bc+QcXwd1apOVM7Un9t8tixPKdaHQFdLSUM1Xgk8=

     

       115
       115
        
       github.com/ipfs/go-blockservice v0.5.2/go.mod h1:VpMblFEqG67A/H2sHKAemeH9vlURVavlysbdUI632yk=

     

       116
       116
       -
       github.com/ipfs/go-bs-sqlite3 v0.0.0-20221122195556-bfcee1be620d h1:9V+GGXCuOfDiFpdAHz58q9mKLg447xp0cQKvqQrAwYE=

     

       117
       117
       -
       github.com/ipfs/go-bs-sqlite3 v0.0.0-20221122195556-bfcee1be620d/go.mod h1:pMbnFyNAGjryYCLCe59YDLRv/ujdN+zGJBT1umlvYRM=

     

       118
       116
        
       github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s=

     

       119
       117
        
       github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk=

     

       120
       118
        
       github.com/ipfs/go-datastore v0.6.0 h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk=

+74 -55

identity/identity.go

···

       13
       13
        
       	"github.com/bluesky-social/indigo/util"

     

       14
       14
        
       )

     

       15
       15
        
       

     

       16
       16
       -
       func ResolveHandle(ctx context.Context, cli *http.Client, handle string) (string, error) {

     

       17
       17
       -
       	if cli == nil {

     

       18
       18
       -
       		cli = util.RobustHTTPClient()

     

       16
       16
       +
       func ResolveHandleFromTXT(ctx context.Context, handle string) (string, error) {

     

       17
       17
       +
       	name := fmt.Sprintf("_atproto.%s", handle)

     

       18
       18
       +
       	recs, err := net.LookupTXT(name)

     

       19
       19
       +
       	if err != nil {

     

       20
       20
       +
       		return "", fmt.Errorf("handle could not be resolved via txt: %w", err)

     

       21
       21
       +
       	}

     

       22
       22
       +
       

     

       23
       23
       +
       	for _, rec := range recs {

     

       24
       24
       +
       		if strings.HasPrefix(rec, "did=") {

     

       25
       25
       +
       			maybeDid := strings.Split(rec, "did=")[1]

     

       26
       26
       +
       			if _, err := syntax.ParseDID(maybeDid); err == nil {

     

       27
       27
       +
       				return maybeDid, nil

     

       28
       28
       +
       			}

     

       29
       29
       +
       		}

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	return "", fmt.Errorf("handle could not be resolved via txt: no record found")

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       func ResolveHandleFromWellKnown(ctx context.Context, cli *http.Client, handle string) (string, error) {

     

       36
       36
       +
       	ustr := fmt.Sprintf("https://%s/.well-known/atproto-did", handle)

     

       37
       37
       +
       	req, err := http.NewRequestWithContext(

     

       38
       38
       +
       		ctx,

     

       39
       39
       +
       		"GET",

     

       40
       40
       +
       		ustr,

     

       41
       41
       +
       		nil,

     

       42
       42
       +
       	)

     

       43
       43
       +
       	if err != nil {

     

       44
       44
       +
       		return "", fmt.Errorf("handle could not be resolved via web: %w", err)

     

       19
       45
        
       	}

     

       20
       46
        
       

     

       21
       21
       -
       	var did string

     

       47
       47
       +
       	resp, err := cli.Do(req)

     

       48
       48
       +
       	if err != nil {

     

       49
       49
       +
       		return "", fmt.Errorf("handle could not be resolved via web: %w", err)

     

       50
       50
       +
       	}

     

       51
       51
       +
       	defer resp.Body.Close()

     

       22
       52
        
       

     

       23
       23
       -
       	_, err := syntax.ParseHandle(handle)

     

       53
       53
       +
       	b, err := io.ReadAll(resp.Body)

     

       24
       54
        
       	if err != nil {

     

       25
       25
       -
       		return "", err

     

       55
       55
       +
       		return "", fmt.Errorf("handle could not be resolved via web: %w", err)

     

       26
       56
        
       	}

     

       27
       57
        
       

     

       28
       28
       -
       	recs, err := net.LookupTXT(fmt.Sprintf("_atproto.%s", handle))

     

       29
       29
       -
       	if err == nil {

     

       30
       30
       -
       		for _, rec := range recs {

     

       31
       31
       -
       			if strings.HasPrefix(rec, "did=") {

     

       32
       32
       -
       				did = strings.Split(rec, "did=")[1]

     

       33
       33
       -
       				break

     

       34
       34
       -
       			}

     

       35
       35
       -
       		}

     

       36
       36
       -
       	} else {

     

       37
       37
       -
       		fmt.Printf("erorr getting txt records: %v\n", err)

     

       58
       58
       +
       	if resp.StatusCode != http.StatusOK {

     

       59
       59
       +
       		return "", fmt.Errorf("handle could not be resolved via web: invalid status code %d", resp.StatusCode)

     

       38
       60
        
       	}

     

       39
       61
        
       

     

       40
       40
       -
       	if did == "" {

     

       41
       41
       -
       		req, err := http.NewRequestWithContext(

     

       42
       42
       -
       			ctx,

     

       43
       43
       -
       			"GET",

     

       44
       44
       -
       			fmt.Sprintf("https://%s/.well-known/atproto-did", handle),

     

       45
       45
       -
       			nil,

     

       46
       46
       -
       		)

     

       47
       47
       -
       		if err != nil {

     

       48
       48
       -
       			return "", nil

     

       49
       49
       -
       		}

     

       62
       62
       +
       	maybeDid := string(b)

     

       50
       63
        
       

     

       51
       51
       -
       		resp, err := http.DefaultClient.Do(req)

     

       52
       52
       -
       		if err != nil {

     

       53
       53
       -
       			return "", nil

     

       54
       54
       -
       		}

     

       55
       55
       -
       		defer resp.Body.Close()

     

       64
       64
       +
       	if _, err := syntax.ParseDID(maybeDid); err != nil {

     

       65
       65
       +
       		return "", fmt.Errorf("handle could not be resolved via web: invalid did in document")

     

       66
       66
       +
       	}

     

       56
       67
        
       

     

       57
       57
       -
       		if resp.StatusCode != http.StatusOK {

     

       58
       58
       -
       			io.Copy(io.Discard, resp.Body)

     

       59
       59
       -
       			return "", fmt.Errorf("unable to resolve handle")

     

       60
       60
       -
       		}

     

       68
       68
       +
       	return maybeDid, nil

     

       69
       69
       +
       }

     

       61
       70
        
       

     

       62
       62
       -
       		b, err := io.ReadAll(resp.Body)

     

       63
       63
       -
       		if err != nil {

     

       64
       64
       -
       			return "", err

     

       65
       65
       -
       		}

     

       71
       71
       +
       func ResolveHandle(ctx context.Context, cli *http.Client, handle string) (string, error) {

     

       72
       72
       +
       	if cli == nil {

     

       73
       73
       +
       		cli = util.RobustHTTPClient()

     

       74
       74
       +
       	}

     

       66
       75
        
       

     

       67
       67
       -
       		maybeDid := string(b)

     

       76
       76
       +
       	_, err := syntax.ParseHandle(handle)

     

       77
       77
       +
       	if err != nil {

     

       78
       78
       +
       		return "", err

     

       79
       79
       +
       	}

     

       68
       80
        
       

     

       69
       69
       -
       		if _, err := syntax.ParseDID(maybeDid); err != nil {

     

       70
       70
       -
       			return "", fmt.Errorf("unable to resolve handle")

     

       71
       71
       -
       		}

     

       81
       81
       +
       	if maybeDidFromTxt, err := ResolveHandleFromTXT(ctx, handle); err == nil {

     

       82
       82
       +
       		return maybeDidFromTxt, nil

     

       83
       83
       +
       	}

     

       72
       84
        
       

     

       73
       73
       -
       		did = maybeDid

     

       85
       85
       +
       	if maybeDidFromWeb, err := ResolveHandleFromWellKnown(ctx, cli, handle); err == nil {

     

       86
       86
       +
       		return maybeDidFromWeb, nil

     

       74
       87
        
       	}

     

       75
       88
        
       

     

       76
       76
       -
       	return did, nil

     

       89
       89
       +
       	return "", fmt.Errorf("handle could not be resolved")

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       92
       92
       +
       func DidToDocUrl(did string) (string, error) {

     

       93
       93
       +
       	if strings.HasPrefix(did, "did:plc:") {

     

       94
       94
       +
       		return fmt.Sprintf("https://plc.directory/%s", did), nil

     

       95
       95
       +
       	} else if after, ok := strings.CutPrefix(did, "did:web:"); ok {

     

       96
       96
       +
       		return fmt.Sprintf("https://%s/.well-known/did.json", after), nil

     

       97
       97
       +
       	} else {

     

       98
       98
       +
       		return "", fmt.Errorf("did was not a supported did type")

     

       99
       99
       +
       	}

     

       77
       100
        
       }

     

       78
       101
        
       

     

       79
       102
        
       func FetchDidDoc(ctx context.Context, cli *http.Client, did string) (*DidDoc, error) {

     
···

       81
       104
        
       		cli = util.RobustHTTPClient()

     

       82
       105
        
       	}

     

       83
       106
        
       

     

       84
       84
       -
       	var ustr string

     

       85
       85
       -
       	if strings.HasPrefix(did, "did:plc:") {

     

       86
       86
       -
       		ustr = fmt.Sprintf("https://plc.directory/%s", did)

     

       87
       87
       -
       	} else if strings.HasPrefix(did, "did:web:") {

     

       88
       88
       -
       		ustr = fmt.Sprintf("https://%s/.well-known/did.json", strings.TrimPrefix(did, "did:web:"))

     

       89
       89
       -
       	} else {

     

       90
       90
       -
       		return nil, fmt.Errorf("did was not a supported did type")

     

       107
       107
       +
       	ustr, err := DidToDocUrl(did)

     

       108
       108
       +
       	if err != nil {

     

       109
       109
       +
       		return nil, err

     

       91
       110
        
       	}

     

       92
       111
        
       

     

       93
       112
        
       	req, err := http.NewRequestWithContext(ctx, "GET", ustr, nil)

     
···

       95
       114
        
       		return nil, err

     

       96
       115
        
       	}

     

       97
       116
        
       

     

       98
       98
       -
       	resp, err := http.DefaultClient.Do(req)

     

       117
       117
       +
       	resp, err := cli.Do(req)

     

       99
       118
        
       	if err != nil {

     

       100
       119
        
       		return nil, err

     

       101
       120
        
       	}

     
···

       103
       122
        
       

     

       104
       123
        
       	if resp.StatusCode != 200 {

     

       105
       124
        
       		io.Copy(io.Discard, resp.Body)

     

       106
       106
       -
       		return nil, fmt.Errorf("could not find identity in plc registry")

     

       125
       125
       +
       		return nil, fmt.Errorf("unable to find did doc at url. did: %s. url: %s", did, ustr)

     

       107
       126
        
       	}

     

       108
       127
        
       

     

       109
       128
        
       	var diddoc DidDoc

     
···

       127
       146
        
       		return nil, err

     

       128
       147
        
       	}

     

       129
       148
        
       

     

       130
       130
       -
       	resp, err := http.DefaultClient.Do(req)

     

       149
       149
       +
       	resp, err := cli.Do(req)

     

       131
       150
        
       	if err != nil {

     

       132
       151
        
       		return nil, err

     

       133
       152
        
       	}

+15 -5

identity/passport.go

···

       19
       19
        
       type Passport struct {

     

       20
       20
        
       	h  *http.Client

     

       21
       21
        
       	bc BackingCache

     

       22
       22
       -
       	lk sync.Mutex

     

       22
       22
       +
       	mu sync.RWMutex

     

       23
       23
        
       }

     

       24
       24
        
       

     

       25
       25
        
       func NewPassport(h *http.Client, bc BackingCache) *Passport {

     
···

       30
       30
        
       	return &Passport{

     

       31
       31
        
       		h:  h,

     

       32
       32
        
       		bc: bc,

     

       33
       33
       -
       		lk: sync.Mutex{},

     

       34
       33
        
       	}

     

       35
       34
        
       }

     

       36
       35
        
       

     
···

       38
       37
        
       	skipCache, _ := ctx.Value("skip-cache").(bool)

     

       39
       38
        
       

     

       40
       39
        
       	if !skipCache {

     

       40
       40
       +
       		p.mu.RLock()

     

       41
       41
        
       		cached, ok := p.bc.GetDoc(did)

     

       42
       42
       +
       		p.mu.RUnlock()

     

       43
       43
       +
       

     

       42
       44
        
       		if ok {

     

       43
       45
        
       			return cached, nil

     

       44
       46
        
       		}

     

       45
       47
        
       	}

     

       46
       48
        
       

     

       47
       47
       -
       	p.lk.Lock() // this is pretty pathetic, and i should rethink this. but for now, fuck it

     

       48
       48
       -
       	defer p.lk.Unlock()

     

       49
       49
       -
       

     

       50
       49
        
       	doc, err := FetchDidDoc(ctx, p.h, did)

     

       51
       50
        
       	if err != nil {

     

       52
       51
        
       		return nil, err

     

       53
       52
        
       	}

     

       54
       53
        
       

     

       54
       54
       +
       	p.mu.Lock()

     

       55
       55
        
       	p.bc.PutDoc(did, doc)

     

       56
       56
       +
       	p.mu.Unlock()

     

       56
       57
        
       

     

       57
       58
        
       	return doc, nil

     

       58
       59
        
       }

     
···

       61
       62
        
       	skipCache, _ := ctx.Value("skip-cache").(bool)

     

       62
       63
        
       

     

       63
       64
        
       	if !skipCache {

     

       65
       65
       +
       		p.mu.RLock()

     

       64
       66
        
       		cached, ok := p.bc.GetDid(handle)

     

       67
       67
       +
       		p.mu.RUnlock()

     

       68
       68
       +
       

     

       65
       69
        
       		if ok {

     

       66
       70
        
       			return cached, nil

     

       67
       71
        
       		}

     
···

       72
       76
        
       		return "", err

     

       73
       77
        
       	}

     

       74
       78
        
       

     

       79
       79
       +
       	p.mu.Lock()

     

       75
       80
        
       	p.bc.PutDid(handle, did)

     

       81
       81
       +
       	p.mu.Unlock()

     

       76
       82
        
       

     

       77
       83
        
       	return did, nil

     

       78
       84
        
       }

     

       79
       85
        
       

     

       80
       86
        
       func (p *Passport) BustDoc(ctx context.Context, did string) error {

     

       87
       87
       +
       	p.mu.Lock()

     

       88
       88
       +
       	defer p.mu.Unlock()

     

       81
       89
        
       	return p.bc.BustDoc(did)

     

       82
       90
        
       }

     

       83
       91
        
       

     

       84
       92
        
       func (p *Passport) BustDid(ctx context.Context, handle string) error {

     

       93
       93
       +
       	p.mu.Lock()

     

       94
       94
       +
       	defer p.mu.Unlock()

     

       85
       95
        
       	return p.bc.BustDid(handle)

     

       86
       96
        
       }

+17 -2

models/models.go

···

       4
       4
        
       	"context"

     

       5
       5
        
       	"time"

     

       6
       6
        
       

     

       7
       7
       -
       	"github.com/bluesky-social/indigo/atproto/crypto"

     

       7
       7
       +
       	"github.com/Azure/go-autorest/autorest/to"

     

       8
       8
       +
       	"github.com/bluesky-social/indigo/atproto/atcrypto"

     

       8
       9
        
       )

     

       9
       10
        
       

     

       10
       11
        
       type Repo struct {

     
···

       23
       24
        
       	Rev                            string

     

       24
       25
        
       	Root                           []byte

     

       25
       26
        
       	Preferences                    []byte

     

       27
       27
       +
       	Deactivated                    bool

     

       26
       28
        
       }

     

       27
       29
        
       

     

       28
       30
        
       func (r *Repo) SignFor(ctx context.Context, did string, msg []byte) ([]byte, error) {

     

       29
       29
       -
       	k, err := crypto.ParsePrivateBytesK256(r.SigningKey)

     

       31
       31
       +
       	k, err := atcrypto.ParsePrivateBytesK256(r.SigningKey)

     

       30
       32
        
       	if err != nil {

     

       31
       33
        
       		return nil, err

     

       32
       34
        
       	}

     
···

       37
       39
        
       	}

     

       38
       40
        
       

     

       39
       41
        
       	return sig, nil

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       func (r *Repo) Status() *string {

     

       45
       45
       +
       	var status *string

     

       46
       46
       +
       	if r.Deactivated {

     

       47
       47
       +
       		status = to.StringPtr("deactivated")

     

       48
       48
       +
       	}

     

       49
       49
       +
       	return status

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       func (r *Repo) Active() bool {

     

       53
       53
       +
       	return r.Status() == nil

     

       40
       54
        
       }

     

       41
       55
        
       

     

       42
       56
        
       type Actor struct {

     
···

       92
       106
        
       	Did       string `gorm:"index;index:idx_blob_did_cid"`

     

       93
       107
        
       	Cid       []byte `gorm:"index;index:idx_blob_did_cid"`

     

       94
       108
        
       	RefCount  int

     

       109
       109
       +
       	Storage   string `gorm:"default:sqlite;check:storage in ('sqlite', 's3')"`

     

       95
       110
        
       }

     

       96
       111
        
       

     

       97
       112
        
       type BlobPart struct {

+11 -3

oauth/client/manager.go

···

       57
       57
        
       	}

     

       58
       58
        
       

     

       59
       59
        
       	var jwks jwk.Key

     

       60
       60
       -
       	if metadata.JWKS != nil {

     

       60
       60
       +
       	if metadata.JWKS != nil && len(metadata.JWKS.Keys) > 0 {

     

       61
       61
        
       		// TODO: this is kinda bad but whatever for now. there could obviously be more than one jwk, and we need to

     

       62
       62
        
       		// make sure we use the right one

     

       63
       63
       -
       		k, err := helpers.ParseJWKFromBytes((*metadata.JWKS)[0])

     

       63
       63
       +
       		b, err := json.Marshal(metadata.JWKS.Keys[0])

     

       64
       64
        
       		if err != nil {

     

       65
       65
        
       			return nil, err

     

       66
       66
        
       		}

     

       67
       67
       +
       

     

       68
       68
       +
       		k, err := helpers.ParseJWKFromBytes(b)

     

       69
       69
       +
       		if err != nil {

     

       70
       70
       +
       			return nil, err

     

       71
       71
       +
       		}

     

       72
       72
       +
       

     

       67
       73
        
       		jwks = k

     

       68
       74
        
       	} else if metadata.JWKSURI != nil {

     

       69
       75
        
       		maybeJwks, err := cm.getClientJwks(ctx, clientId, *metadata.JWKSURI)

     
···

       72
       78
        
       		}

     

       73
       79
        
       

     

       74
       80
        
       		jwks = maybeJwks

     

       81
       81
       +
       	} else {

     

       82
       82
       +
       		return nil, fmt.Errorf("no valid jwks found in oauth client metadata")

     

       75
       83
        
       	}

     

       76
       84
        
       

     

       77
       85
        
       	return &Client{

     
···

       262
       270
        
       			return nil, errors.New("private_key_jwt auth method requires jwks or jwks_uri")

     

       263
       271
        
       		}

     

       264
       272
        
       

     

       265
       265
       -
       		if metadata.JWKS != nil && len(*metadata.JWKS) == 0 {

     

       273
       273
       +
       		if metadata.JWKS != nil && len(metadata.JWKS.Keys) == 0 {

     

       266
       274
        
       			return nil, errors.New("private_key_jwt auth method requires atleast one key in jwks")

     

       267
       275
        
       		}

     

       268
       276

+20 -16

oauth/client/metadata.go

···

       1
       1
        
       package client

     

       2
       2
        
       

     

       3
       3
        
       type Metadata struct {

     

       4
       4
       -
       	ClientID                    string    `json:"client_id"`

     

       5
       5
       -
       	ClientName                  string    `json:"client_name"`

     

       6
       6
       -
       	ClientURI                   string    `json:"client_uri"`

     

       7
       7
       -
       	LogoURI                     string    `json:"logo_uri"`

     

       8
       8
       -
       	TOSURI                      string    `json:"tos_uri"`

     

       9
       9
       -
       	PolicyURI                   string    `json:"policy_uri"`

     

       10
       10
       -
       	RedirectURIs                []string  `json:"redirect_uris"`

     

       11
       11
       -
       	GrantTypes                  []string  `json:"grant_types"`

     

       12
       12
       -
       	ResponseTypes               []string  `json:"response_types"`

     

       13
       13
       -
       	ApplicationType             string    `json:"application_type"`

     

       14
       14
       -
       	DpopBoundAccessTokens       bool      `json:"dpop_bound_access_tokens"`

     

       15
       15
       -
       	JWKSURI                     *string   `json:"jwks_uri,omitempty"`

     

       16
       16
       -
       	JWKS                        *[][]byte `json:"jwks,omitempty"`

     

       17
       17
       -
       	Scope                       string    `json:"scope"`

     

       18
       18
       -
       	TokenEndpointAuthMethod     string    `json:"token_endpoint_auth_method"`

     

       19
       19
       -
       	TokenEndpointAuthSigningAlg string    `json:"token_endpoint_auth_signing_alg"`

     

       4
       4
       +
       	ClientID                    string        `json:"client_id"`

     

       5
       5
       +
       	ClientName                  string        `json:"client_name"`

     

       6
       6
       +
       	ClientURI                   string        `json:"client_uri"`

     

       7
       7
       +
       	LogoURI                     string        `json:"logo_uri"`

     

       8
       8
       +
       	TOSURI                      string        `json:"tos_uri"`

     

       9
       9
       +
       	PolicyURI                   string        `json:"policy_uri"`

     

       10
       10
       +
       	RedirectURIs                []string      `json:"redirect_uris"`

     

       11
       11
       +
       	GrantTypes                  []string      `json:"grant_types"`

     

       12
       12
       +
       	ResponseTypes               []string      `json:"response_types"`

     

       13
       13
       +
       	ApplicationType             string        `json:"application_type"`

     

       14
       14
       +
       	DpopBoundAccessTokens       bool          `json:"dpop_bound_access_tokens"`

     

       15
       15
       +
       	JWKSURI                     *string       `json:"jwks_uri,omitempty"`

     

       16
       16
       +
       	JWKS                        *MetadataJwks `json:"jwks,omitempty"`

     

       17
       17
       +
       	Scope                       string        `json:"scope"`

     

       18
       18
       +
       	TokenEndpointAuthMethod     string        `json:"token_endpoint_auth_method"`

     

       19
       19
       +
       	TokenEndpointAuthSigningAlg string        `json:"token_endpoint_auth_signing_alg"`

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       type MetadataJwks struct {

     

       23
       23
       +
       	Keys []any `json:"keys"`

     

       20
       24
        
       }

+6 -2

oauth/dpop/manager.go

···

       36
       36
        
       	Hostname              string

     

       37
       37
        
       }

     

       38
       38
        
       

     

       39
       39
       +
       var (

     

       40
       40
       +
       	ErrUseDpopNonce = errors.New("use_dpop_nonce")

     

       41
       41
       +
       )

     

       42
       42
       +
       

     

       39
       43
        
       func NewManager(args ManagerArgs) *Manager {

     

       40
       44
        
       	if args.Logger == nil {

     

       41
       45
        
       		args.Logger = slog.Default()

     
···

       194
       198
        
       	nonce, _ := claims["nonce"].(string)

     

       195
       199
        
       	if nonce == "" {

     

       196
       200
        
       		// WARN: this _must_ be `use_dpop_nonce` for clients know they should make another request

     

       197
       197
       -
       		return nil, errors.New("use_dpop_nonce")

     

       201
       201
       +
       		return nil, ErrUseDpopNonce

     

       198
       202
        
       	}

     

       199
       203
        
       

     

       200
       204
        
       	if nonce != "" && !dm.nonce.Check(nonce) {

     

       201
       205
        
       		// WARN: this _must_ be `use_dpop_nonce` so that clients will fetch a new nonce

     

       202
       202
       -
       		return nil, errors.New("use_dpop_nonce")

     

       206
       206
       +
       		return nil, ErrUseDpopNonce

     

       203
       207
        
       	}

     

       204
       208
        
       

     

       205
       209
        
       	ath, _ := claims["ath"].(string)

+5 -5

plc/client.go

···

       13
       13
        
       	"net/url"

     

       14
       14
        
       	"strings"

     

       15
       15
        
       

     

       16
       16
       -
       	"github.com/bluesky-social/indigo/atproto/crypto"

     

       16
       16
       +
       	"github.com/bluesky-social/indigo/atproto/atcrypto"

     

       17
       17
        
       	"github.com/bluesky-social/indigo/util"

     

       18
       18
        
       	"github.com/haileyok/cocoon/identity"

     

       19
       19
        
       )

     
···

       22
       22
        
       	h           *http.Client

     

       23
       23
        
       	service     string

     

       24
       24
        
       	pdsHostname string

     

       25
       25
       -
       	rotationKey *crypto.PrivateKeyK256

     

       25
       25
       +
       	rotationKey *atcrypto.PrivateKeyK256

     

       26
       26
        
       }

     

       27
       27
        
       

     

       28
       28
        
       type ClientArgs struct {

     
···

       41
       41
        
       		args.H = util.RobustHTTPClient()

     

       42
       42
        
       	}

     

       43
       43
        
       

     

       44
       44
       -
       	rk, err := crypto.ParsePrivateBytesK256([]byte(args.RotationKey))

     

       44
       44
       +
       	rk, err := atcrypto.ParsePrivateBytesK256([]byte(args.RotationKey))

     

       45
       45
        
       	if err != nil {

     

       46
       46
        
       		return nil, err

     

       47
       47
        
       	}

     
···

       54
       54
        
       	}, nil

     

       55
       55
        
       }

     

       56
       56
        
       

     

       57
       57
       -
       func (c *Client) CreateDID(sigkey *crypto.PrivateKeyK256, recovery string, handle string) (string, *Operation, error) {

     

       57
       57
       +
       func (c *Client) CreateDID(sigkey *atcrypto.PrivateKeyK256, recovery string, handle string) (string, *Operation, error) {

     

       58
       58
        
       	pubsigkey, err := sigkey.PublicKey()

     

       59
       59
        
       	if err != nil {

     

       60
       60
        
       		return "", nil, err

     
···

       107
       107
        
       	return did, &op, nil

     

       108
       108
        
       }

     

       109
       109
        
       

     

       110
       110
       -
       func (c *Client) SignOp(sigkey *crypto.PrivateKeyK256, op *Operation) error {

     

       110
       110
       +
       func (c *Client) SignOp(sigkey *atcrypto.PrivateKeyK256, op *Operation) error {

     

       111
       111
        
       	b, err := op.MarshalCBOR()

     

       112
       112
        
       	if err != nil {

     

       113
       113
        
       		return err

+2 -2

plc/types.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"encoding/json"

     

       5
       5
        
       

     

       6
       6
       -
       	"github.com/bluesky-social/indigo/atproto/data"

     

       6
       6
       +
       	"github.com/bluesky-social/indigo/atproto/atdata"

     

       7
       7
        
       	"github.com/haileyok/cocoon/identity"

     

       8
       8
        
       	cbg "github.com/whyrusleeping/cbor-gen"

     

       9
       9
        
       )

     
···

       38
       38
        
       		return nil, err

     

       39
       39
        
       	}

     

       40
       40
        
       

     

       41
       41
       -
       	b, err = data.MarshalCBOR(m)

     

       41
       41
       +
       	b, err = atdata.MarshalCBOR(m)

     

       42
       42
        
       	if err != nil {

     

       43
       43
        
       		return nil, err

     

       44
       44
        
       	}

+85

recording_blockstore/recording_blockstore.go

···

       1
       1
       +
       package recording_blockstore

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       

     

       7
       7
       +
       	blockformat "github.com/ipfs/go-block-format"

     

       8
       8
       +
       	"github.com/ipfs/go-cid"

     

       9
       9
       +
       	blockstore "github.com/ipfs/go-ipfs-blockstore"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       type RecordingBlockstore struct {

     

       13
       13
       +
       	base blockstore.Blockstore

     

       14
       14
       +
       

     

       15
       15
       +
       	inserts map[cid.Cid]blockformat.Block

     

       16
       16
       +
       	reads   map[cid.Cid]blockformat.Block

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       func New(base blockstore.Blockstore) *RecordingBlockstore {

     

       20
       20
       +
       	return &RecordingBlockstore{

     

       21
       21
       +
       		base:    base,

     

       22
       22
       +
       		inserts: make(map[cid.Cid]blockformat.Block),

     

       23
       23
       +
       		reads:   make(map[cid.Cid]blockformat.Block),

     

       24
       24
       +
       	}

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       func (bs *RecordingBlockstore) Has(ctx context.Context, c cid.Cid) (bool, error) {

     

       28
       28
       +
       	return bs.base.Has(ctx, c)

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       func (bs *RecordingBlockstore) Get(ctx context.Context, c cid.Cid) (blockformat.Block, error) {

     

       32
       32
       +
       	b, err := bs.base.Get(ctx, c)

     

       33
       33
       +
       	if err != nil {

     

       34
       34
       +
       		return nil, err

     

       35
       35
       +
       	}

     

       36
       36
       +
       	bs.reads[c] = b

     

       37
       37
       +
       	return b, nil

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func (bs *RecordingBlockstore) GetSize(ctx context.Context, c cid.Cid) (int, error) {

     

       41
       41
       +
       	return bs.base.GetSize(ctx, c)

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       func (bs *RecordingBlockstore) DeleteBlock(ctx context.Context, c cid.Cid) error {

     

       45
       45
       +
       	return bs.base.DeleteBlock(ctx, c)

     

       46
       46
       +
       }

     

       47
       47
       +
       

     

       48
       48
       +
       func (bs *RecordingBlockstore) Put(ctx context.Context, block blockformat.Block) error {

     

       49
       49
       +
       	if err := bs.base.Put(ctx, block); err != nil {

     

       50
       50
       +
       		return err

     

       51
       51
       +
       	}

     

       52
       52
       +
       	bs.inserts[block.Cid()] = block

     

       53
       53
       +
       	return nil

     

       54
       54
       +
       }

     

       55
       55
       +
       

     

       56
       56
       +
       func (bs *RecordingBlockstore) PutMany(ctx context.Context, blocks []blockformat.Block) error {

     

       57
       57
       +
       	if err := bs.base.PutMany(ctx, blocks); err != nil {

     

       58
       58
       +
       		return err

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	for _, b := range blocks {

     

       62
       62
       +
       		bs.inserts[b.Cid()] = b

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	return nil

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       func (bs *RecordingBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {

     

       69
       69
       +
       	return nil, fmt.Errorf("iteration not allowed on recording blockstore")

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       func (bs *RecordingBlockstore) HashOnRead(enabled bool) {

     

       73
       73
       +
       }

     

       74
       74
       +
       

     

       75
       75
       +
       func (bs *RecordingBlockstore) GetWriteLog() map[cid.Cid]blockformat.Block {

     

       76
       76
       +
       	return bs.inserts

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       func (bs *RecordingBlockstore) GetReadLog() []blockformat.Block {

     

       80
       80
       +
       	var blocks []blockformat.Block

     

       81
       81
       +
       	for _, b := range bs.reads {

     

       82
       82
       +
       		blocks = append(blocks, b)

     

       83
       83
       +
       	}

     

       84
       84
       +
       	return blocks

     

       85
       85
       +
       }

+30

server/blockstore_variant.go

···

       1
       1
       +
       package server

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"github.com/haileyok/cocoon/sqlite_blockstore"

     

       5
       5
       +
       	blockstore "github.com/ipfs/go-ipfs-blockstore"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       type BlockstoreVariant int

     

       9
       9
       +
       

     

       10
       10
       +
       const (

     

       11
       11
       +
       	BlockstoreVariantSqlite = iota

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       func MustReturnBlockstoreVariant(maybeBsv string) BlockstoreVariant {

     

       15
       15
       +
       	switch maybeBsv {

     

       16
       16
       +
       	case "sqlite":

     

       17
       17
       +
       		return BlockstoreVariantSqlite

     

       18
       18
       +
       	default:

     

       19
       19
       +
       		panic("invalid blockstore variant provided")

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       func (s *Server) getBlockstore(did string) blockstore.Blockstore {

     

       24
       24
       +
       	switch s.config.BlockstoreVariant {

     

       25
       25
       +
       	case BlockstoreVariantSqlite:

     

       26
       26
       +
       		return sqlite_blockstore.New(did, s.db)

     

       27
       27
       +
       	default:

     

       28
       28
       +
       		return sqlite_blockstore.New(did, s.db)

     

       29
       29
       +
       	}

     

       30
       30
       +
       }

+1 -1

server/handle_actor_get_preferences.go

···

       16
       16
        
       	err := json.Unmarshal(repo.Preferences, &prefs)

     

       17
       17
        
       	if err != nil || prefs["preferences"] == nil {

     

       18
       18
        
       		prefs = map[string]any{

     

       19
       19
       -
       			"preferences": map[string]any{},

     

       19
       19
       +
       			"preferences": []any{},

     

       20
       20
        
       		}

     

       21
       21
        
       	}

     

       22
       22

+2 -11

server/handle_identity_update_handle.go

···

       7
       7
        
       

     

       8
       8
        
       	"github.com/Azure/go-autorest/autorest/to"

     

       9
       9
        
       	"github.com/bluesky-social/indigo/api/atproto"

     

       10
       10
       -
       	"github.com/bluesky-social/indigo/atproto/crypto"

     

       10
       10
       +
       	"github.com/bluesky-social/indigo/atproto/atcrypto"

     

       11
       11
        
       	"github.com/bluesky-social/indigo/events"

     

       12
       12
        
       	"github.com/bluesky-social/indigo/util"

     

       13
       13
        
       	"github.com/haileyok/cocoon/identity"

     
···

       66
       66
        
       			Prev:                &latest.Cid,

     

       67
       67
        
       		}

     

       68
       68
        
       

     

       69
       69
       -
       		k, err := crypto.ParsePrivateBytesK256(repo.SigningKey)

     

       69
       69
       +
       		k, err := atcrypto.ParsePrivateBytesK256(repo.SigningKey)

     

       70
       70
        
       		if err != nil {

     

       71
       71
        
       			s.logger.Error("error parsing signing key", "error", err)

     

       72
       72
        
       			return helpers.ServerError(e, nil)

     
···

       84
       84
        
       	if err := s.passport.BustDoc(context.TODO(), repo.Repo.Did); err != nil {

     

       85
       85
        
       		s.logger.Warn("error busting did doc", "error", err)

     

       86
       86
        
       	}

     

       87
       87
       -
       

     

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

     

       89
       89
       -
       		RepoHandle: &atproto.SyncSubscribeRepos_Handle{

     

       90
       90
       -
       			Did:    repo.Repo.Did,

     

       91
       91
       -
       			Handle: req.Handle,

     

       92
       92
       -
       			Seq:    time.Now().UnixMicro(), // TODO: no

     

       93
       93
       -
       			Time:   time.Now().Format(util.ISO8601),

     

       94
       94
       -
       		},

     

       95
       95
       -
       	})

     

       96
       87
        
       

     

       97
       88
        
       	s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{

     

       98
       89
        
       		RepoIdentity: &atproto.SyncSubscribeRepos_Identity{

+2 -3

server/handle_import_repo.go

···

       9
       9
        
       

     

       10
       10
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       11
       11
        
       	"github.com/bluesky-social/indigo/repo"

     

       12
       12
       -
       	"github.com/haileyok/cocoon/blockstore"

     

       13
       12
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       14
       13
        
       	"github.com/haileyok/cocoon/models"

     

       15
       14
        
       	blocks "github.com/ipfs/go-block-format"

     
···

       27
       26
        
       		return helpers.ServerError(e, nil)

     

       28
       27
        
       	}

     

       29
       28
        
       

     

       30
       30
       -
       	bs := blockstore.New(urepo.Repo.Did, s.db)

     

       29
       29
       +
       	bs := s.getBlockstore(urepo.Repo.Did)

     

       31
       30
        
       

     

       32
       31
        
       	cs, err := car.NewCarReader(bytes.NewReader(b))

     

       33
       32
        
       	if err != nil {

     
···

       107
       106
        
       		return helpers.ServerError(e, nil)

     

       108
       107
        
       	}

     

       109
       108
        
       

     

       110
       110
       -
       	if err := bs.UpdateRepo(context.TODO(), root, rev); err != nil {

     

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

     

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

     

       112
       111
        
       		return helpers.ServerError(e, nil)

     

       113
       112
        
       	}

+9 -2

server/handle_oauth_par.go

···

       1
       1
        
       package server

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"errors"

     

       4
       5
        
       	"time"

     

       5
       6
        
       

     

       6
       7
        
       	"github.com/Azure/go-autorest/autorest/to"

     

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

     

       8
       9
        
       	"github.com/haileyok/cocoon/oauth"

     

       9
       10
        
       	"github.com/haileyok/cocoon/oauth/constants"

     

       11
       11
       +
       	"github.com/haileyok/cocoon/oauth/dpop"

     

       10
       12
        
       	"github.com/haileyok/cocoon/oauth/provider"

     

       11
       13
        
       	"github.com/labstack/echo/v4"

     

       12
       14
        
       )

     
···

       31
       33
        
       	// TODO: this seems wrong. should be a way to get the entire request url i believe, but this will work for now

     

       32
       34
        
       	dpopProof, err := s.oauthProvider.DpopManager.CheckProof(e.Request().Method, "https://"+s.config.Hostname+e.Request().URL.String(), e.Request().Header, nil)

     

       33
       35
        
       	if err != nil {

     

       36
       36
       +
       		if errors.Is(err, dpop.ErrUseDpopNonce) {

     

       37
       37
       +
       			return e.JSON(400, map[string]string{

     

       38
       38
       +
       				"error": "use_dpop_nonce",

     

       39
       39
       +
       			})

     

       40
       40
       +
       		}

     

       34
       41
        
       		s.logger.Error("error getting dpop proof", "error", err)

     

       35
       35
       -
       		return helpers.InputError(e, to.StringPtr(err.Error()))

     

       42
       42
       +
       		return helpers.InputError(e, nil)

     

       36
       43
        
       	}

     

       37
       44
        
       

     

       38
       45
        
       	client, clientAuth, err := s.oauthProvider.AuthenticateClient(e.Request().Context(), parRequest.AuthenticateClientRequestBase, dpopProof, &provider.AuthenticateClientOptions{

     
···

       41
       48
        
       		AllowMissingDpopProof: true,

     

       42
       49
        
       	})

     

       43
       50
        
       	if err != nil {

     

       44
       44
       -
       		s.logger.Error("error authenticating client", "error", err)

     

       51
       51
       +
       		s.logger.Error("error authenticating client", "client_id", parRequest.ClientID, "error", err)

     

       45
       52
        
       		return helpers.InputError(e, to.StringPtr(err.Error()))

     

       46
       53
        
       	}

     

       47
       54

+9 -2

server/handle_oauth_token.go

···

       4
       4
        
       	"bytes"

     

       5
       5
        
       	"crypto/sha256"

     

       6
       6
        
       	"encoding/base64"

     

       7
       7
       +
       	"errors"

     

       7
       8
        
       	"fmt"

     

       8
       9
        
       	"slices"

     

       9
       10
        
       	"time"

     
···

       13
       14
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       14
       15
        
       	"github.com/haileyok/cocoon/oauth"

     

       15
       16
        
       	"github.com/haileyok/cocoon/oauth/constants"

     

       17
       17
       +
       	"github.com/haileyok/cocoon/oauth/dpop"

     

       16
       18
        
       	"github.com/haileyok/cocoon/oauth/provider"

     

       17
       19
        
       	"github.com/labstack/echo/v4"

     

       18
       20
        
       )

     
···

       44
       46
        
       

     

       45
       47
        
       	proof, err := s.oauthProvider.DpopManager.CheckProof(e.Request().Method, e.Request().URL.String(), e.Request().Header, nil)

     

       46
       48
        
       	if err != nil {

     

       49
       49
       +
       		if errors.Is(err, dpop.ErrUseDpopNonce) {

     

       50
       50
       +
       			return e.JSON(400, map[string]string{

     

       51
       51
       +
       				"error": "use_dpop_nonce",

     

       52
       52
       +
       			})

     

       53
       53
       +
       		}

     

       47
       54
        
       		s.logger.Error("error getting dpop proof", "error", err)

     

       48
       48
       -
       		return helpers.InputError(e, to.StringPtr(err.Error()))

     

       55
       55
       +
       		return helpers.InputError(e, nil)

     

       49
       56
        
       	}

     

       50
       57
        
       

     

       51
       58
        
       	client, clientAuth, err := s.oauthProvider.AuthenticateClient(e.Request().Context(), req.AuthenticateClientRequestBase, proof, &provider.AuthenticateClientOptions{

     

       52
       59
        
       		AllowMissingDpopProof: true,

     

       53
       60
        
       	})

     

       54
       61
        
       	if err != nil {

     

       55
       55
       -
       		s.logger.Error("error authenticating client", "error", err)

     

       62
       62
       +
       		s.logger.Error("error authenticating client", "client_id", req.ClientID, "error", err)

     

       56
       63
        
       		return helpers.InputError(e, to.StringPtr(err.Error()))

     

       57
       64
        
       	}

     

       58
       65

+2 -2

server/handle_proxy.go

···

       19
       19
        
       

     

       20
       20
        
       func (s *Server) getAtprotoProxyEndpointFromRequest(e echo.Context) (string, string, error) {

     

       21
       21
        
       	svc := e.Request().Header.Get("atproto-proxy")

     

       22
       22
       -
       	if svc == "" {

     

       23
       23
       -
       		svc = s.config.DefaultAtprotoProxy

     

       22
       22
       +
       	if svc == "" && s.config.FallbackProxy != "" {

     

       23
       23
       +
       		svc = s.config.FallbackProxy

     

       24
       24
        
       	}

     

       25
       25
        
       

     

       26
       26
        
       	svcPts := strings.Split(svc, "#")

+2 -2

server/handle_repo_get_record.go

···

       1
       1
        
       package server

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"github.com/bluesky-social/indigo/atproto/data"

     

       4
       4
       +
       	"github.com/bluesky-social/indigo/atproto/atdata"

     

       5
       5
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       6
       6
        
       	"github.com/haileyok/cocoon/models"

     

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

     
···

       37
       37
        
       		return err

     

       38
       38
        
       	}

     

       39
       39
        
       

     

       40
       40
       -
       	val, err := data.UnmarshalCBOR(record.Value)

     

       40
       40
       +
       	val, err := atdata.UnmarshalCBOR(record.Value)

     

       41
       41
        
       	if err != nil {

     

       42
       42
        
       		return s.handleProxy(e) // TODO: this should be getting handled like...if we don't find it in the db. why doesn't it throw error up there?

     

       43
       43
        
       	}

+2 -2

server/handle_repo_list_records.go

···

       4
       4
        
       	"strconv"

     

       5
       5
        
       

     

       6
       6
        
       	"github.com/Azure/go-autorest/autorest/to"

     

       7
       7
       -
       	"github.com/bluesky-social/indigo/atproto/data"

     

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

     

       8
       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       9
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       10
       10
        
       	"github.com/haileyok/cocoon/models"

     
···

       100
       100
        
       

     

       101
       101
        
       	items := []ComAtprotoRepoListRecordsRecordItem{}

     

       102
       102
        
       	for _, r := range records {

     

       103
       103
       -
       		val, err := data.UnmarshalCBOR(r.Value)

     

       103
       103
       +
       		val, err := atdata.UnmarshalCBOR(r.Value)

     

       104
       104
        
       		if err != nil {

     

       105
       105
        
       			return err

     

       106
       106
        
       		}

+2 -2

server/handle_repo_list_repos.go

···

       37
       37
        
       			Did:    r.Did,

     

       38
       38
        
       			Head:   c.String(),

     

       39
       39
        
       			Rev:    r.Rev,

     

       40
       40
       -
       			Active: true,

     

       41
       41
       -
       			Status: nil,

     

       40
       40
       +
       			Active: r.Active(),

     

       41
       41
       +
       			Status: r.Status(),

     

       42
       42
        
       		})

     

       43
       43
        
       	}

     

       44
       44

+50 -8

server/handle_repo_upload_blob.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"bytes"

     

       5
       5
       +
       	"fmt"

     

       5
       6
        
       	"io"

     

       6
       7
        
       

     

       8
       8
       +
       	"github.com/aws/aws-sdk-go/aws"

     

       9
       9
       +
       	"github.com/aws/aws-sdk-go/aws/credentials"

     

       10
       10
       +
       	"github.com/aws/aws-sdk-go/aws/session"

     

       11
       11
       +
       	"github.com/aws/aws-sdk-go/service/s3"

     

       7
       12
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       8
       13
        
       	"github.com/haileyok/cocoon/models"

     

       9
       14
        
       	"github.com/ipfs/go-cid"

     
···

       34
       39
        
       		mime = "application/octet-stream"

     

       35
       40
        
       	}

     

       36
       41
        
       

     

       42
       42
       +
       	storage := "sqlite"

     

       43
       43
       +
       	s3Upload := s.s3Config != nil && s.s3Config.BlobstoreEnabled

     

       44
       44
       +
       	if s3Upload {

     

       45
       45
       +
       		storage = "s3"

     

       46
       46
       +
       	}

     

       37
       47
        
       	blob := models.Blob{

     

       38
       48
        
       		Did:       urepo.Repo.Did,

     

       39
       49
        
       		RefCount:  0,

     

       40
       50
        
       		CreatedAt: s.repoman.clock.Next().String(),

     

       51
       51
       +
       		Storage:   storage,

     

       41
       52
        
       	}

     

       42
       53
        
       

     

       43
       54
        
       	if err := s.db.Create(&blob, nil).Error; err != nil {

     
···

       66
       77
        
       		read += n

     

       67
       78
        
       		fulldata.Write(data)

     

       68
       79
        
       

     

       69
       69
       -
       		blobPart := models.BlobPart{

     

       70
       70
       -
       			BlobID: blob.ID,

     

       71
       71
       -
       			Idx:    part,

     

       72
       72
       -
       			Data:   data,

     

       73
       73
       -
       		}

     

       80
       80
       +
       		if !s3Upload {

     

       81
       81
       +
       			blobPart := models.BlobPart{

     

       82
       82
       +
       				BlobID: blob.ID,

     

       83
       83
       +
       				Idx:    part,

     

       84
       84
       +
       				Data:   data,

     

       85
       85
       +
       			}

     

       74
       86
        
       

     

       75
       75
       -
       		if err := s.db.Create(&blobPart, nil).Error; err != nil {

     

       76
       76
       -
       			s.logger.Error("error adding blob part to db", "error", err)

     

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

     

       87
       87
       +
       			if err := s.db.Create(&blobPart, nil).Error; err != nil {

     

       88
       88
       +
       				s.logger.Error("error adding blob part to db", "error", err)

     

       89
       89
       +
       				return helpers.ServerError(e, nil)

     

       90
       90
       +
       			}

     

       78
       91
        
       		}

     

       79
       92
        
       		part++

     

       80
       93
        
       

     
···

       87
       100
        
       	if err != nil {

     

       88
       101
        
       		s.logger.Error("error creating cid prefix", "error", err)

     

       89
       102
        
       		return helpers.ServerError(e, nil)

     

       103
       103
       +
       	}

     

       104
       104
       +
       

     

       105
       105
       +
       	if s3Upload {

     

       106
       106
       +
       		config := &aws.Config{

     

       107
       107
       +
       			Region:      aws.String(s.s3Config.Region),

     

       108
       108
       +
       			Credentials: credentials.NewStaticCredentials(s.s3Config.AccessKey, s.s3Config.SecretKey, ""),

     

       109
       109
       +
       		}

     

       110
       110
       +
       

     

       111
       111
       +
       		if s.s3Config.Endpoint != "" {

     

       112
       112
       +
       			config.Endpoint = aws.String(s.s3Config.Endpoint)

     

       113
       113
       +
       			config.S3ForcePathStyle = aws.Bool(true)

     

       114
       114
       +
       		}

     

       115
       115
       +
       

     

       116
       116
       +
       		sess, err := session.NewSession(config)

     

       117
       117
       +
       		if err != nil {

     

       118
       118
       +
       			s.logger.Error("error creating aws session", "error", err)

     

       119
       119
       +
       			return helpers.ServerError(e, nil)

     

       120
       120
       +
       		}

     

       121
       121
       +
       

     

       122
       122
       +
       		svc := s3.New(sess)

     

       123
       123
       +
       

     

       124
       124
       +
       		if _, err := svc.PutObject(&s3.PutObjectInput{

     

       125
       125
       +
       			Bucket: aws.String(s.s3Config.Bucket),

     

       126
       126
       +
       			Key:    aws.String(fmt.Sprintf("blobs/%s/%s", urepo.Repo.Did, c.String())),

     

       127
       127
       +
       			Body:   bytes.NewReader(fulldata.Bytes()),

     

       128
       128
       +
       		}); err != nil {

     

       129
       129
       +
       			s.logger.Error("error uploading blob to s3", "error", err)

     

       130
       130
       +
       			return helpers.ServerError(e, nil)

     

       131
       131
       +
       		}

     

       90
       132
        
       	}

     

       91
       133
        
       

     

       92
       134
        
       	if err := s.db.Exec("UPDATE blobs SET cid = ? WHERE id = ?", nil, c.Bytes(), blob.ID).Error; err != nil {

+45

server/handle_server_activate_account.go

···

       1
       1
       +
       package server

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"time"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       	"github.com/bluesky-social/indigo/events"

     

       9
       9
       +
       	"github.com/bluesky-social/indigo/util"

     

       10
       10
       +
       	"github.com/haileyok/cocoon/internal/helpers"

     

       11
       11
       +
       	"github.com/haileyok/cocoon/models"

     

       12
       12
       +
       	"github.com/labstack/echo/v4"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type ComAtprotoServerActivateAccountRequest struct {

     

       16
       16
       +
       	// NOTE: this implementation will not pay attention to this value

     

       17
       17
       +
       	DeleteAfter time.Time `json:"deleteAfter"`

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       func (s *Server) handleServerActivateAccount(e echo.Context) error {

     

       21
       21
       +
       	var req ComAtprotoServerDeactivateAccountRequest

     

       22
       22
       +
       	if err := e.Bind(&req); err != nil {

     

       23
       23
       +
       		s.logger.Error("error binding", "error", err)

     

       24
       24
       +
       		return helpers.ServerError(e, nil)

     

       25
       25
       +
       	}

     

       26
       26
       +
       

     

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

     

       28
       28
       +
       

     

       29
       29
       +
       	if err := s.db.Exec("UPDATE repos SET deactivated = ? WHERE did = ?", nil, false, urepo.Repo.Did).Error; err != nil {

     

       30
       30
       +
       		s.logger.Error("error updating account status to deactivated", "error", err)

     

       31
       31
       +
       		return helpers.ServerError(e, nil)

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{

     

       35
       35
       +
       		RepoAccount: &atproto.SyncSubscribeRepos_Account{

     

       36
       36
       +
       			Active: true,

     

       37
       37
       +
       			Did:    urepo.Repo.Did,

     

       38
       38
       +
       			Status: nil,

     

       39
       39
       +
       			Seq:    time.Now().UnixMicro(), // TODO: bad puppy

     

       40
       40
       +
       			Time:   time.Now().Format(util.ISO8601),

     

       41
       41
       +
       		},

     

       42
       42
       +
       	})

     

       43
       43
       +
       

     

       44
       44
       +
       	return e.NoContent(200)

     

       45
       45
       +
       }

+4 -14

server/handle_server_create_account.go

···

       9
       9
        
       

     

       10
       10
        
       	"github.com/Azure/go-autorest/autorest/to"

     

       11
       11
        
       	"github.com/bluesky-social/indigo/api/atproto"

     

       12
       12
       -
       	"github.com/bluesky-social/indigo/atproto/crypto"

     

       12
       12
       +
       	"github.com/bluesky-social/indigo/atproto/atcrypto"

     

       13
       13
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       14
       14
        
       	"github.com/bluesky-social/indigo/events"

     

       15
       15
        
       	"github.com/bluesky-social/indigo/repo"

     

       16
       16
        
       	"github.com/bluesky-social/indigo/util"

     

       17
       17
       -
       	"github.com/haileyok/cocoon/blockstore"

     

       18
       17
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       19
       18
        
       	"github.com/haileyok/cocoon/models"

     

       20
       19
        
       	"github.com/labstack/echo/v4"

     
···

       126
       125
        
       

     

       127
       126
        
       	// TODO: unsupported domains

     

       128
       127
        
       

     

       129
       129
       -
       	k, err := crypto.GeneratePrivateKeyK256()

     

       128
       128
       +
       	k, err := atcrypto.GeneratePrivateKeyK256()

     

       130
       129
        
       	if err != nil {

     

       131
       130
        
       		s.logger.Error("error creating signing key", "endpoint", "com.atproto.server.createAccount", "error", err)

     

       132
       131
        
       		return helpers.ServerError(e, nil)

     
···

       177
       176
        
       	}

     

       178
       177
        
       

     

       179
       178
        
       	if customDidHeader == "" {

     

       180
       180
       -
       		bs := blockstore.New(signupDid, s.db)

     

       179
       179
       +
       		bs := s.getBlockstore(signupDid)

     

       181
       180
        
       		r := repo.NewRepo(context.TODO(), signupDid, bs)

     

       182
       181
        
       

     

       183
       182
        
       		root, rev, err := r.Commit(context.TODO(), urepo.SignFor)

     
···

       186
       185
        
       			return helpers.ServerError(e, nil)

     

       187
       186
        
       		}

     

       188
       187
        
       

     

       189
       189
       -
       		if err := bs.UpdateRepo(context.TODO(), root, rev); err != nil {

     

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

     

       190
       189
        
       			s.logger.Error("error updating repo after commit", "error", err)

     

       191
       190
        
       			return helpers.ServerError(e, nil)

     

       192
       191
        
       		}

     

       193
       193
       -
       

     

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

     

       195
       195
       -
       			RepoHandle: &atproto.SyncSubscribeRepos_Handle{

     

       196
       196
       -
       				Did:    urepo.Did,

     

       197
       197
       -
       				Handle: request.Handle,

     

       198
       198
       -
       				Seq:    time.Now().UnixMicro(), // TODO: no

     

       199
       199
       -
       				Time:   time.Now().Format(util.ISO8601),

     

       200
       200
       -
       			},

     

       201
       201
       -
       		})

     

       202
       192
        
       

     

       203
       193
        
       		s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{

     

       204
       194
        
       			RepoIdentity: &atproto.SyncSubscribeRepos_Identity{

+2 -2

server/handle_server_create_session.go

···

       102
       102
        
       		Email:           repo.Email,

     

       103
       103
        
       		EmailConfirmed:  repo.EmailConfirmedAt != nil,

     

       104
       104
        
       		EmailAuthFactor: false,

     

       105
       105
       -
       		Active:          true, // TODO: eventually do takedowns

     

       106
       106
       -
       		Status:          nil,  // TODO eventually do takedowns

     

       105
       105
       +
       		Active:          repo.Active(),

     

       106
       106
       +
       		Status:          repo.Status(),

     

       107
       107
        
       	})

     

       108
       108
        
       }

+46

server/handle_server_deactivate_account.go

···

       1
       1
       +
       package server

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"time"

     

       6
       6
       +
       

     

       7
       7
       +
       	"github.com/Azure/go-autorest/autorest/to"

     

       8
       8
       +
       	"github.com/bluesky-social/indigo/api/atproto"

     

       9
       9
       +
       	"github.com/bluesky-social/indigo/events"

     

       10
       10
       +
       	"github.com/bluesky-social/indigo/util"

     

       11
       11
       +
       	"github.com/haileyok/cocoon/internal/helpers"

     

       12
       12
       +
       	"github.com/haileyok/cocoon/models"

     

       13
       13
       +
       	"github.com/labstack/echo/v4"

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       type ComAtprotoServerDeactivateAccountRequest struct {

     

       17
       17
       +
       	// NOTE: this implementation will not pay attention to this value

     

       18
       18
       +
       	DeleteAfter time.Time `json:"deleteAfter"`

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       func (s *Server) handleServerDeactivateAccount(e echo.Context) error {

     

       22
       22
       +
       	var req ComAtprotoServerDeactivateAccountRequest

     

       23
       23
       +
       	if err := e.Bind(&req); err != nil {

     

       24
       24
       +
       		s.logger.Error("error binding", "error", err)

     

       25
       25
       +
       		return helpers.ServerError(e, nil)

     

       26
       26
       +
       	}

     

       27
       27
       +
       

     

       28
       28
       +
       	urepo := e.Get("repo").(*models.RepoActor)

     

       29
       29
       +
       

     

       30
       30
       +
       	if err := s.db.Exec("UPDATE repos SET deactivated = ? WHERE did = ?", nil, true, urepo.Repo.Did).Error; err != nil {

     

       31
       31
       +
       		s.logger.Error("error updating account status to deactivated", "error", err)

     

       32
       32
       +
       		return helpers.ServerError(e, nil)

     

       33
       33
       +
       	}

     

       34
       34
       +
       

     

       35
       35
       +
       	s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{

     

       36
       36
       +
       		RepoAccount: &atproto.SyncSubscribeRepos_Account{

     

       37
       37
       +
       			Active: false,

     

       38
       38
       +
       			Did:    urepo.Repo.Did,

     

       39
       39
       +
       			Status: to.StringPtr("deactivated"),

     

       40
       40
       +
       			Seq:    time.Now().UnixMicro(), // TODO: bad puppy

     

       41
       41
       +
       			Time:   time.Now().Format(util.ISO8601),

     

       42
       42
       +
       		},

     

       43
       43
       +
       	})

     

       44
       44
       +
       

     

       45
       45
       +
       	return e.NoContent(200)

     

       46
       46
       +
       }

+2 -2

server/handle_server_get_session.go

···

       24
       24
        
       		Email:           repo.Email,

     

       25
       25
        
       		EmailConfirmed:  repo.EmailConfirmedAt != nil,

     

       26
       26
        
       		EmailAuthFactor: false, // TODO: todo todo

     

       27
       27
       -
       		Active:          true,

     

       28
       28
       -
       		Status:          nil,

     

       27
       27
       +
       		Active:          repo.Active(),

     

       28
       28
       +
       		Status:          repo.Status(),

     

       29
       29
        
       	})

     

       30
       30
        
       }

+2 -2

server/handle_server_refresh_session.go

···

       40
       40
        
       		RefreshJwt: sess.RefreshToken,

     

       41
       41
        
       		Handle:     repo.Handle,

     

       42
       42
        
       		Did:        repo.Repo.Did,

     

       43
       43
       -
       		Active:     true,

     

       44
       44
       -
       		Status:     nil,

     

       43
       43
       +
       		Active:     repo.Active(),

     

       44
       44
       +
       		Status:     repo.Status(),

     

       45
       45
        
       	})

     

       46
       46
        
       }

+79 -8

server/handle_sync_get_blob.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"bytes"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"io"

     

       5
       7
        
       

     

       8
       8
       +
       	"github.com/Azure/go-autorest/autorest/to"

     

       9
       9
       +
       	"github.com/aws/aws-sdk-go/aws"

     

       10
       10
       +
       	"github.com/aws/aws-sdk-go/aws/credentials"

     

       11
       11
       +
       	"github.com/aws/aws-sdk-go/aws/session"

     

       12
       12
       +
       	"github.com/aws/aws-sdk-go/service/s3"

     

       6
       13
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       7
       14
        
       	"github.com/haileyok/cocoon/models"

     

       8
       15
        
       	"github.com/ipfs/go-cid"

     
···

       25
       32
        
       		return helpers.InputError(e, nil)

     

       26
       33
        
       	}

     

       27
       34
        
       

     

       35
       35
       +
       	urepo, err := s.getRepoActorByDid(did)

     

       36
       36
       +
       	if err != nil {

     

       37
       37
       +
       		s.logger.Error("could not find user for requested blob", "error", err)

     

       38
       38
       +
       		return helpers.InputError(e, nil)

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	status := urepo.Status()

     

       42
       42
       +
       	if status != nil {

     

       43
       43
       +
       		if *status == "deactivated" {

     

       44
       44
       +
       			return helpers.InputError(e, to.StringPtr("RepoDeactivated"))

     

       45
       45
       +
       		}

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       28
       48
        
       	var blob models.Blob

     

       29
       49
        
       	if err := s.db.Raw("SELECT * FROM blobs WHERE did = ? AND cid = ?", nil, did, c.Bytes()).Scan(&blob).Error; err != nil {

     

       30
       50
        
       		s.logger.Error("error looking up blob", "error", err)

     
···

       33
       53
        
       

     

       34
       54
        
       	buf := new(bytes.Buffer)

     

       35
       55
        
       

     

       36
       36
       -
       	var parts []models.BlobPart

     

       37
       37
       -
       	if err := s.db.Raw("SELECT * FROM blob_parts WHERE blob_id = ? ORDER BY idx", nil, blob.ID).Scan(&parts).Error; err != nil {

     

       38
       38
       -
       		s.logger.Error("error getting blob parts", "error", err)

     

       56
       56
       +
       	if blob.Storage == "sqlite" {

     

       57
       57
       +
       		var parts []models.BlobPart

     

       58
       58
       +
       		if err := s.db.Raw("SELECT * FROM blob_parts WHERE blob_id = ? ORDER BY idx", nil, blob.ID).Scan(&parts).Error; err != nil {

     

       59
       59
       +
       			s.logger.Error("error getting blob parts", "error", err)

     

       60
       60
       +
       			return helpers.ServerError(e, nil)

     

       61
       61
       +
       		}

     

       62
       62
       +
       

     

       63
       63
       +
       		// TODO: we can just stream this, don't need to make a buffer

     

       64
       64
       +
       		for _, p := range parts {

     

       65
       65
       +
       			buf.Write(p.Data)

     

       66
       66
       +
       		}

     

       67
       67
       +
       	} else if blob.Storage == "s3" && s.s3Config != nil && s.s3Config.BlobstoreEnabled {

     

       68
       68
       +
       		config := &aws.Config{

     

       69
       69
       +
       			Region:      aws.String(s.s3Config.Region),

     

       70
       70
       +
       			Credentials: credentials.NewStaticCredentials(s.s3Config.AccessKey, s.s3Config.SecretKey, ""),

     

       71
       71
       +
       		}

     

       72
       72
       +
       

     

       73
       73
       +
       		if s.s3Config.Endpoint != "" {

     

       74
       74
       +
       			config.Endpoint = aws.String(s.s3Config.Endpoint)

     

       75
       75
       +
       			config.S3ForcePathStyle = aws.Bool(true)

     

       76
       76
       +
       		}

     

       77
       77
       +
       

     

       78
       78
       +
       		sess, err := session.NewSession(config)

     

       79
       79
       +
       		if err != nil {

     

       80
       80
       +
       			s.logger.Error("error creating aws session", "error", err)

     

       81
       81
       +
       			return helpers.ServerError(e, nil)

     

       82
       82
       +
       		}

     

       83
       83
       +
       

     

       84
       84
       +
       		svc := s3.New(sess)

     

       85
       85
       +
       		if result, err := svc.GetObject(&s3.GetObjectInput{

     

       86
       86
       +
       			Bucket: aws.String(s.s3Config.Bucket),

     

       87
       87
       +
       			Key:    aws.String(fmt.Sprintf("blobs/%s/%s", urepo.Repo.Did, c.String())),

     

       88
       88
       +
       		}); err != nil {

     

       89
       89
       +
       			s.logger.Error("error getting blob from s3", "error", err)

     

       90
       90
       +
       			return helpers.ServerError(e, nil)

     

       91
       91
       +
       		} else {

     

       92
       92
       +
       			read := 0

     

       93
       93
       +
       			part := 0

     

       94
       94
       +
       			partBuf := make([]byte, 0x10000)

     

       95
       95
       +
       

     

       96
       96
       +
       			for {

     

       97
       97
       +
       				n, err := io.ReadFull(result.Body, partBuf)

     

       98
       98
       +
       				if err == io.ErrUnexpectedEOF || err == io.EOF {

     

       99
       99
       +
       					if n == 0 {

     

       100
       100
       +
       						break

     

       101
       101
       +
       					}

     

       102
       102
       +
       				} else if err != nil && err != io.ErrUnexpectedEOF {

     

       103
       103
       +
       					s.logger.Error("error reading blob", "error", err)

     

       104
       104
       +
       					return helpers.ServerError(e, nil)

     

       105
       105
       +
       				}

     

       106
       106
       +
       

     

       107
       107
       +
       				data := partBuf[:n]

     

       108
       108
       +
       				read += n

     

       109
       109
       +
       				buf.Write(data)

     

       110
       110
       +
       				part++

     

       111
       111
       +
       			}

     

       112
       112
       +
       		}

     

       113
       113
       +
       	} else {

     

       114
       114
       +
       		s.logger.Error("unknown storage", "storage", blob.Storage)

     

       39
       115
        
       		return helpers.ServerError(e, nil)

     

       40
       40
       -
       	}

     

       41
       41
       -
       

     

       42
       42
       -
       	// TODO: we can just stream this, don't need to make a buffer

     

       43
       43
       -
       	for _, p := range parts {

     

       44
       44
       -
       		buf.Write(p.Data)

     

       45
       116
        
       	}

     

       46
       117
        
       

     

       47
       118
        
       	e.Response().Header().Set(echo.HeaderContentDisposition, "attachment; filename="+c.String())

+14 -12

server/handle_sync_get_blocks.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"bytes"

     

       5
       5
       -
       	"context"

     

       6
       6
       -
       	"strings"

     

       7
       5
        
       

     

       8
       6
        
       	"github.com/bluesky-social/indigo/carstore"

     

       9
       9
       -
       	"github.com/haileyok/cocoon/blockstore"

     

       10
       7
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       11
       8
        
       	"github.com/ipfs/go-cid"

     

       12
       9
        
       	cbor "github.com/ipfs/go-ipld-cbor"

     
···

       14
       11
        
       	"github.com/labstack/echo/v4"

     

       15
       12
        
       )

     

       16
       13
        
       

     

       14
       14
       +
       type ComAtprotoSyncGetBlocksRequest struct {

     

       15
       15
       +
       	Did  string   `query:"did"`

     

       16
       16
       +
       	Cids []string `query:"cids"`

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

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

     

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

     

       19
       19
       -
       	cidsstr := e.QueryParam("cids")

     

       20
       20
       -
       	if did == "" {

     

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

     

       21
       21
       +
       

     

       22
       22
       +
       	var req ComAtprotoSyncGetBlocksRequest

     

       23
       23
       +
       	if err := e.Bind(&req); err != nil {

     

       21
       24
        
       		return helpers.InputError(e, nil)

     

       22
       25
        
       	}

     

       23
       26
        
       

     

       24
       24
       -
       	cidstrs := strings.Split(cidsstr, ",")

     

       25
       25
       -
       	cids := []cid.Cid{}

     

       27
       27
       +
       	var cids []cid.Cid

     

       26
       28
        
       

     

       27
       27
       -
       	for _, cs := range cidstrs {

     

       29
       29
       +
       	for _, cs := range req.Cids {

     

       28
       30
        
       		c, err := cid.Cast([]byte(cs))

     

       29
       31
        
       		if err != nil {

     

       30
       32
        
       			return err

     
···

       33
       35
        
       		cids = append(cids, c)

     

       34
       36
        
       	}

     

       35
       37
        
       

     

       36
       36
       -
       	urepo, err := s.getRepoActorByDid(did)

     

       38
       38
       +
       	urepo, err := s.getRepoActorByDid(req.Did)

     

       37
       39
        
       	if err != nil {

     

       38
       40
        
       		return helpers.ServerError(e, nil)

     

       39
       41
        
       	}

     
···

       54
       56
        
       		return helpers.ServerError(e, nil)

     

       55
       57
        
       	}

     

       56
       58
        
       

     

       57
       57
       -
       	bs := blockstore.New(urepo.Repo.Did, s.db)

     

       59
       59
       +
       	bs := s.getBlockstore(urepo.Repo.Did)

     

       58
       60
        
       

     

       59
       61
        
       	for _, c := range cids {

     

       60
       60
       -
       		b, err := bs.Get(context.TODO(), c)

     

       62
       62
       +
       		b, err := bs.Get(ctx, c)

     

       61
       63
        
       		if err != nil {

     

       62
       64
        
       			return err

     

       63
       65
        
       		}

+2 -2

server/handle_sync_get_repo_status.go

···

       26
       26
        
       

     

       27
       27
        
       	return e.JSON(200, ComAtprotoSyncGetRepoStatusResponse{

     

       28
       28
        
       		Did:    urepo.Repo.Did,

     

       29
       29
       -
       		Active: true,

     

       30
       30
       -
       		Status: nil,

     

       29
       29
       +
       		Active: urepo.Active(),

     

       30
       30
       +
       		Status: urepo.Status(),

     

       31
       31
        
       		Rev:    &urepo.Rev,

     

       32
       32
        
       	})

     

       33
       33
        
       }

+14

server/handle_sync_list_blobs.go

···

       1
       1
        
       package server

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"github.com/Azure/go-autorest/autorest/to"

     

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

     

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

     

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

     
···

       33
       34
        
       		cursorquery = "AND created_at < ?"

     

       34
       35
        
       	}

     

       35
       36
        
       	params = append(params, limit)

     

       37
       37
       +
       

     

       38
       38
       +
       	urepo, err := s.getRepoActorByDid(did)

     

       39
       39
       +
       	if err != nil {

     

       40
       40
       +
       		s.logger.Error("could not find user for requested blobs", "error", err)

     

       41
       41
       +
       		return helpers.InputError(e, nil)

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

       44
       44
       +
       	status := urepo.Status()

     

       45
       45
       +
       	if status != nil {

     

       46
       46
       +
       		if *status == "deactivated" {

     

       47
       47
       +
       			return helpers.InputError(e, to.StringPtr("RepoDeactivated"))

     

       48
       48
       +
       		}

     

       49
       49
       +
       	}

     

       36
       50
        
       

     

       37
       51
        
       	var blobs []models.Blob

     

       38
       52
        
       	if err := s.db.Raw("SELECT * FROM blobs WHERE did = ? "+cursorquery+" ORDER BY created_at DESC LIMIT ?", nil, params...).Scan(&blobs).Error; err != nil {

-18

server/handle_sync_subscribe_repos.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"fmt"

     

       5
       5
       -
       	"net/http"

     

       6
       5
        
       

     

       7
       6
        
       	"github.com/bluesky-social/indigo/events"

     

       8
       7
        
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       8
        
       	"github.com/btcsuite/websocket"

     

       10
       9
        
       	"github.com/labstack/echo/v4"

     

       11
       10
        
       )

     

       12
       12
       -
       

     

       13
       13
       -
       var upgrader = websocket.Upgrader{

     

       14
       14
       -
       	ReadBufferSize:  1024,

     

       15
       15
       -
       	WriteBufferSize: 1024,

     

       16
       16
       -
       	CheckOrigin: func(r *http.Request) bool {

     

       17
       17
       -
       		return true

     

       18
       18
       -
       	},

     

       19
       19
       -
       }

     

       20
       11
        
       

     

       21
       12
        
       func (s *Server) handleSyncSubscribeRepos(e echo.Context) error {

     

       22
       13
        
       	conn, err := websocket.Upgrade(e.Response().Writer, e.Request(), e.Response().Header(), 1<<10, 1<<10)

     
···

       54
       45
        
       		case evt.RepoCommit != nil:

     

       55
       46
        
       			header.MsgType = "#commit"

     

       56
       47
        
       			obj = evt.RepoCommit

     

       57
       57
       -
       		case evt.RepoHandle != nil:

     

       58
       58
       -
       			header.MsgType = "#handle"

     

       59
       59
       -
       			obj = evt.RepoHandle

     

       60
       48
        
       		case evt.RepoIdentity != nil:

     

       61
       49
        
       			header.MsgType = "#identity"

     

       62
       50
        
       			obj = evt.RepoIdentity

     
···

       66
       54
        
       		case evt.RepoInfo != nil:

     

       67
       55
        
       			header.MsgType = "#info"

     

       68
       56
        
       			obj = evt.RepoInfo

     

       69
       69
       -
       		case evt.RepoMigrate != nil:

     

       70
       70
       -
       			header.MsgType = "#migrate"

     

       71
       71
       -
       			obj = evt.RepoMigrate

     

       72
       72
       -
       		case evt.RepoTombstone != nil:

     

       73
       73
       -
       			header.MsgType = "#tombstone"

     

       74
       74
       -
       			obj = evt.RepoTombstone

     

       75
       57
        
       		default:

     

       76
       58
        
       			return fmt.Errorf("unrecognized event kind")

     

       77
       59
        
       		}

+8 -1

server/middleware.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"crypto/sha256"

     

       5
       5
        
       	"encoding/base64"

     

       6
       6
       +
       	"errors"

     

       6
       7
        
       	"fmt"

     

       7
       8
        
       	"strings"

     

       8
       9
        
       	"time"

     
···

       11
       12
        
       	"github.com/golang-jwt/jwt/v4"

     

       12
       13
        
       	"github.com/haileyok/cocoon/internal/helpers"

     

       13
       14
        
       	"github.com/haileyok/cocoon/models"

     

       15
       15
       +
       	"github.com/haileyok/cocoon/oauth/dpop"

     

       14
       16
        
       	"github.com/haileyok/cocoon/oauth/provider"

     

       15
       17
        
       	"github.com/labstack/echo/v4"

     

       16
       18
        
       	"gitlab.com/yawning/secp256k1-voi"

     
···

       229
       231
        
       

     

       230
       232
        
       		proof, err := s.oauthProvider.DpopManager.CheckProof(e.Request().Method, "https://"+s.config.Hostname+e.Request().URL.String(), e.Request().Header, to.StringPtr(accessToken))

     

       231
       233
        
       		if err != nil {

     

       234
       234
       +
       			if errors.Is(err, dpop.ErrUseDpopNonce) {

     

       235
       235
       +
       				return e.JSON(400, map[string]string{

     

       236
       236
       +
       					"error": "use_dpop_nonce",

     

       237
       237
       +
       				})

     

       238
       238
       +
       			}

     

       232
       239
        
       			s.logger.Error("invalid dpop proof", "error", err)

     

       233
       233
       -
       			return helpers.InputError(e, to.StringPtr(err.Error()))

     

       240
       240
       +
       			return helpers.InputError(e, nil)

     

       234
       241
        
       		}

     

       235
       242
        
       

     

       236
       243
        
       		var oauthToken provider.OauthToken

+26 -20

server/repo.go

···

       10
       10
        
       

     

       11
       11
        
       	"github.com/Azure/go-autorest/autorest/to"

     

       12
       12
        
       	"github.com/bluesky-social/indigo/api/atproto"

     

       13
       13
       -
       	"github.com/bluesky-social/indigo/atproto/data"

     

       13
       13
       +
       	"github.com/bluesky-social/indigo/atproto/atdata"

     

       14
       14
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       15
       15
        
       	"github.com/bluesky-social/indigo/carstore"

     

       16
       16
        
       	"github.com/bluesky-social/indigo/events"

     

       17
       17
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       18
       18
        
       	"github.com/bluesky-social/indigo/repo"

     

       19
       19
       -
       	"github.com/bluesky-social/indigo/util"

     

       20
       20
       -
       	"github.com/haileyok/cocoon/blockstore"

     

       21
       19
        
       	"github.com/haileyok/cocoon/internal/db"

     

       22
       20
        
       	"github.com/haileyok/cocoon/models"

     

       21
       21
       +
       	"github.com/haileyok/cocoon/recording_blockstore"

     

       23
       22
        
       	blocks "github.com/ipfs/go-block-format"

     

       24
       23
        
       	"github.com/ipfs/go-cid"

     

       25
       24
        
       	cbor "github.com/ipfs/go-ipld-cbor"

     
···

       73
       72
        
       }

     

       74
       73
        
       

     

       75
       74
        
       func (mm *MarshalableMap) MarshalCBOR(w io.Writer) error {

     

       76
       76
       -
       	data, err := data.MarshalCBOR(*mm)

     

       75
       75
       +
       	data, err := atdata.MarshalCBOR(*mm)

     

       77
       76
        
       	if err != nil {

     

       78
       77
        
       		return err

     

       79
       78
        
       	}

     
···

       103
       102
        
       		return nil, err

     

       104
       103
        
       	}

     

       105
       104
        
       

     

       106
       106
       -
       	dbs := blockstore.New(urepo.Did, rm.db)

     

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

     

       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)

     

       108
       108
        
       

     

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

     

       110
       110
        
       	var results []ApplyWriteResult

     
···

       133
       133
        
       			if err != nil {

     

       134
       134
        
       				return nil, err

     

       135
       135
        
       			}

     

       136
       136
       -
       			out, err := data.UnmarshalJSON(j)

     

       136
       136
       +
       			out, err := atdata.UnmarshalJSON(j)

     

       137
       137
        
       			if err != nil {

     

       138
       138
        
       				return nil, err

     

       139
       139
        
       			}

     

       140
       140
        
       			mm := MarshalableMap(out)

     

       141
       141
       +
       

     

       142
       142
       +
       			// HACK: if a record doesn't contain a $type, we can manually set it here based on the op's collection

     

       143
       143
       +
       			if mm["$type"] == "" {

     

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

     

       145
       145
       +
       			}

     

       146
       146
       +
       

     

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

     

       142
       148
        
       			if err != nil {

     

       143
       149
        
       				return nil, err

     

       144
       150
        
       			}

     

       145
       145
       -
       			d, err := data.MarshalCBOR(mm)

     

       151
       151
       +
       			d, err := atdata.MarshalCBOR(mm)

     

       146
       152
        
       			if err != nil {

     

       147
       153
        
       				return nil, err

     

       148
       154
        
       			}

     
···

       183
       189
        
       			if err != nil {

     

       184
       190
        
       				return nil, err

     

       185
       191
        
       			}

     

       186
       186
       -
       			out, err := data.UnmarshalJSON(j)

     

       192
       192
       +
       			out, err := atdata.UnmarshalJSON(j)

     

       187
       193
        
       			if err != nil {

     

       188
       194
        
       				return nil, err

     

       189
       195
        
       			}

     
···

       192
       198
        
       			if err != nil {

     

       193
       199
        
       				return nil, err

     

       194
       200
        
       			}

     

       195
       195
       -
       			d, err := data.MarshalCBOR(mm)

     

       201
       201
       +
       			d, err := atdata.MarshalCBOR(mm)

     

       196
       202
        
       			if err != nil {

     

       197
       203
        
       				return nil, err

     

       198
       204
        
       			}

     
···

       274
       280
        
       		}

     

       275
       281
        
       	}

     

       276
       282
        
       

     

       277
       277
       -
       	for _, op := range dbs.GetLog() {

     

       283
       283
       +
       	for _, op := range bs.GetWriteLog() {

     

       278
       284
        
       		if _, err := carstore.LdWrite(buf, op.Cid().Bytes(), op.RawData()); err != nil {

     

       279
       285
        
       			return nil, err

     

       280
       286
        
       		}

     
···

       324
       330
        
       		},

     

       325
       331
        
       	})

     

       326
       332
        
       

     

       327
       327
       -
       	if err := dbs.UpdateRepo(context.TODO(), newroot, rev); err != nil {

     

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

     

       328
       334
        
       		return nil, err

     

       329
       335
        
       	}

     

       330
       336
        
       

     
···

       345
       351
        
       		return cid.Undef, nil, err

     

       346
       352
        
       	}

     

       347
       353
        
       

     

       348
       348
       -
       	dbs := blockstore.New(urepo.Did, rm.db)

     

       349
       349
       -
       	bs := util.NewLoggingBstore(dbs)

     

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

     

       355
       355
       +
       	bs := recording_blockstore.New(dbs)

     

       350
       356
        
       

     

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

     

       352
       358
        
       	if err != nil {

     
···

       358
       364
        
       		return cid.Undef, nil, err

     

       359
       365
        
       	}

     

       360
       366
        
       

     

       361
       361
       -
       	return c, bs.GetLoggedBlocks(), nil

     

       367
       367
       +
       	return c, bs.GetReadLog(), nil

     

       362
       368
        
       }

     

       363
       369
        
       

     

       364
       370
        
       func (rm *RepoMan) incrementBlobRefs(urepo models.Repo, cbor []byte) ([]cid.Cid, error) {

     
···

       409
       415
        
       func getBlobCidsFromCbor(cbor []byte) ([]cid.Cid, error) {

     

       410
       416
        
       	var cids []cid.Cid

     

       411
       417
        
       

     

       412
       412
       -
       	decoded, err := data.UnmarshalCBOR(cbor)

     

       418
       418
       +
       	decoded, err := atdata.UnmarshalCBOR(cbor)

     

       413
       419
        
       	if err != nil {

     

       414
       420
        
       		return nil, fmt.Errorf("error unmarshaling cbor: %w", err)

     

       415
       421
        
       	}

     

       416
       422
        
       

     

       417
       417
       -
       	var deepiter func(interface{}) error

     

       418
       418
       -
       	deepiter = func(item interface{}) error {

     

       423
       423
       +
       	var deepiter func(any) error

     

       424
       424
       +
       	deepiter = func(item any) error {

     

       419
       425
        
       		switch val := item.(type) {

     

       420
       420
       -
       		case map[string]interface{}:

     

       426
       426
       +
       		case map[string]any:

     

       421
       427
        
       			if val["$type"] == "blob" {

     

       422
       428
        
       				if ref, ok := val["ref"].(string); ok {

     

       423
       429
        
       					c, err := cid.Parse(ref)

     
···

       430
       436
        
       					return deepiter(v)

     

       431
       437
        
       				}

     

       432
       438
        
       			}

     

       433
       433
       -
       		case []interface{}:

     

       439
       439
       +
       		case []any:

     

       434
       440
        
       			for _, v := range val {

     

       435
       441
        
       				deepiter(v)

     

       436
       442
        
       			}

+45 -29

server/server.go

···

       38
       38
        
       	"github.com/haileyok/cocoon/oauth/dpop"

     

       39
       39
        
       	"github.com/haileyok/cocoon/oauth/provider"

     

       40
       40
        
       	"github.com/haileyok/cocoon/plc"

     

       41
       41
       +
       	"github.com/ipfs/go-cid"

     

       41
       42
        
       	echo_session "github.com/labstack/echo-contrib/session"

     

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

     

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

     
···

       51
       52
        
       )

     

       52
       53
        
       

     

       53
       54
        
       type S3Config struct {

     

       54
       54
       -
       	BackupsEnabled bool

     

       55
       55
       -
       	Endpoint       string

     

       56
       56
       -
       	Region         string

     

       57
       57
       -
       	Bucket         string

     

       58
       58
       -
       	AccessKey      string

     

       59
       59
       -
       	SecretKey      string

     

       55
       55
       +
       	BackupsEnabled   bool

     

       56
       56
       +
       	BlobstoreEnabled bool

     

       57
       57
       +
       	Endpoint         string

     

       58
       58
       +
       	Region           string

     

       59
       59
       +
       	Bucket           string

     

       60
       60
       +
       	AccessKey        string

     

       61
       61
       +
       	SecretKey        string

     

       60
       62
        
       }

     

       61
       63
        
       

     

       62
       64
        
       type Server struct {

     
···

       74
       76
        
       	oauthProvider *provider.Provider

     

       75
       77
        
       	evtman        *events.EventManager

     

       76
       78
        
       	passport      *identity.Passport

     

       79
       79
       +
       	fallbackProxy string

     

       77
       80
        
       

     

       78
       81
        
       	dbName   string

     

       79
       82
        
       	s3Config *S3Config

     
···

       103
       106
        
       

     

       104
       107
        
       	SessionSecret string

     

       105
       108
        
       

     

       106
       106
       -
       	DefaultAtprotoProxy string

     

       109
       109
       +
       	BlockstoreVariant BlockstoreVariant

     

       110
       110
       +
       	FallbackProxy     string

     

       107
       111
        
       }

     

       108
       112
        
       

     

       109
       113
        
       type config struct {

     

       110
       110
       -
       	Version             string

     

       111
       111
       -
       	Did                 string

     

       112
       112
       -
       	Hostname            string

     

       113
       113
       -
       	ContactEmail        string

     

       114
       114
       -
       	EnforcePeering      bool

     

       115
       115
       -
       	Relays              []string

     

       116
       116
       -
       	AdminPassword       string

     

       117
       117
       -
       	SmtpEmail           string

     

       118
       118
       -
       	SmtpName            string

     

       119
       119
       -
       	DefaultAtprotoProxy string

     

       114
       114
       +
       	Version           string

     

       115
       115
       +
       	Did               string

     

       116
       116
       +
       	Hostname          string

     

       117
       117
       +
       	ContactEmail      string

     

       118
       118
       +
       	EnforcePeering    bool

     

       119
       119
       +
       	Relays            []string

     

       120
       120
       +
       	AdminPassword     string

     

       121
       121
       +
       	SmtpEmail         string

     

       122
       122
       +
       	SmtpName          string

     

       123
       123
       +
       	BlockstoreVariant BlockstoreVariant

     

       124
       124
       +
       	FallbackProxy     string

     

       120
       125
        
       }

     

       121
       126
        
       

     

       122
       127
        
       type CustomValidator struct {

     
···

       280
       285
        
       		IdleTimeout:  5 * time.Minute,

     

       281
       286
        
       	}

     

       282
       287
        
       

     

       283
       283
       -
       	gdb, err := gorm.Open(sqlite.Open("cocoon.db"), &gorm.Config{})

     

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

     

       284
       289
        
       	if err != nil {

     

       285
       290
        
       		return nil, err

     

       286
       291
        
       	}

     
···

       339
       344
        
       		plcClient:  plcClient,

     

       340
       345
        
       		privateKey: &pkey,

     

       341
       346
        
       		config: &config{

     

       342
       342
       -
       			Version:             args.Version,

     

       343
       343
       -
       			Did:                 args.Did,

     

       344
       344
       -
       			Hostname:            args.Hostname,

     

       345
       345
       -
       			ContactEmail:        args.ContactEmail,

     

       346
       346
       -
       			EnforcePeering:      false,

     

       347
       347
       -
       			Relays:              args.Relays,

     

       348
       348
       -
       			AdminPassword:       args.AdminPassword,

     

       349
       349
       -
       			SmtpName:            args.SmtpName,

     

       350
       350
       -
       			SmtpEmail:           args.SmtpEmail,

     

       351
       351
       -
       			DefaultAtprotoProxy: args.DefaultAtprotoProxy,

     

       347
       347
       +
       			Version:           args.Version,

     

       348
       348
       +
       			Did:               args.Did,

     

       349
       349
       +
       			Hostname:          args.Hostname,

     

       350
       350
       +
       			ContactEmail:      args.ContactEmail,

     

       351
       351
       +
       			EnforcePeering:    false,

     

       352
       352
       +
       			Relays:            args.Relays,

     

       353
       353
       +
       			AdminPassword:     args.AdminPassword,

     

       354
       354
       +
       			SmtpName:          args.SmtpName,

     

       355
       355
       +
       			SmtpEmail:         args.SmtpEmail,

     

       356
       356
       +
       			BlockstoreVariant: args.BlockstoreVariant,

     

       357
       357
       +
       			FallbackProxy:     args.FallbackProxy,

     

       352
       358
        
       		},

     

       353
       359
        
       		evtman:   events.NewEventManager(events.NewMemPersister()),

     

       354
       360
        
       		passport: identity.NewPassport(h, identity.NewMemCache(10_000)),

     
···

       382
       388
        
       

     

       383
       389
        
       	// TODO: should validate these args

     

       384
       390
        
       	if args.SmtpUser == "" || args.SmtpPass == "" || args.SmtpHost == "" || args.SmtpPort == "" || args.SmtpEmail == "" || args.SmtpName == "" {

     

       385
       385
       -
       		args.Logger.Warn("not enough smpt args were provided. mailing will not work for your server.")

     

       391
       391
       +
       		args.Logger.Warn("not enough smtp args were provided. mailing will not work for your server.")

     

       386
       392
        
       	} else {

     

       387
       393
        
       		mail := mailyak.New(args.SmtpHost+":"+args.SmtpPort, smtp.PlainAuth("", args.SmtpUser, args.SmtpPass, args.SmtpHost))

     

       388
       394
        
       		mail.From(s.config.SmtpEmail)

     
···

       460
       466
        
       	s.echo.POST("/xrpc/com.atproto.server.updateEmail", s.handleServerUpdateEmail, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)

     

       461
       467
        
       	s.echo.GET("/xrpc/com.atproto.server.getServiceAuth", s.handleServerGetServiceAuth, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)

     

       462
       468
        
       	s.echo.GET("/xrpc/com.atproto.server.checkAccountStatus", s.handleServerCheckAccountStatus, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)

     

       469
       469
       +
       	s.echo.POST("/xrpc/com.atproto.server.deactivateAccount", s.handleServerDeactivateAccount, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)

     

       470
       470
       +
       	s.echo.POST("/xrpc/com.atproto.server.activateAccount", s.handleServerActivateAccount, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)

     

       463
       471
        
       

     

       464
       472
        
       	// repo

     

       465
       473
        
       	s.echo.POST("/xrpc/com.atproto.repo.createRecord", s.handleCreateRecord, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)

     
···

       641
       649
        
       		go s.doBackup()

     

       642
       650
        
       	}

     

       643
       651
        
       }

     

       652
       652
       +
       

     

       653
       653
       +
       func (s *Server) UpdateRepo(ctx context.Context, did string, root cid.Cid, rev string) error {

     

       654
       654
       +
       	if err := s.db.Exec("UPDATE repos SET root = ?, rev = ? WHERE did = ?", nil, root.Bytes(), rev, did).Error; err != nil {

     

       655
       655
       +
       		return err

     

       656
       656
       +
       	}

     

       657
       657
       +
       

     

       658
       658
       +
       	return nil

     

       659
       659
       +
       }

+137

sqlite_blockstore/sqlite_blockstore.go

···

       1
       1
       +
       package sqlite_blockstore

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       	"github.com/haileyok/cocoon/internal/db"

     

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

     

       10
       10
       +
       	blocks "github.com/ipfs/go-block-format"

     

       11
       11
       +
       	"github.com/ipfs/go-cid"

     

       12
       12
       +
       	"gorm.io/gorm/clause"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       type SqliteBlockstore struct {

     

       16
       16
       +
       	db       *db.DB

     

       17
       17
       +
       	did      string

     

       18
       18
       +
       	readonly bool

     

       19
       19
       +
       	inserts  map[cid.Cid]blocks.Block

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func New(did string, db *db.DB) *SqliteBlockstore {

     

       23
       23
       +
       	return &SqliteBlockstore{

     

       24
       24
       +
       		did:      did,

     

       25
       25
       +
       		db:       db,

     

       26
       26
       +
       		readonly: false,

     

       27
       27
       +
       		inserts:  map[cid.Cid]blocks.Block{},

     

       28
       28
       +
       	}

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       func NewReadOnly(did string, db *db.DB) *SqliteBlockstore {

     

       32
       32
       +
       	return &SqliteBlockstore{

     

       33
       33
       +
       		did:      did,

     

       34
       34
       +
       		db:       db,

     

       35
       35
       +
       		readonly: true,

     

       36
       36
       +
       		inserts:  map[cid.Cid]blocks.Block{},

     

       37
       37
       +
       	}

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func (bs *SqliteBlockstore) Get(ctx context.Context, cid cid.Cid) (blocks.Block, error) {

     

       41
       41
       +
       	var block models.Block

     

       42
       42
       +
       

     

       43
       43
       +
       	maybeBlock, ok := bs.inserts[cid]

     

       44
       44
       +
       	if ok {

     

       45
       45
       +
       		return maybeBlock, nil

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	if err := bs.db.Raw("SELECT * FROM blocks WHERE did = ? AND cid = ?", nil, bs.did, cid.Bytes()).Scan(&block).Error; err != nil {

     

       49
       49
       +
       		return nil, err

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	b, err := blocks.NewBlockWithCid(block.Value, cid)

     

       53
       53
       +
       	if err != nil {

     

       54
       54
       +
       		return nil, err

     

       55
       55
       +
       	}

     

       56
       56
       +
       

     

       57
       57
       +
       	return b, nil

     

       58
       58
       +
       }

     

       59
       59
       +
       

     

       60
       60
       +
       func (bs *SqliteBlockstore) Put(ctx context.Context, block blocks.Block) error {

     

       61
       61
       +
       	bs.inserts[block.Cid()] = block

     

       62
       62
       +
       

     

       63
       63
       +
       	if bs.readonly {

     

       64
       64
       +
       		return nil

     

       65
       65
       +
       	}

     

       66
       66
       +
       

     

       67
       67
       +
       	b := models.Block{

     

       68
       68
       +
       		Did:   bs.did,

     

       69
       69
       +
       		Cid:   block.Cid().Bytes(),

     

       70
       70
       +
       		Rev:   syntax.NewTIDNow(0).String(), // TODO: WARN, this is bad. don't do this

     

       71
       71
       +
       		Value: block.RawData(),

     

       72
       72
       +
       	}

     

       73
       73
       +
       

     

       74
       74
       +
       	if err := bs.db.Create(&b, []clause.Expression{clause.OnConflict{

     

       75
       75
       +
       		Columns:   []clause.Column{{Name: "did"}, {Name: "cid"}},

     

       76
       76
       +
       		UpdateAll: true,

     

       77
       77
       +
       	}}).Error; err != nil {

     

       78
       78
       +
       		return err

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	return nil

     

       82
       82
       +
       }

     

       83
       83
       +
       

     

       84
       84
       +
       func (bs *SqliteBlockstore) DeleteBlock(context.Context, cid.Cid) error {

     

       85
       85
       +
       	panic("not implemented")

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       func (bs *SqliteBlockstore) Has(context.Context, cid.Cid) (bool, error) {

     

       89
       89
       +
       	panic("not implemented")

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       92
       92
       +
       func (bs *SqliteBlockstore) GetSize(context.Context, cid.Cid) (int, error) {

     

       93
       93
       +
       	panic("not implemented")

     

       94
       94
       +
       }

     

       95
       95
       +
       

     

       96
       96
       +
       func (bs *SqliteBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error {

     

       97
       97
       +
       	tx := bs.db.BeginDangerously()

     

       98
       98
       +
       

     

       99
       99
       +
       	for _, block := range blocks {

     

       100
       100
       +
       		bs.inserts[block.Cid()] = block

     

       101
       101
       +
       

     

       102
       102
       +
       		if bs.readonly {

     

       103
       103
       +
       			continue

     

       104
       104
       +
       		}

     

       105
       105
       +
       

     

       106
       106
       +
       		b := models.Block{

     

       107
       107
       +
       			Did:   bs.did,

     

       108
       108
       +
       			Cid:   block.Cid().Bytes(),

     

       109
       109
       +
       			Rev:   syntax.NewTIDNow(0).String(), // TODO: WARN, this is bad. don't do this

     

       110
       110
       +
       			Value: block.RawData(),

     

       111
       111
       +
       		}

     

       112
       112
       +
       

     

       113
       113
       +
       		if err := tx.Clauses(clause.OnConflict{

     

       114
       114
       +
       			Columns:   []clause.Column{{Name: "did"}, {Name: "cid"}},

     

       115
       115
       +
       			UpdateAll: true,

     

       116
       116
       +
       		}).Create(&b).Error; err != nil {

     

       117
       117
       +
       			tx.Rollback()

     

       118
       118
       +
       			return err

     

       119
       119
       +
       		}

     

       120
       120
       +
       	}

     

       121
       121
       +
       

     

       122
       122
       +
       	if bs.readonly {

     

       123
       123
       +
       		return nil

     

       124
       124
       +
       	}

     

       125
       125
       +
       

     

       126
       126
       +
       	tx.Commit()

     

       127
       127
       +
       

     

       128
       128
       +
       	return nil

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       131
       131
       +
       func (bs *SqliteBlockstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {

     

       132
       132
       +
       	return nil, fmt.Errorf("iteration not allowed on sqlite blockstore")

     

       133
       133
       +
       }

     

       134
       134
       +
       

     

       135
       135
       +
       func (bs *SqliteBlockstore) HashOnRead(enabled bool) {

     

       136
       136
       +
       	panic("not implemented")

     

       137
       137
       +
       }

Compare changes