+955 -486

api/tangled/cbor_gen.go

··· 676 676 677 677 cw := cbg.NewCborWriter(w) 678 678 679 679 - if _, err := cw.Write([]byte{167}); err != nil { 679 679 + if _, err := cw.Write([]byte{168}); err != nil { 680 680 return err 681 681 } 682 682 ··· 700 700 return err 701 701 } 702 702 if _, err := cw.WriteString(string(t.Ref)); err != nil { 703 703 + return err 704 704 + } 705 705 + 706 706 + // t.Meta (tangled.GitRefUpdate_Meta) (struct) 707 707 + if len("meta") > 1000000 { 708 708 + return xerrors.Errorf("Value in field \"meta\" was too long") 709 709 + } 710 710 + 711 711 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil { 712 712 + return err 713 713 + } 714 714 + if _, err := cw.WriteString(string("meta")); err != nil { 715 715 + return err 716 716 + } 717 717 + 718 718 + if err := t.Meta.MarshalCBOR(cw); err != nil { 703 719 return err 704 720 } 705 721 ··· 891 907 892 908 t.Ref = string(sval) 893 909 } 910 910 + // t.Meta (tangled.GitRefUpdate_Meta) (struct) 911 911 + case "meta": 912 912 + 913 913 + { 914 914 + 915 915 + b, err := cr.ReadByte() 916 916 + if err != nil { 917 917 + return err 918 918 + } 919 919 + if b != cbg.CborNull[0] { 920 920 + if err := cr.UnreadByte(); err != nil { 921 921 + return err 922 922 + } 923 923 + t.Meta = new(GitRefUpdate_Meta) 924 924 + if err := t.Meta.UnmarshalCBOR(cr); err != nil { 925 925 + return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err) 926 926 + } 927 927 + } 928 928 + 929 929 + } 894 930 // t.LexiconTypeID (string) (string) 895 931 case "$type": 896 932 ··· 956 992 } 957 993 958 994 t.CommitterDid = string(sval) 995 995 + } 996 996 + 997 997 + default: 998 998 + // Field doesn't exist on this type, so ignore it 999 999 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1000 1000 + return err 1001 1001 + } 1002 1002 + } 1003 1003 + } 1004 1004 + 1005 1005 + return nil 1006 1006 + } 1007 1007 + func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error { 1008 1008 + if t == nil { 1009 1009 + _, err := w.Write(cbg.CborNull) 1010 1010 + return err 1011 1011 + } 1012 1012 + 1013 1013 + cw := cbg.NewCborWriter(w) 1014 1014 + 1015 1015 + if _, err := cw.Write([]byte{162}); err != nil { 1016 1016 + return err 1017 1017 + } 1018 1018 + 1019 1019 + // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) 1020 1020 + if len("commitCount") > 1000000 { 1021 1021 + return xerrors.Errorf("Value in field \"commitCount\" was too long") 1022 1022 + } 1023 1023 + 1024 1024 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil { 1025 1025 + return err 1026 1026 + } 1027 1027 + if _, err := cw.WriteString(string("commitCount")); err != nil { 1028 1028 + return err 1029 1029 + } 1030 1030 + 1031 1031 + if err := t.CommitCount.MarshalCBOR(cw); err != nil { 1032 1032 + return err 1033 1033 + } 1034 1034 + 1035 1035 + // t.IsDefaultRef (bool) (bool) 1036 1036 + if len("isDefaultRef") > 1000000 { 1037 1037 + return xerrors.Errorf("Value in field \"isDefaultRef\" was too long") 1038 1038 + } 1039 1039 + 1040 1040 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil { 1041 1041 + return err 1042 1042 + } 1043 1043 + if _, err := cw.WriteString(string("isDefaultRef")); err != nil { 1044 1044 + return err 1045 1045 + } 1046 1046 + 1047 1047 + if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil { 1048 1048 + return err 1049 1049 + } 1050 1050 + return nil 1051 1051 + } 1052 1052 + 1053 1053 + func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) { 1054 1054 + *t = GitRefUpdate_Meta{} 1055 1055 + 1056 1056 + cr := cbg.NewCborReader(r) 1057 1057 + 1058 1058 + maj, extra, err := cr.ReadHeader() 1059 1059 + if err != nil { 1060 1060 + return err 1061 1061 + } 1062 1062 + defer func() { 1063 1063 + if err == io.EOF { 1064 1064 + err = io.ErrUnexpectedEOF 1065 1065 + } 1066 1066 + }() 1067 1067 + 1068 1068 + if maj != cbg.MajMap { 1069 1069 + return fmt.Errorf("cbor input should be of type map") 1070 1070 + } 1071 1071 + 1072 1072 + if extra > cbg.MaxLength { 1073 1073 + return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra) 1074 1074 + } 1075 1075 + 1076 1076 + n := extra 1077 1077 + 1078 1078 + nameBuf := make([]byte, 12) 1079 1079 + for i := uint64(0); i < n; i++ { 1080 1080 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1081 1081 + if err != nil { 1082 1082 + return err 1083 1083 + } 1084 1084 + 1085 1085 + if !ok { 1086 1086 + // Field doesn't exist on this type, so ignore it 1087 1087 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1088 1088 + return err 1089 1089 + } 1090 1090 + continue 1091 1091 + } 1092 1092 + 1093 1093 + switch string(nameBuf[:nameLen]) { 1094 1094 + // t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct) 1095 1095 + case "commitCount": 1096 1096 + 1097 1097 + { 1098 1098 + 1099 1099 + b, err := cr.ReadByte() 1100 1100 + if err != nil { 1101 1101 + return err 1102 1102 + } 1103 1103 + if b != cbg.CborNull[0] { 1104 1104 + if err := cr.UnreadByte(); err != nil { 1105 1105 + return err 1106 1106 + } 1107 1107 + t.CommitCount = new(GitRefUpdate_Meta_CommitCount) 1108 1108 + if err := t.CommitCount.UnmarshalCBOR(cr); err != nil { 1109 1109 + return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err) 1110 1110 + } 1111 1111 + } 1112 1112 + 1113 1113 + } 1114 1114 + // t.IsDefaultRef (bool) (bool) 1115 1115 + case "isDefaultRef": 1116 1116 + 1117 1117 + maj, extra, err = cr.ReadHeader() 1118 1118 + if err != nil { 1119 1119 + return err 1120 1120 + } 1121 1121 + if maj != cbg.MajOther { 1122 1122 + return fmt.Errorf("booleans must be major type 7") 1123 1123 + } 1124 1124 + switch extra { 1125 1125 + case 20: 1126 1126 + t.IsDefaultRef = false 1127 1127 + case 21: 1128 1128 + t.IsDefaultRef = true 1129 1129 + default: 1130 1130 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 1131 1131 + } 1132 1132 + 1133 1133 + default: 1134 1134 + // Field doesn't exist on this type, so ignore it 1135 1135 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1136 1136 + return err 1137 1137 + } 1138 1138 + } 1139 1139 + } 1140 1140 + 1141 1141 + return nil 1142 1142 + } 1143 1143 + func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error { 1144 1144 + if t == nil { 1145 1145 + _, err := w.Write(cbg.CborNull) 1146 1146 + return err 1147 1147 + } 1148 1148 + 1149 1149 + cw := cbg.NewCborWriter(w) 1150 1150 + fieldCount := 1 1151 1151 + 1152 1152 + if t.ByEmail == nil { 1153 1153 + fieldCount-- 1154 1154 + } 1155 1155 + 1156 1156 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1157 1157 + return err 1158 1158 + } 1159 1159 + 1160 1160 + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1161 1161 + if t.ByEmail != nil { 1162 1162 + 1163 1163 + if len("byEmail") > 1000000 { 1164 1164 + return xerrors.Errorf("Value in field \"byEmail\" was too long") 1165 1165 + } 1166 1166 + 1167 1167 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil { 1168 1168 + return err 1169 1169 + } 1170 1170 + if _, err := cw.WriteString(string("byEmail")); err != nil { 1171 1171 + return err 1172 1172 + } 1173 1173 + 1174 1174 + if len(t.ByEmail) > 8192 { 1175 1175 + return xerrors.Errorf("Slice value in field t.ByEmail was too long") 1176 1176 + } 1177 1177 + 1178 1178 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil { 1179 1179 + return err 1180 1180 + } 1181 1181 + for _, v := range t.ByEmail { 1182 1182 + if err := v.MarshalCBOR(cw); err != nil { 1183 1183 + return err 1184 1184 + } 1185 1185 + 1186 1186 + } 1187 1187 + } 1188 1188 + return nil 1189 1189 + } 1190 1190 + 1191 1191 + func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) { 1192 1192 + *t = GitRefUpdate_Meta_CommitCount{} 1193 1193 + 1194 1194 + cr := cbg.NewCborReader(r) 1195 1195 + 1196 1196 + maj, extra, err := cr.ReadHeader() 1197 1197 + if err != nil { 1198 1198 + return err 1199 1199 + } 1200 1200 + defer func() { 1201 1201 + if err == io.EOF { 1202 1202 + err = io.ErrUnexpectedEOF 1203 1203 + } 1204 1204 + }() 1205 1205 + 1206 1206 + if maj != cbg.MajMap { 1207 1207 + return fmt.Errorf("cbor input should be of type map") 1208 1208 + } 1209 1209 + 1210 1210 + if extra > cbg.MaxLength { 1211 1211 + return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra) 1212 1212 + } 1213 1213 + 1214 1214 + n := extra 1215 1215 + 1216 1216 + nameBuf := make([]byte, 7) 1217 1217 + for i := uint64(0); i < n; i++ { 1218 1218 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1219 1219 + if err != nil { 1220 1220 + return err 1221 1221 + } 1222 1222 + 1223 1223 + if !ok { 1224 1224 + // Field doesn't exist on this type, so ignore it 1225 1225 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1226 1226 + return err 1227 1227 + } 1228 1228 + continue 1229 1229 + } 1230 1230 + 1231 1231 + switch string(nameBuf[:nameLen]) { 1232 1232 + // t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice) 1233 1233 + case "byEmail": 1234 1234 + 1235 1235 + maj, extra, err = cr.ReadHeader() 1236 1236 + if err != nil { 1237 1237 + return err 1238 1238 + } 1239 1239 + 1240 1240 + if extra > 8192 { 1241 1241 + return fmt.Errorf("t.ByEmail: array too large (%d)", extra) 1242 1242 + } 1243 1243 + 1244 1244 + if maj != cbg.MajArray { 1245 1245 + return fmt.Errorf("expected cbor array") 1246 1246 + } 1247 1247 + 1248 1248 + if extra > 0 { 1249 1249 + t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra) 1250 1250 + } 1251 1251 + 1252 1252 + for i := 0; i < int(extra); i++ { 1253 1253 + { 1254 1254 + var maj byte 1255 1255 + var extra uint64 1256 1256 + var err error 1257 1257 + _ = maj 1258 1258 + _ = extra 1259 1259 + _ = err 1260 1260 + 1261 1261 + { 1262 1262 + 1263 1263 + b, err := cr.ReadByte() 1264 1264 + if err != nil { 1265 1265 + return err 1266 1266 + } 1267 1267 + if b != cbg.CborNull[0] { 1268 1268 + if err := cr.UnreadByte(); err != nil { 1269 1269 + return err 1270 1270 + } 1271 1271 + t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem) 1272 1272 + if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil { 1273 1273 + return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err) 1274 1274 + } 1275 1275 + } 1276 1276 + 1277 1277 + } 1278 1278 + 1279 1279 + } 1280 1280 + } 1281 1281 + 1282 1282 + default: 1283 1283 + // Field doesn't exist on this type, so ignore it 1284 1284 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1285 1285 + return err 1286 1286 + } 1287 1287 + } 1288 1288 + } 1289 1289 + 1290 1290 + return nil 1291 1291 + } 1292 1292 + func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error { 1293 1293 + if t == nil { 1294 1294 + _, err := w.Write(cbg.CborNull) 1295 1295 + return err 1296 1296 + } 1297 1297 + 1298 1298 + cw := cbg.NewCborWriter(w) 1299 1299 + 1300 1300 + if _, err := cw.Write([]byte{162}); err != nil { 1301 1301 + return err 1302 1302 + } 1303 1303 + 1304 1304 + // t.Count (int64) (int64) 1305 1305 + if len("count") > 1000000 { 1306 1306 + return xerrors.Errorf("Value in field \"count\" was too long") 1307 1307 + } 1308 1308 + 1309 1309 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil { 1310 1310 + return err 1311 1311 + } 1312 1312 + if _, err := cw.WriteString(string("count")); err != nil { 1313 1313 + return err 1314 1314 + } 1315 1315 + 1316 1316 + if t.Count >= 0 { 1317 1317 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil { 1318 1318 + return err 1319 1319 + } 1320 1320 + } else { 1321 1321 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil { 1322 1322 + return err 1323 1323 + } 1324 1324 + } 1325 1325 + 1326 1326 + // t.Email (string) (string) 1327 1327 + if len("email") > 1000000 { 1328 1328 + return xerrors.Errorf("Value in field \"email\" was too long") 1329 1329 + } 1330 1330 + 1331 1331 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil { 1332 1332 + return err 1333 1333 + } 1334 1334 + if _, err := cw.WriteString(string("email")); err != nil { 1335 1335 + return err 1336 1336 + } 1337 1337 + 1338 1338 + if len(t.Email) > 1000000 { 1339 1339 + return xerrors.Errorf("Value in field t.Email was too long") 1340 1340 + } 1341 1341 + 1342 1342 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil { 1343 1343 + return err 1344 1344 + } 1345 1345 + if _, err := cw.WriteString(string(t.Email)); err != nil { 1346 1346 + return err 1347 1347 + } 1348 1348 + return nil 1349 1349 + } 1350 1350 + 1351 1351 + func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) { 1352 1352 + *t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{} 1353 1353 + 1354 1354 + cr := cbg.NewCborReader(r) 1355 1355 + 1356 1356 + maj, extra, err := cr.ReadHeader() 1357 1357 + if err != nil { 1358 1358 + return err 1359 1359 + } 1360 1360 + defer func() { 1361 1361 + if err == io.EOF { 1362 1362 + err = io.ErrUnexpectedEOF 1363 1363 + } 1364 1364 + }() 1365 1365 + 1366 1366 + if maj != cbg.MajMap { 1367 1367 + return fmt.Errorf("cbor input should be of type map") 1368 1368 + } 1369 1369 + 1370 1370 + if extra > cbg.MaxLength { 1371 1371 + return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra) 1372 1372 + } 1373 1373 + 1374 1374 + n := extra 1375 1375 + 1376 1376 + nameBuf := make([]byte, 5) 1377 1377 + for i := uint64(0); i < n; i++ { 1378 1378 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1379 1379 + if err != nil { 1380 1380 + return err 1381 1381 + } 1382 1382 + 1383 1383 + if !ok { 1384 1384 + // Field doesn't exist on this type, so ignore it 1385 1385 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1386 1386 + return err 1387 1387 + } 1388 1388 + continue 1389 1389 + } 1390 1390 + 1391 1391 + switch string(nameBuf[:nameLen]) { 1392 1392 + // t.Count (int64) (int64) 1393 1393 + case "count": 1394 1394 + { 1395 1395 + maj, extra, err := cr.ReadHeader() 1396 1396 + if err != nil { 1397 1397 + return err 1398 1398 + } 1399 1399 + var extraI int64 1400 1400 + switch maj { 1401 1401 + case cbg.MajUnsignedInt: 1402 1402 + extraI = int64(extra) 1403 1403 + if extraI < 0 { 1404 1404 + return fmt.Errorf("int64 positive overflow") 1405 1405 + } 1406 1406 + case cbg.MajNegativeInt: 1407 1407 + extraI = int64(extra) 1408 1408 + if extraI < 0 { 1409 1409 + return fmt.Errorf("int64 negative overflow") 1410 1410 + } 1411 1411 + extraI = -1 - extraI 1412 1412 + default: 1413 1413 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1414 1414 + } 1415 1415 + 1416 1416 + t.Count = int64(extraI) 1417 1417 + } 1418 1418 + // t.Email (string) (string) 1419 1419 + case "email": 1420 1420 + 1421 1421 + { 1422 1422 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1423 1423 + if err != nil { 1424 1424 + return err 1425 1425 + } 1426 1426 + 1427 1427 + t.Email = string(sval) 959 1428 } 960 1429 961 1430 default: ··· 1719 2188 1720 2189 return nil 1721 2190 } 1722 1722 - func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { 1723 1723 - if t == nil { 1724 1724 - _, err := w.Write(cbg.CborNull) 1725 1725 - return err 1726 1726 - } 1727 1727 - 1728 1728 - cw := cbg.NewCborWriter(w) 1729 1729 - 1730 1730 - if _, err := cw.Write([]byte{165}); err != nil { 1731 1731 - return err 1732 1732 - } 1733 1733 - 1734 1734 - // t.Name (string) (string) 1735 1735 - if len("name") > 1000000 { 1736 1736 - return xerrors.Errorf("Value in field \"name\" was too long") 1737 1737 - } 1738 1738 - 1739 1739 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 1740 1740 - return err 1741 1741 - } 1742 1742 - if _, err := cw.WriteString(string("name")); err != nil { 1743 1743 - return err 1744 1744 - } 1745 1745 - 1746 1746 - if len(t.Name) > 1000000 { 1747 1747 - return xerrors.Errorf("Value in field t.Name was too long") 1748 1748 - } 1749 1749 - 1750 1750 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 1751 1751 - return err 1752 1752 - } 1753 1753 - if _, err := cw.WriteString(string(t.Name)); err != nil { 1754 1754 - return err 1755 1755 - } 1756 1756 - 1757 1757 - // t.Clone (tangled.Pipeline_CloneOpts) (struct) 1758 1758 - if len("clone") > 1000000 { 1759 1759 - return xerrors.Errorf("Value in field \"clone\" was too long") 1760 1760 - } 1761 1761 - 1762 1762 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil { 1763 1763 - return err 1764 1764 - } 1765 1765 - if _, err := cw.WriteString(string("clone")); err != nil { 1766 1766 - return err 1767 1767 - } 1768 1768 - 1769 1769 - if err := t.Clone.MarshalCBOR(cw); err != nil { 1770 1770 - return err 1771 1771 - } 1772 1772 - 1773 1773 - // t.Steps ([]*tangled.Pipeline_Step) (slice) 1774 1774 - if len("steps") > 1000000 { 1775 1775 - return xerrors.Errorf("Value in field \"steps\" was too long") 1776 1776 - } 1777 1777 - 1778 1778 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil { 1779 1779 - return err 1780 1780 - } 1781 1781 - if _, err := cw.WriteString(string("steps")); err != nil { 1782 1782 - return err 1783 1783 - } 1784 1784 - 1785 1785 - if len(t.Steps) > 8192 { 1786 1786 - return xerrors.Errorf("Slice value in field t.Steps was too long") 1787 1787 - } 1788 1788 - 1789 1789 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil { 1790 1790 - return err 1791 1791 - } 1792 1792 - for _, v := range t.Steps { 1793 1793 - if err := v.MarshalCBOR(cw); err != nil { 1794 1794 - return err 1795 1795 - } 1796 1796 - 1797 1797 - } 1798 1798 - 1799 1799 - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 1800 1800 - if len("environment") > 1000000 { 1801 1801 - return xerrors.Errorf("Value in field \"environment\" was too long") 1802 1802 - } 1803 1803 - 1804 1804 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil { 1805 1805 - return err 1806 1806 - } 1807 1807 - if _, err := cw.WriteString(string("environment")); err != nil { 1808 1808 - return err 1809 1809 - } 1810 1810 - 1811 1811 - if len(t.Environment) > 8192 { 1812 1812 - return xerrors.Errorf("Slice value in field t.Environment was too long") 1813 1813 - } 1814 1814 - 1815 1815 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil { 1816 1816 - return err 1817 1817 - } 1818 1818 - for _, v := range t.Environment { 1819 1819 - if err := v.MarshalCBOR(cw); err != nil { 1820 1820 - return err 1821 1821 - } 1822 1822 - 1823 1823 - } 1824 1824 - 1825 1825 - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 1826 1826 - if len("dependencies") > 1000000 { 1827 1827 - return xerrors.Errorf("Value in field \"dependencies\" was too long") 1828 1828 - } 1829 1829 - 1830 1830 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil { 1831 1831 - return err 1832 1832 - } 1833 1833 - if _, err := cw.WriteString(string("dependencies")); err != nil { 1834 1834 - return err 1835 1835 - } 1836 1836 - 1837 1837 - if len(t.Dependencies) > 8192 { 1838 1838 - return xerrors.Errorf("Slice value in field t.Dependencies was too long") 1839 1839 - } 1840 1840 - 1841 1841 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil { 1842 1842 - return err 1843 1843 - } 1844 1844 - for _, v := range t.Dependencies { 1845 1845 - if err := v.MarshalCBOR(cw); err != nil { 1846 1846 - return err 1847 1847 - } 1848 1848 - 1849 1849 - } 1850 1850 - return nil 1851 1851 - } 1852 1852 - 1853 1853 - func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { 1854 1854 - *t = Pipeline_Workflow{} 1855 1855 - 1856 1856 - cr := cbg.NewCborReader(r) 1857 1857 - 1858 1858 - maj, extra, err := cr.ReadHeader() 1859 1859 - if err != nil { 1860 1860 - return err 1861 1861 - } 1862 1862 - defer func() { 1863 1863 - if err == io.EOF { 1864 1864 - err = io.ErrUnexpectedEOF 1865 1865 - } 1866 1866 - }() 1867 1867 - 1868 1868 - if maj != cbg.MajMap { 1869 1869 - return fmt.Errorf("cbor input should be of type map") 1870 1870 - } 1871 1871 - 1872 1872 - if extra > cbg.MaxLength { 1873 1873 - return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra) 1874 1874 - } 1875 1875 - 1876 1876 - n := extra 1877 1877 - 1878 1878 - nameBuf := make([]byte, 12) 1879 1879 - for i := uint64(0); i < n; i++ { 1880 1880 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1881 1881 - if err != nil { 1882 1882 - return err 1883 1883 - } 1884 1884 - 1885 1885 - if !ok { 1886 1886 - // Field doesn't exist on this type, so ignore it 1887 1887 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1888 1888 - return err 1889 1889 - } 1890 1890 - continue 1891 1891 - } 1892 1892 - 1893 1893 - switch string(nameBuf[:nameLen]) { 1894 1894 - // t.Name (string) (string) 1895 1895 - case "name": 1896 1896 - 1897 1897 - { 1898 1898 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1899 1899 - if err != nil { 1900 1900 - return err 1901 1901 - } 1902 1902 - 1903 1903 - t.Name = string(sval) 1904 1904 - } 1905 1905 - // t.Clone (tangled.Pipeline_CloneOpts) (struct) 1906 1906 - case "clone": 1907 1907 - 1908 1908 - { 1909 1909 - 1910 1910 - b, err := cr.ReadByte() 1911 1911 - if err != nil { 1912 1912 - return err 1913 1913 - } 1914 1914 - if b != cbg.CborNull[0] { 1915 1915 - if err := cr.UnreadByte(); err != nil { 1916 1916 - return err 1917 1917 - } 1918 1918 - t.Clone = new(Pipeline_CloneOpts) 1919 1919 - if err := t.Clone.UnmarshalCBOR(cr); err != nil { 1920 1920 - return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err) 1921 1921 - } 1922 1922 - } 1923 1923 - 1924 1924 - } 1925 1925 - // t.Steps ([]*tangled.Pipeline_Step) (slice) 1926 1926 - case "steps": 1927 1927 - 1928 1928 - maj, extra, err = cr.ReadHeader() 1929 1929 - if err != nil { 1930 1930 - return err 1931 1931 - } 1932 1932 - 1933 1933 - if extra > 8192 { 1934 1934 - return fmt.Errorf("t.Steps: array too large (%d)", extra) 1935 1935 - } 1936 1936 - 1937 1937 - if maj != cbg.MajArray { 1938 1938 - return fmt.Errorf("expected cbor array") 1939 1939 - } 1940 1940 - 1941 1941 - if extra > 0 { 1942 1942 - t.Steps = make([]*Pipeline_Step, extra) 1943 1943 - } 1944 1944 - 1945 1945 - for i := 0; i < int(extra); i++ { 1946 1946 - { 1947 1947 - var maj byte 1948 1948 - var extra uint64 1949 1949 - var err error 1950 1950 - _ = maj 1951 1951 - _ = extra 1952 1952 - _ = err 1953 1953 - 1954 1954 - { 1955 1955 - 1956 1956 - b, err := cr.ReadByte() 1957 1957 - if err != nil { 1958 1958 - return err 1959 1959 - } 1960 1960 - if b != cbg.CborNull[0] { 1961 1961 - if err := cr.UnreadByte(); err != nil { 1962 1962 - return err 1963 1963 - } 1964 1964 - t.Steps[i] = new(Pipeline_Step) 1965 1965 - if err := t.Steps[i].UnmarshalCBOR(cr); err != nil { 1966 1966 - return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err) 1967 1967 - } 1968 1968 - } 1969 1969 - 1970 1970 - } 1971 1971 - 1972 1972 - } 1973 1973 - } 1974 1974 - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 1975 1975 - case "environment": 1976 1976 - 1977 1977 - maj, extra, err = cr.ReadHeader() 1978 1978 - if err != nil { 1979 1979 - return err 1980 1980 - } 1981 1981 - 1982 1982 - if extra > 8192 { 1983 1983 - return fmt.Errorf("t.Environment: array too large (%d)", extra) 1984 1984 - } 1985 1985 - 1986 1986 - if maj != cbg.MajArray { 1987 1987 - return fmt.Errorf("expected cbor array") 1988 1988 - } 1989 1989 - 1990 1990 - if extra > 0 { 1991 1991 - t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) 1992 1992 - } 1993 1993 - 1994 1994 - for i := 0; i < int(extra); i++ { 1995 1995 - { 1996 1996 - var maj byte 1997 1997 - var extra uint64 1998 1998 - var err error 1999 1999 - _ = maj 2000 2000 - _ = extra 2001 2001 - _ = err 2002 2002 - 2003 2003 - { 2004 2004 - 2005 2005 - b, err := cr.ReadByte() 2006 2006 - if err != nil { 2007 2007 - return err 2008 2008 - } 2009 2009 - if b != cbg.CborNull[0] { 2010 2010 - if err := cr.UnreadByte(); err != nil { 2011 2011 - return err 2012 2012 - } 2013 2013 - t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) 2014 2014 - if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 2015 2015 - return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 2016 2016 - } 2017 2017 - } 2018 2018 - 2019 2019 - } 2020 2020 - 2021 2021 - } 2022 2022 - } 2023 2023 - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 2024 2024 - case "dependencies": 2025 2025 - 2026 2026 - maj, extra, err = cr.ReadHeader() 2027 2027 - if err != nil { 2028 2028 - return err 2029 2029 - } 2030 2030 - 2031 2031 - if extra > 8192 { 2032 2032 - return fmt.Errorf("t.Dependencies: array too large (%d)", extra) 2033 2033 - } 2034 2034 - 2035 2035 - if maj != cbg.MajArray { 2036 2036 - return fmt.Errorf("expected cbor array") 2037 2037 - } 2038 2038 - 2039 2039 - if extra > 0 { 2040 2040 - t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) 2041 2041 - } 2042 2042 - 2043 2043 - for i := 0; i < int(extra); i++ { 2044 2044 - { 2045 2045 - var maj byte 2046 2046 - var extra uint64 2047 2047 - var err error 2048 2048 - _ = maj 2049 2049 - _ = extra 2050 2050 - _ = err 2051 2051 - 2052 2052 - { 2053 2053 - 2054 2054 - if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 2055 2055 - return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) 2056 2056 - } 2057 2057 - 2058 2058 - } 2059 2059 - 2060 2060 - } 2061 2061 - } 2062 2062 - 2063 2063 - default: 2064 2064 - // Field doesn't exist on this type, so ignore it 2065 2065 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2066 2066 - return err 2067 2067 - } 2068 2068 - } 2069 2069 - } 2070 2070 - 2071 2071 - return nil 2072 2072 - } 2073 2073 - func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 2074 2074 - if t == nil { 2075 2075 - _, err := w.Write(cbg.CborNull) 2076 2076 - return err 2077 2077 - } 2078 2078 - 2079 2079 - cw := cbg.NewCborWriter(w) 2080 2080 - 2081 2081 - if _, err := cw.Write([]byte{162}); err != nil { 2082 2082 - return err 2083 2083 - } 2084 2084 - 2085 2085 - // t.Key (string) (string) 2086 2086 - if len("key") > 1000000 { 2087 2087 - return xerrors.Errorf("Value in field \"key\" was too long") 2088 2088 - } 2089 2089 - 2090 2090 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 2091 2091 - return err 2092 2092 - } 2093 2093 - if _, err := cw.WriteString(string("key")); err != nil { 2094 2094 - return err 2095 2095 - } 2096 2096 - 2097 2097 - if len(t.Key) > 1000000 { 2098 2098 - return xerrors.Errorf("Value in field t.Key was too long") 2099 2099 - } 2100 2100 - 2101 2101 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 2102 2102 - return err 2103 2103 - } 2104 2104 - if _, err := cw.WriteString(string(t.Key)); err != nil { 2105 2105 - return err 2106 2106 - } 2107 2107 - 2108 2108 - // t.Value (string) (string) 2109 2109 - if len("value") > 1000000 { 2110 2110 - return xerrors.Errorf("Value in field \"value\" was too long") 2111 2111 - } 2112 2112 - 2113 2113 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 2114 2114 - return err 2115 2115 - } 2116 2116 - if _, err := cw.WriteString(string("value")); err != nil { 2117 2117 - return err 2118 2118 - } 2119 2119 - 2120 2120 - if len(t.Value) > 1000000 { 2121 2121 - return xerrors.Errorf("Value in field t.Value was too long") 2122 2122 - } 2123 2123 - 2124 2124 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 2125 2125 - return err 2126 2126 - } 2127 2127 - if _, err := cw.WriteString(string(t.Value)); err != nil { 2128 2128 - return err 2129 2129 - } 2130 2130 - return nil 2131 2131 - } 2132 2132 - 2133 2133 - func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2134 2134 - *t = Pipeline_Workflow_Environment_Elem{} 2135 2135 - 2136 2136 - cr := cbg.NewCborReader(r) 2137 2137 - 2138 2138 - maj, extra, err := cr.ReadHeader() 2139 2139 - if err != nil { 2140 2140 - return err 2141 2141 - } 2142 2142 - defer func() { 2143 2143 - if err == io.EOF { 2144 2144 - err = io.ErrUnexpectedEOF 2145 2145 - } 2146 2146 - }() 2147 2147 - 2148 2148 - if maj != cbg.MajMap { 2149 2149 - return fmt.Errorf("cbor input should be of type map") 2150 2150 - } 2151 2151 - 2152 2152 - if extra > cbg.MaxLength { 2153 2153 - return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 2154 2154 - } 2155 2155 - 2156 2156 - n := extra 2157 2157 - 2158 2158 - nameBuf := make([]byte, 5) 2159 2159 - for i := uint64(0); i < n; i++ { 2160 2160 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2161 2161 - if err != nil { 2162 2162 - return err 2163 2163 - } 2164 2164 - 2165 2165 - if !ok { 2166 2166 - // Field doesn't exist on this type, so ignore it 2167 2167 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2168 2168 - return err 2169 2169 - } 2170 2170 - continue 2171 2171 - } 2172 2172 - 2173 2173 - switch string(nameBuf[:nameLen]) { 2174 2174 - // t.Key (string) (string) 2175 2175 - case "key": 2176 2176 - 2177 2177 - { 2178 2178 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2179 2179 - if err != nil { 2180 2180 - return err 2181 2181 - } 2182 2182 - 2183 2183 - t.Key = string(sval) 2184 2184 - } 2185 2185 - // t.Value (string) (string) 2186 2186 - case "value": 2187 2187 - 2188 2188 - { 2189 2189 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2190 2190 - if err != nil { 2191 2191 - return err 2192 2192 - } 2193 2193 - 2194 2194 - t.Value = string(sval) 2195 2195 - } 2196 2196 - 2197 2197 - default: 2198 2198 - // Field doesn't exist on this type, so ignore it 2199 2199 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2200 2200 - return err 2201 2201 - } 2202 2202 - } 2203 2203 - } 2204 2204 - 2205 2205 - return nil 2206 2206 - } 2207 2191 func (t *Pipeline_Dependencies_Elem) MarshalCBOR(w io.Writer) error { 2208 2192 if t == nil { 2209 2193 _, err := w.Write(cbg.CborNull) ··· 3620 3604 } 3621 3605 3622 3606 t.DefaultBranch = string(sval) 3607 3607 + } 3608 3608 + 3609 3609 + default: 3610 3610 + // Field doesn't exist on this type, so ignore it 3611 3611 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3612 3612 + return err 3613 3613 + } 3614 3614 + } 3615 3615 + } 3616 3616 + 3617 3617 + return nil 3618 3618 + } 3619 3619 + func (t *Pipeline_Workflow) MarshalCBOR(w io.Writer) error { 3620 3620 + if t == nil { 3621 3621 + _, err := w.Write(cbg.CborNull) 3622 3622 + return err 3623 3623 + } 3624 3624 + 3625 3625 + cw := cbg.NewCborWriter(w) 3626 3626 + 3627 3627 + if _, err := cw.Write([]byte{165}); err != nil { 3628 3628 + return err 3629 3629 + } 3630 3630 + 3631 3631 + // t.Name (string) (string) 3632 3632 + if len("name") > 1000000 { 3633 3633 + return xerrors.Errorf("Value in field \"name\" was too long") 3634 3634 + } 3635 3635 + 3636 3636 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 3637 3637 + return err 3638 3638 + } 3639 3639 + if _, err := cw.WriteString(string("name")); err != nil { 3640 3640 + return err 3641 3641 + } 3642 3642 + 3643 3643 + if len(t.Name) > 1000000 { 3644 3644 + return xerrors.Errorf("Value in field t.Name was too long") 3645 3645 + } 3646 3646 + 3647 3647 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 3648 3648 + return err 3649 3649 + } 3650 3650 + if _, err := cw.WriteString(string(t.Name)); err != nil { 3651 3651 + return err 3652 3652 + } 3653 3653 + 3654 3654 + // t.Clone (tangled.Pipeline_CloneOpts) (struct) 3655 3655 + if len("clone") > 1000000 { 3656 3656 + return xerrors.Errorf("Value in field \"clone\" was too long") 3657 3657 + } 3658 3658 + 3659 3659 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("clone"))); err != nil { 3660 3660 + return err 3661 3661 + } 3662 3662 + if _, err := cw.WriteString(string("clone")); err != nil { 3663 3663 + return err 3664 3664 + } 3665 3665 + 3666 3666 + if err := t.Clone.MarshalCBOR(cw); err != nil { 3667 3667 + return err 3668 3668 + } 3669 3669 + 3670 3670 + // t.Steps ([]*tangled.Pipeline_Step) (slice) 3671 3671 + if len("steps") > 1000000 { 3672 3672 + return xerrors.Errorf("Value in field \"steps\" was too long") 3673 3673 + } 3674 3674 + 3675 3675 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil { 3676 3676 + return err 3677 3677 + } 3678 3678 + if _, err := cw.WriteString(string("steps")); err != nil { 3679 3679 + return err 3680 3680 + } 3681 3681 + 3682 3682 + if len(t.Steps) > 8192 { 3683 3683 + return xerrors.Errorf("Slice value in field t.Steps was too long") 3684 3684 + } 3685 3685 + 3686 3686 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil { 3687 3687 + return err 3688 3688 + } 3689 3689 + for _, v := range t.Steps { 3690 3690 + if err := v.MarshalCBOR(cw); err != nil { 3691 3691 + return err 3692 3692 + } 3693 3693 + 3694 3694 + } 3695 3695 + 3696 3696 + // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 3697 3697 + if len("environment") > 1000000 { 3698 3698 + return xerrors.Errorf("Value in field \"environment\" was too long") 3699 3699 + } 3700 3700 + 3701 3701 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil { 3702 3702 + return err 3703 3703 + } 3704 3704 + if _, err := cw.WriteString(string("environment")); err != nil { 3705 3705 + return err 3706 3706 + } 3707 3707 + 3708 3708 + if len(t.Environment) > 8192 { 3709 3709 + return xerrors.Errorf("Slice value in field t.Environment was too long") 3710 3710 + } 3711 3711 + 3712 3712 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil { 3713 3713 + return err 3714 3714 + } 3715 3715 + for _, v := range t.Environment { 3716 3716 + if err := v.MarshalCBOR(cw); err != nil { 3717 3717 + return err 3718 3718 + } 3719 3719 + 3720 3720 + } 3721 3721 + 3722 3722 + // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 3723 3723 + if len("dependencies") > 1000000 { 3724 3724 + return xerrors.Errorf("Value in field \"dependencies\" was too long") 3725 3725 + } 3726 3726 + 3727 3727 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil { 3728 3728 + return err 3729 3729 + } 3730 3730 + if _, err := cw.WriteString(string("dependencies")); err != nil { 3731 3731 + return err 3732 3732 + } 3733 3733 + 3734 3734 + if len(t.Dependencies) > 8192 { 3735 3735 + return xerrors.Errorf("Slice value in field t.Dependencies was too long") 3736 3736 + } 3737 3737 + 3738 3738 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil { 3739 3739 + return err 3740 3740 + } 3741 3741 + for _, v := range t.Dependencies { 3742 3742 + if err := v.MarshalCBOR(cw); err != nil { 3743 3743 + return err 3744 3744 + } 3745 3745 + 3746 3746 + } 3747 3747 + return nil 3748 3748 + } 3749 3749 + 3750 3750 + func (t *Pipeline_Workflow) UnmarshalCBOR(r io.Reader) (err error) { 3751 3751 + *t = Pipeline_Workflow{} 3752 3752 + 3753 3753 + cr := cbg.NewCborReader(r) 3754 3754 + 3755 3755 + maj, extra, err := cr.ReadHeader() 3756 3756 + if err != nil { 3757 3757 + return err 3758 3758 + } 3759 3759 + defer func() { 3760 3760 + if err == io.EOF { 3761 3761 + err = io.ErrUnexpectedEOF 3762 3762 + } 3763 3763 + }() 3764 3764 + 3765 3765 + if maj != cbg.MajMap { 3766 3766 + return fmt.Errorf("cbor input should be of type map") 3767 3767 + } 3768 3768 + 3769 3769 + if extra > cbg.MaxLength { 3770 3770 + return fmt.Errorf("Pipeline_Workflow: map struct too large (%d)", extra) 3771 3771 + } 3772 3772 + 3773 3773 + n := extra 3774 3774 + 3775 3775 + nameBuf := make([]byte, 12) 3776 3776 + for i := uint64(0); i < n; i++ { 3777 3777 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3778 3778 + if err != nil { 3779 3779 + return err 3780 3780 + } 3781 3781 + 3782 3782 + if !ok { 3783 3783 + // Field doesn't exist on this type, so ignore it 3784 3784 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3785 3785 + return err 3786 3786 + } 3787 3787 + continue 3788 3788 + } 3789 3789 + 3790 3790 + switch string(nameBuf[:nameLen]) { 3791 3791 + // t.Name (string) (string) 3792 3792 + case "name": 3793 3793 + 3794 3794 + { 3795 3795 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3796 3796 + if err != nil { 3797 3797 + return err 3798 3798 + } 3799 3799 + 3800 3800 + t.Name = string(sval) 3801 3801 + } 3802 3802 + // t.Clone (tangled.Pipeline_CloneOpts) (struct) 3803 3803 + case "clone": 3804 3804 + 3805 3805 + { 3806 3806 + 3807 3807 + b, err := cr.ReadByte() 3808 3808 + if err != nil { 3809 3809 + return err 3810 3810 + } 3811 3811 + if b != cbg.CborNull[0] { 3812 3812 + if err := cr.UnreadByte(); err != nil { 3813 3813 + return err 3814 3814 + } 3815 3815 + t.Clone = new(Pipeline_CloneOpts) 3816 3816 + if err := t.Clone.UnmarshalCBOR(cr); err != nil { 3817 3817 + return xerrors.Errorf("unmarshaling t.Clone pointer: %w", err) 3818 3818 + } 3819 3819 + } 3820 3820 + 3821 3821 + } 3822 3822 + // t.Steps ([]*tangled.Pipeline_Step) (slice) 3823 3823 + case "steps": 3824 3824 + 3825 3825 + maj, extra, err = cr.ReadHeader() 3826 3826 + if err != nil { 3827 3827 + return err 3828 3828 + } 3829 3829 + 3830 3830 + if extra > 8192 { 3831 3831 + return fmt.Errorf("t.Steps: array too large (%d)", extra) 3832 3832 + } 3833 3833 + 3834 3834 + if maj != cbg.MajArray { 3835 3835 + return fmt.Errorf("expected cbor array") 3836 3836 + } 3837 3837 + 3838 3838 + if extra > 0 { 3839 3839 + t.Steps = make([]*Pipeline_Step, extra) 3840 3840 + } 3841 3841 + 3842 3842 + for i := 0; i < int(extra); i++ { 3843 3843 + { 3844 3844 + var maj byte 3845 3845 + var extra uint64 3846 3846 + var err error 3847 3847 + _ = maj 3848 3848 + _ = extra 3849 3849 + _ = err 3850 3850 + 3851 3851 + { 3852 3852 + 3853 3853 + b, err := cr.ReadByte() 3854 3854 + if err != nil { 3855 3855 + return err 3856 3856 + } 3857 3857 + if b != cbg.CborNull[0] { 3858 3858 + if err := cr.UnreadByte(); err != nil { 3859 3859 + return err 3860 3860 + } 3861 3861 + t.Steps[i] = new(Pipeline_Step) 3862 3862 + if err := t.Steps[i].UnmarshalCBOR(cr); err != nil { 3863 3863 + return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err) 3864 3864 + } 3865 3865 + } 3866 3866 + 3867 3867 + } 3868 3868 + 3869 3869 + } 3870 3870 + } 3871 3871 + // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 3872 3872 + case "environment": 3873 3873 + 3874 3874 + maj, extra, err = cr.ReadHeader() 3875 3875 + if err != nil { 3876 3876 + return err 3877 3877 + } 3878 3878 + 3879 3879 + if extra > 8192 { 3880 3880 + return fmt.Errorf("t.Environment: array too large (%d)", extra) 3881 3881 + } 3882 3882 + 3883 3883 + if maj != cbg.MajArray { 3884 3884 + return fmt.Errorf("expected cbor array") 3885 3885 + } 3886 3886 + 3887 3887 + if extra > 0 { 3888 3888 + t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) 3889 3889 + } 3890 3890 + 3891 3891 + for i := 0; i < int(extra); i++ { 3892 3892 + { 3893 3893 + var maj byte 3894 3894 + var extra uint64 3895 3895 + var err error 3896 3896 + _ = maj 3897 3897 + _ = extra 3898 3898 + _ = err 3899 3899 + 3900 3900 + { 3901 3901 + 3902 3902 + b, err := cr.ReadByte() 3903 3903 + if err != nil { 3904 3904 + return err 3905 3905 + } 3906 3906 + if b != cbg.CborNull[0] { 3907 3907 + if err := cr.UnreadByte(); err != nil { 3908 3908 + return err 3909 3909 + } 3910 3910 + t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) 3911 3911 + if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 3912 3912 + return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 3913 3913 + } 3914 3914 + } 3915 3915 + 3916 3916 + } 3917 3917 + 3918 3918 + } 3919 3919 + } 3920 3920 + // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 3921 3921 + case "dependencies": 3922 3922 + 3923 3923 + maj, extra, err = cr.ReadHeader() 3924 3924 + if err != nil { 3925 3925 + return err 3926 3926 + } 3927 3927 + 3928 3928 + if extra > 8192 { 3929 3929 + return fmt.Errorf("t.Dependencies: array too large (%d)", extra) 3930 3930 + } 3931 3931 + 3932 3932 + if maj != cbg.MajArray { 3933 3933 + return fmt.Errorf("expected cbor array") 3934 3934 + } 3935 3935 + 3936 3936 + if extra > 0 { 3937 3937 + t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) 3938 3938 + } 3939 3939 + 3940 3940 + for i := 0; i < int(extra); i++ { 3941 3941 + { 3942 3942 + var maj byte 3943 3943 + var extra uint64 3944 3944 + var err error 3945 3945 + _ = maj 3946 3946 + _ = extra 3947 3947 + _ = err 3948 3948 + 3949 3949 + { 3950 3950 + 3951 3951 + if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 3952 3952 + return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) 3953 3953 + } 3954 3954 + 3955 3955 + } 3956 3956 + 3957 3957 + } 3958 3958 + } 3959 3959 + 3960 3960 + default: 3961 3961 + // Field doesn't exist on this type, so ignore it 3962 3962 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3963 3963 + return err 3964 3964 + } 3965 3965 + } 3966 3966 + } 3967 3967 + 3968 3968 + return nil 3969 3969 + } 3970 3970 + func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 3971 3971 + if t == nil { 3972 3972 + _, err := w.Write(cbg.CborNull) 3973 3973 + return err 3974 3974 + } 3975 3975 + 3976 3976 + cw := cbg.NewCborWriter(w) 3977 3977 + 3978 3978 + if _, err := cw.Write([]byte{162}); err != nil { 3979 3979 + return err 3980 3980 + } 3981 3981 + 3982 3982 + // t.Key (string) (string) 3983 3983 + if len("key") > 1000000 { 3984 3984 + return xerrors.Errorf("Value in field \"key\" was too long") 3985 3985 + } 3986 3986 + 3987 3987 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 3988 3988 + return err 3989 3989 + } 3990 3990 + if _, err := cw.WriteString(string("key")); err != nil { 3991 3991 + return err 3992 3992 + } 3993 3993 + 3994 3994 + if len(t.Key) > 1000000 { 3995 3995 + return xerrors.Errorf("Value in field t.Key was too long") 3996 3996 + } 3997 3997 + 3998 3998 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 3999 3999 + return err 4000 4000 + } 4001 4001 + if _, err := cw.WriteString(string(t.Key)); err != nil { 4002 4002 + return err 4003 4003 + } 4004 4004 + 4005 4005 + // t.Value (string) (string) 4006 4006 + if len("value") > 1000000 { 4007 4007 + return xerrors.Errorf("Value in field \"value\" was too long") 4008 4008 + } 4009 4009 + 4010 4010 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 4011 4011 + return err 4012 4012 + } 4013 4013 + if _, err := cw.WriteString(string("value")); err != nil { 4014 4014 + return err 4015 4015 + } 4016 4016 + 4017 4017 + if len(t.Value) > 1000000 { 4018 4018 + return xerrors.Errorf("Value in field t.Value was too long") 4019 4019 + } 4020 4020 + 4021 4021 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 4022 4022 + return err 4023 4023 + } 4024 4024 + if _, err := cw.WriteString(string(t.Value)); err != nil { 4025 4025 + return err 4026 4026 + } 4027 4027 + return nil 4028 4028 + } 4029 4029 + 4030 4030 + func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 4031 4031 + *t = Pipeline_Workflow_Environment_Elem{} 4032 4032 + 4033 4033 + cr := cbg.NewCborReader(r) 4034 4034 + 4035 4035 + maj, extra, err := cr.ReadHeader() 4036 4036 + if err != nil { 4037 4037 + return err 4038 4038 + } 4039 4039 + defer func() { 4040 4040 + if err == io.EOF { 4041 4041 + err = io.ErrUnexpectedEOF 4042 4042 + } 4043 4043 + }() 4044 4044 + 4045 4045 + if maj != cbg.MajMap { 4046 4046 + return fmt.Errorf("cbor input should be of type map") 4047 4047 + } 4048 4048 + 4049 4049 + if extra > cbg.MaxLength { 4050 4050 + return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 4051 4051 + } 4052 4052 + 4053 4053 + n := extra 4054 4054 + 4055 4055 + nameBuf := make([]byte, 5) 4056 4056 + for i := uint64(0); i < n; i++ { 4057 4057 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4058 4058 + if err != nil { 4059 4059 + return err 4060 4060 + } 4061 4061 + 4062 4062 + if !ok { 4063 4063 + // Field doesn't exist on this type, so ignore it 4064 4064 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4065 4065 + return err 4066 4066 + } 4067 4067 + continue 4068 4068 + } 4069 4069 + 4070 4070 + switch string(nameBuf[:nameLen]) { 4071 4071 + // t.Key (string) (string) 4072 4072 + case "key": 4073 4073 + 4074 4074 + { 4075 4075 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4076 4076 + if err != nil { 4077 4077 + return err 4078 4078 + } 4079 4079 + 4080 4080 + t.Key = string(sval) 4081 4081 + } 4082 4082 + // t.Value (string) (string) 4083 4083 + case "value": 4084 4084 + 4085 4085 + { 4086 4086 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 4087 4087 + if err != nil { 4088 4088 + return err 4089 4089 + } 4090 4090 + 4091 4091 + t.Value = string(sval) 3623 4092 } 3624 4093 3625 4094 default:

+22 -7

api/tangled/gitrefUpdate.go

··· 4 4 5 5 // schema: sh.tangled.git.refUpdate 6 6 7 7 - //import ( 8 8 - // "github.com/bluesky-social/indigo/lex/util" 9 9 - //) 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 11 11 const ( 12 12 GitRefUpdateNSID = "sh.tangled.git.refUpdate" 13 13 ) 14 14 15 15 - //func init() { 16 16 - // util.RegisterType("sh.tangled.git.refUpdate", &GitRefUpdate{}) 17 17 - //} // 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.git.refUpdate", &GitRefUpdate{}) 17 17 + } // 18 18 // RECORDTYPE: GitRefUpdate 19 19 type GitRefUpdate struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.git.refUpdate" cborgen:"$type,const=sh.tangled.git.refUpdate"` 21 21 // committerDid: did of the user that pushed this ref 22 22 - CommitterDid string `json:"committerDid" cborgen:"committerDid"` 22 22 + CommitterDid string `json:"committerDid" cborgen:"committerDid"` 23 23 + Meta *GitRefUpdate_Meta `json:"meta" cborgen:"meta"` 23 24 // newSha: new SHA of this ref 24 25 NewSha string `json:"newSha" cborgen:"newSha"` 25 26 // oldSha: old SHA of this ref ··· 31 32 // repoName: name of the repo 32 33 RepoName string `json:"repoName" cborgen:"repoName"` 33 34 } 35 35 + 36 36 + type GitRefUpdate_Meta struct { 37 37 + CommitCount *GitRefUpdate_Meta_CommitCount `json:"commitCount" cborgen:"commitCount"` 38 38 + IsDefaultRef bool `json:"isDefaultRef" cborgen:"isDefaultRef"` 39 39 + } 40 40 + 41 41 + type GitRefUpdate_Meta_CommitCount struct { 42 42 + ByEmail []*GitRefUpdate_Meta_CommitCount_ByEmail_Elem `json:"byEmail,omitempty" cborgen:"byEmail,omitempty"` 43 43 + } 44 44 + 45 45 + type GitRefUpdate_Meta_CommitCount_ByEmail_Elem struct { 46 46 + Count int64 `json:"count" cborgen:"count"` 47 47 + Email string `json:"email" cborgen:"email"` 48 48 + }

+6 -6

api/tangled/tangledpipeline.go

··· 4 4 5 5 // schema: sh.tangled.pipeline 6 6 7 7 - //import ( 8 8 - // "github.com/bluesky-social/indigo/lex/util" 9 9 - //) 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 11 11 const ( 12 12 PipelineNSID = "sh.tangled.pipeline" 13 13 ) 14 14 15 15 - //func init() { 16 16 - // util.RegisterType("sh.tangled.pipeline", &Pipeline{}) 17 17 - //} // 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.pipeline", &Pipeline{}) 17 17 + } // 18 18 // RECORDTYPE: Pipeline 19 19 type Pipeline struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.pipeline" cborgen:"$type,const=sh.tangled.pipeline"`

+5 -2

cmd/gen.go

··· 17 17 tangled.ActorProfile{}, 18 18 tangled.FeedStar{}, 19 19 tangled.GitRefUpdate{}, 20 20 + tangled.GitRefUpdate_Meta{}, 21 21 + tangled.GitRefUpdate_Meta_CommitCount{}, 22 22 + tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}, 20 23 tangled.GraphFollow{}, 21 24 tangled.KnotMember{}, 22 25 tangled.Pipeline{}, 23 26 tangled.Pipeline_CloneOpts{}, 24 24 - tangled.Pipeline_Workflow{}, 25 25 - tangled.Pipeline_Workflow_Environment_Elem{}, 26 27 tangled.Pipeline_Dependencies_Elem{}, 27 28 tangled.Pipeline_ManualTriggerData{}, 28 29 tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, ··· 31 32 tangled.Pipeline_Step{}, 32 33 tangled.Pipeline_TriggerMetadata{}, 33 34 tangled.Pipeline_TriggerRepo{}, 35 35 + tangled.Pipeline_Workflow{}, 36 36 + tangled.Pipeline_Workflow_Environment_Elem{}, 34 37 tangled.PublicKey{}, 35 38 tangled.Repo{}, 36 39 tangled.RepoArtifact{},

+99 -5

knotserver/git/post_receive.go

··· 2 2 3 3 import ( 4 4 "bufio" 5 5 + "fmt" 5 6 "io" 6 7 "strings" 8 8 + 9 9 + "tangled.sh/tangled.sh/core/api/tangled" 10 10 + 11 11 + "github.com/go-git/go-git/v5/plumbing" 7 12 ) 8 13 9 14 type PostReceiveLine struct { 10 10 - OldSha string // old sha of reference being updated 11 11 - NewSha string // new sha of reference being updated 12 12 - Ref string // the reference being updated 15 15 + OldSha plumbing.Hash // old sha of reference being updated 16 16 + NewSha plumbing.Hash // new sha of reference being updated 17 17 + Ref string // the reference being updated 13 18 } 14 19 15 20 func ParsePostReceive(buf io.Reader) ([]PostReceiveLine, error) { ··· 27 32 ref := parts[2] 28 33 29 34 lines = append(lines, PostReceiveLine{ 30 30 - OldSha: oldSha, 31 31 - NewSha: newSha, 35 35 + OldSha: plumbing.NewHash(oldSha), 36 36 + NewSha: plumbing.NewHash(newSha), 32 37 Ref: ref, 33 38 }) 34 39 } ··· 39 44 40 45 return lines, nil 41 46 } 47 47 + 48 48 + type RefUpdateMeta struct { 49 49 + CommitCount CommitCount 50 50 + IsDefaultRef bool 51 51 + } 52 52 + 53 53 + type CommitCount struct { 54 54 + ByEmail map[string]int 55 55 + } 56 56 + 57 57 + func (g *GitRepo) RefUpdateMeta(line PostReceiveLine) RefUpdateMeta { 58 58 + commitCount, err := g.newCommitCount(line) 59 59 + if err != nil { 60 60 + // TODO: non-fatal, log this 61 61 + } 62 62 + 63 63 + isDefaultRef, err := g.isDefaultBranch(line) 64 64 + if err != nil { 65 65 + // TODO: non-fatal, log this 66 66 + } 67 67 + 68 68 + return RefUpdateMeta{ 69 69 + CommitCount: commitCount, 70 70 + IsDefaultRef: isDefaultRef, 71 71 + } 72 72 + } 73 73 + 74 74 + func (g *GitRepo) newCommitCount(line PostReceiveLine) (CommitCount, error) { 75 75 + byEmail := make(map[string]int) 76 76 + commitCount := CommitCount{ 77 77 + ByEmail: byEmail, 78 78 + } 79 79 + 80 80 + if !line.NewSha.IsZero() { 81 81 + output, err := g.revList( 82 82 + fmt.Sprintf("--max-count=%d", 100), 83 83 + fmt.Sprintf("%s..%s", line.OldSha.String(), line.NewSha.String()), 84 84 + ) 85 85 + if err != nil { 86 86 + return commitCount, fmt.Errorf("failed to run rev-list: %w", err) 87 87 + } 88 88 + 89 89 + lines := strings.Split(strings.TrimSpace(string(output)), "\n") 90 90 + if len(lines) == 1 && lines[0] == "" { 91 91 + return commitCount, nil 92 92 + } 93 93 + 94 94 + for _, item := range lines { 95 95 + obj, err := g.r.CommitObject(plumbing.NewHash(item)) 96 96 + if err != nil { 97 97 + continue 98 98 + } 99 99 + commitCount.ByEmail[obj.Author.Email] += 1 100 100 + } 101 101 + } 102 102 + 103 103 + return commitCount, nil 104 104 + } 105 105 + 106 106 + func (g *GitRepo) isDefaultBranch(line PostReceiveLine) (bool, error) { 107 107 + defaultBranch, err := g.FindMainBranch() 108 108 + if err != nil { 109 109 + return false, err 110 110 + } 111 111 + 112 112 + refName := plumbing.ReferenceName(line.Ref) 113 113 + if refName.IsBranch() { 114 114 + return defaultBranch == refName.Short(), nil 115 115 + } 116 116 + 117 117 + return false, err 118 118 + } 119 119 + 120 120 + func (m RefUpdateMeta) AsRecord() tangled.GitRefUpdate_Meta { 121 121 + var byEmail []*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem 122 122 + for e, v := range m.CommitCount.ByEmail { 123 123 + byEmail = append(byEmail, &tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{ 124 124 + Email: e, 125 125 + Count: int64(v), 126 126 + }) 127 127 + } 128 128 + 129 129 + return tangled.GitRefUpdate_Meta{ 130 130 + CommitCount: &tangled.GitRefUpdate_Meta_CommitCount{ 131 131 + ByEmail: byEmail, 132 132 + }, 133 133 + IsDefaultRef: m.IsDefaultRef, 134 134 + } 135 135 + }

+23 -4

knotserver/internal.go

··· 105 105 } 106 106 107 107 func (h *InternalHandle) insertRefUpdate(line git.PostReceiveLine, gitUserDid, repoDid, repoName string) error { 108 108 + didSlashRepo, err := securejoin.SecureJoin(repoDid, repoName) 109 109 + if err != nil { 110 110 + return err 111 111 + } 112 112 + 113 113 + repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, didSlashRepo) 114 114 + if err != nil { 115 115 + return err 116 116 + } 117 117 + 118 118 + gr, err := git.PlainOpen(repoPath) 119 119 + if err != nil { 120 120 + return err 121 121 + } 122 122 + 123 123 + meta := gr.RefUpdateMeta(line) 124 124 + metaRecord := meta.AsRecord() 125 125 + 108 126 refUpdate := tangled.GitRefUpdate{ 109 109 - OldSha: line.OldSha, 110 110 - NewSha: line.NewSha, 127 127 + OldSha: line.OldSha.String(), 128 128 + NewSha: line.NewSha.String(), 111 129 Ref: line.Ref, 112 130 CommitterDid: gitUserDid, 113 131 RepoDid: repoDid, 114 132 RepoName: repoName, 133 133 + Meta: &metaRecord, 115 134 } 116 135 eventJson, err := json.Marshal(refUpdate) 117 136 if err != nil { ··· 175 194 176 195 trigger := tangled.Pipeline_PushTriggerData{ 177 196 Ref: line.Ref, 178 178 - OldSha: line.OldSha, 179 179 - NewSha: line.NewSha, 197 197 + OldSha: line.OldSha.String(), 198 198 + NewSha: line.NewSha.String(), 180 199 } 181 200 182 201 compiler := workflow.Compiler{

+39 -1

lexicons/git/refUpdate.json

··· 14 14 "repoDid", 15 15 "repoName", 16 16 "oldSha", 17 17 - "newSha" 17 17 + "newSha", 18 18 + "meta" 18 19 ], 19 20 "properties": { 20 21 "ref": { ··· 48 49 "description": "new SHA of this ref", 49 50 "minLength": 40, 50 51 "maxLength": 40 52 52 + }, 53 53 + "meta": { 54 54 + "type": "object", 55 55 + "required": [ 56 56 + "isDefaultRef", 57 57 + "commitCount" 58 58 + ], 59 59 + "properties": { 60 60 + "isDefaultRef": { 61 61 + "type": "boolean", 62 62 + "default": "false" 63 63 + }, 64 64 + "commitCount": { 65 65 + "type": "object", 66 66 + "required": [], 67 67 + "properties": { 68 68 + "byEmail": { 69 69 + "type": "array", 70 70 + "items": { 71 71 + "type": "object", 72 72 + "required": [ 73 73 + "email", 74 74 + "count" 75 75 + ], 76 76 + "properties": { 77 77 + "email": { 78 78 + "type": "string" 79 79 + }, 80 80 + "count": { 81 81 + "type": "integer" 82 82 + } 83 83 + } 84 84 + } 85 85 + } 86 86 + } 87 87 + } 88 88 + } 51 89 } 52 90 } 53 91 }