diff --git a/api/tangled/cbor_gen.go b/api/tangled/cbor_gen.go index a42a4651..bb6f06ba 100644 --- a/api/tangled/cbor_gen.go +++ b/api/tangled/cbor_gen.go @@ -676,7 +676,7 @@ func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { cw := cbg.NewCborWriter(w) - if _, err := cw.Write([]byte{167}); err != nil { + if _, err := cw.Write([]byte{168}); err != nil { return err } @@ -703,6 +703,22 @@ func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error { return err } + // t.Meta (tangled.GitRefUpdate_Meta) (struct) + if len("meta") > 1000000 { + return xerrors.Errorf("Value in field \"meta\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { + return err + } + if _, err := cw.WriteString(string("meta")); err != nil { + return err + } + + if err := t.Meta.MarshalCBOR(cw); err != nil { + return err + } + // t.LexiconTypeID (string) (string) if len("$type") > 1000000 { return xerrors.Errorf("Value in field \"$type\" was too long") @@ -891,6 +907,26 @@ func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { t.Ref = string(sval) } + // t.Meta (tangled.GitRefUpdate_Meta) (struct) + case "meta": + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Meta = new(GitRefUpdate_Meta) + if err := t.Meta.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) + } + } + + } // t.LexiconTypeID (string) (string) case "$type": @@ -968,7 +1004,7 @@ func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) { return nil } -func (t *GraphFollow) MarshalCBOR(w io.Writer) error { +func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err @@ -976,79 +1012,46 @@ func (t *GraphFollow) MarshalCBOR(w io.Writer) error { cw := cbg.NewCborWriter(w) - if _, err := cw.Write([]byte{163}); err != nil { - return err - } - - // t.LexiconTypeID (string) (string) - if len("$type") > 1000000 { - return xerrors.Errorf("Value in field \"$type\" was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { - return err - } - if _, err := cw.WriteString(string("$type")); err != nil { - return err - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil { - return err - } - if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil { + if _, err := cw.Write([]byte{162}); err != nil { return err } - // t.Subject (string) (string) - if len("subject") > 1000000 { - return xerrors.Errorf("Value in field \"subject\" was too long") + // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) + if len("commitCount") > 1000000 { + return xerrors.Errorf("Value in field \"commitCount\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil { return err } - if _, err := cw.WriteString(string("subject")); err != nil { + if _, err := cw.WriteString(string("commitCount")); err != nil { return err } - if len(t.Subject) > 1000000 { - return xerrors.Errorf("Value in field t.Subject was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.Subject)); err != nil { + if err := t.CommitCount.MarshalCBOR(cw); err != nil { return err } - // t.CreatedAt (string) (string) - if len("createdAt") > 1000000 { - return xerrors.Errorf("Value in field \"createdAt\" was too long") + // t.IsDefaultRef (bool) (bool) + if len("isDefaultRef") > 1000000 { + return xerrors.Errorf("Value in field \"isDefaultRef\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil { return err } - if _, err := cw.WriteString(string("createdAt")); err != nil { + if _, err := cw.WriteString(string("isDefaultRef")); err != nil { return err } - if len(t.CreatedAt) > 1000000 { - return xerrors.Errorf("Value in field t.CreatedAt was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { + if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil { return err } return nil } -func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { - *t = GraphFollow{} +func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) { + *t = GitRefUpdate_Meta{} cr := cbg.NewCborReader(r) @@ -1067,12 +1070,12 @@ func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { } if extra > cbg.MaxLength { - return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) + return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 9) + nameBuf := make([]byte, 12) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1088,38 +1091,43 @@ func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { } switch string(nameBuf[:nameLen]) { - // t.LexiconTypeID (string) (string) - case "$type": + // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) + case "commitCount": { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } - - t.LexiconTypeID = string(sval) - } - // t.Subject (string) (string) - case "subject": - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) + b, err := cr.ReadByte() if err != nil { return err } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.CommitCount = new(GitRefUpdate_Meta_CommitCount) + if err := t.CommitCount.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err) + } + } - t.Subject = string(sval) } - // t.CreatedAt (string) (string) - case "createdAt": - - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } + // t.IsDefaultRef (bool) (bool) + case "isDefaultRef": - t.CreatedAt = string(sval) + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.IsDefaultRef = false + case 21: + t.IsDefaultRef = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) } default: @@ -1132,110 +1140,56 @@ func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { return nil } -func (t *KnotMember) MarshalCBOR(w io.Writer) error { +func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err } cw := cbg.NewCborWriter(w) + fieldCount := 1 - if _, err := cw.Write([]byte{164}); err != nil { - return err - } - - // t.LexiconTypeID (string) (string) - if len("$type") > 1000000 { - return xerrors.Errorf("Value in field \"$type\" was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { - return err - } - if _, err := cw.WriteString(string("$type")); err != nil { - return err - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil { - return err - } - if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil { - return err - } - - // t.Domain (string) (string) - if len("domain") > 1000000 { - return xerrors.Errorf("Value in field \"domain\" was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil { - return err - } - if _, err := cw.WriteString(string("domain")); err != nil { - return err - } - - if len(t.Domain) > 1000000 { - return xerrors.Errorf("Value in field t.Domain was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.Domain)); err != nil { - return err - } - - // t.Subject (string) (string) - if len("subject") > 1000000 { - return xerrors.Errorf("Value in field \"subject\" was too long") + if t.ByEmail == nil { + fieldCount-- } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { - return err - } - if _, err := cw.WriteString(string("subject")); err != nil { + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { return err } - if len(t.Subject) > 1000000 { - return xerrors.Errorf("Value in field t.Subject was too long") - } + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) + if t.ByEmail != nil { - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.Subject)); err != nil { - return err - } + if len("byEmail") > 1000000 { + return xerrors.Errorf("Value in field \"byEmail\" was too long") + } - // t.CreatedAt (string) (string) - if len("createdAt") > 1000000 { - return xerrors.Errorf("Value in field \"createdAt\" was too long") - } + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil { + return err + } + if _, err := cw.WriteString(string("byEmail")); err != nil { + return err + } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { - return err - } - if _, err := cw.WriteString(string("createdAt")); err != nil { - return err - } + if len(t.ByEmail) > 8192 { + return xerrors.Errorf("Slice value in field t.ByEmail was too long") + } - if len(t.CreatedAt) > 1000000 { - return xerrors.Errorf("Value in field t.CreatedAt was too long") - } + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil { + return err + } + for _, v := range t.ByEmail { + if err := v.MarshalCBOR(cw); err != nil { + return err + } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { - return err + } } return nil } -func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) { - *t = KnotMember{} +func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) { + *t = GitRefUpdate_Meta_CommitCount{} cr := cbg.NewCborReader(r) @@ -1254,12 +1208,12 @@ func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) { } if extra > cbg.MaxLength { - return fmt.Errorf("KnotMember: map struct too large (%d)", extra) + return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 9) + nameBuf := make([]byte, 7) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1275,49 +1229,54 @@ func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) { } switch string(nameBuf[:nameLen]) { - // t.LexiconTypeID (string) (string) - case "$type": - - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) + case "byEmail": - t.LexiconTypeID = string(sval) + maj, extra, err = cr.ReadHeader() + if err != nil { + return err } - // t.Domain (string) (string) - case "domain": - - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } - t.Domain = string(sval) + if extra > 8192 { + return fmt.Errorf("t.ByEmail: array too large (%d)", extra) } - // t.Subject (string) (string) - case "subject": - - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } - t.Subject = string(sval) + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") } - // t.CreatedAt (string) (string) - case "createdAt": - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } + if extra > 0 { + t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra) + } - t.CreatedAt = string(sval) + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem) + if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err) + } + } + + } + + } } default: @@ -1330,7 +1289,7 @@ func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) { return nil } -func (t *Pipeline) MarshalCBOR(w io.Writer) error { +func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err @@ -1338,75 +1297,59 @@ func (t *Pipeline) MarshalCBOR(w io.Writer) error { cw := cbg.NewCborWriter(w) - if _, err := cw.Write([]byte{163}); err != nil { + if _, err := cw.Write([]byte{162}); err != nil { return err } - // t.LexiconTypeID (string) (string) - if len("$type") > 1000000 { - return xerrors.Errorf("Value in field \"$type\" was too long") + // t.Count (int64) (int64) + if len("count") > 1000000 { + return xerrors.Errorf("Value in field \"count\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil { return err } - if _, err := cw.WriteString(string("$type")); err != nil { + if _, err := cw.WriteString(string("count")); err != nil { return err } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { - return err - } - if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { - return err + if t.Count >= 0 { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil { + return err + } + } else { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil { + return err + } } - // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) - if len("workflows") > 1000000 { - return xerrors.Errorf("Value in field \"workflows\" was too long") + // t.Email (string) (string) + if len("email") > 1000000 { + return xerrors.Errorf("Value in field \"email\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { - return err - } - if _, err := cw.WriteString(string("workflows")); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil { return err } - - if len(t.Workflows) > 8192 { - return xerrors.Errorf("Slice value in field t.Workflows was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { + if _, err := cw.WriteString(string("email")); err != nil { return err } - for _, v := range t.Workflows { - if err := v.MarshalCBOR(cw); err != nil { - return err - } + if len(t.Email) > 1000000 { + return xerrors.Errorf("Value in field t.Email was too long") } - // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) - if len("triggerMetadata") > 1000000 { - return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { - return err - } - if _, err := cw.WriteString(string("triggerMetadata")); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil { return err } - - if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { + if _, err := cw.WriteString(string(t.Email)); err != nil { return err } return nil } -func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { - *t = Pipeline{} +func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) { + *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{} cr := cbg.NewCborReader(r) @@ -1425,12 +1368,12 @@ func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { } if extra > cbg.MaxLength { - return fmt.Errorf("Pipeline: map struct too large (%d)", extra) + return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 15) + nameBuf := make([]byte, 5) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1446,85 +1389,42 @@ func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { } switch string(nameBuf[:nameLen]) { - // t.LexiconTypeID (string) (string) - case "$type": - + // t.Count (int64) (int64) + case "count": { - sval, err := cbg.ReadStringWithMax(cr, 1000000) + maj, extra, err := cr.ReadHeader() if err != nil { return err } - - t.LexiconTypeID = string(sval) - } - // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) - case "workflows": - - maj, extra, err = cr.ReadHeader() - if err != nil { - return err - } - - if extra > 8192 { - return fmt.Errorf("t.Workflows: array too large (%d)", extra) - } - - if maj != cbg.MajArray { - return fmt.Errorf("expected cbor array") - } - - if extra > 0 { - t.Workflows = make([]*Pipeline_Workflow, extra) - } - - for i := 0; i < int(extra); i++ { - { - var maj byte - var extra uint64 - var err error - _ = maj - _ = extra - _ = err - - { - - b, err := cr.ReadByte() - if err != nil { - return err - } - if b != cbg.CborNull[0] { - if err := cr.UnreadByte(); err != nil { - return err - } - t.Workflows[i] = new(Pipeline_Workflow) - if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) - } - } - + var extraI int64 + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") } - + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative overflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) } + + t.Count = int64(extraI) } - // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) - case "triggerMetadata": + // t.Email (string) (string) + case "email": { - - b, err := cr.ReadByte() + sval, err := cbg.ReadStringWithMax(cr, 1000000) if err != nil { return err } - if b != cbg.CborNull[0] { - if err := cr.UnreadByte(); err != nil { - return err - } - t.TriggerMetadata = new(Pipeline_TriggerMetadata) - if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) - } - } + t.Email = string(sval) } default: @@ -1537,7 +1437,7 @@ func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { return nil } -func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error { +func (t *GraphFollow) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err @@ -1549,64 +1449,75 @@ func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error { return err } - // t.Skip (bool) (bool) - if len("skip") > 1000000 { - return xerrors.Errorf("Value in field \"skip\" was too long") + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { return err } - if _, err := cw.WriteString(string("skip")); err != nil { + if _, err := cw.WriteString(string("$type")); err != nil { return err } - if err := cbg.WriteBool(w, t.Skip); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.graph.follow"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.graph.follow")); err != nil { return err } - // t.Depth (int64) (int64) - if len("depth") > 1000000 { - return xerrors.Errorf("Value in field \"depth\" was too long") + // t.Subject (string) (string) + if len("subject") > 1000000 { + return xerrors.Errorf("Value in field \"subject\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { return err } - if _, err := cw.WriteString(string("depth")); err != nil { + if _, err := cw.WriteString(string("subject")); err != nil { return err } - if t.Depth >= 0 { - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil { - return err - } - } else { - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil { - return err - } + if len(t.Subject) > 1000000 { + return xerrors.Errorf("Value in field t.Subject was too long") } - // t.Submodules (bool) (bool) - if len("submodules") > 1000000 { - return xerrors.Errorf("Value in field \"submodules\" was too long") + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Subject)); err != nil { + return err } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil { + // t.CreatedAt (string) (string) + if len("createdAt") > 1000000 { + return xerrors.Errorf("Value in field \"createdAt\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { return err } - if _, err := cw.WriteString(string("submodules")); err != nil { + if _, err := cw.WriteString(string("createdAt")); err != nil { return err } - if err := cbg.WriteBool(w, t.Submodules); err != nil { + if len(t.CreatedAt) > 1000000 { + return xerrors.Errorf("Value in field t.CreatedAt was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { return err } return nil } -func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) { - *t = Pipeline_CloneOpts{} +func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { + *t = GraphFollow{} cr := cbg.NewCborReader(r) @@ -1625,12 +1536,12 @@ func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) { } if extra > cbg.MaxLength { - return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra) + return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 10) + nameBuf := make([]byte, 9) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1646,67 +1557,38 @@ func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) { } switch string(nameBuf[:nameLen]) { - // t.Skip (bool) (bool) - case "skip": + // t.LexiconTypeID (string) (string) + case "$type": - maj, extra, err = cr.ReadHeader() - if err != nil { - return err - } - if maj != cbg.MajOther { - return fmt.Errorf("booleans must be major type 7") + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.LexiconTypeID = string(sval) } - switch extra { - case 20: - t.Skip = false - case 21: - t.Skip = true - default: - return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) - } - // t.Depth (int64) (int64) - case "depth": + // t.Subject (string) (string) + case "subject": + { - maj, extra, err := cr.ReadHeader() + sval, err := cbg.ReadStringWithMax(cr, 1000000) if err != nil { return err } - var extraI int64 - switch maj { - case cbg.MajUnsignedInt: - extraI = int64(extra) - if extraI < 0 { - return fmt.Errorf("int64 positive overflow") - } - case cbg.MajNegativeInt: - extraI = int64(extra) - if extraI < 0 { - return fmt.Errorf("int64 negative overflow") - } - extraI = -1 - extraI - default: - return fmt.Errorf("wrong type for int64 field: %d", maj) - } - t.Depth = int64(extraI) + t.Subject = string(sval) } - // t.Submodules (bool) (bool) - case "submodules": + // t.CreatedAt (string) (string) + case "createdAt": - maj, extra, err = cr.ReadHeader() - if err != nil { - return err - } - if maj != cbg.MajOther { - return fmt.Errorf("booleans must be major type 7") - } - switch extra { - case 20: - t.Submodules = false - case 21: - t.Submodules = true - default: - return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.CreatedAt = string(sval) } default: @@ -1719,7 +1601,7 @@ func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) { return nil } -func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { +func (t *KnotMember) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err @@ -1727,131 +1609,102 @@ func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { cw := cbg.NewCborWriter(w) - if _, err := cw.Write([]byte{165}); err != nil { + if _, err := cw.Write([]byte{164}); err != nil { return err } - // t.Name (string) (string) - if len("name") > 1000000 { - return xerrors.Errorf("Value in field \"name\" was too long") + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { return err } - if _, err := cw.WriteString(string("name")); err != nil { + if _, err := cw.WriteString(string("$type")); err != nil { return err } - if len(t.Name) > 1000000 { - return xerrors.Errorf("Value in field t.Name was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot.member"))); err != nil { return err } - if _, err := cw.WriteString(string(t.Name)); err != nil { + if _, err := cw.WriteString(string("sh.tangled.knot.member")); err != nil { return err } - // t.Clone (tangled.Pipeline_CloneOpts) (struct) - if len("clone") > 1000000 { - return xerrors.Errorf("Value in field \"clone\" was too long") + // t.Domain (string) (string) + if len("domain") > 1000000 { + return xerrors.Errorf("Value in field \"domain\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil { - return err - } - if _, err := cw.WriteString(string("clone")); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("domain"))); err != nil { return err } - - if err := t.Clone.MarshalCBOR(cw); err != nil { + if _, err := cw.WriteString(string("domain")); err != nil { return err } - // t.Steps ([]*tangled.Pipeline_Step) (slice) - if len("steps") > 1000000 { - return xerrors.Errorf("Value in field \"steps\" was too long") + if len(t.Domain) > 1000000 { + return xerrors.Errorf("Value in field t.Domain was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil { - return err - } - if _, err := cw.WriteString(string("steps")); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Domain))); err != nil { return err } - - if len(t.Steps) > 8192 { - return xerrors.Errorf("Slice value in field t.Steps was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil { + if _, err := cw.WriteString(string(t.Domain)); err != nil { return err } - for _, v := range t.Steps { - if err := v.MarshalCBOR(cw); err != nil { - return err - } - - } - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) - if len("environment") > 1000000 { - return xerrors.Errorf("Value in field \"environment\" was too long") + // t.Subject (string) (string) + if len("subject") > 1000000 { + return xerrors.Errorf("Value in field \"subject\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { return err } - if _, err := cw.WriteString(string("environment")); err != nil { + if _, err := cw.WriteString(string("subject")); err != nil { return err } - if len(t.Environment) > 8192 { - return xerrors.Errorf("Slice value in field t.Environment was too long") + if len(t.Subject) > 1000000 { + return xerrors.Errorf("Value in field t.Subject was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { return err } - for _, v := range t.Environment { - if err := v.MarshalCBOR(cw); err != nil { - return err - } - + if _, err := cw.WriteString(string(t.Subject)); err != nil { + return err } - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) - if len("dependencies") > 1000000 { - return xerrors.Errorf("Value in field \"dependencies\" was too long") + // t.CreatedAt (string) (string) + if len("createdAt") > 1000000 { + return xerrors.Errorf("Value in field \"createdAt\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { return err } - if _, err := cw.WriteString(string("dependencies")); err != nil { + if _, err := cw.WriteString(string("createdAt")); err != nil { return err } - if len(t.Dependencies) > 8192 { - return xerrors.Errorf("Slice value in field t.Dependencies was too long") + if len(t.CreatedAt) > 1000000 { + return xerrors.Errorf("Value in field t.CreatedAt was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { return err } - for _, v := range t.Dependencies { - if err := v.MarshalCBOR(cw); err != nil { - return err - } - + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { + return err } return nil } -func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { - *t = Pipeline_Workflow{} +func (t *KnotMember) UnmarshalCBOR(r io.Reader) (err error) { + *t = KnotMember{} cr := cbg.NewCborReader(r) @@ -1870,12 +1723,12 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { } if extra > cbg.MaxLength { - return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra) + return fmt.Errorf("KnotMember: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 12) + nameBuf := make([]byte, 9) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -1891,8 +1744,8 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { } switch string(nameBuf[:nameLen]) { - // t.Name (string) (string) - case "name": + // t.LexiconTypeID (string) (string) + case "$type": { sval, err := cbg.ReadStringWithMax(cr, 1000000) @@ -1900,79 +1753,181 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { return err } - t.Name = string(sval) + t.LexiconTypeID = string(sval) } - // t.Clone (tangled.Pipeline_CloneOpts) (struct) - case "clone": + // t.Domain (string) (string) + case "domain": { - - b, err := cr.ReadByte() + sval, err := cbg.ReadStringWithMax(cr, 1000000) if err != nil { return err } - if b != cbg.CborNull[0] { - if err := cr.UnreadByte(); err != nil { - return err - } - t.Clone = new(Pipeline_CloneOpts) - if err := t.Clone.UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err) - } - } + t.Domain = string(sval) } - // t.Steps ([]*tangled.Pipeline_Step) (slice) - case "steps": + // t.Subject (string) (string) + case "subject": - maj, extra, err = cr.ReadHeader() - if err != nil { - return err - } + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } - if extra > 8192 { - return fmt.Errorf("t.Steps: array too large (%d)", extra) + t.Subject = string(sval) } + // t.CreatedAt (string) (string) + case "createdAt": - if maj != cbg.MajArray { - return fmt.Errorf("expected cbor array") + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.CreatedAt = string(sval) } - if extra > 0 { - t.Steps = make([]*Pipeline_Step, extra) + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err } + } + } - for i := 0; i < int(extra); i++ { - { - var maj byte - var extra uint64 - var err error - _ = maj - _ = extra - _ = err + return nil +} +func (t *Pipeline) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } - { + cw := cbg.NewCborWriter(w) - b, err := cr.ReadByte() - if err != nil { - return err - } - if b != cbg.CborNull[0] { - if err := cr.UnreadByte(); err != nil { - return err - } - t.Steps[i] = new(Pipeline_Step) - if err := t.Steps[i].UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err) - } - } + if _, err := cw.Write([]byte{163}); err != nil { + return err + } - } + // t.LexiconTypeID (string) (string) + if len("$type") > 1000000 { + return xerrors.Errorf("Value in field \"$type\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { + return err + } + if _, err := cw.WriteString(string("$type")); err != nil { + return err + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil { + return err + } + if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil { + return err + } + + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) + if len("workflows") > 1000000 { + return xerrors.Errorf("Value in field \"workflows\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil { + return err + } + if _, err := cw.WriteString(string("workflows")); err != nil { + return err + } + + if len(t.Workflows) > 8192 { + return xerrors.Errorf("Slice value in field t.Workflows was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil { + return err + } + for _, v := range t.Workflows { + if err := v.MarshalCBOR(cw); err != nil { + return err + } + + } + + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) + if len("triggerMetadata") > 1000000 { + return xerrors.Errorf("Value in field \"triggerMetadata\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil { + return err + } + if _, err := cw.WriteString(string("triggerMetadata")); err != nil { + return err + } + + if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil { + return err + } + return nil +} + +func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) { + *t = Pipeline{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("Pipeline: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 15) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.LexiconTypeID (string) (string) + case "$type": + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err } + + t.LexiconTypeID = string(sval) } - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) - case "environment": + // t.Workflows ([]*tangled.Pipeline_Workflow) (slice) + case "workflows": maj, extra, err = cr.ReadHeader() if err != nil { @@ -1980,7 +1935,7 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { } if extra > 8192 { - return fmt.Errorf("t.Environment: array too large (%d)", extra) + return fmt.Errorf("t.Workflows: array too large (%d)", extra) } if maj != cbg.MajArray { @@ -1988,7 +1943,7 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { } if extra > 0 { - t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) + t.Workflows = make([]*Pipeline_Workflow, extra) } for i := 0; i < int(extra); i++ { @@ -2010,9 +1965,9 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { if err := cr.UnreadByte(); err != nil { return err } - t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) - if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) + t.Workflows[i] = new(Pipeline_Workflow) + if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err) } } @@ -2020,44 +1975,25 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { } } - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) - case "dependencies": - - maj, extra, err = cr.ReadHeader() - if err != nil { - return err - } - - if extra > 8192 { - return fmt.Errorf("t.Dependencies: array too large (%d)", extra) - } - - if maj != cbg.MajArray { - return fmt.Errorf("expected cbor array") - } - - if extra > 0 { - t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) - } - - for i := 0; i < int(extra); i++ { - { - var maj byte - var extra uint64 - var err error - _ = maj - _ = extra - _ = err - - { + // t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct) + case "triggerMetadata": - if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { - return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) - } + { + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.TriggerMetadata = new(Pipeline_TriggerMetadata) + if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err) } - } + } default: @@ -2070,7 +2006,7 @@ func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { return nil } -func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { +func (t *Pipeline_CloneOpts) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) return err @@ -2078,60 +2014,68 @@ func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { cw := cbg.NewCborWriter(w) - if _, err := cw.Write([]byte{162}); err != nil { + if _, err := cw.Write([]byte{163}); err != nil { return err } - // t.Key (string) (string) - if len("key") > 1000000 { - return xerrors.Errorf("Value in field \"key\" was too long") + // t.Skip (bool) (bool) + if len("skip") > 1000000 { + return xerrors.Errorf("Value in field \"skip\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("skip"))); err != nil { return err } - if _, err := cw.WriteString(string("key")); err != nil { + if _, err := cw.WriteString(string("skip")); err != nil { return err } - if len(t.Key) > 1000000 { - return xerrors.Errorf("Value in field t.Key was too long") - } - - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { - return err - } - if _, err := cw.WriteString(string(t.Key)); err != nil { + if err := cbg.WriteBool(w, t.Skip); err != nil { return err } - // t.Value (string) (string) - if len("value") > 1000000 { - return xerrors.Errorf("Value in field \"value\" was too long") + // t.Depth (int64) (int64) + if len("depth") > 1000000 { + return xerrors.Errorf("Value in field \"depth\" was too long") } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("depth"))); err != nil { return err } - if _, err := cw.WriteString(string("value")); err != nil { + if _, err := cw.WriteString(string("depth")); err != nil { return err } - if len(t.Value) > 1000000 { - return xerrors.Errorf("Value in field t.Value was too long") + if t.Depth >= 0 { + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Depth)); err != nil { + return err + } + } else { + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Depth-1)); err != nil { + return err + } } - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { + // t.Submodules (bool) (bool) + if len("submodules") > 1000000 { + return xerrors.Errorf("Value in field \"submodules\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("submodules"))); err != nil { return err } - if _, err := cw.WriteString(string(t.Value)); err != nil { + if _, err := cw.WriteString(string("submodules")); err != nil { + return err + } + + if err := cbg.WriteBool(w, t.Submodules); err != nil { return err } return nil } -func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { - *t = Pipeline_Workflow_Environment_Elem{} +func (t *Pipeline_CloneOpts) UnmarshalCBOR(r io.Reader) (err error) { + *t = Pipeline_CloneOpts{} cr := cbg.NewCborReader(r) @@ -2150,12 +2094,12 @@ func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err err } if extra > cbg.MaxLength { - return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) + return fmt.Errorf("Pipeline_CloneOpts: map struct too large (%d)", extra) } n := extra - nameBuf := make([]byte, 5) + nameBuf := make([]byte, 10) for i := uint64(0); i < n; i++ { nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) if err != nil { @@ -2171,27 +2115,67 @@ func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err err } switch string(nameBuf[:nameLen]) { - // t.Key (string) (string) - case "key": - - { - sval, err := cbg.ReadStringWithMax(cr, 1000000) - if err != nil { - return err - } + // t.Skip (bool) (bool) + case "skip": - t.Key = string(sval) + maj, extra, err = cr.ReadHeader() + if err != nil { + return err } - // t.Value (string) (string) - case "value": - + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.Skip = false + case 21: + t.Skip = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + // t.Depth (int64) (int64) + case "depth": { - sval, err := cbg.ReadStringWithMax(cr, 1000000) + maj, extra, err := cr.ReadHeader() if err != nil { return err } + var extraI int64 + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative overflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } - t.Value = string(sval) + t.Depth = int64(extraI) + } + // t.Submodules (bool) (bool) + case "submodules": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.Submodules = false + case 21: + t.Submodules = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) } default: @@ -3632,6 +3616,491 @@ func (t *Pipeline_TriggerRepo) UnmarshalCBOR(r io.Reader) (err error) { return nil } +func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{165}); err != nil { + return err + } + + // t.Name (string) (string) + if len("name") > 1000000 { + return xerrors.Errorf("Value in field \"name\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { + return err + } + if _, err := cw.WriteString(string("name")); err != nil { + return err + } + + if len(t.Name) > 1000000 { + return xerrors.Errorf("Value in field t.Name was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Name)); err != nil { + return err + } + + // t.Clone (tangled.Pipeline_CloneOpts) (struct) + if len("clone") > 1000000 { + return xerrors.Errorf("Value in field \"clone\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil { + return err + } + if _, err := cw.WriteString(string("clone")); err != nil { + return err + } + + if err := t.Clone.MarshalCBOR(cw); err != nil { + return err + } + + // t.Steps ([]*tangled.Pipeline_Step) (slice) + if len("steps") > 1000000 { + return xerrors.Errorf("Value in field \"steps\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil { + return err + } + if _, err := cw.WriteString(string("steps")); err != nil { + return err + } + + if len(t.Steps) > 8192 { + return xerrors.Errorf("Slice value in field t.Steps was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil { + return err + } + for _, v := range t.Steps { + if err := v.MarshalCBOR(cw); err != nil { + return err + } + + } + + // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) + if len("environment") > 1000000 { + return xerrors.Errorf("Value in field \"environment\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil { + return err + } + if _, err := cw.WriteString(string("environment")); err != nil { + return err + } + + if len(t.Environment) > 8192 { + return xerrors.Errorf("Slice value in field t.Environment was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil { + return err + } + for _, v := range t.Environment { + if err := v.MarshalCBOR(cw); err != nil { + return err + } + + } + + // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) + if len("dependencies") > 1000000 { + return xerrors.Errorf("Value in field \"dependencies\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil { + return err + } + if _, err := cw.WriteString(string("dependencies")); err != nil { + return err + } + + if len(t.Dependencies) > 8192 { + return xerrors.Errorf("Slice value in field t.Dependencies was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil { + return err + } + for _, v := range t.Dependencies { + if err := v.MarshalCBOR(cw); err != nil { + return err + } + + } + return nil +} + +func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { + *t = Pipeline_Workflow{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 12) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.Name (string) (string) + case "name": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Name = string(sval) + } + // t.Clone (tangled.Pipeline_CloneOpts) (struct) + case "clone": + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Clone = new(Pipeline_CloneOpts) + if err := t.Clone.UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err) + } + } + + } + // t.Steps ([]*tangled.Pipeline_Step) (slice) + case "steps": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.Steps: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Steps = make([]*Pipeline_Step, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Steps[i] = new(Pipeline_Step) + if err := t.Steps[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err) + } + } + + } + + } + } + // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) + case "environment": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.Environment: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + + b, err := cr.ReadByte() + if err != nil { + return err + } + if b != cbg.CborNull[0] { + if err := cr.UnreadByte(); err != nil { + return err + } + t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) + if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) + } + } + + } + + } + } + // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) + case "dependencies": + + maj, extra, err = cr.ReadHeader() + if err != nil { + return err + } + + if extra > 8192 { + return fmt.Errorf("t.Dependencies: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + _ = maj + _ = extra + _ = err + + { + + if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { + return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) + } + + } + + } + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} +func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + cw := cbg.NewCborWriter(w) + + if _, err := cw.Write([]byte{162}); err != nil { + return err + } + + // t.Key (string) (string) + if len("key") > 1000000 { + return xerrors.Errorf("Value in field \"key\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { + return err + } + if _, err := cw.WriteString(string("key")); err != nil { + return err + } + + if len(t.Key) > 1000000 { + return xerrors.Errorf("Value in field t.Key was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Key)); err != nil { + return err + } + + // t.Value (string) (string) + if len("value") > 1000000 { + return xerrors.Errorf("Value in field \"value\" was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { + return err + } + if _, err := cw.WriteString(string("value")); err != nil { + return err + } + + if len(t.Value) > 1000000 { + return xerrors.Errorf("Value in field t.Value was too long") + } + + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { + return err + } + if _, err := cw.WriteString(string(t.Value)); err != nil { + return err + } + return nil +} + +func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { + *t = Pipeline_Workflow_Environment_Elem{} + + cr := cbg.NewCborReader(r) + + maj, extra, err := cr.ReadHeader() + if err != nil { + return err + } + defer func() { + if err == io.EOF { + err = io.ErrUnexpectedEOF + } + }() + + if maj != cbg.MajMap { + return fmt.Errorf("cbor input should be of type map") + } + + if extra > cbg.MaxLength { + return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) + } + + n := extra + + nameBuf := make([]byte, 5) + for i := uint64(0); i < n; i++ { + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) + if err != nil { + return err + } + + if !ok { + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { + return err + } + continue + } + + switch string(nameBuf[:nameLen]) { + // t.Key (string) (string) + case "key": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Key = string(sval) + } + // t.Value (string) (string) + case "value": + + { + sval, err := cbg.ReadStringWithMax(cr, 1000000) + if err != nil { + return err + } + + t.Value = string(sval) + } + + default: + // Field doesn't exist on this type, so ignore it + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { + return err + } + } + } + + return nil +} func (t *PublicKey) MarshalCBOR(w io.Writer) error { if t == nil { _, err := w.Write(cbg.CborNull) diff --git a/api/tangled/gitrefUpdate.go b/api/tangled/gitrefUpdate.go index 9c7d30d3..37f68e76 100644 --- a/api/tangled/gitrefUpdate.go +++ b/api/tangled/gitrefUpdate.go @@ -4,22 +4,23 @@ package tangled // schema: sh.tangled.git.refUpdate -//import ( -// "github.com/bluesky-social/indigo/lex/util" -//) +import ( + "github.com/bluesky-social/indigo/lex/util" +) const ( GitRefUpdateNSID = "sh.tangled.git.refUpdate" ) -//func init() { -// util.RegisterType("sh.tangled.git.refUpdate", &GitRefUpdate{}) -//} // +func init() { + util.RegisterType("sh.tangled.git.refUpdate", &GitRefUpdate{}) +} // // RECORDTYPE: GitRefUpdate type GitRefUpdate struct { LexiconTypeID string `json:"$type,const=sh.tangled.git.refUpdate" cborgen:"$type,const=sh.tangled.git.refUpdate"` // committerDid: did of the user that pushed this ref - CommitterDid string `json:"committerDid" cborgen:"committerDid"` + CommitterDid string `json:"committerDid" cborgen:"committerDid"` + Meta *GitRefUpdate_Meta `json:"meta" cborgen:"meta"` // newSha: new SHA of this ref NewSha string `json:"newSha" cborgen:"newSha"` // oldSha: old SHA of this ref @@ -31,3 +32,17 @@ type GitRefUpdate struct { // repoName: name of the repo RepoName string `json:"repoName" cborgen:"repoName"` } + +type GitRefUpdate_Meta struct { + CommitCount *GitRefUpdate_Meta_CommitCount `json:"commitCount" cborgen:"commitCount"` + IsDefaultRef bool `json:"isDefaultRef" cborgen:"isDefaultRef"` +} + +type GitRefUpdate_Meta_CommitCount struct { + ByEmail []*GitRefUpdate_Meta_CommitCount_ByEmail_Elem `json:"byEmail,omitempty" cborgen:"byEmail,omitempty"` +} + +type GitRefUpdate_Meta_CommitCount_ByEmail_Elem struct { + Count int64 `json:"count" cborgen:"count"` + Email string `json:"email" cborgen:"email"` +} diff --git a/api/tangled/tangledpipeline.go b/api/tangled/tangledpipeline.go index 6dec4fb8..11c8b1b2 100644 --- a/api/tangled/tangledpipeline.go +++ b/api/tangled/tangledpipeline.go @@ -4,17 +4,17 @@ package tangled // schema: sh.tangled.pipeline -//import ( -// "github.com/bluesky-social/indigo/lex/util" -//) +import ( + "github.com/bluesky-social/indigo/lex/util" +) const ( PipelineNSID = "sh.tangled.pipeline" ) -//func init() { -// util.RegisterType("sh.tangled.pipeline", &Pipeline{}) -//} // +func init() { + util.RegisterType("sh.tangled.pipeline", &Pipeline{}) +} // // RECORDTYPE: Pipeline type Pipeline struct { LexiconTypeID string `json:"$type,const=sh.tangled.pipeline" cborgen:"$type,const=sh.tangled.pipeline"` diff --git a/cmd/gen.go b/cmd/gen.go index 8516771a..2532bd1a 100644 --- a/cmd/gen.go +++ b/cmd/gen.go @@ -17,12 +17,13 @@ func main() { tangled.ActorProfile{}, tangled.FeedStar{}, tangled.GitRefUpdate{}, + tangled.GitRefUpdate_Meta{}, + tangled.GitRefUpdate_Meta_CommitCount{}, + tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}, tangled.GraphFollow{}, tangled.KnotMember{}, tangled.Pipeline{}, tangled.Pipeline_CloneOpts{}, - tangled.Pipeline_Workflow{}, - tangled.Pipeline_Workflow_Environment_Elem{}, tangled.Pipeline_Dependencies_Elem{}, tangled.Pipeline_ManualTriggerData{}, tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, @@ -31,6 +32,8 @@ func main() { tangled.Pipeline_Step{}, tangled.Pipeline_TriggerMetadata{}, tangled.Pipeline_TriggerRepo{}, + tangled.Pipeline_Workflow{}, + tangled.Pipeline_Workflow_Environment_Elem{}, tangled.PublicKey{}, tangled.Repo{}, tangled.RepoArtifact{}, diff --git a/knotserver/git/post_receive.go b/knotserver/git/post_receive.go index 525afb08..24bbbc1b 100644 --- a/knotserver/git/post_receive.go +++ b/knotserver/git/post_receive.go @@ -2,14 +2,19 @@ package git import ( "bufio" + "fmt" "io" "strings" + + "tangled.sh/tangled.sh/core/api/tangled" + + "github.com/go-git/go-git/v5/plumbing" ) type PostReceiveLine struct { - OldSha string // old sha of reference being updated - NewSha string // new sha of reference being updated - Ref string // the reference being updated + OldSha plumbing.Hash // old sha of reference being updated + NewSha plumbing.Hash // new sha of reference being updated + Ref string // the reference being updated } func ParsePostReceive(buf io.Reader) ([]PostReceiveLine, error) { @@ -27,8 +32,8 @@ func ParsePostReceive(buf io.Reader) ([]PostReceiveLine, error) { ref := parts[2] lines = append(lines, PostReceiveLine{ - OldSha: oldSha, - NewSha: newSha, + OldSha: plumbing.NewHash(oldSha), + NewSha: plumbing.NewHash(newSha), Ref: ref, }) } @@ -39,3 +44,92 @@ func ParsePostReceive(buf io.Reader) ([]PostReceiveLine, error) { return lines, nil } + +type RefUpdateMeta struct { + CommitCount CommitCount + IsDefaultRef bool +} + +type CommitCount struct { + ByEmail map[string]int +} + +func (g *GitRepo) RefUpdateMeta(line PostReceiveLine) RefUpdateMeta { + commitCount, err := g.newCommitCount(line) + if err != nil { + // TODO: non-fatal, log this + } + + isDefaultRef, err := g.isDefaultBranch(line) + if err != nil { + // TODO: non-fatal, log this + } + + return RefUpdateMeta{ + CommitCount: commitCount, + IsDefaultRef: isDefaultRef, + } +} + +func (g *GitRepo) newCommitCount(line PostReceiveLine) (CommitCount, error) { + byEmail := make(map[string]int) + commitCount := CommitCount{ + ByEmail: byEmail, + } + + if !line.NewSha.IsZero() { + output, err := g.revList( + fmt.Sprintf("--max-count=%d", 100), + fmt.Sprintf("%s..%s", line.OldSha.String(), line.NewSha.String()), + ) + if err != nil { + return commitCount, fmt.Errorf("failed to run rev-list: %w", err) + } + + lines := strings.Split(strings.TrimSpace(string(output)), "\n") + if len(lines) == 1 && lines[0] == "" { + return commitCount, nil + } + + for _, item := range lines { + obj, err := g.r.CommitObject(plumbing.NewHash(item)) + if err != nil { + continue + } + commitCount.ByEmail[obj.Author.Email] += 1 + } + } + + return commitCount, nil +} + +func (g *GitRepo) isDefaultBranch(line PostReceiveLine) (bool, error) { + defaultBranch, err := g.FindMainBranch() + if err != nil { + return false, err + } + + refName := plumbing.ReferenceName(line.Ref) + if refName.IsBranch() { + return defaultBranch == refName.Short(), nil + } + + return false, err +} + +func (m RefUpdateMeta) AsRecord() tangled.GitRefUpdate_Meta { + var byEmail []*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem + for e, v := range m.CommitCount.ByEmail { + byEmail = append(byEmail, &tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{ + Email: e, + Count: int64(v), + }) + } + + return tangled.GitRefUpdate_Meta{ + CommitCount: &tangled.GitRefUpdate_Meta_CommitCount{ + ByEmail: byEmail, + }, + IsDefaultRef: m.IsDefaultRef, + } +} diff --git a/knotserver/internal.go b/knotserver/internal.go index 881bc2bd..c7989e7e 100644 --- a/knotserver/internal.go +++ b/knotserver/internal.go @@ -105,13 +105,32 @@ func (h *InternalHandle) PostReceiveHook(w http.ResponseWriter, r *http.Request) } func (h *InternalHandle) insertRefUpdate(line git.PostReceiveLine, gitUserDid, repoDid, repoName string) error { + didSlashRepo, err := securejoin.SecureJoin(repoDid, repoName) + if err != nil { + return err + } + + repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, didSlashRepo) + if err != nil { + return err + } + + gr, err := git.PlainOpen(repoPath) + if err != nil { + return err + } + + meta := gr.RefUpdateMeta(line) + metaRecord := meta.AsRecord() + refUpdate := tangled.GitRefUpdate{ - OldSha: line.OldSha, - NewSha: line.NewSha, + OldSha: line.OldSha.String(), + NewSha: line.NewSha.String(), Ref: line.Ref, CommitterDid: gitUserDid, RepoDid: repoDid, RepoName: repoName, + Meta: &metaRecord, } eventJson, err := json.Marshal(refUpdate) if err != nil { @@ -175,8 +194,8 @@ func (h *InternalHandle) triggerPipeline(line git.PostReceiveLine, gitUserDid, r trigger := tangled.Pipeline_PushTriggerData{ Ref: line.Ref, - OldSha: line.OldSha, - NewSha: line.NewSha, + OldSha: line.OldSha.String(), + NewSha: line.NewSha.String(), } compiler := workflow.Compiler{ diff --git a/lexicons/git/refUpdate.json b/lexicons/git/refUpdate.json index c4fe0c3b..f15bb204 100644 --- a/lexicons/git/refUpdate.json +++ b/lexicons/git/refUpdate.json @@ -14,7 +14,8 @@ "repoDid", "repoName", "oldSha", - "newSha" + "newSha", + "meta" ], "properties": { "ref": { @@ -48,6 +49,43 @@ "description": "new SHA of this ref", "minLength": 40, "maxLength": 40 + }, + "meta": { + "type": "object", + "required": [ + "isDefaultRef", + "commitCount" + ], + "properties": { + "isDefaultRef": { + "type": "boolean", + "default": "false" + }, + "commitCount": { + "type": "object", + "required": [], + "properties": { + "byEmail": { + "type": "array", + "items": { + "type": "object", + "required": [ + "email", + "count" + ], + "properties": { + "email": { + "type": "string" + }, + "count": { + "type": "integer" + } + } + } + } + } + } + } } } }