back round 0 view raw

appview/repo: add new spindles to consumer as they are ingested #250

merged

opened by

oppi.li 5 months ago targeting master from push-mwkwusmyymno

Signed-off-by: oppiliappan me@oppi.li

options

unified split

Changed files

+44 -21

appview

ingester.go

repo

repo.go

state

router.go

+17 -5

appview/ingester.go

···

       294
       294
        
       	return nil

     

       295
       295
        
       }

     

       296
       296
        
       

     

       297
       297
       -
       func ingestSpindleMember(d *db.DbWrapper, e *models.Event, enforcer *rbac.Enforcer) error {

     

       297
       297
       +
       func ingestSpindleMember(_ *db.DbWrapper, e *models.Event, enforcer *rbac.Enforcer) error {

     

       298
       298
        
       	did := e.Did

     

       299
       299
        
       	var err error

     

       300
       300
        
       

     
···

       338
       338
        
       		}

     

       339
       339
        
       

     

       340
       340
        
       		// this is a special record whose rkey is the instance of the spindle itself

     

       341
       341
       -
       		domain := e.Commit.RKey

     

       341
       341
       +
       		instance := e.Commit.RKey

     

       342
       342
        
       

     

       343
       343
       -
       		owner, err := fetchOwner(context.TODO(), domain, true)

     

       343
       343
       +
       		owner, err := fetchOwner(context.TODO(), instance, dev)

     

       344
       344
        
       		if err != nil {

     

       345
       345
       -
       			log.Printf("failed to verify owner of %s: %w", domain, err)

     

       345
       345
       +
       			log.Printf("failed to verify owner of %s: %s", instance, err)

     

       346
       346
        
       			return err

     

       347
       347
        
       		}

     

       348
       348
        
       

     

       349
       349
        
       		// verify that the spindle owner points back to this did

     

       350
       350
        
       		if owner != did {

     

       351
       351
       -
       			log.Printf("incorrect owner for domain: %s, %s != %s", domain, owner, did)

     

       351
       351
       +
       			log.Printf("incorrect owner for domain: %s, %s != %s", instance, owner, did)

     

       352
       352
        
       			return err

     

       353
       353
        
       		}

     

       354
       354
        
       

     

       355
       355
        
       		// mark this spindle as registered

     

       356
       356
       +
       		ddb, ok := d.Execer.(*db.DB)

     

       357
       357
       +
       		if !ok {

     

       358
       358
       +
       			return fmt.Errorf("failed to index profile record, invalid db cast")

     

       359
       359
       +
       		}

     

       360
       360
       +
       

     

       361
       361
       +
       		_, err = db.VerifySpindle(

     

       362
       362
       +
       			ddb,

     

       363
       363
       +
       			db.FilterEq("owner", did),

     

       364
       364
       +
       			db.FilterEq("instance", instance),

     

       365
       365
       +
       		)

     

       366
       366
       +
       

     

       367
       367
       +
       		return err

     

       356
       368
        
       	}

     

       357
       369
        
       

     

       358
       370
        
       	return nil

+26 -15

appview/repo/repo.go

···

       1
       1
        
       package repo

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       4
       5
        
       	"database/sql"

     

       5
       6
        
       	"encoding/json"

     

       6
       7
        
       	"errors"

     
···

       27
       28
        
       	"tangled.sh/tangled.sh/core/appview/pages/markup"

     

       28
       29
        
       	"tangled.sh/tangled.sh/core/appview/pages/repoinfo"

     

       29
       30
        
       	"tangled.sh/tangled.sh/core/appview/reporesolver"

     

       31
       31
       +
       	"tangled.sh/tangled.sh/core/eventconsumer"

     

       30
       32
        
       	"tangled.sh/tangled.sh/core/knotclient"

     

       31
       33
        
       	"tangled.sh/tangled.sh/core/patchutil"

     

       32
       34
        
       	"tangled.sh/tangled.sh/core/rbac"

     
···

       42
       44
        
       )

     

       43
       45
        
       

     

       44
       46
        
       type Repo struct {

     

       45
       45
       -
       	repoResolver *reporesolver.RepoResolver

     

       46
       46
       -
       	idResolver   *idresolver.Resolver

     

       47
       47
       -
       	config       *config.Config

     

       48
       48
       -
       	oauth        *oauth.OAuth

     

       49
       49
       -
       	pages        *pages.Pages

     

       50
       50
       -
       	db           *db.DB

     

       51
       51
       -
       	enforcer     *rbac.Enforcer

     

       52
       52
       -
       	posthog      posthog.Client

     

       47
       47
       +
       	repoResolver  *reporesolver.RepoResolver

     

       48
       48
       +
       	idResolver    *idresolver.Resolver

     

       49
       49
       +
       	config        *config.Config

     

       50
       50
       +
       	oauth         *oauth.OAuth

     

       51
       51
       +
       	pages         *pages.Pages

     

       52
       52
       +
       	spindlestream *eventconsumer.Consumer

     

       53
       53
       +
       	db            *db.DB

     

       54
       54
       +
       	enforcer      *rbac.Enforcer

     

       55
       55
       +
       	posthog       posthog.Client

     

       53
       56
        
       }

     

       54
       57
        
       

     

       55
       58
        
       func New(

     

       56
       59
        
       	oauth *oauth.OAuth,

     

       57
       60
        
       	repoResolver *reporesolver.RepoResolver,

     

       58
       61
        
       	pages *pages.Pages,

     

       62
       62
       +
       	spindlestream *eventconsumer.Consumer,

     

       59
       63
        
       	idResolver *idresolver.Resolver,

     

       60
       64
        
       	db *db.DB,

     

       61
       65
        
       	config *config.Config,

     
···

       63
       67
        
       	enforcer *rbac.Enforcer,

     

       64
       68
        
       ) *Repo {

     

       65
       69
        
       	return &Repo{oauth: oauth,

     

       66
       66
       -
       		repoResolver: repoResolver,

     

       67
       67
       -
       		pages:        pages,

     

       68
       68
       -
       		idResolver:   idResolver,

     

       69
       69
       -
       		config:       config,

     

       70
       70
       -
       		db:           db,

     

       71
       71
       -
       		posthog:      posthog,

     

       72
       72
       -
       		enforcer:     enforcer,

     

       70
       70
       +
       		repoResolver:  repoResolver,

     

       71
       71
       +
       		pages:         pages,

     

       72
       72
       +
       		idResolver:    idResolver,

     

       73
       73
       +
       		config:        config,

     

       74
       74
       +
       		spindlestream: spindlestream,

     

       75
       75
       +
       		db:            db,

     

       76
       76
       +
       		posthog:       posthog,

     

       77
       77
       +
       		enforcer:      enforcer,

     

       73
       78
        
       	}

     

       74
       79
        
       }

     

       75
       80
        
       

     
···

       831
       836
        
       		return

     

       832
       837
        
       	}

     

       833
       838
        
       

     

       839
       839
       +
       	// add this spindle to spindle stream

     

       840
       840
       +
       	rp.spindlestream.AddSource(

     

       841
       841
       +
       		context.Background(),

     

       842
       842
       +
       		eventconsumer.NewSpindleSource(newSpindle),

     

       843
       843
       +
       	)

     

       844
       844
       +
       

     

       834
       845
        
       	w.Write(fmt.Append(nil, "spindle set to: ", newSpindle))

     

       835
       846
        
       }

     

       836
       847

+1 -1

appview/state/router.go

···

       199
       199
        
       }

     

       200
       200
        
       

     

       201
       201
        
       func (s *State) RepoRouter(mw *middleware.Middleware) http.Handler {

     

       202
       202
       -
       	repo := repo.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config, s.posthog, s.enforcer)

     

       202
       202
       +
       	repo := repo.New(s.oauth, s.repoResolver, s.pages, s.spindlestream, s.idResolver, s.db, s.config, s.posthog, s.enforcer)

     

       203
       203
        
       	return repo.Router(mw)

     

       204
       204
        
       }