Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610package main
import ( "bytes" "embed" "errors" "fmt" "html/template" "os" "path/filepath" "reflect" "strings"
"codeberg.org/marcig/riploy/slag" "github.com/goccy/go-yaml")
var cmdArgs = os.Args[1:]
func main() { var r Riploy
baseDefaults := Riploy{ Ctx: "production", DockerFile: "Dockerfile.prod", }
config := readConfigFileOrDie()
// We load the config file defaults err := mergo(&config.Defaults, baseDefaults)
if err != nil { exitln(err) }
err = slag.Parse(&r, config.Defaults, cmdArgs)
if r.StupidSong { fmt.Printf("%v\n", stupid_song) return }
if r.StackName == "" { r.StackName = generateNameFromDir("_") }
if r.IdentityName == "" { r.IdentityName = getIdentityNameFromDir() }
if r.Upgrade { upgradeRiploy(true, false) return }
if r.Help || len(os.Args[1:]) == 0 { printHelpMessage() return }
if err != nil { switch { case errors.Is(err, slag.ErrNoFlagsProvided): printHelpMessage() okExit("") default: exitln(err) } }
shouldForce := false shouldRerun := true
if upgradeRiploy(shouldForce, shouldRerun) { return }
r.ProductionHome = filepath.Clean(r.ProductionHome)
if r.DBPort == 0 { r.DBPort = r.ServerPort + 1 }
if r.DebuggerPort == 0 { r.DebuggerPort = r.DBPort + 1 }
data := DockerTemplate{ User: r.DockerUser, Name: r.StackName, ProductionHome: r.ProductionHome, Domain: r.Domain, IdentityName: r.IdentityName, VCS: r.Vcs, Ports: DockerPorts{ Frontend: r.SveltePort, Server: r.ServerPort, DB: r.DBPort, Debugger: r.DebuggerPort, }, JWT: JWT{ Secret: r.JWTSecret, Audience: r.JWTAudience, Issuer: r.JWTIssuer, }, }
tmpl, err := template.New(""). ParseFS(templateFS, "templates/*") if err != nil { exitln(err) }
if r.Init { // @Todo: put the secrets dir into .gitignore and all the .riploy.* files too
switch { case r.Svelte: errs := initSvelteDockerFiles(tmpl, data, r) exitIfAnyError(errs) case r.Golang: if r.MailUser == "" { r.MailUser = r.MailSender } if r.MailSender == "" { warnln("the mail-sender arg was not set, will be fallbacking into empty string") } if r.MailPassword == "" { warnln("the mail-password arg was not set, will be fallbacking into empty string") } err = generateSecrets( r.StackName, fmt.Sprintf("db_%v", r.StackName), r.MailSender, r.MailUser, r.MailPassword, r.JWTSecret, r.JWTAudience, r.JWTIssuer, r.OverwriteSecrets, ) if err != nil { exitln(err) } errs := initGolangDockerFiles(tmpl, data) exitIfAnyError(errs) default: errorln("provide a -svelte or -golang flag so i can know what kind of project deploy scaffold you need") }
} else { riploy(r) }
}
func build(imageName, dockerFile string) { runOrDie("docker", "build", "--tag", imageName, "-f", dockerFile, ".") fmt.Printf("image built\n")}
func push(imageName string) { runOrDie("docker", "push", imageName) fmt.Printf("pushed\n")}
func deploy(dockerStackYaml, stackName, ctx string) { runOrDie("docker", "--debug", "--context", ctx, "stack", "deploy", "-c", dockerStackYaml, stackName) fmt.Printf("deployed\n")}
//go:embed "templates"var templateFS embed.FS
const ( _GENERAL_DIR_PERM os.FileMode = 0755)
type Config struct { Hash string `yaml:"hash"` DeploymentHash string `yaml:"last_deployment_hash"` Defaults Riploy `yaml:"defaults"`}
func readConfigFileOrDie() Config { home := getHome()
configPath := fmt.Sprintf("%v/riploy.yaml", home) _, err := os.ReadFile(configPath) var config Config if err != nil { switch { case errors.Is(err, os.ErrNotExist): return config default: exitln(err) } } b := readFileOrDie(configPath)
err = yaml.Unmarshal(b, &config)
if err != nil { exitln(err) }
return config}
func writeConfigFile(config Config) { home := getHome()
configPath := fmt.Sprintf("%v/riploy.yaml", home)
b, err := yaml.Marshal(config)
if err != nil { exitln(err) }
writeFileOrDie(configPath, b)
}
type DockerPorts struct { Server int DB int Frontend int Debugger int}
type JWT struct { Secret string Audience string Issuer string}type DockerTemplate struct { User string Name string IdentityName string ProductionHome string Ports DockerPorts Domain string VCS string JWT JWT}
func getGitHash() string { h := runGetOrDie("git", "rev-parse", "HEAD") hash := bytes.TrimSpace(h) return string(hash)}
type Riploy struct { Ctx string `yaml:"ctx"` DockerFile string `yaml:"docker_file"` DockerUser string `yaml:"docker_user"` MailSender string `yaml:"mail_sender"` JWTSecret string `yaml:"jwt_secret"` JWTIssuer string `yaml:"jwt_issuer"` JWTAudience string `yaml:"jwt_audience"` MailUser string `yaml:"mail_user"` MailPassword string `yaml:"mail_password"` ProductionHome string `yaml:"production_home"` StackName string `yaml:"-"` IdentityName string `json:"-"` Vcs string `yaml:"-"` Domain string `yaml:"domain"` OverwriteSecrets bool `yaml:"overwrite_secrets"` Build bool `yaml:"-"` Push bool `yaml:"-"` Deploy bool `yaml:"-"` All bool `yaml:"-"` Force bool `yaml:"-"` Init bool `yaml:"-"` Svelte bool `yaml:"-"` Golang bool `yaml:"-"` Static bool `yaml:"-"` SSR bool `yaml:"-"` Node bool `yaml:"-"` Deno bool `yaml:"-"` Bun bool `yaml:"-"` Help bool `yaml:"-"` Upgrade bool `yaml:"-"` SveltePort int `yaml:"-"` ServerPort int `yaml:"-"` DBPort int `yaml:"-"` DebuggerPort int `yaml:"-"` StupidSong bool `yaml:"-"`}
func printHelpMessage() {
msg := ` ctx: string context name to use docker-file: string docker file name to use for building the final service docker-user: string name for the dockerhub account stack-name: string name of the stack to deploy mail-sender: string email address from which we are sending emails mail-user: string email use (will fallback into mail-sender if not present) mail-password: string email password production-home string production home path vcs: string vcs repository url domain: string name of the domain overwrite-secrets: bool should overwrite all the secrets files (defaults to false) build: bool should build push: bool should push deploy: bool should deploy all: bool do everything force: bool ignore if there are not new changes (just use in case the build was interrupted) init: bool init an empty docker-stack.yaml svelte: bool (depends on init) -> tells riploy to generate the svelte docker files golang: bool (depends on init) -> tells riploy to generate the golang/backend docker files static: bool init an svelte-static Dockerfile ssr: bool init an svelte-ssr Dockerfile node: bool init an svelte-node Dockerfile bun: bool init an svelte-bun Dockerfile deno: bool init an svelte-deno Dockerfile svelte-port: int port to use for the svelte app server-port: int port to use for the server debugger-port: int port to use for the debugger jwt-secret: string containing the token secret (jwt) jwt-issuer: string issuer for the token (jwt) jwt-audience: string audience for the token (jwt) stupid-song: bool just for testing btw listen to olivia she is goated <3 help: bool prints this help message `
fmt.Printf("%v\n", msg)}
func assignIfEmpty[T any](ptr *T, value T) { rv := reflect.ValueOf(ptr).Elem() fmt.Printf("%v:%v", ptr, rv.IsZero()) if rv.IsZero() { rv.Set(reflect.ValueOf(value)) }}
func generateSecrets(user, dbName, mailSender, mailUser, mailPass, tokenSecret, tokenAudience, tokenIssuer string, shouldOverwrite bool) error { err := os.MkdirAll("secrets", _GENERAL_DIR_PERM)
if err != nil { return err }
generatedRootPass, err := RandomHash(16) if err != nil { return err }
genreatedUserPass, err := RandomHash(16) if err != nil { return err }
type File struct { content string shouldOverwrite bool }
ts, err := RandomHash(16) if err != nil { return err }
assignIfEmpty(&tokenSecret, ts) assignIfEmpty(&tokenAudience, user) assignIfEmpty(&tokenIssuer, user)
secrets := map[string]File{ "./secrets/db-root-password.secret": {content: generatedRootPass, shouldOverwrite: false}, "./secrets/db-root-user.secret": {content: fmt.Sprintf("root-%v", user), shouldOverwrite: true}, "./secrets/db-password.secret": {content: genreatedUserPass, shouldOverwrite: false}, "./secrets/db-user.secret": {content: user, shouldOverwrite: false}, "./secrets/db-name.secret": {content: dbName, shouldOverwrite: false}, "./secrets/mail-password.secret": {content: mailPass, shouldOverwrite: false}, "./secrets/mail-sender.secret": {content: mailSender, shouldOverwrite: false}, "./secrets/mail-user.secret": {content: mailUser, shouldOverwrite: false}, "./secrets/jwt-secret.secret": {content: tokenSecret, shouldOverwrite: false}, "./secrets/jwt-audience.secret": {content: tokenAudience, shouldOverwrite: false}, "./secrets/jwt-issuer.secret": {content: tokenIssuer, shouldOverwrite: false}, }
for name, secret := range secrets { overwrite := secret.shouldOverwrite if shouldOverwrite { overwrite = true } if secret.content != "" { writeFileString(name, secret.content, overwrite) } }
return nil}
func canInitializeSvelteDockerFiles(data DockerTemplate) []error { var errors []error
if data.Ports.Frontend == 0 { errors = append(errors, ErrNoFrontendPort) }
if data.User == "" { errors = append(errors, ErrNoDockerhubUserName) }
if data.Name == "" { errors = append(errors, ErrNoProjectName) }
if data.Domain == "" { errors = append(errors, ErrNoDomain) }
return errors}
func initSvelteDockerFiles(tmpl *template.Template, data DockerTemplate, r Riploy) []error {
errors := canInitializeSvelteDockerFiles(data)
if errors != nil { return errors }
var err error
prod := createFileOrDie("docker-stack.yaml") err = tmpl.ExecuteTemplate(prod, "prod-frontend-svelte.yaml", data) if err != nil { errors = append(errors, err) return errors }
// XD var sb strings.Builder sb.WriteString("prod")
switch { case r.Node: sb.WriteString("-node") case r.Deno: sb.WriteString("-deno") case r.Bun: sb.WriteString("-bun") default: if r.SSR { errorln("please tell me which js runtime to use for building and running your project") } else { errorln("please tell me which js runtime to use for building your project (-deno, -node, -bun)") } exit() }
sb.WriteString("-svelte")
if r.SSR { sb.WriteString("-ssr.Dockerfile") } else { sb.WriteString("-static.Dockerfile") }
dockerTemplateName := sb.String()
err = createFileFromTemplate(tmpl, dockerTemplateName, "Dockerfile.prod", data) if err != nil { errors = append(errors, err) return errors }
err = createFileFromTemplate(tmpl, "nginx.conf", "nginx.conf", data)
if err != nil { errors = append(errors, err) return errors }
return nil}
func upgradeRiploy(force, rerun bool) bool { source := sourceFile() config := readConfigFileOrDie() // @Todo: might need to check also the utils.go file or all the go files inside the project but blehgh checksum := getFileChecksumOrDie(fmt.Sprintf("%v/main.go", source))
msg := "[^v^]:changes to riploy were detected, rebuilt itself" if force { msg = "[óvó]:force upgrade, rebuilt itself\n" } if force || config.Hash != checksum { prev := pwd() cd(source) runOrDie("go", "build", ".") config.Hash = checksum writeConfigFile(config) fmt.Println(msg) if rerun { cd(prev) runOrDie("riploy", cmdArgs...) } return true } return false}
func canInitializeGolangDockerFiles(data DockerTemplate) []error { var errors []error
if data.Ports.Server == 0 { errors = append(errors, ErrNoServerPort) }
if data.User == "" { errors = append(errors, ErrNoDockerhubUserName) }
if data.VCS == "" { errors = append(errors, ErrNoVCS) }
if data.Domain == "" { errors = append(errors, ErrNoDomain) }
return errors}
func initGolangDockerFiles(tmpl *template.Template, data DockerTemplate) []error { // execute template prod-backend-postgres var errors []error
errors = canInitializeGolangDockerFiles(data) if errors != nil { return errors }
files := map[string]string{ "prod-backend-postgres.Dockerfile": "Dockerfile.prod", "dev-backend-postgres.Dockerfile": "Dockerfile.dev", "prod-backend-postgres.yaml": "docker-stack.yaml", "dev-backend-postgres.yaml": "compose.yaml", "backend.env": ".env", "backend.Makefile": "Makefile", "backend.gitignore": ".gitignore", }
for templateName, fileName := range files { err := createFileFromTemplate(tmpl, templateName, fileName, data) if err != nil { errors = append(errors, err) } }
return errors}
const ( RiployStackFileName = ".riploy.docker-stack.yaml" DockerStackFileName = "docker-stack.yaml")
func generateDockerRiployFileOrDie(hash string) { os.Setenv("GIT_HASH", hash) // Generate the config file with the enviroment variables written into it filecontent := runGetOrDie("docker", "compose", "-f", DockerStackFileName, "config") newLine := []byte{'\n'} lines := bytes.Split(filecontent, newLine) // @Note: `docker compose config` creates a field that docker-stack doesn't support for deploying content := bytes.Join(lines[1:], newLine) writeFileOrDie(RiployStackFileName, content)}
func riploy(r Riploy) { gitHash := getGitHash() config := readConfigFileOrDie()
// @Verify this would never happen because riploy would exit if getting the git hash fails so it doesn't matter to do this // if len(gitHash) == 0 { // exitln("please run this command inside a git repository") // }
imageName := fmt.Sprintf("%v/%v:%s", r.DockerUser, r.StackName, gitHash) generateDockerRiployFileOrDie(gitHash)
if !r.Force && config.DeploymentHash == gitHash { exitln("no changes") } else if r.Force { warnln("forcing riploy (this is safe to do when the image was not pushed or deployed correctly the last time!) is not safe the other way because the hashes are the same and docker stack won't update the service cause it just sees the tag which has not changed") }
if r.All || r.Build { build(imageName, r.DockerFile) }
if r.All || r.Push { push(imageName) }
if r.All || r.Deploy { deploy(RiployStackFileName, r.StackName, r.Ctx) }
config.DeploymentHash = gitHash writeConfigFile(config)}