argo-cd

1
package generator
2

3
import (
4
	"context"
5
	"encoding/json"
6
	"errors"
7
	"fmt"
8
	"io"
9
	"log"
10
	"net/http"
11

12
	v1 "k8s.io/api/core/v1"
13
	v1meta "k8s.io/apimachinery/pkg/apis/meta/v1"
14

15
	"github.com/argoproj/argo-cd/v2/hack/gen-resources/util"
16

17
	"k8s.io/client-go/kubernetes"
18
)
19

20
type Repo struct {
21
	Id  int    `json:"id"`
22
	Url string `json:"html_url"`
23
}
24

25
type RepoGenerator struct {
26
	clientSet *kubernetes.Clientset
27
	bar       *util.Bar
28
}
29

30
func NewRepoGenerator(clientSet *kubernetes.Clientset) Generator {
31
	return &RepoGenerator{clientSet: clientSet, bar: &util.Bar{}}
32
}
33

34
func fetchRepos(token string, page int) ([]Repo, error) {
35
	client := &http.Client{}
36
	req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("https://api.github.com/repos/argoproj/argocd-example-apps/forks?per_page=100&page=%v", page), nil)
37
	req.Header.Set("Authorization", token)
38
	resp, err := client.Do(req)
39
	if err != nil {
40
		return nil, err
41
	}
42
	body, err := io.ReadAll(resp.Body)
43
	if err != nil {
44
		return nil, err
45
	}
46
	var repos []Repo
47
	err = json.Unmarshal(body, &repos)
48
	if err != nil {
49
		return nil, errors.New("failed to retrieve repos, reason: " + string(body))
50
	}
51
	return repos, nil
52
}
53

54
func FetchRepos(token string, samples int) ([]Repo, error) {
55
	log.Print("Fetch repos started")
56
	var (
57
		repos []Repo
58
		page  = 1
59
	)
60

61
	for {
62
		if page%10 == 0 {
63
			log.Printf("Fetch repos, page: %v", page)
64
		}
65
		fetchedRepos, err := fetchRepos(token, page)
66
		if err != nil {
67
			return nil, err
68
		}
69
		if len(fetchedRepos) == 0 {
70
			break
71
		}
72
		if len(repos)+len(fetchedRepos) > samples {
73
			repos = append(repos, fetchedRepos[0:samples-len(repos)]...)
74
			break
75
		}
76
		repos = append(repos, fetchedRepos...)
77
		page++
78
	}
79
	return repos, nil
80
}
81

82
func (rg *RepoGenerator) Generate(opts *util.GenerateOpts) error {
83
	repos, err := FetchRepos(opts.GithubToken, opts.RepositoryOpts.Samples)
84
	if err != nil {
85
		return err
86
	}
87

88
	secrets := rg.clientSet.CoreV1().Secrets(opts.Namespace)
89
	rg.bar.NewOption(0, int64(len(repos)))
90
	for _, repo := range repos {
91
		_, err = secrets.Create(context.TODO(), &v1.Secret{
92
			ObjectMeta: v1meta.ObjectMeta{
93
				GenerateName: "repo-",
94
				Namespace:    opts.Namespace,
95
				Labels: map[string]string{
96
					"app.kubernetes.io/generated-by": "argocd-generator",
97
					"argocd.argoproj.io/secret-type": "repository",
98
				},
99
				Annotations: map[string]string{
100
					"managed-by": "argocd.argoproj.io",
101
				},
102
			},
103
			Data: map[string][]byte{
104
				"type":    []byte("git"),
105
				"url":     []byte(repo.Url),
106
				"project": []byte("default"),
107
			},
108
		}, v1meta.CreateOptions{})
109
		rg.bar.Increment()
110
		rg.bar.Play()
111
	}
112
	rg.bar.Finish()
113
	if err != nil {
114
		return err
115
	}
116
	return nil
117
}
118

119
func (rg *RepoGenerator) Clean(opts *util.GenerateOpts) error {
120
	log.Printf("Clean repos")
121
	secrets := rg.clientSet.CoreV1().Secrets(opts.Namespace)
122
	return secrets.DeleteCollection(context.TODO(), v1meta.DeleteOptions{}, v1meta.ListOptions{
123
		LabelSelector: "app.kubernetes.io/generated-by=argocd-generator",
124
	})
125
}
126