GitRoot
craft your forge, build your project, grow your community freely
1// SPDX-FileCopyrightText: 2025 Romain Maneschi <romain@gitroot.dev>
2//
3// SPDX-License-Identifier: EUPL-1.2
4
5package plugin
6
7import (
8 "context"
9 "encoding/json"
10 "fmt"
11 "io/fs"
12 "slices"
13 "time"
14
15 "github.com/go-git/go-git/v5/plumbing"
16 "github.com/go-git/go-git/v5/plumbing/protocol/packp"
17 "github.com/samber/oops"
18 "github.com/tetratelabs/wazero/api"
19 pluginLib "gitroot.dev/libs/golang/plugin/model"
20 grfs "gitroot.dev/server/fs"
21 "gitroot.dev/server/logger"
22 "gitroot.dev/server/repository"
23 "gitroot.dev/server/user"
24)
25
26type callPlugin struct {
27 manager *Manager
28 plugin Plugin
29 repo *repository.GitRootRepository
30 repoWriter *repository.GitRootRepositoryWrite
31 module api.Module
32 logger *logger.Logger
33}
34
35func (r *runtime) start(ctx context.Context, repo *repository.GitRootRepository, repoWriter *repository.GitRootRepositoryWrite, plugins []Plugin, commands []CommandForDiff, mergeHook func(cmd *packp.Command, pusher user.SimpleUser, toDeleteBranchName string)) error {
36 r.repo = repo
37 r.repoWriter = repoWriter
38 r.command = nil
39 r.commit = nil
40
41 r.commitHook = func(hash plumbing.Hash) {
42 command, err := repoWriter.GetLastCommit(hash)
43 if err != nil {
44 r.logger.Error("can't GetLastCommit in start runtime", err)
45 return
46 }
47 newCmd, err := CommandForDiffFromCommitCmd(ctx, r.plugin.commiter.SimpleUser, command, r.command.branch)
48 if err != nil {
49 r.logger.Error("can't CommandForDiffFromCommitCmd in start runtime", err)
50 return
51 }
52 commands = append(commands, newCmd)
53 }
54
55 r.mergeHook = mergeHook
56 defer func() {
57 r.commitHook = nil
58 r.mergeHook = nil
59 }()
60
61 fs := grfs.NewMultiple(ctx, map[string]fs.FS{
62 "worktree": r.repoWriter.ToFs(ctx),
63 "webcontent": r.manager.conf.DataWeb(r.repo.Name()),
64 })
65
66 for _, plugin := range plugins {
67 fs.UpdateSubFs("cache", r.manager.conf.Cache(r.repo.Name(), plugin.Name))
68 r.plugin = plugin
69 timerStop := r.logger.Time(fmt.Sprintf("Timer %s", plugin.Name))
70 r.logger.Debug("start plugin", logger.NewLoggerPair("repo", repo.Name()), logger.NewLoggerPair("name", plugin.Name))
71 m, err := r.loadModule(ctx, plugin, fs)
72 if err != nil {
73 r.logger.Error("loadModule for start error", err, logger.NewLoggerPair("name", plugin.Name))
74 continue
75 }
76 l := logger.NewLogger(logger.WASM)
77 l.Debug("memory before", logger.NewLoggerPair("size", m.Memory().Size()), logger.NewLoggerPair("plugin", plugin.Name))
78 cp := callPlugin{
79 manager: r.manager,
80 plugin: plugin,
81 repo: repo,
82 repoWriter: repoWriter,
83 module: m,
84 logger: r.logger.NewSubLogger(plugin.Name),
85 }
86 if err := cp.callPluginForDiff(ctx, r, commands); err != nil {
87 r.logger.Error("finish plugin with error", err, logger.NewLoggerPair("name", plugin.Name))
88 }
89 l.Debug("memory after", logger.NewLoggerPair("size", m.Memory().Size()), logger.NewLoggerPair("plugin", plugin.Name))
90 r.logger.Debug("finish plugin", logger.NewLoggerPair("name", plugin.Name))
91 timerStop()
92 }
93 return nil
94}
95
96func (c callPlugin) callPluginForDiff(ctx context.Context, r *runtime, commands []CommandForDiff) error {
97 startCommit := c.module.ExportedFunction("startCommit")
98 addFile := c.module.ExportedFunction("addFile")
99 modFile := c.module.ExportedFunction("modFile")
100 delFile := c.module.ExportedFunction("delFile")
101 endCommit := c.module.ExportedFunction("endCommit")
102 malloc := c.module.ExportedFunction("gitrootAlloc")
103 if malloc == nil {
104 malloc = c.module.ExportedFunction("malloc")
105 }
106
107 currentBranch, err := c.repo.CurrentBranch()
108 if err != nil {
109 return oops.Wrapf(err, "can't get CurrentBranch")
110 }
111
112 for _, cmd := range commands {
113 r.command = &cmd
114 for _, pluginRun := range r.plugin.Run {
115 r.pluginRun = pluginRun
116 callOnAdd := addFile != nil && slices.Contains(pluginRun.When, pluginLib.PluginRunWhenAdd)
117 callOnMod := modFile != nil && slices.Contains(pluginRun.When, pluginLib.PluginRunWhenMod)
118 callOnDel := delFile != nil && slices.Contains(pluginRun.When, pluginLib.PluginRunWhenDel)
119 isAuthorized := checkBranch(pluginRun, cmd.branch)
120 if !isAuthorized {
121 continue
122 }
123
124 if cmd.branchAction == commitForDiffActionDel {
125 c.logger.Info("delete branch", logger.NewLoggerPair("branch", cmd.branch))
126 continue
127 }
128
129 if err := c.repoWriter.Checkout(cmd.branch); err != nil {
130 c.logger.Error("can't Checkout from cmd", err, logger.NewLoggerPair("branch", cmd.branch))
131 continue
132 }
133
134 atLeastOneFile := slices.ContainsFunc(cmd.commits, func(com commitForDiffCommit) bool {
135 return slices.ContainsFunc(com.files, func(f pluginLib.File) bool {
136 return pluginRun.glob.Match(f.Path)
137 })
138 })
139 if !atLeastOneFile {
140 c.logger.Info("no file match, skip execution", logger.NewLoggerPair("plugin", r.plugin.Name))
141 continue
142 }
143
144 if init := c.module.ExportedFunction("init"); init != nil {
145 arg, err := pluginRun.Marshal()
146 if err != nil {
147 c.logger.Error("can't Marshal pluginRun", err, logger.NewLoggerPair("branch", cmd.branch))
148 continue
149 }
150 c.logger.Debug("init plugin", logger.NewLoggerPair("name", c.plugin.Name), logger.NewLoggerPair("arg", arg))
151 if err := r.writeMemoryAndCall(c.module, init, malloc, c.repo.Name(), "false", string(arg)); err != nil {
152 c.logger.Error("can't init plugin", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
153 continue
154 }
155 } else {
156 c.logger.Info("no init fn to call", logger.NewLoggerPair("plugin", r.plugin.Name))
157 }
158
159 for _, com := range cmd.commits {
160 r.commit = &com
161 comMarshalled, err := MarshallOne(cmd.branch.Short(), com)
162 if err != nil {
163 c.logger.Error("can't marshall commit", err, logger.NewLoggerPair("branch", cmd.branch))
164 continue
165 }
166 c.logger.Debug("diff start commit", logger.NewLoggerPair("com", comMarshalled))
167 if startCommit != nil {
168 c.logger.Debug("startCommit", logger.NewLoggerPair("branch", cmd.branch.Short()), logger.NewLoggerPair("hash", com.hash.String()), logger.NewLoggerPair("message", com.message), logger.NewLoggerPair("date", com.date.Format(time.RFC3339)))
169 if err := r.writeMemoryAndCall(c.module, startCommit, malloc, comMarshalled); err != nil {
170 c.logger.Error("startCommit error", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
171 continue
172 }
173 }
174
175 for _, f := range com.files {
176 c.logger.Debug("diff start commit file", logger.NewLoggerPair("file", f.Path), logger.NewLoggerPair("action", f.Action))
177 if pluginRun.glob.Match(f.Path) {
178 jsonFile, err := json.Marshal(f)
179 if err != nil {
180 c.logger.Error("can marshal file", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
181 continue
182 }
183 if f.Action == pluginLib.FileActionTypeAdd && callOnAdd {
184 c.logger.Debug("add", logger.NewLoggerPair("confPath", pluginRun.Path), logger.NewLoggerPair("currentPath", f.Path))
185 // creation
186 r.writeMemoryAndCall(c.module, addFile, malloc, string(jsonFile))
187 } else {
188 if f.Action == pluginLib.FileActionTypeDel && callOnDel {
189 // deletion
190 r.writeMemoryAndCall(c.module, delFile, malloc, string(jsonFile))
191 } else if f.Action == pluginLib.FileActionTypeMod && callOnMod {
192 //modification
193 r.writeMemoryAndCall(c.module, modFile, malloc, string(jsonFile))
194 }
195 }
196 }
197 }
198
199 if endCommit != nil {
200 if err := r.writeMemoryAndCall(c.module, endCommit, malloc, comMarshalled); err != nil {
201 c.logger.Error("endCommit error", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
202 continue
203 }
204 } else {
205 c.logger.Info("no endCommit fn to call", logger.NewLoggerPair("plugin", r.plugin.Name))
206 }
207 }
208
209 if finish := c.module.ExportedFunction("finish"); finish != nil {
210 if _, err := finish.Call(ctx); err != nil {
211 c.logger.Error("finish error", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
212 continue
213 }
214 } else {
215 c.logger.Info("no finish fn to call", logger.NewLoggerPair("plugin", r.plugin.Name))
216 }
217 }
218 }
219
220 if err := c.repoWriter.Checkout(currentBranch); err != nil {
221 c.logger.Error("can't Checkout currentBranch", err, logger.NewLoggerPair("branch", currentBranch.Short()))
222 return err
223 }
224 return nil
225}
226
227func (r *runtime) writeMemoryAndCall(module api.Module, toCall api.Function, malloc api.Function, message ...string) error {
228 _, err := r.writeMemoryAndCallWithRes(module, toCall, malloc, message...)
229 if err != nil {
230 return err
231 }
232 return nil
233}
234
235func (r *runtime) writeMemoryAndCallWithRes(module api.Module, toCall api.Function, malloc api.Function, message ...string) (uint64, error) {
236 params := make([]uint64, 0)
237 for _, m := range message {
238 size := uint64(len(m))
239
240 results, err := malloc.Call(r.ctx, size)
241 if err != nil {
242 return 0, oops.Wrapf(err, "can't malloc memory for %s with %s", toCall.Definition().Name(), m)
243 }
244 ptr := results[0]
245
246 // The pointer is a linear memory offset, which is where we write the name.
247 if !module.Memory().Write(uint32(ptr), []byte(m)) {
248 return 0, oops.Wrapf(err, "can't write memory")
249 }
250
251 params = append(params, ptr, size)
252 }
253
254 defer func() {
255 ptrSizes := make([]ptrSize, 0)
256 for i, d := range params {
257 if i%2 == 0 {
258 ptrSizes = append(ptrSizes, ptrSize{ptr: d, size: params[i+1]})
259 }
260 }
261 r.free(module, ptrSizes)
262 }()
263
264 if res, err := toCall.Call(r.ctx, params...); err != nil {
265 return 0, oops.With("method", toCall.Definition().ExportNames()).Wrapf(err, "can't call")
266 } else if len(res) > 0 {
267 return res[0], nil
268 }
269
270 return 0, nil
271}