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 continue
141 }
142
143 if init := c.module.ExportedFunction("init"); init != nil {
144 arg, err := pluginRun.Marshal()
145 if err != nil {
146 c.logger.Error("can't Marshal pluginRun", err, logger.NewLoggerPair("branch", cmd.branch))
147 continue
148 }
149 c.logger.Debug("init plugin", logger.NewLoggerPair("name", c.plugin.Name), logger.NewLoggerPair("arg", arg))
150 if err := r.writeMemoryAndCall(c.module, init, malloc, c.repo.Name(), "false", string(arg)); err != nil {
151 c.logger.Error("can't init plugin", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
152 continue
153 }
154 }
155
156 for _, com := range cmd.commits {
157 r.commit = &com
158 comMarshalled, err := MarshallOne(cmd.branch.Short(), com)
159 if err != nil {
160 c.logger.Error("can't marshall commit", err, logger.NewLoggerPair("branch", cmd.branch))
161 continue
162 }
163 c.logger.Debug("diff start commit", logger.NewLoggerPair("com", comMarshalled))
164 if startCommit != nil {
165 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)))
166 if err := r.writeMemoryAndCall(c.module, startCommit, malloc, comMarshalled); err != nil {
167 c.logger.Error("startCommit error", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
168 continue
169 }
170 }
171
172 for _, f := range com.files {
173 c.logger.Debug("diff start commit file", logger.NewLoggerPair("file", f.Path), logger.NewLoggerPair("action", f.Action))
174 if pluginRun.glob.Match(f.Path) {
175 jsonFile, err := json.Marshal(f)
176 if err != nil {
177 c.logger.Error("can marshal file", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
178 continue
179 }
180 if f.Action == pluginLib.FileActionTypeAdd && callOnAdd {
181 c.logger.Debug("add", logger.NewLoggerPair("confPath", pluginRun.Path), logger.NewLoggerPair("currentPath", f.Path))
182 // creation
183 r.writeMemoryAndCall(c.module, addFile, malloc, string(jsonFile))
184 } else {
185 if f.Action == pluginLib.FileActionTypeDel && callOnDel {
186 // deletion
187 r.writeMemoryAndCall(c.module, delFile, malloc, string(jsonFile))
188 } else if f.Action == pluginLib.FileActionTypeMod && callOnMod {
189 //modification
190 r.writeMemoryAndCall(c.module, modFile, malloc, string(jsonFile))
191 }
192 }
193 }
194 }
195
196 if endCommit != nil {
197 if err := r.writeMemoryAndCall(c.module, endCommit, malloc, comMarshalled); err != nil {
198 c.logger.Error("endCommit error", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
199 continue
200 }
201 }
202 }
203
204 if finish := c.module.ExportedFunction("finish"); finish != nil {
205 if _, err := finish.Call(ctx); err != nil {
206 c.logger.Error("finish error", err, logger.NewLoggerPair("branch", cmd.branch), logger.NewLoggerPair("plugin", c.plugin.Name))
207 continue
208 }
209 }
210 }
211 }
212
213 if err := c.repoWriter.Checkout(currentBranch); err != nil {
214 c.logger.Error("can't Checkout currentBranch", err, logger.NewLoggerPair("branch", currentBranch.Short()))
215 return err
216 }
217 return nil
218}
219
220func (r *runtime) writeMemoryAndCall(module api.Module, toCall api.Function, malloc api.Function, message ...string) error {
221 _, err := r.writeMemoryAndCallWithRes(module, toCall, malloc, message...)
222 if err != nil {
223 return err
224 }
225 return nil
226}
227
228func (r *runtime) writeMemoryAndCallWithRes(module api.Module, toCall api.Function, malloc api.Function, message ...string) (uint64, error) {
229 params := make([]uint64, 0)
230 for _, m := range message {
231 size := uint64(len(m))
232
233 results, err := malloc.Call(r.ctx, size)
234 if err != nil {
235 return 0, oops.Wrapf(err, "can't malloc memory for %s with %s", toCall.Definition().Name(), m)
236 }
237 ptr := results[0]
238
239 // The pointer is a linear memory offset, which is where we write the name.
240 if !module.Memory().Write(uint32(ptr), []byte(m)) {
241 return 0, oops.Wrapf(err, "can't write memory")
242 }
243
244 params = append(params, ptr, size)
245 }
246
247 defer func() {
248 ptrSizes := make([]ptrSize, 0)
249 for i, d := range params {
250 if i%2 == 0 {
251 ptrSizes = append(ptrSizes, ptrSize{ptr: d, size: params[i+1]})
252 }
253 }
254 r.free(module, ptrSizes)
255 }()
256
257 if res, err := toCall.Call(r.ctx, params...); err != nil {
258 return 0, oops.With("method", toCall.Definition().ExportNames()).Wrapf(err, "can't call")
259 } else if len(res) > 0 {
260 return res[0], nil
261 }
262
263 return 0, nil
264}