.gitignore

@@ -1,2 +1 @@
 *.db
-beretta*

Justfile

@@ -0,0 +1,2 @@
+run:
+    go run src/*.go

Makefile

@@ -1,8 +0,0 @@
-run:
-	go run src/*.go
-
-build:
-	go build -o beretta src/*.go
-
-clean:
-	rm beretta

src/db.go

@@ -1,10 +1,9 @@
 package main
 
 import (
-	"database/sql"
 	_ "embed"
 	_ "github.com/mattn/go-sqlite3"
-	"sync"
+	"database/sql"
 )
 
 //go:embed init.sql
@@ -17,15 +16,10 @@ type Db interface {
 
 type SQLiteDb struct {
 	DB *sql.DB
-	db_mtx sync.Mutex
 }
 
-func (s *SQLiteDb) CheckAndStore(repo, tag string) (bool, error) {
+func (s SQLiteDb) CheckAndStore(repo, tag string) (bool, error) {
 	var count int
-
-	s.db_mtx.Lock()
-	defer s.db_mtx.Unlock()
-
 	err := s.DB.QueryRow("SELECT COUNT(*) FROM tags WHERE repo = ? AND tag = ?", repo, tag).Scan(&count)
 	if err != nil {
 		return false, err

src/main.go

@@ -1,35 +1,34 @@
 package main
 
 import (
-	"flag"
 	"log"
 	"math/rand"
 	"time"
 )
 
 type RepoUpdate struct {
-	repo Repo
+	repo RepoConfig
 	Tag  string
 }
 
 func notifierThread(c chan RepoUpdate, n Notifier) {
 	update := <-c
-	log.Printf("New tag stored for %s: %s", update.repo.IdTuple(), update.Tag)
+	log.Printf("New tag stored for %s: %s", update.repo.Repo, update.Tag)
 	if n.Notify(update.repo, update.Tag) {
-		log.Printf("Notified for %s: %s", update.repo.IdTuple(), update.Tag)
+		log.Printf("Notified for %s/%s: %s", update.repo.Owner, update.repo.Repo, update.Tag)
 	}
 	notifierThread(c, n)
 }
 
-func repoThread(c chan RepoUpdate, repo Repo, avgInterval int, db Db) {
+func repoThread(c chan RepoUpdate, repo RepoConfig, avgInterval int, db Db) {
-	log.Println("Checking", repo.IdTuple())
+	log.Println("Checking", repo.Repo)
 	tag, err := repo.GetLatestTag()
-	isNewVersion, err_2 := db.CheckAndStore(repo.IdTuple(), tag.Name)
+	isNewVersion, err_2 := db.CheckAndStore(repo.Owner, repo.Repo)
 
 	if err != nil {
-		log.Printf("Failed to fetch latest tag for %s: %v", repo.IdTuple(), err)
+		log.Printf("Failed to fetch latest tag for %s: %v", repo.Repo, err)
 	} else if err_2 != nil {
-		log.Printf("Failed to store latest tag for %s: %v", repo.IdTuple(), err_2)
+		log.Printf("Failed to store latest tag for %s: %v", repo.Repo, err_2)
 	} else if isNewVersion {
 		c <- RepoUpdate{repo, tag.Name}
 	}
@@ -41,14 +40,8 @@ func repoThread(c chan RepoUpdate, repo Repo, avgInterval int, db Db) {
 }
 
 func main() {
-
-	conf := flag.String("config", "./beretta.json", "The path to the config file")
-	flag.Parse()
-
-	log.Printf("Using config path: %s", *conf)
-
 	// Load configuration
-	config, err := loadConfig(*conf)
+	config, err := loadConfig("config.json")
 	if err != nil {
 		log.Fatalf("Failed to load configuration: %v", err)
 	}
@@ -65,7 +58,7 @@ func main() {
 
 	// Spawn a goroutine for each repository
 	for _, repo := range config.Repos {
-		go repoThread(c, repo, config.Interval, &db)
+		go repoThread(c, repo, config.Interval, db)
 	}
 
 	notifierThread(c, notifier)

src/repo.go

@@ -9,58 +9,38 @@ import (
 
 type Repo interface {
 	GetLatestTag() (Tag, error)
-	TagsUrl() string
-	Owner() string
-	Name() string
-	IdTuple() string
 }
 
 // Description of a repository (owner and name)
 type RepoConfig struct {
-	OwnerName string `json:"owner"`
+	Owner string `json:"owner"`
-	RepoName  string `json:"repo"`
+	Repo  string `json:"repo"`
 }
 
 func (r RepoConfig) GetLatestTag() (Tag, error) {
-	// url := fmt.Sprintf("https://api.github.com/repos/%s/%s/tags", r.Owner, r.Url)
+	url := fmt.Sprintf("https://api.github.com/repos/%s/%s/tags", r.Owner, r.Repo)
 
-	resp, err := http.Get(r.TagsUrl())
+	resp, err := http.Get(url)
 	if err != nil {
-		log.Printf("Failed to fetch releases for %s: %v", r.TagsUrl(), err)
+		log.Printf("Failed to fetch releases for %s/%s: %v", r.Owner, r.Repo, err)
 		return Tag{}, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		log.Printf("Unexpected response status for %s: %d", r.TagsUrl(), resp.StatusCode)
+		log.Printf("Unexpected response status for %s/%s: %d", r.Owner, r.Repo, resp.StatusCode)
 		return Tag{}, fmt.Errorf("unexpected response status: %d", resp.StatusCode)
 	}
 
 	var tags = []Tag{}
 	if err := json.NewDecoder(resp.Body).Decode(&tags); err != nil {
-		log.Printf("Failed to decode response for %s: %v", r.TagsUrl(), err)
+		log.Printf("Failed to decode response for %s/%s: %v", r.Owner, r.Repo, err)
 		return Tag{}, err
 	}
 
 	return tags[0], nil
 }
 
-func (r RepoConfig) TagsUrl() string {
-	return fmt.Sprintf("https://api.github.com/repos/%s/%s/tags", r.OwnerName, r.RepoName)
-}
-
-func (r RepoConfig) Owner() string {
-	return r.OwnerName
-}
-
-func (r RepoConfig) Name() string {
-	return r.RepoName
-}
-
-func (r RepoConfig) IdTuple() string {
-	return fmt.Sprintf("%s/%s", r.OwnerName, r.RepoName)
-}
-
 type Commit struct {
 	Sha string `json:"sha"`
 	URL string `json:"url"`

src/types.go

@@ -38,16 +38,16 @@ func loadConfig(file string) (Config, error) {
 }
 
 type Notifier interface {
-	Notify(repo Repo, tag string) bool
+	Notify(repo RepoConfig, tag string) bool
 }
 
 type NtfyNotifier struct {
 	Topic string
 }
 
-func (n NtfyNotifier) Notify(repo Repo, tag string) bool {
+func (n NtfyNotifier) Notify(repo RepoConfig, tag string) bool {
 	ntfyURL := fmt.Sprintf("https://ntfy.sh/%s", n.Topic)
-	message := fmt.Sprintf("New release for %s/%s: %s", repo.Owner(), repo.Name(), tag)
+	message := fmt.Sprintf("New release for %s/%s: %s", repo.Owner, repo.Repo, tag)
 
 	_, err := http.Post(ntfyURL, "text/plain", bytes.NewBuffer([]byte(message)))
 	if err != nil {