+911

api/tangled/cbor_gen.go

··· 9890 9890 9891 9891 return nil 9892 9892 } 9893 9893 + func (t *CiEvent) MarshalCBOR(w io.Writer) error { 9894 9894 + if t == nil { 9895 9895 + _, err := w.Write(cbg.CborNull) 9896 9896 + return err 9897 9897 + } 9898 9898 + 9899 9899 + cw := cbg.NewCborWriter(w) 9900 9900 + 9901 9901 + if _, err := cw.Write([]byte{161}); err != nil { 9902 9902 + return err 9903 9903 + } 9904 9904 + 9905 9905 + // t.Meta (tangled.CiEvent_Meta) (struct) 9906 9906 + if len("meta") > 1000000 { 9907 9907 + return xerrors.Errorf("Value in field \"meta\" was too long") 9908 9908 + } 9909 9909 + 9910 9910 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { 9911 9911 + return err 9912 9912 + } 9913 9913 + if _, err := cw.WriteString(string("meta")); err != nil { 9914 9914 + return err 9915 9915 + } 9916 9916 + 9917 9917 + if err := t.Meta.MarshalCBOR(cw); err != nil { 9918 9918 + return err 9919 9919 + } 9920 9920 + return nil 9921 9921 + } 9922 9922 + 9923 9923 + func (t *CiEvent) UnmarshalCBOR(r io.Reader) (err error) { 9924 9924 + *t = CiEvent{} 9925 9925 + 9926 9926 + cr := cbg.NewCborReader(r) 9927 9927 + 9928 9928 + maj, extra, err := cr.ReadHeader() 9929 9929 + if err != nil { 9930 9930 + return err 9931 9931 + } 9932 9932 + defer func() { 9933 9933 + if err == io.EOF { 9934 9934 + err = io.ErrUnexpectedEOF 9935 9935 + } 9936 9936 + }() 9937 9937 + 9938 9938 + if maj != cbg.MajMap { 9939 9939 + return fmt.Errorf("cbor input should be of type map") 9940 9940 + } 9941 9941 + 9942 9942 + if extra > cbg.MaxLength { 9943 9943 + return fmt.Errorf("CiEvent: map struct too large (%d)", extra) 9944 9944 + } 9945 9945 + 9946 9946 + n := extra 9947 9947 + 9948 9948 + nameBuf := make([]byte, 4) 9949 9949 + for i := uint64(0); i < n; i++ { 9950 9950 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 9951 9951 + if err != nil { 9952 9952 + return err 9953 9953 + } 9954 9954 + 9955 9955 + if !ok { 9956 9956 + // Field doesn't exist on this type, so ignore it 9957 9957 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 9958 9958 + return err 9959 9959 + } 9960 9960 + continue 9961 9961 + } 9962 9962 + 9963 9963 + switch string(nameBuf[:nameLen]) { 9964 9964 + // t.Meta (tangled.CiEvent_Meta) (struct) 9965 9965 + case "meta": 9966 9966 + 9967 9967 + { 9968 9968 + 9969 9969 + b, err := cr.ReadByte() 9970 9970 + if err != nil { 9971 9971 + return err 9972 9972 + } 9973 9973 + if b != cbg.CborNull[0] { 9974 9974 + if err := cr.UnreadByte(); err != nil { 9975 9975 + return err 9976 9976 + } 9977 9977 + t.Meta = new(CiEvent_Meta) 9978 9978 + if err := t.Meta.UnmarshalCBOR(cr); err != nil { 9979 9979 + return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) 9980 9980 + } 9981 9981 + } 9982 9982 + 9983 9983 + } 9984 9984 + 9985 9985 + default: 9986 9986 + // Field doesn't exist on this type, so ignore it 9987 9987 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 9988 9988 + return err 9989 9989 + } 9990 9990 + } 9991 9991 + } 9992 9992 + 9993 9993 + return nil 9994 9994 + } 9995 9995 + func (t *CiEvent_PullRequest) MarshalCBOR(w io.Writer) error { 9996 9996 + if t == nil { 9997 9997 + _, err := w.Write(cbg.CborNull) 9998 9998 + return err 9999 9999 + } 10000 10000 + 10001 10001 + cw := cbg.NewCborWriter(w) 10002 10002 + 10003 10003 + if _, err := cw.Write([]byte{161}); err != nil { 10004 10004 + return err 10005 10005 + } 10006 10006 + 10007 10007 + // t.LexiconTypeID (string) (string) 10008 10008 + if len("$type") > 1000000 { 10009 10009 + return xerrors.Errorf("Value in field \"$type\" was too long") 10010 10010 + } 10011 10011 + 10012 10012 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 10013 10013 + return err 10014 10014 + } 10015 10015 + if _, err := cw.WriteString(string("$type")); err != nil { 10016 10016 + return err 10017 10017 + } 10018 10018 + 10019 10019 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.event#pullRequest"))); err != nil { 10020 10020 + return err 10021 10021 + } 10022 10022 + if _, err := cw.WriteString(string("sh.tangled.ci.event#pullRequest")); err != nil { 10023 10023 + return err 10024 10024 + } 10025 10025 + return nil 10026 10026 + } 10027 10027 + 10028 10028 + func (t *CiEvent_PullRequest) UnmarshalCBOR(r io.Reader) (err error) { 10029 10029 + *t = CiEvent_PullRequest{} 10030 10030 + 10031 10031 + cr := cbg.NewCborReader(r) 10032 10032 + 10033 10033 + maj, extra, err := cr.ReadHeader() 10034 10034 + if err != nil { 10035 10035 + return err 10036 10036 + } 10037 10037 + defer func() { 10038 10038 + if err == io.EOF { 10039 10039 + err = io.ErrUnexpectedEOF 10040 10040 + } 10041 10041 + }() 10042 10042 + 10043 10043 + if maj != cbg.MajMap { 10044 10044 + return fmt.Errorf("cbor input should be of type map") 10045 10045 + } 10046 10046 + 10047 10047 + if extra > cbg.MaxLength { 10048 10048 + return fmt.Errorf("CiEvent_PullRequest: map struct too large (%d)", extra) 10049 10049 + } 10050 10050 + 10051 10051 + n := extra 10052 10052 + 10053 10053 + nameBuf := make([]byte, 5) 10054 10054 + for i := uint64(0); i < n; i++ { 10055 10055 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 10056 10056 + if err != nil { 10057 10057 + return err 10058 10058 + } 10059 10059 + 10060 10060 + if !ok { 10061 10061 + // Field doesn't exist on this type, so ignore it 10062 10062 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 10063 10063 + return err 10064 10064 + } 10065 10065 + continue 10066 10066 + } 10067 10067 + 10068 10068 + switch string(nameBuf[:nameLen]) { 10069 10069 + // t.LexiconTypeID (string) (string) 10070 10070 + case "$type": 10071 10071 + 10072 10072 + { 10073 10073 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10074 10074 + if err != nil { 10075 10075 + return err 10076 10076 + } 10077 10077 + 10078 10078 + t.LexiconTypeID = string(sval) 10079 10079 + } 10080 10080 + 10081 10081 + default: 10082 10082 + // Field doesn't exist on this type, so ignore it 10083 10083 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 10084 10084 + return err 10085 10085 + } 10086 10086 + } 10087 10087 + } 10088 10088 + 10089 10089 + return nil 10090 10090 + } 10091 10091 + func (t *CiEvent_Push) MarshalCBOR(w io.Writer) error { 10092 10092 + if t == nil { 10093 10093 + _, err := w.Write(cbg.CborNull) 10094 10094 + return err 10095 10095 + } 10096 10096 + 10097 10097 + cw := cbg.NewCborWriter(w) 10098 10098 + 10099 10099 + if _, err := cw.Write([]byte{164}); err != nil { 10100 10100 + return err 10101 10101 + } 10102 10102 + 10103 10103 + // t.Ref (string) (string) 10104 10104 + if len("ref") > 1000000 { 10105 10105 + return xerrors.Errorf("Value in field \"ref\" was too long") 10106 10106 + } 10107 10107 + 10108 10108 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil { 10109 10109 + return err 10110 10110 + } 10111 10111 + if _, err := cw.WriteString(string("ref")); err != nil { 10112 10112 + return err 10113 10113 + } 10114 10114 + 10115 10115 + if len(t.Ref) > 1000000 { 10116 10116 + return xerrors.Errorf("Value in field t.Ref was too long") 10117 10117 + } 10118 10118 + 10119 10119 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil { 10120 10120 + return err 10121 10121 + } 10122 10122 + if _, err := cw.WriteString(string(t.Ref)); err != nil { 10123 10123 + return err 10124 10124 + } 10125 10125 + 10126 10126 + // t.LexiconTypeID (string) (string) 10127 10127 + if len("$type") > 1000000 { 10128 10128 + return xerrors.Errorf("Value in field \"$type\" was too long") 10129 10129 + } 10130 10130 + 10131 10131 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 10132 10132 + return err 10133 10133 + } 10134 10134 + if _, err := cw.WriteString(string("$type")); err != nil { 10135 10135 + return err 10136 10136 + } 10137 10137 + 10138 10138 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.event#push"))); err != nil { 10139 10139 + return err 10140 10140 + } 10141 10141 + if _, err := cw.WriteString(string("sh.tangled.ci.event#push")); err != nil { 10142 10142 + return err 10143 10143 + } 10144 10144 + 10145 10145 + // t.NewSha (string) (string) 10146 10146 + if len("newSha") > 1000000 { 10147 10147 + return xerrors.Errorf("Value in field \"newSha\" was too long") 10148 10148 + } 10149 10149 + 10150 10150 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil { 10151 10151 + return err 10152 10152 + } 10153 10153 + if _, err := cw.WriteString(string("newSha")); err != nil { 10154 10154 + return err 10155 10155 + } 10156 10156 + 10157 10157 + if len(t.NewSha) > 1000000 { 10158 10158 + return xerrors.Errorf("Value in field t.NewSha was too long") 10159 10159 + } 10160 10160 + 10161 10161 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil { 10162 10162 + return err 10163 10163 + } 10164 10164 + if _, err := cw.WriteString(string(t.NewSha)); err != nil { 10165 10165 + return err 10166 10166 + } 10167 10167 + 10168 10168 + // t.OldSha (string) (string) 10169 10169 + if len("oldSha") > 1000000 { 10170 10170 + return xerrors.Errorf("Value in field \"oldSha\" was too long") 10171 10171 + } 10172 10172 + 10173 10173 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil { 10174 10174 + return err 10175 10175 + } 10176 10176 + if _, err := cw.WriteString(string("oldSha")); err != nil { 10177 10177 + return err 10178 10178 + } 10179 10179 + 10180 10180 + if len(t.OldSha) > 1000000 { 10181 10181 + return xerrors.Errorf("Value in field t.OldSha was too long") 10182 10182 + } 10183 10183 + 10184 10184 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil { 10185 10185 + return err 10186 10186 + } 10187 10187 + if _, err := cw.WriteString(string(t.OldSha)); err != nil { 10188 10188 + return err 10189 10189 + } 10190 10190 + return nil 10191 10191 + } 10192 10192 + 10193 10193 + func (t *CiEvent_Push) UnmarshalCBOR(r io.Reader) (err error) { 10194 10194 + *t = CiEvent_Push{} 10195 10195 + 10196 10196 + cr := cbg.NewCborReader(r) 10197 10197 + 10198 10198 + maj, extra, err := cr.ReadHeader() 10199 10199 + if err != nil { 10200 10200 + return err 10201 10201 + } 10202 10202 + defer func() { 10203 10203 + if err == io.EOF { 10204 10204 + err = io.ErrUnexpectedEOF 10205 10205 + } 10206 10206 + }() 10207 10207 + 10208 10208 + if maj != cbg.MajMap { 10209 10209 + return fmt.Errorf("cbor input should be of type map") 10210 10210 + } 10211 10211 + 10212 10212 + if extra > cbg.MaxLength { 10213 10213 + return fmt.Errorf("CiEvent_Push: map struct too large (%d)", extra) 10214 10214 + } 10215 10215 + 10216 10216 + n := extra 10217 10217 + 10218 10218 + nameBuf := make([]byte, 6) 10219 10219 + for i := uint64(0); i < n; i++ { 10220 10220 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 10221 10221 + if err != nil { 10222 10222 + return err 10223 10223 + } 10224 10224 + 10225 10225 + if !ok { 10226 10226 + // Field doesn't exist on this type, so ignore it 10227 10227 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 10228 10228 + return err 10229 10229 + } 10230 10230 + continue 10231 10231 + } 10232 10232 + 10233 10233 + switch string(nameBuf[:nameLen]) { 10234 10234 + // t.Ref (string) (string) 10235 10235 + case "ref": 10236 10236 + 10237 10237 + { 10238 10238 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10239 10239 + if err != nil { 10240 10240 + return err 10241 10241 + } 10242 10242 + 10243 10243 + t.Ref = string(sval) 10244 10244 + } 10245 10245 + // t.LexiconTypeID (string) (string) 10246 10246 + case "$type": 10247 10247 + 10248 10248 + { 10249 10249 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10250 10250 + if err != nil { 10251 10251 + return err 10252 10252 + } 10253 10253 + 10254 10254 + t.LexiconTypeID = string(sval) 10255 10255 + } 10256 10256 + // t.NewSha (string) (string) 10257 10257 + case "newSha": 10258 10258 + 10259 10259 + { 10260 10260 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10261 10261 + if err != nil { 10262 10262 + return err 10263 10263 + } 10264 10264 + 10265 10265 + t.NewSha = string(sval) 10266 10266 + } 10267 10267 + // t.OldSha (string) (string) 10268 10268 + case "oldSha": 10269 10269 + 10270 10270 + { 10271 10271 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10272 10272 + if err != nil { 10273 10273 + return err 10274 10274 + } 10275 10275 + 10276 10276 + t.OldSha = string(sval) 10277 10277 + } 10278 10278 + 10279 10279 + default: 10280 10280 + // Field doesn't exist on this type, so ignore it 10281 10281 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 10282 10282 + return err 10283 10283 + } 10284 10284 + } 10285 10285 + } 10286 10286 + 10287 10287 + return nil 10288 10288 + } 10289 10289 + func (t *CiEvent_Manual) MarshalCBOR(w io.Writer) error { 10290 10290 + if t == nil { 10291 10291 + _, err := w.Write(cbg.CborNull) 10292 10292 + return err 10293 10293 + } 10294 10294 + 10295 10295 + cw := cbg.NewCborWriter(w) 10296 10296 + 10297 10297 + if _, err := cw.Write([]byte{161}); err != nil { 10298 10298 + return err 10299 10299 + } 10300 10300 + 10301 10301 + // t.LexiconTypeID (string) (string) 10302 10302 + if len("$type") > 1000000 { 10303 10303 + return xerrors.Errorf("Value in field \"$type\" was too long") 10304 10304 + } 10305 10305 + 10306 10306 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 10307 10307 + return err 10308 10308 + } 10309 10309 + if _, err := cw.WriteString(string("$type")); err != nil { 10310 10310 + return err 10311 10311 + } 10312 10312 + 10313 10313 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.event#manual"))); err != nil { 10314 10314 + return err 10315 10315 + } 10316 10316 + if _, err := cw.WriteString(string("sh.tangled.ci.event#manual")); err != nil { 10317 10317 + return err 10318 10318 + } 10319 10319 + return nil 10320 10320 + } 10321 10321 + 10322 10322 + func (t *CiEvent_Manual) UnmarshalCBOR(r io.Reader) (err error) { 10323 10323 + *t = CiEvent_Manual{} 10324 10324 + 10325 10325 + cr := cbg.NewCborReader(r) 10326 10326 + 10327 10327 + maj, extra, err := cr.ReadHeader() 10328 10328 + if err != nil { 10329 10329 + return err 10330 10330 + } 10331 10331 + defer func() { 10332 10332 + if err == io.EOF { 10333 10333 + err = io.ErrUnexpectedEOF 10334 10334 + } 10335 10335 + }() 10336 10336 + 10337 10337 + if maj != cbg.MajMap { 10338 10338 + return fmt.Errorf("cbor input should be of type map") 10339 10339 + } 10340 10340 + 10341 10341 + if extra > cbg.MaxLength { 10342 10342 + return fmt.Errorf("CiEvent_Manual: map struct too large (%d)", extra) 10343 10343 + } 10344 10344 + 10345 10345 + n := extra 10346 10346 + 10347 10347 + nameBuf := make([]byte, 5) 10348 10348 + for i := uint64(0); i < n; i++ { 10349 10349 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 10350 10350 + if err != nil { 10351 10351 + return err 10352 10352 + } 10353 10353 + 10354 10354 + if !ok { 10355 10355 + // Field doesn't exist on this type, so ignore it 10356 10356 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 10357 10357 + return err 10358 10358 + } 10359 10359 + continue 10360 10360 + } 10361 10361 + 10362 10362 + switch string(nameBuf[:nameLen]) { 10363 10363 + // t.LexiconTypeID (string) (string) 10364 10364 + case "$type": 10365 10365 + 10366 10366 + { 10367 10367 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10368 10368 + if err != nil { 10369 10369 + return err 10370 10370 + } 10371 10371 + 10372 10372 + t.LexiconTypeID = string(sval) 10373 10373 + } 10374 10374 + 10375 10375 + default: 10376 10376 + // Field doesn't exist on this type, so ignore it 10377 10377 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 10378 10378 + return err 10379 10379 + } 10380 10380 + } 10381 10381 + } 10382 10382 + 10383 10383 + return nil 10384 10384 + } 10385 10385 + func (t *CiPipeline) MarshalCBOR(w io.Writer) error { 10386 10386 + if t == nil { 10387 10387 + _, err := w.Write(cbg.CborNull) 10388 10388 + return err 10389 10389 + } 10390 10390 + 10391 10391 + cw := cbg.NewCborWriter(w) 10392 10392 + 10393 10393 + if _, err := cw.Write([]byte{163}); err != nil { 10394 10394 + return err 10395 10395 + } 10396 10396 + 10397 10397 + // t.LexiconTypeID (string) (string) 10398 10398 + if len("$type") > 1000000 { 10399 10399 + return xerrors.Errorf("Value in field \"$type\" was too long") 10400 10400 + } 10401 10401 + 10402 10402 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 10403 10403 + return err 10404 10404 + } 10405 10405 + if _, err := cw.WriteString(string("$type")); err != nil { 10406 10406 + return err 10407 10407 + } 10408 10408 + 10409 10409 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.pipeline"))); err != nil { 10410 10410 + return err 10411 10411 + } 10412 10412 + if _, err := cw.WriteString(string("sh.tangled.ci.pipeline")); err != nil { 10413 10413 + return err 10414 10414 + } 10415 10415 + 10416 10416 + // t.Event (tangled.CiEvent) (struct) 10417 10417 + if len("event") > 1000000 { 10418 10418 + return xerrors.Errorf("Value in field \"event\" was too long") 10419 10419 + } 10420 10420 + 10421 10421 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("event"))); err != nil { 10422 10422 + return err 10423 10423 + } 10424 10424 + if _, err := cw.WriteString(string("event")); err != nil { 10425 10425 + return err 10426 10426 + } 10427 10427 + 10428 10428 + if err := t.Event.MarshalCBOR(cw); err != nil { 10429 10429 + return err 10430 10430 + } 10431 10431 + 10432 10432 + // t.WorkflowRuns ([]string) (slice) 10433 10433 + if len("workflowRuns") > 1000000 { 10434 10434 + return xerrors.Errorf("Value in field \"workflowRuns\" was too long") 10435 10435 + } 10436 10436 + 10437 10437 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflowRuns"))); err != nil { 10438 10438 + return err 10439 10439 + } 10440 10440 + if _, err := cw.WriteString(string("workflowRuns")); err != nil { 10441 10441 + return err 10442 10442 + } 10443 10443 + 10444 10444 + if len(t.WorkflowRuns) > 8192 { 10445 10445 + return xerrors.Errorf("Slice value in field t.WorkflowRuns was too long") 10446 10446 + } 10447 10447 + 10448 10448 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.WorkflowRuns))); err != nil { 10449 10449 + return err 10450 10450 + } 10451 10451 + for _, v := range t.WorkflowRuns { 10452 10452 + if len(v) > 1000000 { 10453 10453 + return xerrors.Errorf("Value in field v was too long") 10454 10454 + } 10455 10455 + 10456 10456 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 10457 10457 + return err 10458 10458 + } 10459 10459 + if _, err := cw.WriteString(string(v)); err != nil { 10460 10460 + return err 10461 10461 + } 10462 10462 + 10463 10463 + } 10464 10464 + return nil 10465 10465 + } 10466 10466 + 10467 10467 + func (t *CiPipeline) UnmarshalCBOR(r io.Reader) (err error) { 10468 10468 + *t = CiPipeline{} 10469 10469 + 10470 10470 + cr := cbg.NewCborReader(r) 10471 10471 + 10472 10472 + maj, extra, err := cr.ReadHeader() 10473 10473 + if err != nil { 10474 10474 + return err 10475 10475 + } 10476 10476 + defer func() { 10477 10477 + if err == io.EOF { 10478 10478 + err = io.ErrUnexpectedEOF 10479 10479 + } 10480 10480 + }() 10481 10481 + 10482 10482 + if maj != cbg.MajMap { 10483 10483 + return fmt.Errorf("cbor input should be of type map") 10484 10484 + } 10485 10485 + 10486 10486 + if extra > cbg.MaxLength { 10487 10487 + return fmt.Errorf("CiPipeline: map struct too large (%d)", extra) 10488 10488 + } 10489 10489 + 10490 10490 + n := extra 10491 10491 + 10492 10492 + nameBuf := make([]byte, 12) 10493 10493 + for i := uint64(0); i < n; i++ { 10494 10494 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 10495 10495 + if err != nil { 10496 10496 + return err 10497 10497 + } 10498 10498 + 10499 10499 + if !ok { 10500 10500 + // Field doesn't exist on this type, so ignore it 10501 10501 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 10502 10502 + return err 10503 10503 + } 10504 10504 + continue 10505 10505 + } 10506 10506 + 10507 10507 + switch string(nameBuf[:nameLen]) { 10508 10508 + // t.LexiconTypeID (string) (string) 10509 10509 + case "$type": 10510 10510 + 10511 10511 + { 10512 10512 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10513 10513 + if err != nil { 10514 10514 + return err 10515 10515 + } 10516 10516 + 10517 10517 + t.LexiconTypeID = string(sval) 10518 10518 + } 10519 10519 + // t.Event (tangled.CiEvent) (struct) 10520 10520 + case "event": 10521 10521 + 10522 10522 + { 10523 10523 + 10524 10524 + b, err := cr.ReadByte() 10525 10525 + if err != nil { 10526 10526 + return err 10527 10527 + } 10528 10528 + if b != cbg.CborNull[0] { 10529 10529 + if err := cr.UnreadByte(); err != nil { 10530 10530 + return err 10531 10531 + } 10532 10532 + t.Event = new(CiEvent) 10533 10533 + if err := t.Event.UnmarshalCBOR(cr); err != nil { 10534 10534 + return xerrors.Errorf("unmarshaling t.Event pointer: %w", err) 10535 10535 + } 10536 10536 + } 10537 10537 + 10538 10538 + } 10539 10539 + // t.WorkflowRuns ([]string) (slice) 10540 10540 + case "workflowRuns": 10541 10541 + 10542 10542 + maj, extra, err = cr.ReadHeader() 10543 10543 + if err != nil { 10544 10544 + return err 10545 10545 + } 10546 10546 + 10547 10547 + if extra > 8192 { 10548 10548 + return fmt.Errorf("t.WorkflowRuns: array too large (%d)", extra) 10549 10549 + } 10550 10550 + 10551 10551 + if maj != cbg.MajArray { 10552 10552 + return fmt.Errorf("expected cbor array") 10553 10553 + } 10554 10554 + 10555 10555 + if extra > 0 { 10556 10556 + t.WorkflowRuns = make([]string, extra) 10557 10557 + } 10558 10558 + 10559 10559 + for i := 0; i < int(extra); i++ { 10560 10560 + { 10561 10561 + var maj byte 10562 10562 + var extra uint64 10563 10563 + var err error 10564 10564 + _ = maj 10565 10565 + _ = extra 10566 10566 + _ = err 10567 10567 + 10568 10568 + { 10569 10569 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10570 10570 + if err != nil { 10571 10571 + return err 10572 10572 + } 10573 10573 + 10574 10574 + t.WorkflowRuns[i] = string(sval) 10575 10575 + } 10576 10576 + 10577 10577 + } 10578 10578 + } 10579 10579 + 10580 10580 + default: 10581 10581 + // Field doesn't exist on this type, so ignore it 10582 10582 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 10583 10583 + return err 10584 10584 + } 10585 10585 + } 10586 10586 + } 10587 10587 + 10588 10588 + return nil 10589 10589 + } 10590 10590 + func (t *CiWorkflowRun) MarshalCBOR(w io.Writer) error { 10591 10591 + if t == nil { 10592 10592 + _, err := w.Write(cbg.CborNull) 10593 10593 + return err 10594 10594 + } 10595 10595 + 10596 10596 + cw := cbg.NewCborWriter(w) 10597 10597 + 10598 10598 + if _, err := cw.Write([]byte{164}); err != nil { 10599 10599 + return err 10600 10600 + } 10601 10601 + 10602 10602 + // t.Name (string) (string) 10603 10603 + if len("name") > 1000000 { 10604 10604 + return xerrors.Errorf("Value in field \"name\" was too long") 10605 10605 + } 10606 10606 + 10607 10607 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 10608 10608 + return err 10609 10609 + } 10610 10610 + if _, err := cw.WriteString(string("name")); err != nil { 10611 10611 + return err 10612 10612 + } 10613 10613 + 10614 10614 + if len(t.Name) > 1000000 { 10615 10615 + return xerrors.Errorf("Value in field t.Name was too long") 10616 10616 + } 10617 10617 + 10618 10618 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 10619 10619 + return err 10620 10620 + } 10621 10621 + if _, err := cw.WriteString(string(t.Name)); err != nil { 10622 10622 + return err 10623 10623 + } 10624 10624 + 10625 10625 + // t.LexiconTypeID (string) (string) 10626 10626 + if len("$type") > 1000000 { 10627 10627 + return xerrors.Errorf("Value in field \"$type\" was too long") 10628 10628 + } 10629 10629 + 10630 10630 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 10631 10631 + return err 10632 10632 + } 10633 10633 + if _, err := cw.WriteString(string("$type")); err != nil { 10634 10634 + return err 10635 10635 + } 10636 10636 + 10637 10637 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.ci.workflow.run"))); err != nil { 10638 10638 + return err 10639 10639 + } 10640 10640 + if _, err := cw.WriteString(string("sh.tangled.ci.workflow.run")); err != nil { 10641 10641 + return err 10642 10642 + } 10643 10643 + 10644 10644 + // t.Status (string) (string) 10645 10645 + if len("status") > 1000000 { 10646 10646 + return xerrors.Errorf("Value in field \"status\" was too long") 10647 10647 + } 10648 10648 + 10649 10649 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 10650 10650 + return err 10651 10651 + } 10652 10652 + if _, err := cw.WriteString(string("status")); err != nil { 10653 10653 + return err 10654 10654 + } 10655 10655 + 10656 10656 + if t.Status == nil { 10657 10657 + if _, err := cw.Write(cbg.CborNull); err != nil { 10658 10658 + return err 10659 10659 + } 10660 10660 + } else { 10661 10661 + if len(*t.Status) > 1000000 { 10662 10662 + return xerrors.Errorf("Value in field t.Status was too long") 10663 10663 + } 10664 10664 + 10665 10665 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Status))); err != nil { 10666 10666 + return err 10667 10667 + } 10668 10668 + if _, err := cw.WriteString(string(*t.Status)); err != nil { 10669 10669 + return err 10670 10670 + } 10671 10671 + } 10672 10672 + 10673 10673 + // t.Adapter (string) (string) 10674 10674 + if len("adapter") > 1000000 { 10675 10675 + return xerrors.Errorf("Value in field \"adapter\" was too long") 10676 10676 + } 10677 10677 + 10678 10678 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("adapter"))); err != nil { 10679 10679 + return err 10680 10680 + } 10681 10681 + if _, err := cw.WriteString(string("adapter")); err != nil { 10682 10682 + return err 10683 10683 + } 10684 10684 + 10685 10685 + if len(t.Adapter) > 1000000 { 10686 10686 + return xerrors.Errorf("Value in field t.Adapter was too long") 10687 10687 + } 10688 10688 + 10689 10689 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Adapter))); err != nil { 10690 10690 + return err 10691 10691 + } 10692 10692 + if _, err := cw.WriteString(string(t.Adapter)); err != nil { 10693 10693 + return err 10694 10694 + } 10695 10695 + return nil 10696 10696 + } 10697 10697 + 10698 10698 + func (t *CiWorkflowRun) UnmarshalCBOR(r io.Reader) (err error) { 10699 10699 + *t = CiWorkflowRun{} 10700 10700 + 10701 10701 + cr := cbg.NewCborReader(r) 10702 10702 + 10703 10703 + maj, extra, err := cr.ReadHeader() 10704 10704 + if err != nil { 10705 10705 + return err 10706 10706 + } 10707 10707 + defer func() { 10708 10708 + if err == io.EOF { 10709 10709 + err = io.ErrUnexpectedEOF 10710 10710 + } 10711 10711 + }() 10712 10712 + 10713 10713 + if maj != cbg.MajMap { 10714 10714 + return fmt.Errorf("cbor input should be of type map") 10715 10715 + } 10716 10716 + 10717 10717 + if extra > cbg.MaxLength { 10718 10718 + return fmt.Errorf("CiWorkflowRun: map struct too large (%d)", extra) 10719 10719 + } 10720 10720 + 10721 10721 + n := extra 10722 10722 + 10723 10723 + nameBuf := make([]byte, 7) 10724 10724 + for i := uint64(0); i < n; i++ { 10725 10725 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 10726 10726 + if err != nil { 10727 10727 + return err 10728 10728 + } 10729 10729 + 10730 10730 + if !ok { 10731 10731 + // Field doesn't exist on this type, so ignore it 10732 10732 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 10733 10733 + return err 10734 10734 + } 10735 10735 + continue 10736 10736 + } 10737 10737 + 10738 10738 + switch string(nameBuf[:nameLen]) { 10739 10739 + // t.Name (string) (string) 10740 10740 + case "name": 10741 10741 + 10742 10742 + { 10743 10743 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10744 10744 + if err != nil { 10745 10745 + return err 10746 10746 + } 10747 10747 + 10748 10748 + t.Name = string(sval) 10749 10749 + } 10750 10750 + // t.LexiconTypeID (string) (string) 10751 10751 + case "$type": 10752 10752 + 10753 10753 + { 10754 10754 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10755 10755 + if err != nil { 10756 10756 + return err 10757 10757 + } 10758 10758 + 10759 10759 + t.LexiconTypeID = string(sval) 10760 10760 + } 10761 10761 + // t.Status (string) (string) 10762 10762 + case "status": 10763 10763 + 10764 10764 + { 10765 10765 + b, err := cr.ReadByte() 10766 10766 + if err != nil { 10767 10767 + return err 10768 10768 + } 10769 10769 + if b != cbg.CborNull[0] { 10770 10770 + if err := cr.UnreadByte(); err != nil { 10771 10771 + return err 10772 10772 + } 10773 10773 + 10774 10774 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10775 10775 + if err != nil { 10776 10776 + return err 10777 10777 + } 10778 10778 + 10779 10779 + t.Status = (*string)(&sval) 10780 10780 + } 10781 10781 + } 10782 10782 + // t.Adapter (string) (string) 10783 10783 + case "adapter": 10784 10784 + 10785 10785 + { 10786 10786 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10787 10787 + if err != nil { 10788 10788 + return err 10789 10789 + } 10790 10790 + 10791 10791 + t.Adapter = string(sval) 10792 10792 + } 10793 10793 + 10794 10794 + default: 10795 10795 + // Field doesn't exist on this type, so ignore it 10796 10796 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 10797 10797 + return err 10798 10798 + } 10799 10799 + } 10800 10800 + } 10801 10801 + 10802 10802 + return nil 10803 10803 + }

+124

api/tangled/cievent.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + // Lexicon schema: sh.tangled.ci.event 4 4 + 5 5 + package tangled 6 6 + 7 7 + import ( 8 8 + "bytes" 9 9 + "encoding/json" 10 10 + "fmt" 11 11 + "io" 12 12 + 13 13 + lexutil "github.com/bluesky-social/indigo/lex/util" 14 14 + cbg "github.com/whyrusleeping/cbor-gen" 15 15 + ) 16 16 + 17 17 + const ( 18 18 + CiEventNSID = "sh.tangled.ci.event" 19 19 + ) 20 20 + 21 21 + // CiEvent is a "main" in the sh.tangled.ci.event schema. 22 22 + type CiEvent struct { 23 23 + Meta *CiEvent_Meta `json:"meta" cborgen:"meta"` 24 24 + } 25 25 + 26 26 + // CiEvent_Manual is a "manual" in the sh.tangled.ci.event schema. 27 27 + type CiEvent_Manual struct { 28 28 + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.event#manual"` 29 29 + } 30 30 + 31 31 + type CiEvent_Meta struct { 32 32 + CiEvent_PullRequest *CiEvent_PullRequest 33 33 + CiEvent_Push *CiEvent_Push 34 34 + CiEvent_Manual *CiEvent_Manual 35 35 + } 36 36 + 37 37 + func (t *CiEvent_Meta) MarshalJSON() ([]byte, error) { 38 38 + if t.CiEvent_PullRequest != nil { 39 39 + t.CiEvent_PullRequest.LexiconTypeID = "sh.tangled.ci.event#pullRequest" 40 40 + return json.Marshal(t.CiEvent_PullRequest) 41 41 + } 42 42 + if t.CiEvent_Push != nil { 43 43 + t.CiEvent_Push.LexiconTypeID = "sh.tangled.ci.event#push" 44 44 + return json.Marshal(t.CiEvent_Push) 45 45 + } 46 46 + if t.CiEvent_Manual != nil { 47 47 + t.CiEvent_Manual.LexiconTypeID = "sh.tangled.ci.event#manual" 48 48 + return json.Marshal(t.CiEvent_Manual) 49 49 + } 50 50 + return nil, fmt.Errorf("can not marshal empty union as JSON") 51 51 + } 52 52 + 53 53 + func (t *CiEvent_Meta) UnmarshalJSON(b []byte) error { 54 54 + typ, err := lexutil.TypeExtract(b) 55 55 + if err != nil { 56 56 + return err 57 57 + } 58 58 + 59 59 + switch typ { 60 60 + case "sh.tangled.ci.event#pullRequest": 61 61 + t.CiEvent_PullRequest = new(CiEvent_PullRequest) 62 62 + return json.Unmarshal(b, t.CiEvent_PullRequest) 63 63 + case "sh.tangled.ci.event#push": 64 64 + t.CiEvent_Push = new(CiEvent_Push) 65 65 + return json.Unmarshal(b, t.CiEvent_Push) 66 66 + case "sh.tangled.ci.event#manual": 67 67 + t.CiEvent_Manual = new(CiEvent_Manual) 68 68 + return json.Unmarshal(b, t.CiEvent_Manual) 69 69 + default: 70 70 + return nil 71 71 + } 72 72 + } 73 73 + 74 74 + func (t *CiEvent_Meta) MarshalCBOR(w io.Writer) error { 75 75 + 76 76 + if t == nil { 77 77 + _, err := w.Write(cbg.CborNull) 78 78 + return err 79 79 + } 80 80 + if t.CiEvent_PullRequest != nil { 81 81 + return t.CiEvent_PullRequest.MarshalCBOR(w) 82 82 + } 83 83 + if t.CiEvent_Push != nil { 84 84 + return t.CiEvent_Push.MarshalCBOR(w) 85 85 + } 86 86 + if t.CiEvent_Manual != nil { 87 87 + return t.CiEvent_Manual.MarshalCBOR(w) 88 88 + } 89 89 + return fmt.Errorf("can not marshal empty union as CBOR") 90 90 + } 91 91 + 92 92 + func (t *CiEvent_Meta) UnmarshalCBOR(r io.Reader) error { 93 93 + typ, b, err := lexutil.CborTypeExtractReader(r) 94 94 + if err != nil { 95 95 + return err 96 96 + } 97 97 + 98 98 + switch typ { 99 99 + case "sh.tangled.ci.event#pullRequest": 100 100 + t.CiEvent_PullRequest = new(CiEvent_PullRequest) 101 101 + return t.CiEvent_PullRequest.UnmarshalCBOR(bytes.NewReader(b)) 102 102 + case "sh.tangled.ci.event#push": 103 103 + t.CiEvent_Push = new(CiEvent_Push) 104 104 + return t.CiEvent_Push.UnmarshalCBOR(bytes.NewReader(b)) 105 105 + case "sh.tangled.ci.event#manual": 106 106 + t.CiEvent_Manual = new(CiEvent_Manual) 107 107 + return t.CiEvent_Manual.UnmarshalCBOR(bytes.NewReader(b)) 108 108 + default: 109 109 + return nil 110 110 + } 111 111 + } 112 112 + 113 113 + // CiEvent_PullRequest is a "pullRequest" in the sh.tangled.ci.event schema. 114 114 + type CiEvent_PullRequest struct { 115 115 + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.event#pullRequest"` 116 116 + } 117 117 + 118 118 + // CiEvent_Push is a "push" in the sh.tangled.ci.event schema. 119 119 + type CiEvent_Push struct { 120 120 + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.event#push"` 121 121 + NewSha string `json:"newSha" cborgen:"newSha"` 122 122 + OldSha string `json:"oldSha" cborgen:"oldSha"` 123 123 + Ref string `json:"ref" cborgen:"ref"` 124 124 + }

+23

api/tangled/cipipeline.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + // Lexicon schema: sh.tangled.ci.pipeline 4 4 + 5 5 + package tangled 6 6 + 7 7 + import ( 8 8 + lexutil "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + CiPipelineNSID = "sh.tangled.ci.pipeline" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + lexutil.RegisterType("sh.tangled.ci.pipeline", &CiPipeline{}) 17 17 + } 18 18 + 19 19 + type CiPipeline struct { 20 20 + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.pipeline"` 21 21 + Event *CiEvent `json:"event" cborgen:"event"` 22 22 + WorkflowRuns []string `json:"workflowRuns" cborgen:"workflowRuns"` 23 23 + }

+24

api/tangled/workflowrun.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + // Lexicon schema: sh.tangled.ci.workflow.run 4 4 + 5 5 + package tangled 6 6 + 7 7 + import ( 8 8 + lexutil "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + CiWorkflowRunNSID = "sh.tangled.ci.workflow.run" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + lexutil.RegisterType("sh.tangled.ci.workflow.run", &CiWorkflowRun{}) 17 17 + } 18 18 + 19 19 + type CiWorkflowRun struct { 20 20 + LexiconTypeID string `json:"$type" cborgen:"$type,const=sh.tangled.ci.workflow.run"` 21 21 + Adapter string `json:"adapter" cborgen:"adapter"` 22 22 + Name string `json:"name" cborgen:"name"` 23 23 + Status *string `json:"status" cborgen:"status"` 24 24 + }

+9

api/tangled/workflowstatus.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + // Lexicon schema: sh.tangled.ci.workflow.status 4 4 + 5 5 + package tangled 6 6 + 7 7 + const ( 8 8 + CiWorkflowStatusNSID = "sh.tangled.ci.workflow.status" 9 9 + )

+6

cmd/cborgen/cborgen.go

··· 55 55 tangled.Spindle{}, 56 56 tangled.SpindleMember{}, 57 57 tangled.String{}, 58 58 + tangled.CiEvent{}, 59 59 + tangled.CiEvent_PullRequest{}, 60 60 + tangled.CiEvent_Push{}, 61 61 + tangled.CiEvent_Manual{}, 62 62 + tangled.CiPipeline{}, 63 63 + tangled.CiWorkflowRun{}, 58 64 ); err != nil { 59 65 panic(err) 60 66 }

+57

lexicons/ci/event.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.ci.event", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "object", 9 9 + "required": [ 10 10 + "meta" 11 11 + ], 12 12 + "properties": { 13 13 + "meta": { 14 14 + "type": "union", 15 15 + "refs": [ 16 16 + "#pullRequest", 17 17 + "#push", 18 18 + "#manual" 19 19 + ] 20 20 + } 21 21 + } 22 22 + }, 23 23 + "pullRequest": { 24 24 + "type": "object", 25 25 + "required": [], 26 26 + "properties": {} 27 27 + }, 28 28 + "push": { 29 29 + "type": "object", 30 30 + "required": [ 31 31 + "ref", 32 32 + "oldSha", 33 33 + "newSha" 34 34 + ], 35 35 + "properties": { 36 36 + "ref": { 37 37 + "type": "string" 38 38 + }, 39 39 + "oldSha": { 40 40 + "type": "string", 41 41 + "minLength": 40, 42 42 + "maxLength": 40 43 43 + }, 44 44 + "newSha": { 45 45 + "type": "string", 46 46 + "minLength": 40, 47 47 + "maxLength": 40 48 48 + } 49 49 + } 50 50 + }, 51 51 + "manual": { 52 52 + "type": "object", 53 53 + "required": [], 54 54 + "properties": {} 55 55 + } 56 56 + } 57 57 + }

+30

lexicons/ci/pipeline.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.ci.pipeline", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "key": "tid", 8 8 + "record": { 9 9 + "type": "object", 10 10 + "required": [ 11 11 + "event", 12 12 + "workflowRuns" 13 13 + ], 14 14 + "properties": { 15 15 + "event": { 16 16 + "type": "ref", 17 17 + "ref": "sh.tangled.ci.event" 18 18 + }, 19 19 + "workflowRuns": { 20 20 + "type": "array", 21 21 + "items": { 22 22 + "type": "string", 23 23 + "format": "at-uri" 24 24 + } 25 25 + } 26 26 + } 27 27 + } 28 28 + } 29 29 + } 30 30 + }

+30

lexicons/ci/workflow/run.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.ci.workflow.run", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "key": "tid", 8 8 + "record": { 9 9 + "type": "object", 10 10 + "required": [ 11 11 + "name", 12 12 + "adapter", 13 13 + "status" 14 14 + ], 15 15 + "properties": { 16 16 + "name": { 17 17 + "type": "string" 18 18 + }, 19 19 + "adapter": { 20 20 + "type": "string" 21 21 + }, 22 22 + "status": { 23 23 + "type": "ref", 24 24 + "ref": "sh.tangled.ci.workflow.status" 25 25 + } 26 26 + } 27 27 + } 28 28 + } 29 29 + } 30 30 + }

+18

lexicons/ci/workflow/status.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.ci.workflow.status", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "string", 7 7 + "description": "status of the workflow run", 8 8 + "enum": [ 9 9 + "pending", 10 10 + "running", 11 11 + "failed", 12 12 + "timeout", 13 13 + "cancelled", 14 14 + "success" 15 15 + ] 16 16 + } 17 17 + } 18 18 + }