1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
package main
import (
"fmt"
"os"
"path/filepath"
"github.com/google/uuid"
"go.wit.com/lib/protobuf/forgepb"
"go.wit.com/log"
"google.golang.org/protobuf/proto"
)
func doMerge() error {
if err := loadConfigfile(); err != nil {
if argv.Force == true {
me.all = forgepb.NewPatchsets()
} else {
return err
}
}
mergePatchsets()
if err := savePatchsets(); err != nil {
log.Warn("savePatchsets() failed", err)
return err
}
return nil
}
func findAutoPatchset() *forgepb.Patchset {
for pset := range me.all.IterAll() {
if pset.Name == "forge auto commit" {
return pset
break
}
}
var fauto *forgepb.Patchset
log.Warn("findAutoPatchset() had to create 'forge auto commit'")
if fauto == nil {
fauto = new(forgepb.Patchset)
fauto.Name = "forge auto commit"
fauto.Patches = forgepb.NewPatches()
fauto.Uuid = uuid.New().String()
me.all.Patchsets = append(me.all.Patchsets, fauto)
}
return fauto
}
// adds submitted patches not specifically assigned to a patchset
// to the generic patchset called "forge auto commit"
func addRandomPatch(patch *forgepb.Patch) error {
// ignore patch if it's already here
if findPatch(patch) {
log.Info("already found patch", patch.CommitHash, patch.Namespace)
return nil
}
fauto := findAutoPatchset()
if fauto == nil {
return log.Errorf("no default place yet")
}
newpb := proto.Clone(patch).(*forgepb.Patch)
if newpb == nil {
return log.Errorf("proto.Clone returned nil")
}
fauto.Patches.Patches = append(fauto.Patches.Patches, newpb)
return nil
}
func addPatchset(filename string, pb *forgepb.Patchset) {
if pb.Name == "forge auto commit" {
author := "Author: " + pb.GitAuthorName
author += " <" + pb.GitAuthorEmail + ">"
// author := "Author: " + os.Getenv("GIT_AUTHOR_NAME")
// author += " <" + os.Getenv("GIT_AUTHOR_EMAIL") + ">"
fmt.Println(filename, pb.Name, pb.Comment, author)
for _, patch := range pb.Patches.Patches {
// log.Info("\tnew patch:", i, patch.CommitHash, patch.Namespace)
if findPatch(patch) {
// log.Info("\talready found!!!!!!!", pset.Uuid, patch.Namespace)
} else {
log.Info("\tnew patch:", filename, pb.Name, pb.Comment, author)
addRandomPatch(patch)
}
}
// add each of the patches to the general pool
} else {
// Clone() this protobuf into me.all
var newpb *forgepb.Patchset
newpb = proto.Clone(pb).(*forgepb.Patchset)
if newpb != nil {
me.all.Patchsets = append(me.all.Patchsets, newpb)
}
}
}
func mergePatchsets() {
dirname := filepath.Join(LIBDIR, "patchset/")
// Open the directory
entries, err := os.ReadDir(dirname)
if err != nil {
fmt.Printf("Error reading directory: %v\n", err)
return
}
// Iterate through the directory entries
for _, entry := range entries {
// Check if the entry is a file and matches the *.pb pattern
if !entry.IsDir() && filepath.Ext(entry.Name()) == ".pb" {
bytes, err := os.ReadFile(filepath.Join(dirname, entry.Name()))
if err != nil {
fmt.Println(entry.Name(), err)
continue
}
var p *forgepb.Patchset
p = new(forgepb.Patchset)
err = p.Unmarshal(bytes)
if err != nil {
fmt.Println(entry.Name(), err)
continue
}
addPatchset(entry.Name(), p)
}
}
}
|
