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

package main

import (
	"encoding/json"
	"flag"
	"os"
	"path/filepath"
	"strings"
)

func maine() error {
	fs := flag.NewFlagSet("gitpeckerhook", flag.ExitOnError)
	domainFlag := fs.String("domain", "", "Woodpecker domain (e.g. https://ci.example.com)")
	fs.StringVar(domainFlag, "d", *domainFlag, "--domain")
	cacheFlag := fs.String("cache", ".cache.json", "Path to JSON cache file")
	fs.StringVar(cacheFlag, "c", *cacheFlag, "--cache")
	tokenFlag := fs.String("token", "", "Woodpecker API token")
	fs.StringVar(tokenFlag, "t", *tokenFlag, "--token")
	tokenFileFlag := fs.String("token-file", "", "Path to a file containing a Woodpecker API token")
	fs.StringVar(tokenFileFlag, "T", *tokenFileFlag, "--token-file")
	if err := fs.Parse(os.Args[1:]); err != nil {
		return err
	}

	token := *tokenFlag
	if *tokenFileFlag != "" {
		data, err := os.ReadFile(*tokenFileFlag)
		if err != nil {
			return err
		}
		token = strings.TrimSpace(string(data))
	}

	pwd, err := os.Getwd()
	if err != nil {
		return err
	}

	repo := filepath.Base(pwd)
	repo = strings.TrimSuffix(repo, ".git")

	cache, err := ensureCache(*cacheFlag)
	if err != nil {
		return err
	}

	client := client{domain: *domainFlag, token: token}

	if _, ok := cache[repo]; !ok {
		id, err := client.lookupRepo(repo)
		if err != nil {
			return err
		}
		cache[repo] = id
		fi, err := os.Open(*cacheFlag)
		if err != nil {
			return err
		}
		defer fi.Close()
		if err := json.NewEncoder(fi).Encode(cache); err != nil {
			return err
		}
	}

	return client.triggerPipeline(cache[repo])
}

func ensureCache(cachePath string) (map[string]int, error) {
	var c map[string]int

	_, err := os.Stat(cachePath)
	if err != nil {
		if err := os.MkdirAll(filepath.Dir(cachePath), os.ModePerm); err != nil {
			return c, err
		}
		fi, err := os.Create(cachePath)
		if err != nil {
			return c, err
		}
		fi.WriteString("{}")
		fi.Close()
	}

	fi, err := os.Open(cachePath)
	if err != nil {
		return c, err
	}
	defer fi.Close()

	return c, json.NewDecoder(fi).Decode(&c)
}

func main() {
	if err := maine(); err != nil {
		panic(err)
	}
}