commit 10f31b91e539fec4cf0e1c11930c8d554e45f288 · hailey.at/cocoon

+46 -15
server/handle_server_check_account_status.go
···

       1
       1
        
       package server

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"errors"

     

       5
       5
       +
       	"sync"

     

       6
       6
       +
       

     

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

     

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

     

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

     

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

     
···

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

     

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

     

       24
       28
        
       

     

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

     

       30
       30
       +
       	if didErr != nil {

     

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

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       25
       34
        
       	resp := ComAtprotoServerCheckAccountStatusResponse{

     

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

     

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

     

       36
       36
       +
       		ValidDid:      didErr == nil,

     

       28
       37
        
       		RepoRev:       urepo.Rev,

     

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

     

       30
       39
        
       	}

     
···

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

     

       35
       44
        
       		return helpers.ServerError(e, nil)

     

       36
       45
        
       	}

     

       46
       46
       +
       

     

       37
       47
        
       	resp.RepoCommit = rootcid.String()

     

       38
       48
        
       

     

       39
       49
        
       	type CountResp struct {

     
···

       41
       51
        
       	}

     

       42
       52
        
       

     

       43
       53
        
       	var blockCtResp CountResp

     

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

     

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

     

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

     

       47
       47
       -
       	}

     

       48
       48
       -
       	resp.RepoBlocks = blockCtResp.Ct

     

       54
       54
       +
       	var recCtResp CountResp

     

       55
       55
       +
       	var blobCtResp CountResp

     

       56
       56
       +
       

     

       57
       57
       +
       	var wg sync.WaitGroup

     

       58
       58
       +
       	var procErr error

     

       59
       59
       +
       

     

       60
       60
       +
       	wg.Add(1)

     

       61
       61
       +
       	go func() {

     

       62
       62
       +
       		defer wg.Done()

     

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

     

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

     

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

     

       66
       66
       +
       		}

     

       67
       67
       +
       	}()

     

       68
       68
       +
       

     

       69
       69
       +
       	wg.Add(1)

     

       70
       70
       +
       	go func() {

     

       71
       71
       +
       		defer wg.Done()

     

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

     

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

     

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

     

       75
       75
       +
       		}

     

       76
       76
       +
       	}()

     

       49
       77
        
       

     

       50
       50
       -
       	var recCtResp CountResp

     

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

     

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

     

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

     

       54
       54
       -
       	}

     

       55
       55
       -
       	resp.IndexedRecords = recCtResp.Ct

     

       78
       78
       +
       	wg.Add(1)

     

       79
       79
       +
       	go func() {

     

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

     

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

     

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

     

       83
       83
       +
       		}

     

       84
       84
       +
       	}()

     

       56
       85
        
       

     

       57
       57
       -
       	var blobCtResp CountResp

     

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

     

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

     

       86
       86
       +
       	wg.Wait()

     

       87
       87
       +
       	if procErr != nil {

     

       60
       88
        
       		return helpers.ServerError(e, nil)

     

       61
       89
        
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	resp.RepoBlocks = blockCtResp.Ct

     

       92
       92
       +
       	resp.IndexedRecords = recCtResp.Ct

     

       62
       93
        
       	resp.ExpectedBlobs = blobCtResp.Ct

     

       63
       94
        
       

     

       64
       95
        
       	return e.JSON(200, resp)