Implement JSONLoad, To, and On functions for ForgeFed types

Changes

10 changed files (+315/-71)

• go.mod
  • @@ -299,7 +299,7 @@ replace github.com/shurcooL/vfsgen => github.com/lunny/vfsgen v0.0.0-20220105142
    replace github.com/satori/go.uuid v1.2.0 => github.com/gofrs/uuid v4.2.0+incompatible - replace github.com/go-ap/activitypub => gitea.com/Ta180m/activitypub v0.0.0-20220711172827-b05423b54985 + replace github.com/go-ap/activitypub => gitea.com/Ta180m/activitypub v0.0.0-20220821033718-79a43a998240 exclude github.com/gofrs/uuid v3.2.0+incompatible
• go.sum
  • @@ -73,8 +73,8 @@ contrib.go.opencensus.io/resource v0.1.1/go.mod h1:F361eGI91LCmW1I/Saf+rX0+OFcig
    dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078 h1:cliQ4HHsCo6xi2oWZYKWW4bly/Ory9FuTpFPRxj/mAg= git.sr.ht/~mariusor/go-xsd-duration v0.0.0-20220703122237-02e73435a078/go.mod h1:g/V2Hjas6Z1UHUp4yIx6bATpNzJ7DYtD0FG3+xARWxs= - gitea.com/Ta180m/activitypub v0.0.0-20220711172827-b05423b54985 h1:mFjFQxAsUdcvtM3klWtTbkhGnsRVF+DPhZPofsKmPlk= - gitea.com/Ta180m/activitypub v0.0.0-20220711172827-b05423b54985/go.mod h1:KDY/LAOthmTlRA4ft9TKrvPKVe+AZaSaU+3HS/UITvU= + gitea.com/Ta180m/activitypub v0.0.0-20220821033718-79a43a998240 h1:ZW+5jY1ibiRPGoBlUcwBA9eHdFVGD70qWrKXw877Yd4= + gitea.com/Ta180m/activitypub v0.0.0-20220821033718-79a43a998240/go.mod h1:Md4CYDr9vFkojPjSqzG04PN03hgnd+X3jf4i8Nbb7OE= gitea.com/go-chi/binding v0.0.0-20220309004920-114340dabecb h1:Yy0Bxzc8R2wxiwXoG/rECGplJUSpXqCsog9PuJFgiHs= gitea.com/go-chi/binding v0.0.0-20220309004920-114340dabecb/go.mod h1:77TZu701zMXWJFvB8gvTbQ92zQ3DQq/H7l5wAEjQRKc= gitea.com/go-chi/cache v0.0.0-20210110083709-82c4c9ce2d5e/go.mod h1:k2V/gPDEtXGjjMGuBJiapffAXTv76H4snSmlJRLUhH0=
• modules/activitypub/authorize_interaction.go
  • @@ -27,6 +27,7 @@ func AuthorizeInteraction(ctx *context.Context) {
    } ap.ItemTyperFunc = forgefed.GetItemByType + ap.JSONItemUnmarshal = forgefed.JSONUnmarshalerFn object, err := ap.UnmarshalJSON(resp) if err != nil { ctx.ServerError("UnmarshalJSON", err)
  • @@ -51,11 +52,19 @@ func AuthorizeInteraction(ctx *context.Context) {
    } ctx.Redirect(name) case forgefed.RepositoryType: - err = FederatedRepoNew(ctx, object.(forgefed.Repository)) + err = forgefed.OnRepository(object, func(r *forgefed.Repository) error { + return FederatedRepoNew(ctx, r) + }) if err != nil { ctx.ServerError("FederatedRepoNew", err) return } + username, reponame, err := repositoryIRIToName(object.GetLink()) + if err != nil { + ctx.ServerError("repositoryIRIToName", err) + return + } + ctx.Redirect(username+"/"+reponame) } ctx.Status(http.StatusOK)
• modules/activitypub/repo.go
  • @@ -8,12 +8,12 @@ import (
    "context" "code.gitea.io/gitea/models" - repo_model "code.gitea.io/gitea/models/repo" + repo_service "code.gitea.io/gitea/services/repository" "code.gitea.io/gitea/modules/forgefed" ) // Create a new federated repo from a Repository object - func FederatedRepoNew(ctx context.Context, repository forgefed.Repository) error { + func FederatedRepoNew(ctx context.Context, repository *forgefed.Repository) error { ownerIRI, err := repositoryIRIToOwnerIRI(repository.GetLink()) if err != nil { return err
  • @@ -23,9 +23,14 @@ func FederatedRepoNew(ctx context.Context, repository forgefed.Repository) error
    return err } - repo := repo_model.Repository{ + // TODO: Check if repo already exists + repo, err := repo_service.CreateRepository(user, user, models.CreateRepoOptions{ Name: repository.Name.String(), + }) + if err != nil { + return err } + if repository.ForkedFrom != nil { repo.IsFork = true forkedFrom, err := repositoryIRIToRepository(ctx, repository.ForkedFrom.GetLink())
  • @@ -34,7 +39,5 @@ func FederatedRepoNew(ctx context.Context, repository forgefed.Repository) error
    } repo.ForkID = forkedFrom.ID } - - // TODO: Check if repo already exists - return models.CreateRepository(ctx, user, user, &repo, false) + return nil }
• modules/forgefed/branch.go
  • @@ -5,6 +5,9 @@
    package forgefed import ( + "reflect" + "unsafe" + ap "github.com/go-ap/activitypub" "github.com/valyala/fastjson" )
  • @@ -26,30 +29,68 @@ func BranchNew() *Branch {
    return &o } - func (br Branch) MarshalJSON() ([]byte, error) { - b, err := br.Object.MarshalJSON() - if len(b) == 0 || err != nil { + func (b Branch) MarshalJSON() ([]byte, error) { + bin, err := b.Object.MarshalJSON() + if len(bin) == 0 || err != nil { return nil, err } - b = b[:len(b)-1] - if br.Ref != nil { - ap.WriteItemJSONProp(&b, "ref", br.Ref) + bin = bin[:len(bin)-1] + if b.Ref != nil { + ap.JSONWriteItemJSONProp(&bin, "ref", b.Ref) } - ap.Write(&b, '}') - return b, nil + ap.JSONWrite(&bin, '}') + return bin, nil + } + + func JSONLoadBranch(val *fastjson.Value, b *Branch) error { + ap.OnObject(&b.Object, func(o *ap.Object) error { + return ap.JSONLoadObject(val, o) + }) + b.Ref = ap.JSONGetItem(val, "ref") + return nil } - func (br *Branch) UnmarshalJSON(data []byte) error { + func (b *Branch) UnmarshalJSON(data []byte) error { p := fastjson.Parser{} val, err := p.ParseBytes(data) if err != nil { return err } + return JSONLoadBranch(val, b) + } - br.Ref = ap.JSONGetItem(val, "ref") + // ToBranch tries to convert the it Item to a Branch object. + func ToBranch(it ap.Item) (*Branch, error) { + switch i := it.(type) { + case *Branch: + return i, nil + case Branch: + return &i, nil + case *ap.Object: + return (*Branch)(unsafe.Pointer(i)), nil + case ap.Object: + return (*Branch)(unsafe.Pointer(&i)), nil + default: + // NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes + typ := reflect.TypeOf(new(Branch)) + if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Branch); ok { + return i, nil + } + } + return nil, ap.ErrorInvalidType[ap.Object](it) + } - return ap.OnObject(&br.Object, func(a *ap.Object) error { - return ap.LoadObject(val, a) - }) + type withBranchFn func(*Branch) error + + // OnBranch calls function fn on it Item if it can be asserted to type *Branch + func OnBranch(it ap.Item, fn withBranchFn) error { + if it == nil { + return nil + } + ob, err := ToBranch(it) + if err != nil { + return err + } + return fn(ob) }
• modules/forgefed/commit.go
  • @@ -5,7 +5,9 @@
    package forgefed import ( + "reflect" "time" + "unsafe" ap "github.com/go-ap/activitypub" "github.com/valyala/fastjson"
  • @@ -38,26 +40,64 @@ func (c Commit) MarshalJSON() ([]byte, error) {
    b = b[:len(b)-1] if !c.Created.IsZero() { - ap.WriteTimeJSONProp(&b, "created", c.Created) + ap.JSONWriteTimeJSONProp(&b, "created", c.Created) } if !c.Committed.IsZero() { - ap.WriteTimeJSONProp(&b, "committed", c.Committed) + ap.JSONWriteTimeJSONProp(&b, "committed", c.Committed) } - ap.Write(&b, '}') + ap.JSONWrite(&b, '}') return b, nil } + func JSONLoadCommit(val *fastjson.Value, c *Commit) error { + ap.OnObject(&c.Object, func(o *ap.Object) error { + return ap.JSONLoadObject(val, o) + }) + c.Created = ap.JSONGetTime(val, "created") + c.Committed = ap.JSONGetTime(val, "committed") + return nil + } + func (c *Commit) UnmarshalJSON(data []byte) error { p := fastjson.Parser{} val, err := p.ParseBytes(data) if err != nil { return err } + return JSONLoadCommit(val, c) + } - c.Created = ap.JSONGetTime(val, "created") - c.Committed = ap.JSONGetTime(val, "committed") + // ToCommit tries to convert the it Item to a Commit object. + func ToCommit(it ap.Item) (*Commit, error) { + switch i := it.(type) { + case *Commit: + return i, nil + case Commit: + return &i, nil + case *ap.Object: + return (*Commit)(unsafe.Pointer(i)), nil + case ap.Object: + return (*Commit)(unsafe.Pointer(&i)), nil + default: + // NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes + typ := reflect.TypeOf(new(Commit)) + if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Commit); ok { + return i, nil + } + } + return nil, ap.ErrorInvalidType[ap.Object](it) + } - return ap.OnObject(&c.Object, func(a *ap.Object) error { - return ap.LoadObject(val, a) - }) + type withCommitFn func(*Commit) error + + // OnCommit calls function fn on it Item if it can be asserted to type *Commit + func OnCommit(it ap.Item, fn withCommitFn) error { + if it == nil { + return nil + } + ob, err := ToCommit(it) + if err != nil { + return err + } + return fn(ob) }
• modules/forgefed/forgefed.go
  • @@ -6,6 +6,7 @@ package forgefed
    import ( ap "github.com/go-ap/activitypub" + "github.com/valyala/fastjson" ) const ForgeFedNamespaceURI = "https://forgefed.org/ns"
  • @@ -27,3 +28,31 @@ func GetItemByType(typ ap.ActivityVocabularyType) (ap.Item, error) {
    } return ap.GetItemByType(typ) } + + // JSONUnmarshalerFn is the type of the function that will load the data from a fastjson.Value into an Item + // that the go-ap/activitypub package doesn't know about. + func JSONUnmarshalerFn(typ ap.ActivityVocabularyType, val *fastjson.Value, i ap.Item) error { + switch typ { + case CommitType: + return OnCommit(i, func(c *Commit) error { + return JSONLoadCommit(val, c) + }) + case BranchType: + return OnBranch(i, func(b *Branch) error { + return JSONLoadBranch(val, b) + }) + case RepositoryType: + return OnRepository(i, func(r *Repository) error { + return JSONLoadRepository(val, r) + }) + case PushType: + return OnPush(i, func(p *Push) error { + return JSONLoadPush(val, p) + }) + case TicketType: + return OnTicket(i, func(t *Ticket) error { + return JSONLoadTicket(val, t) + }) + } + return nil + }
• modules/forgefed/push.go
  • @@ -5,6 +5,9 @@
    package forgefed import ( + "reflect" + "unsafe" + ap "github.com/go-ap/activitypub" "github.com/valyala/fastjson" )
  • @@ -38,30 +41,68 @@ func (p Push) MarshalJSON() ([]byte, error) {
    b = b[:len(b)-1] if p.Target != nil { - ap.WriteItemJSONProp(&b, "target", p.Target) + ap.JSONWriteItemJSONProp(&b, "target", p.Target) } if p.HashBefore != nil { - ap.WriteItemJSONProp(&b, "hashBefore", p.HashBefore) + ap.JSONWriteItemJSONProp(&b, "hashBefore", p.HashBefore) } if p.HashAfter != nil { - ap.WriteItemJSONProp(&b, "hashAfter", p.HashAfter) + ap.JSONWriteItemJSONProp(&b, "hashAfter", p.HashAfter) } - ap.Write(&b, '}') + ap.JSONWrite(&b, '}') return b, nil } + func JSONLoadPush(val *fastjson.Value, p *Push) error { + ap.OnObject(&p.Object, func(o *ap.Object) error { + return ap.JSONLoadObject(val, o) + }) + p.Target = ap.JSONGetItem(val, "target") + p.HashBefore = ap.JSONGetItem(val, "hashBefore") + p.HashAfter = ap.JSONGetItem(val, "hashAfter") + return nil + } + func (p *Push) UnmarshalJSON(data []byte) error { - ps := fastjson.Parser{} - val, err := ps.ParseBytes(data) + par := fastjson.Parser{} + val, err := par.ParseBytes(data) if err != nil { return err } + return JSONLoadPush(val, p) + } - p.Target = ap.JSONGetItem(val, "target") - p.HashBefore = ap.JSONGetItem(val, "hashBefore") - p.HashAfter = ap.JSONGetItem(val, "hashAfter") + // ToPush tries to convert the it Item to a Push object. + func ToPush(it ap.Item) (*Push, error) { + switch i := it.(type) { + case *Push: + return i, nil + case Push: + return &i, nil + case *ap.Object: + return (*Push)(unsafe.Pointer(i)), nil + case ap.Object: + return (*Push)(unsafe.Pointer(&i)), nil + default: + // NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes + typ := reflect.TypeOf(new(Push)) + if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Push); ok { + return i, nil + } + } + return nil, ap.ErrorInvalidType[ap.Object](it) + } - return ap.OnObject(&p.Object, func(a *ap.Object) error { - return ap.LoadObject(val, a) - }) + type withPushFn func(*Push) error + + // OnPush calls function fn on it Item if it can be asserted to type *Push + func OnPush(it ap.Item, fn withPushFn) error { + if it == nil { + return nil + } + ob, err := ToPush(it) + if err != nil { + return err + } + return fn(ob) }
• modules/forgefed/repository.go
  • @@ -5,6 +5,9 @@
    package forgefed import ( + "reflect" + "unsafe" + ap "github.com/go-ap/activitypub" "github.com/valyala/fastjson" )
  • @@ -39,30 +42,68 @@ func (r Repository) MarshalJSON() ([]byte, error) {
    b = b[:len(b)-1] if r.Team != nil { - ap.WriteItemJSONProp(&b, "team", r.Team) + ap.JSONWriteItemJSONProp(&b, "team", r.Team) } if r.Forks != nil { - ap.WriteItemJSONProp(&b, "forks", r.Forks) + ap.JSONWriteItemJSONProp(&b, "forks", r.Forks) } if r.ForkedFrom != nil { - ap.WriteItemJSONProp(&b, "forkedFrom", r.ForkedFrom) + ap.JSONWriteItemJSONProp(&b, "forkedFrom", r.ForkedFrom) } - ap.Write(&b, '}') + ap.JSONWrite(&b, '}') return b, nil } + func JSONLoadRepository(val *fastjson.Value, r *Repository) error { + ap.OnActor(&r.Actor, func(a *ap.Actor) error { + return ap.JSONLoadActor(val, a) + }) + r.Team = ap.JSONGetItem(val, "team") + r.Forks = ap.JSONGetItem(val, "forks") + r.ForkedFrom = ap.JSONGetItem(val, "forkedFrom") + return nil + } + func (r *Repository) UnmarshalJSON(data []byte) error { p := fastjson.Parser{} val, err := p.ParseBytes(data) if err != nil { return err } + return JSONLoadRepository(val, r) + } - r.Team = ap.JSONGetItem(val, "team") - r.Forks = ap.JSONGetItem(val, "forks") - r.ForkedFrom = ap.JSONGetItem(val, "forkedFrom") + // ToRepository tries to convert the it Item to a Repository Actor. + func ToRepository(it ap.Item) (*Repository, error) { + switch i := it.(type) { + case *Repository: + return i, nil + case Repository: + return &i, nil + case *ap.Actor: + return (*Repository)(unsafe.Pointer(i)), nil + case ap.Actor: + return (*Repository)(unsafe.Pointer(&i)), nil + default: + // NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes + typ := reflect.TypeOf(new(Repository)) + if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Repository); ok { + return i, nil + } + } + return nil, ap.ErrorInvalidType[ap.Actor](it) + } - return ap.OnActor(&r.Actor, func(a *ap.Actor) error { - return ap.LoadActor(val, a) - }) + type withRepositoryFn func(*Repository) error + + // OnRepository calls function fn on it Item if it can be asserted to type *Repository + func OnRepository(it ap.Item, fn withRepositoryFn) error { + if it == nil { + return nil + } + ob, err := ToRepository(it) + if err != nil { + return err + } + return fn(ob) }
• modules/forgefed/ticket.go
  • @@ -5,7 +5,9 @@
    package forgefed import ( + "reflect" "time" + "unsafe" ap "github.com/go-ap/activitypub" "github.com/valyala/fastjson"
  • @@ -48,35 +50,32 @@ func (t Ticket) MarshalJSON() ([]byte, error) {
    b = b[:len(b)-1] if t.Dependants != nil { - ap.WriteItemCollectionJSONProp(&b, "dependants", t.Dependants) + ap.JSONWriteItemCollectionJSONProp(&b, "dependants", t.Dependants) } if t.Dependencies != nil { - ap.WriteItemCollectionJSONProp(&b, "dependencies", t.Dependencies) + ap.JSONWriteItemCollectionJSONProp(&b, "dependencies", t.Dependencies) } - ap.WriteBoolJSONProp(&b, "isResolved", t.IsResolved) + ap.JSONWriteBoolJSONProp(&b, "isResolved", t.IsResolved) if t.ResolvedBy != nil { - ap.WriteItemJSONProp(&b, "resolvedBy", t.ResolvedBy) + ap.JSONWriteItemJSONProp(&b, "resolvedBy", t.ResolvedBy) } if !t.Resolved.IsZero() { - ap.WriteTimeJSONProp(&b, "resolved", t.Resolved) + ap.JSONWriteTimeJSONProp(&b, "resolved", t.Resolved) } if t.Origin != nil { - ap.WriteItemJSONProp(&b, "origin", t.Origin) + ap.JSONWriteItemJSONProp(&b, "origin", t.Origin) } if t.Target != nil { - ap.WriteItemJSONProp(&b, "target", t.Target) + ap.JSONWriteItemJSONProp(&b, "target", t.Target) } - ap.Write(&b, '}') + ap.JSONWrite(&b, '}') return b, nil } - func (t *Ticket) UnmarshalJSON(data []byte) error { - p := fastjson.Parser{} - val, err := p.ParseBytes(data) - if err != nil { - return err - } - + func JSONLoadTicket(val *fastjson.Value, t *Ticket) error { + ap.OnObject(&t.Object, func(o *ap.Object) error { + return ap.JSONLoadObject(val, o) + }) t.Dependants = ap.JSONGetItems(val, "dependants") t.Dependencies = ap.JSONGetItems(val, "dependencies") t.IsResolved = ap.JSONGetBoolean(val, "isResolved")
  • @@ -84,8 +83,49 @@ func (t *Ticket) UnmarshalJSON(data []byte) error {
    t.Resolved = ap.JSONGetTime(val, "resolved") t.Origin = ap.JSONGetItem(val, "origin") t.Target = ap.JSONGetItem(val, "target") + return nil + } - return ap.OnObject(&t.Object, func(a *ap.Object) error { - return ap.LoadObject(val, a) - }) + func (t *Ticket) UnmarshalJSON(data []byte) error { + p := fastjson.Parser{} + val, err := p.ParseBytes(data) + if err != nil { + return err + } + return JSONLoadTicket(val, t) + } + + // ToTicket tries to convert the it Item to a Ticket object. + func ToTicket(it ap.Item) (*Ticket, error) { + switch i := it.(type) { + case *Ticket: + return i, nil + case Ticket: + return &i, nil + case *ap.Object: + return (*Ticket)(unsafe.Pointer(i)), nil + case ap.Object: + return (*Ticket)(unsafe.Pointer(&i)), nil + default: + // NOTE(marius): this is an ugly way of dealing with the interface conversion error: types from different scopes + typ := reflect.TypeOf(new(Ticket)) + if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Ticket); ok { + return i, nil + } + } + return nil, ap.ErrorInvalidType[ap.Object](it) + } + + type withTicketFn func(*Ticket) error + + // OnTicket calls function fn on it Item if it can be asserted to type *Ticket + func OnTicket(it ap.Item, fn withTicketFn) error { + if it == nil { + return nil + } + ob, err := ToTicket(it) + if err != nil { + return err + } + return fn(ob) }