dave/gitea-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Modernize the logging and flag parsing a bit

Browse Source
This commit is contained in:
PhatPhuckDave
2025-09-25 15:50:02 +02:00
parent 0adbca216c
commit 476f71a90c
3 changed files with 106 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
main.go
View File

@@ -3,9 +3,6 @@ package main
import (
_ "embed"
"flag"
"fmt"
"io"
"log"
"os"
"path"
@@ -13,149 +10,171 @@ import (
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/config"
"golang.design/x/clipboard"
logger "git.site.quack-lab.dev/dave/cylogger"
)
var Error *log.Logger
var Warning *log.Logger
func init() {
log.SetFlags(log.Lmicroseconds | log.Lshortfile)
// logFile, err := os.Create("main.log")
// if err != nil {
// log.Printf("Error creating log file: %v", err)
// os.Exit(1)
// }
logger := io.MultiWriter(os.Stdout)
log.SetOutput(logger)
Error = log.New(io.MultiWriter(os.Stderr, os.Stdout),
fmt.Sprintf("%sERROR:%s ", "\033[0;101m", "\033[0m"),
log.Lmicroseconds|log.Lshortfile)
Warning = log.New(io.MultiWriter(os.Stdout),
fmt.Sprintf("%sWarning:%s ", "\033[0;93m", "\033[0m"),
log.Lmicroseconds|log.Lshortfile)
}
var Version = "1.0.0"
func main() {
name := flag.String("name", "", "Name of the repository")
flag.String("n", "", "Name of the repository")
private := flag.Bool("private", false, "Make the repository private")
flag.Bool("p", false, "Make the repository private (shorthand)")
noinit := flag.Bool("noinit", false, "Do not add remote to the new repo")
flag.Bool("ni", false, "Do not add remote to the new repo (shorthand)")
forceInit := flag.Bool("f", false, "Force assignment of the remote (deletes existing origin)")
remote := flag.String("remote", "origin", "Name of the remote to create for the new repository")
flag.String("r", "origin", "Name of the remote to create for the new repository (shorthand)")
version := flag.Bool("v", false, "Show version")
flag.Bool("version", false, "Show version")
help := flag.Bool("h", false, "Show help")
flag.Bool("help", false, "Show help")
flag.Parse()
logger.InitFlag()
logger.Info("Starting repo %s", Version)
if *version {
logger.Info("Version: %s", Version)
return
}
if *help {
flag.PrintDefaults()
return
}
err := clipboard.Init()
if err != nil {
Error.Fatalf("Error initializing clipboard: %v", err)
logger.Error("Error initializing clipboard: %v", err)
return
}
username, ok := os.LookupEnv("GITEA_USER")
if !ok {
Error.Fatalf("GITEA_USER environment variable is required")
logger.Error("GITEA_USER environment variable is required")
return
}
password, ok := os.LookupEnv("GITEA_PASSWORD")
if !ok {
Error.Fatalf("GITEA_PASSWORD environment variable is required")
logger.Error("GITEA_PASSWORD environment variable is required")
return
}
url, ok := os.LookupEnv("GITEA_URL")
if !ok {
Error.Fatalf("GITEA_URL environment variable is required")
logger.Error("GITEA_URL environment variable is required")
return
}
if username == "" || password == "" {
Error.Fatalf("GITEA_USER and GITEA_PASSWORD environment variables are required")
logger.Error("GITEA_USER and GITEA_PASSWORD environment variables are required")
return
}
var name, remote string
var private, noinit, forceInit bool
flag.StringVar(&name, "name", "", "Name of the repository")
flag.StringVar(&name, "n", "", "Name of the repository (shorthand)")
flag.BoolVar(&private, "private", false, "Make the repository private")
flag.BoolVar(&private, "p", false, "Make the repository private (shorthand)")
flag.BoolVar(&noinit, "noinit", false, "Do not add remote to the new repo")
flag.BoolVar(&noinit, "ni", false, "Do not add remote to the new repo (shorthand)")
flag.BoolVar(&forceInit, "f", false, "Force assignment of the remote (deletes existing origin)")
flag.StringVar(&remote, "remote", "origin", "Name of the remote to create for the new repository")
flag.StringVar(&remote, "r", "origin", "Name of the remote to create for the new repository (shorthand)")
flag.Parse()
if len(flag.Args()) > 0 {
name = flag.Args()[0]
if flag.NArg() > 0 {
*name = flag.Arg(0)
}
if name == "" {
Error.Fatalf("Repository name is required")
if *name == "" {
logger.Error("Repository name is required")
return
}
logger.Info("Username: %s", username)
logger.Info("URL: %s", url)
logger.Info("Name: %s", *name)
logger.Info("Private: %t", *private)
logger.Info("Noinit: %t", *noinit)
logger.Info("ForceInit: %t", *forceInit)
logger.Info("Remote: %s", *remote)
client, err := gitea.NewClient(url)
if err != nil {
Error.Fatalf("Error creating client: %v", err)
logger.Error("Error creating client: %v", err)
return
}
client.SetBasicAuth(username, password)
repo, _, err := client.GetRepo(username, name)
logger.Info("Getting repository...")
repo, _, err := client.GetRepo(username, *name)
if err == nil {
log.Printf("Repository already exists at:\n%s", repo.CloneURL)
logger.Info("Repository already exists at:\n%s", repo.CloneURL)
clipboard.Write(clipboard.FmtText, []byte(repo.CloneURL))
} else {
logger.Info("Repository does not exist, creating...")
repo, _, err = client.CreateRepo(gitea.CreateRepoOption{
Name: name,
Private: private,
Name: *name,
Private: *private,
DefaultBranch: "master",
})
if err != nil {
Error.Fatalf("Error creating repository: %v", err)
logger.Error("Error creating repository: %v", err)
return
}
log.Printf("Repository created at:\n%s", repo.CloneURL)
logger.Info("Repository created at: %s", repo.CloneURL)
clipboard.Write(clipboard.FmtText, []byte(repo.CloneURL))
}
if !noinit {
if !*noinit {
logger.Info("Adding remote to local repository...")
cwd, err := os.Getwd()
if err != nil {
Error.Fatalf("Error getting current working directory: %v", err)
logger.Error("Error getting current working directory: %v", err)
return
}
cwd = path.Clean(cwd)
var localRepo *git.Repository
logger.Info("Checking if local repository exists at %s/.git...", cwd)
_, err = os.Stat(path.Join(cwd, ".git"))
if err == nil {
localRepo, err = git.PlainOpen(cwd)
if err != nil {
Error.Fatalf("Error opening git repository: %v", err)
logger.Error("Error opening git repository: %v", err)
return
}
} else {
localRepo, err = git.PlainInit(cwd, false)
if err != nil {
Error.Fatalf("Error initializing git repository: %v", err)
logger.Error("Error initializing git repository: %v", err)
return
}
}
_, err = localRepo.Remote(remote)
logger.Info("Checking if remote %s exists in local repository...", *remote)
_, err = localRepo.Remote(*remote)
if err == nil {
if forceInit {
err = localRepo.DeleteRemote(remote)
logger.Info("Remote %s exists in local repository", *remote)
if *forceInit {
logger.Info("Deleting remote %s from local repository...", *remote)
err = localRepo.DeleteRemote(*remote)
if err != nil {
Error.Fatalf("Error deleting remote %s from local repository: %v", remote, err)
logger.Error("Error deleting remote %s from local repository: %v", *remote, err)
return
}
logger.Info("Remote %s deleted from local repository", *remote)
} else {
Error.Fatalf("Remote %s already exists in local repository", remote)
logger.Error("Remote %s already exists in local repository", *remote)
return
}
}
logger.Info("Adding remote %s to local repository...", *remote)
_, err = localRepo.CreateRemote(&config.RemoteConfig{
Name: remote,
Name: *remote,
URLs: []string{repo.CloneURL},
})
if err != nil {
Error.Fatalf("Error adding remote %s to local repository: %v", remote, err)
logger.Error("Error adding remote %s to local repository: %v", *remote, err)
return
}
log.Printf("Remote added to local repository")
logger.Info("Remote added to local repository")
}
logger.Info("Done")
}