274 lines
6.7 KiB
Go
274 lines
6.7 KiB
Go
package providers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"git.badhouseplants.net/allanger/shoebill/internal/config/release"
|
|
"git.badhouseplants.net/allanger/shoebill/internal/config/repository"
|
|
"git.badhouseplants.net/allanger/shoebill/internal/utils/diff"
|
|
"git.badhouseplants.net/allanger/shoebill/internal/utils/githelper"
|
|
release_v2beta1 "github.com/fluxcd/helm-controller/api/v2beta1"
|
|
helmrepo_v1beta2 "github.com/fluxcd/source-controller/api/v1beta2"
|
|
"github.com/sirupsen/logrus"
|
|
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
type Flux struct {
|
|
path string
|
|
gh githelper.Githelper
|
|
}
|
|
|
|
func FluxProvider(path string, gh githelper.Githelper) Provider {
|
|
return &Flux{
|
|
path: path,
|
|
gh: gh,
|
|
}
|
|
}
|
|
|
|
func (f *Flux) SyncState(diff diff.Diff) error {
|
|
entity := "repository"
|
|
srcPath := fmt.Sprintf("%s/src", f.path)
|
|
filePath := fmt.Sprintf("%s/%s-", srcPath, entity)
|
|
|
|
for _, repo := range diff.DeletedRepositories {
|
|
if err := os.Remove(filePath + repo.Name + ".yaml"); err != nil {
|
|
return err
|
|
}
|
|
message := `chore(repository): Removed a repo: %s
|
|
|
|
A repo has been removed from the cluster:
|
|
Name: %s
|
|
URL: %s
|
|
`
|
|
if err := f.gh.AddAllAndCommit(f.path, fmt.Sprintf(message, repo.Name, repo.Name, repo.URL)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for _, repo := range diff.UpdatedRepositories {
|
|
manifest, err := GenerateRepository(repo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := os.WriteFile(filePath+repo.Name+".yaml", manifest, os.ModeExclusive); err != nil {
|
|
return err
|
|
}
|
|
message := `chore(repository): Update a repo: %s
|
|
|
|
A repo has been updated:
|
|
Name: %s
|
|
URL: %s
|
|
`
|
|
if err := f.gh.AddAllAndCommit(f.path, fmt.Sprintf(message, repo.Name, repo.Name, repo.URL)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, repo := range diff.AddedRepositories {
|
|
manifest, err := GenerateRepository(repo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
file, err := os.Create(filePath + repo.Name + ".yaml")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := file.Write(manifest); err != nil {
|
|
return err
|
|
}
|
|
message := `chore(repository): Add a repo: %s
|
|
|
|
A new repo added to the cluster:
|
|
Name: %s
|
|
URL: %s
|
|
`
|
|
if err := f.gh.AddAllAndCommit(f.path, fmt.Sprintf(message, repo.Name, repo.Name, repo.URL)); err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
|
|
entity = "release"
|
|
filePath = fmt.Sprintf("%s/%s-", srcPath, entity)
|
|
|
|
for _, release := range diff.AddedReleases {
|
|
if err := SyncValues(release, srcPath); err != nil {
|
|
return err
|
|
}
|
|
manifest, err := GenerateRelease(release)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
file, err := os.Create(filePath + release.Release + ".yaml")
|
|
if err != nil {
|
|
return err
|
|
|
|
}
|
|
if _, err := file.Write(manifest); err != nil {
|
|
return err
|
|
}
|
|
message := `chore(release): Add a new release: %s
|
|
|
|
A new release is added to the cluster:
|
|
Name: %s
|
|
Namespace: %s
|
|
Version: %s
|
|
Chart: %s/%s
|
|
`
|
|
if err := f.gh.AddAllAndCommit(f.path, fmt.Sprintf(message, release.Release, release.Release, release.Namespace, release.Version, release.Repository, release.Release)); err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
|
|
for _, release := range diff.UpdatedReleases {
|
|
SyncValues(release, srcPath)
|
|
manifest, err := GenerateRelease(release)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := os.WriteFile(filePath+release.Release+".yaml", manifest, os.ModeExclusive); err != nil {
|
|
return err
|
|
}
|
|
|
|
message := `chore(release): Update a release: %s
|
|
|
|
A release has been updated:
|
|
Name: %s
|
|
Namespace: %s
|
|
Version: %s
|
|
Chart: %s/%s
|
|
`
|
|
if err := f.gh.AddAllAndCommit(f.path, fmt.Sprintf(message, release.Release, release.Release, release.Namespace, release.Version, release.Repository, release.Release)); err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
|
|
for _, release := range diff.DeletedReleases {
|
|
if err := os.Remove(filePath + release.Release + ".yaml"); err != nil {
|
|
return err
|
|
}
|
|
|
|
message := `chore(release): Remove a release: %s
|
|
|
|
A release has been removed from the cluster:
|
|
Name: %s
|
|
Namespace: %s
|
|
Version: %s
|
|
Chart: %s/%s
|
|
`
|
|
if err := f.gh.AddAllAndCommit(f.path, fmt.Sprintf(message, release.Release, release.Release, release.Namespace, release.Version, release.Repository, release.Release)); err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func GenerateRepository(repo *repository.Repository) ([]byte, error) {
|
|
fluxRepo := &helmrepo_v1beta2.HelmRepository{
|
|
TypeMeta: v1.TypeMeta{
|
|
Kind: helmrepo_v1beta2.HelmRepositoryKind,
|
|
APIVersion: helmrepo_v1beta2.GroupVersion.String(),
|
|
},
|
|
ObjectMeta: v1.ObjectMeta{
|
|
Name: repo.Name,
|
|
Namespace: "flux-namespace",
|
|
},
|
|
Spec: helmrepo_v1beta2.HelmRepositorySpec{
|
|
URL: repo.URL,
|
|
Type: repo.Kind,
|
|
},
|
|
}
|
|
return yaml.Marshal(&fluxRepo)
|
|
}
|
|
|
|
// GenerateRelease and put
|
|
func GenerateRelease(release *release.Release) ([]byte, error) {
|
|
fluxRelease := &release_v2beta1.HelmRelease{
|
|
TypeMeta: v1.TypeMeta{
|
|
Kind: release_v2beta1.HelmReleaseKind,
|
|
APIVersion: release_v2beta1.GroupVersion.String(),
|
|
},
|
|
ObjectMeta: v1.ObjectMeta{
|
|
Name: release.Release,
|
|
Namespace: "flux-namespace",
|
|
},
|
|
Spec: release_v2beta1.HelmReleaseSpec{
|
|
Chart: release_v2beta1.HelmChartTemplate{
|
|
Spec: release_v2beta1.HelmChartTemplateSpec{
|
|
Chart: release.Chart,
|
|
Version: release.Version,
|
|
SourceRef: release_v2beta1.CrossNamespaceObjectReference{
|
|
Kind: helmrepo_v1beta2.HelmRepositoryKind,
|
|
Name: release.RepositoryObj.Name,
|
|
Namespace: "flux-namespace",
|
|
},
|
|
},
|
|
},
|
|
ReleaseName: release.Release,
|
|
Install: &release_v2beta1.Install{
|
|
CRDs: release_v2beta1.Create,
|
|
CreateNamespace: true,
|
|
},
|
|
TargetNamespace: "release-namespace",
|
|
},
|
|
}
|
|
return yaml.Marshal(&fluxRelease)
|
|
}
|
|
|
|
func SyncValues(release *release.Release, path string) error {
|
|
for _, valueFile := range release.Values {
|
|
// Prepare a dir for values
|
|
valuesPath := fmt.Sprintf("%s/%s", path, "values")
|
|
if _, err := os.Stat(valuesPath); errors.Is(err, os.ErrNotExist) {
|
|
err := os.Mkdir(valuesPath, os.ModePerm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
|
|
destFileName := fmt.Sprintf("%s/%s-%s", valuesPath, release.Release, filepath.Base(valueFile))
|
|
logrus.Info(destFileName)
|
|
logrus.Info(valueFile)
|
|
var dstValues *os.File
|
|
var srcValues *os.File
|
|
var err error
|
|
srcValues, err = os.Open(valueFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer srcValues.Close()
|
|
if _, err = os.Stat(destFileName); err == nil {
|
|
dstValues, err = os.Open(destFileName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer dstValues.Close()
|
|
} else if errors.Is(err, os.ErrNotExist) {
|
|
dstValues, err = os.Create(destFileName)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer dstValues.Close()
|
|
} else {
|
|
return err
|
|
}
|
|
_, err = io.Copy(dstValues, srcValues)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|