1// SPDX-FileCopyrightText: Amolith <amolith@secluded.site>
2//
3// SPDX-License-Identifier: Apache-2.0
4
5package project
6
7import (
8 "crypto/sha256"
9 "database/sql"
10 "errors"
11 "fmt"
12 "log"
13 "sort"
14 "strings"
15 "sync"
16 "time"
17
18 "git.sr.ht/~amolith/willow/db"
19 "git.sr.ht/~amolith/willow/git"
20 "git.sr.ht/~amolith/willow/rss"
21 "github.com/unascribed/FlexVer/go/flexver"
22)
23
24type Project struct {
25 ID string
26 URL string
27 Name string
28 Forge string
29 Running string
30 Releases []Release
31}
32
33type Release struct {
34 ID string
35 ProjectID string
36 URL string
37 Tag string
38 Content string
39 Date time.Time
40}
41
42// GetReleases returns a list of all releases for a project from the database.
43func GetReleases(dbConn *sql.DB, mu *sync.Mutex, proj Project) (Project, error) {
44 proj.ID = GenProjectID(proj.URL, proj.Name, proj.Forge)
45
46 ret, err := db.GetReleases(dbConn, proj.ID)
47 if err != nil {
48 return proj, err
49 }
50
51 if len(ret) == 0 {
52 return fetchReleases(dbConn, mu, proj)
53 }
54
55 for _, row := range ret {
56 proj.Releases = append(proj.Releases, Release{
57 ID: row["id"],
58 ProjectID: proj.ID,
59 Tag: row["tag"],
60 Content: row["content"],
61 URL: row["release_url"],
62 Date: time.Time{},
63 })
64 }
65
66 proj.Releases = SortReleases(proj.Releases)
67
68 return proj, nil
69}
70
71// fetchReleases fetches releases from a project's forge given its URI.
72func fetchReleases(dbConn *sql.DB, mu *sync.Mutex, p Project) (Project, error) {
73 var err error
74
75 switch p.Forge {
76 case "github", "gitea", "forgejo":
77 rssReleases, err := rss.GetReleases(p.URL)
78 if err != nil {
79 fmt.Println("Error getting RSS releases:", err)
80 return p, err
81 }
82
83 for _, release := range rssReleases {
84 p.Releases = append(p.Releases, Release{
85 ID: GenReleaseID(p.URL, release.URL, release.Tag),
86 Tag: release.Tag,
87 Content: release.Content,
88 URL: release.URL,
89 Date: release.Date,
90 })
91
92 err = upsertReleases(dbConn, mu, p.ID, p.Releases)
93 if err != nil {
94 log.Printf("Error upserting release: %v", err)
95 return p, err
96 }
97 }
98 default:
99 gitReleases, err := git.GetReleases(p.URL, p.Forge)
100 if err != nil {
101 return p, err
102 }
103
104 for _, release := range gitReleases {
105 p.Releases = append(p.Releases, Release{
106 ID: GenReleaseID(p.URL, release.URL, release.Tag),
107 Tag: release.Tag,
108 Content: release.Content,
109 URL: release.URL,
110 Date: release.Date,
111 })
112
113 err = upsertReleases(dbConn, mu, p.ID, p.Releases)
114 if err != nil {
115 log.Printf("Error upserting release: %v", err)
116 return p, err
117 }
118 }
119 }
120
121 p.Releases = SortReleases(p.Releases)
122
123 return p, err
124}
125
126func SortReleases(releases []Release) []Release {
127 sort.Slice(releases, func(i, j int) bool {
128 return !flexver.Less(releases[i].Tag, releases[j].Tag)
129 })
130
131 return releases
132}
133
134func SortProjects(projects []Project) []Project {
135 sort.Slice(projects, func(i, j int) bool {
136 return strings.ToLower(projects[i].Name) < strings.ToLower(projects[j].Name)
137 })
138
139 return projects
140}
141
142// upsertReleases updates or inserts a release in the database.
143func upsertReleases(dbConn *sql.DB, mu *sync.Mutex, projID string, releases []Release) error {
144 for _, release := range releases {
145 date := release.Date.Format("2006-01-02 15:04:05")
146
147 err := db.UpsertRelease(dbConn, mu, release.ID, projID, release.URL, release.Tag, release.Content, date)
148 if err != nil {
149 log.Printf("Error upserting release: %v", err)
150 return err
151 }
152 }
153
154 return nil
155}
156
157// GenReleaseID generates a likely-unique ID from its project's URL, its release's URL, and its tag.
158func GenReleaseID(projectURL, releaseURL, tag string) string {
159 idByte := sha256.Sum256([]byte(projectURL + releaseURL + tag))
160 return fmt.Sprintf("%x", idByte)
161}
162
163// GenProjectID generates a likely-unique ID from a project's URI, name, and forge.
164func GenProjectID(url, name, forge string) string {
165 idByte := sha256.Sum256([]byte(url + name + forge))
166 return fmt.Sprintf("%x", idByte)
167}
168
169func Track(dbConn *sql.DB, mu *sync.Mutex, manualRefresh *chan struct{}, name, url, forge, release string) {
170 id := GenProjectID(url, name, forge)
171
172 err := db.UpsertProject(dbConn, mu, id, url, name, forge, release)
173 if err != nil {
174 fmt.Println("Error upserting project:", err)
175 }
176
177 *manualRefresh <- struct{}{}
178}
179
180func Untrack(dbConn *sql.DB, mu *sync.Mutex, id string) {
181 proj, err := db.GetProject(dbConn, id)
182 if err != nil {
183 fmt.Println("Error getting project:", err)
184 }
185
186 err = db.DeleteProject(dbConn, mu, proj["id"])
187 if err != nil {
188 fmt.Println("Error deleting project:", err)
189 }
190
191 // TODO: before removing, check whether other tracked projects use the same
192 // repo
193 err = git.RemoveRepo(proj["url"])
194 if err != nil {
195 log.Println(err)
196 }
197}
198
199func RefreshLoop(dbConn *sql.DB, mu *sync.Mutex, interval int, manualRefresh, req *chan struct{}, res *chan []Project) {
200 ticker := time.NewTicker(time.Second * time.Duration(interval))
201
202 fetch := func() []Project {
203 projectsList, err := GetProjects(dbConn)
204 if err != nil {
205 fmt.Println("Error getting projects:", err)
206 }
207
208 for i, p := range projectsList {
209 p, err := fetchReleases(dbConn, mu, p)
210 if err != nil {
211 fmt.Println(err)
212 continue
213 }
214
215 projectsList[i] = p
216 }
217
218 sort.Slice(projectsList, func(i, j int) bool {
219 return strings.ToLower(projectsList[i].Name) < strings.ToLower(projectsList[j].Name)
220 })
221
222 for i := range projectsList {
223 err = upsertReleases(dbConn, mu, projectsList[i].ID, projectsList[i].Releases)
224 if err != nil {
225 fmt.Println("Error upserting release:", err)
226 continue
227 }
228 }
229
230 return projectsList
231 }
232
233 projects := fetch()
234
235 for {
236 select {
237 case <-ticker.C:
238 projects = fetch()
239 case <-*manualRefresh:
240 ticker.Reset(time.Second * 3600)
241
242 projects = fetch()
243 case <-*req:
244 projectsCopy := make([]Project, len(projects))
245 copy(projectsCopy, projects)
246
247 *res <- projectsCopy
248 }
249 }
250}
251
252// GetProject returns a project from the database.
253func GetProject(dbConn *sql.DB, proj Project) (Project, error) {
254 projectDB, err := db.GetProject(dbConn, proj.ID)
255 if err != nil && errors.Is(err, sql.ErrNoRows) {
256 return proj, nil
257 } else if err != nil {
258 return proj, err
259 }
260
261 p := Project{
262 ID: proj.ID,
263 URL: proj.URL,
264 Name: proj.Name,
265 Forge: proj.Forge,
266 Running: projectDB["version"],
267 }
268
269 return p, err
270}
271
272// GetProjectWithReleases returns a single project from the database along with its releases.
273func GetProjectWithReleases(dbConn *sql.DB, mu *sync.Mutex, proj Project) (Project, error) {
274 project, err := GetProject(dbConn, proj)
275 if err != nil {
276 return Project{}, err
277 }
278
279 return GetReleases(dbConn, mu, project)
280}
281
282// GetProjects returns a list of all projects from the database.
283func GetProjects(dbConn *sql.DB) ([]Project, error) {
284 projectsDB, err := db.GetProjects(dbConn)
285 if err != nil {
286 return nil, err
287 }
288
289 projects := make([]Project, len(projectsDB))
290 for i, p := range projectsDB {
291 projects[i] = Project{
292 ID: p["id"],
293 URL: p["url"],
294 Name: p["name"],
295 Forge: p["forge"],
296 Running: p["version"],
297 }
298 }
299
300 return SortProjects(projects), nil
301}
302
303// GetProjectsWithReleases returns a list of all projects and all their releases
304// from the database.
305func GetProjectsWithReleases(dbConn *sql.DB, mu *sync.Mutex) ([]Project, error) {
306 projects, err := GetProjects(dbConn)
307 if err != nil {
308 return nil, err
309 }
310
311 for i := range projects {
312 projects[i], err = GetReleases(dbConn, mu, projects[i])
313 if err != nil {
314 return nil, err
315 }
316
317 projects[i].Releases = SortReleases(projects[i].Releases)
318 }
319
320 return SortProjects(projects), nil
321}