Server and Client daemons functional

main.go

@@ -1,42 +1,25 @@
 package main
 
 import (
-	"bufio"
 	"context"
+	"errors"
 	"flag"
 	"fmt"
+	"log"
 	"os"
-	"os/exec"
 	"os/signal"
-	"strconv"
 	"strings"
 	"sync"
 	"syscall"
 	"time"
 
-	"code.gitea.io/sdk/gitea"
 	"git.nevets.tech/Steven/ezconf"
-	"github.com/go-git/go-billy/v5"
-	"github.com/go-git/go-billy/v5/memfs"
-	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/plumbing/transport/http"
-	"github.com/go-git/go-git/v5/storage/memory"
-	"github.com/google/go-github/v55/github"
-	"github.com/makifdb/pidfile"
 )
 
+var version = "1.1.0-beta"
+var build = "1"
+
 var config *ezconf.Configuration
-var githubClient *github.Client
-var giteaClient *gitea.Client
-var domain string
-var legoBaseArgs []string
-
-var storage *memory.Storage
-var fs billy.Filesystem
-var workTree *git.Worktree
-var creds *http.BasicAuth
-
-var repo *git.Repository
 
 var ctx context.Context
 var cancel context.CancelFunc
@@ -48,10 +31,14 @@ func main() {
 
 	devFlag := flag.Bool("dev", false, "Developer Mode")
 
+	versionFlag := flag.Bool("version", false, "Show version")
+	helpFlag := flag.Bool("help", false, "Show help")
+
 	configFile := flag.String("config", "/etc/certman/certman.conf", "Configuration file")
 
 	newDomainFlag := flag.String("new-domain", "example.com", "Domain to create new configs and directories for")
 	newDomainDirFlag := flag.String("new-domain-dir", "/opt/certs/example.com", "Directory that certs will be stored in")
+	localOnlyFlag := flag.Bool("local-only", false, "Local only")
 
 	installFlag := flag.Bool("install", false, "Install Certman")
 	modeFlag := flag.String("mode", "client", "CertManager Mode [server, client]")
@@ -60,82 +47,143 @@ func main() {
 	newKeyFlag := flag.Bool("newkey", false, "Generate new encryption key")
 
 	reloadFlag := flag.Bool("reload", false, "Reload configs")
+	stopFlag := flag.Bool("stop", false, "Stop certman")
 
 	daemonFlag := flag.Bool("d", false, "Daemon Mode")
 
 	flag.Parse()
 
 	if *devFlag {
+		testDomain := "lunamc.org"
+		var err error
+		config, err = ezconf.LoadConfiguration("/etc/certman/certman.conf")
+		if err != nil {
+			log.Fatalf("Error loading configuration: %v\n", err)
+		}
+		err = loadDomainConfigs()
+		if err != nil {
+			log.Fatalf("Error loading configs: %v\n", err)
+		}
+
+		fmt.Println(testDomain)
+
 		os.Exit(0)
 	}
+
+	if *versionFlag {
+		fmt.Println("CertManager (certman) - Steven Tracey\nVersion: " + version + " build-" + build)
+		os.Exit(0)
+	}
+
+	if *helpFlag {
+		fmt.Printf(`CertManager (certman) - Steven Tracey
+Version: %s build-%s
+
+Subcommands: certman -subcommand
+ - version                  Shows the current version and build
+ - help                     Displays this help message
+ - newkey                   Creates a new random 256 bit base64 key
+
+Daemon Controls: certman -command
+ - d                        Start in daemon mode
+ - reload                   Reload configs
+ - stop                     Stop Daemon
+
+Installation: certman -install -mode (mode) [-t] [-config /path/to/file]
+ - install
+   - mode [mode]            Uses the specified config file [server, client]
+   - t                      Thin install (skip creating directories)
+   - config /path/to/file   Create config file at the specified path
+
+New Domain Options: certman -new-domain example.com [-new-domain-dir /path/to/certs]
+ - new-domain               Creates a new domain config
+   - new-domain-dir         Specifies directory for new domain certificates to be stored
+   - local-only             Don't create git repo
+
+`, version, build)
+
+		os.Exit(0)
+	}
+
 	if *newDomainFlag != "example.com" {
 		fmt.Printf("Creating new domain %s\n", *newDomainFlag)
 		createNewDomainConfig(*newDomainFlag)
 		createNewDomainCertsDir(*newDomainFlag, *newDomainDirFlag)
+		if !*localOnlyFlag {
+			//TODO create git repo
+		}
 		fmt.Println("Successfully created domain entry for " + *newDomainFlag + "\nUpdate config file as needed in /etc/certman/domains/" + *newDomainFlag + ".conf")
 		os.Exit(0)
 	}
+
 	if *installFlag {
 		if !*thinInstallFlag {
 			makeDirs()
 		}
-		config = ezconf.NewConfiguration(*configFile, strings.ReplaceAll(defaultConfig, "{mode}", *modeFlag))
+		var err error
+		config, err = ezconf.NewConfiguration(*configFile, strings.ReplaceAll(defaultConfig, "{mode}", *modeFlag))
+		if err != nil {
+			log.Fatalf("Error creating config: %s\n", err)
+		}
 		os.Exit(0)
 	}
 
 	if *newKeyFlag {
 		key, err := GenerateKey()
 		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
+			log.Fatalf("%v", err)
 		}
 		fmt.Printf(key)
 		os.Exit(0)
 	}
 
 	if *reloadFlag {
-		pidBytes, err := os.ReadFile("/var/run/certman.pid")
+		proc, err := getDaemonProcess()
 		if err != nil {
-			fmt.Printf("Error getting PID from /var/run/certman.pid: %v\n", err)
-			os.Exit(1)
-		}
-		pidStr := strings.TrimSpace(string(pidBytes))
-		daemonPid, err := strconv.Atoi(pidStr)
-		if err != nil {
-			fmt.Printf("Error converting PID string to int (%s): %v\n", pidStr, err)
-			os.Exit(1)
-		}
-		proc, err := os.FindProcess(daemonPid)
-		if err != nil {
-			fmt.Printf("Error finding process with PID %d: %v\n", daemonPid, err)
-			os.Exit(1)
+			log.Fatalf("Error getting daemon process: %v", err)
 		}
 
 		err = proc.Signal(syscall.SIGHUP)
 		if err != nil {
-			fmt.Printf("Error sending SIGHUP to PID %d: %v\n", daemonPid, err)
-			os.Exit(1)
+			log.Fatalf("Error sending SIGHUP to daemon PID: %v\n", err)
+		}
+		os.Exit(0)
+	}
+
+	if *stopFlag {
+		proc, err := getDaemonProcess()
+		if err != nil {
+			log.Fatalf("Error getting daemon process: %v", err)
+		}
+
+		err = proc.Signal(syscall.SIGTERM)
+		if err != nil {
+			log.Fatalf("Error sending SIGTERM to daemon PID: %v\n", err)
 		}
 		os.Exit(0)
 	}
 
 	if *daemonFlag {
-		err := pidfile.CreateOrUpdatePIDFile("/var/run/certman.pid")
+		err := createOrUpdatePIDFile("/var/run/certman.pid")
 		if err != nil {
-			fmt.Println("Error creating pidfile")
-			os.Exit(1)
+			if errors.Is(err, ErrorPIDInUse) {
+				log.Fatalf("Deemon process is already running\n")
+			}
+			log.Fatalf("Error creating pidfile: %v\n", err)
 		}
 
 		ctx, cancel = context.WithCancel(context.Background())
 
 		// Check if main config exists
 		if _, err := os.Stat(*configFile); os.IsNotExist(err) {
-			fmt.Println("Main config file not found, please run 'certman --install', then properly configure /etc/certman/certman.conf.")
-			os.Exit(1)
+			log.Fatalf("Main config file not found, please run 'certman --install', then properly configure /etc/certman/certman.conf.")
 		} else if err != nil {
 			fmt.Printf("Error opening %s: %v\n", *configFile, err)
 		}
-		config = ezconf.LoadConfiguration(*configFile)
+		config, err = ezconf.LoadConfiguration(*configFile)
+		if err != nil {
+			log.Fatalf("Error loading configuration: %v\n", err)
+		}
 
 		// Setup SIGINT and SIGTERM listeners
 		sigChannel := make(chan os.Signal, 1)
@@ -146,7 +194,7 @@ func main() {
 		signal.Notify(reloadSigChan, syscall.SIGHUP)
 		defer signal.Stop(reloadSigChan)
 
-		ticker := time.NewTicker(5 * time.Second)
+		ticker := time.NewTicker(30 * time.Second)
 		defer ticker.Stop()
 
 		wg.Add(1)
@@ -154,20 +202,17 @@ func main() {
 			fmt.Println("Starting CertManager in server mode...")
 			// Server Task loop
 			go func() {
+				initServer()
 				defer wg.Done()
 				for {
 					select {
 					case <-ctx.Done():
-						fmt.Println("Shutting down server")
+						stopServer()
 						return
 					case <-reloadSigChan:
-						{
-							fmt.Println("Reloading configs...")
-						}
+						reloadServer()
 					case <-ticker.C:
-						{
-							fmt.Println("Tick!")
-						}
+						serverTick()
 					}
 				}
 			}()
@@ -175,20 +220,17 @@ func main() {
 			fmt.Println("Starting CertManager in client mode...")
 			// Client Task loop
 			go func() {
+				initClient()
 				defer wg.Done()
 				for {
 					select {
 					case <-ctx.Done():
-						fmt.Println("Shutting down client")
+						stopClient()
 						return
 					case <-reloadSigChan:
-						{
-							fmt.Println("Reloading configs...")
-						}
+						reloadClient()
 					case <-ticker.C:
-						{
-							fmt.Println("Tick!")
-						}
+						clientTick()
 					}
 				}
 			}()
@@ -207,119 +249,143 @@ func main() {
 
 func stop() {
 	cancel()
+	clearPIDFile()
 }
 
-func maindis() {
-	config = ezconf.NewConfiguration("/etc/certman/certman.conf", "")
-
-	var err error
-	args := os.Args
-
-	// -d
-	hasDomain, domainIndex := contains(args, "-d")
-	if hasDomain {
-		domain = args[domainIndex+1]
-	} else {
-		fmt.Printf("Error, no domain passed. Please add '-d domain.tld' to the command\n")
-		os.Exit(1)
-	}
-
-	hasDns, dnsIndex := contains(args, "--dns")
-
-	legoBaseArgs = []string{
-		"-a",
-		"--dns",
-		"cloudflare",
-		"--email=" + config.GetAsString("Cloudflare.cf_email"),
-		"--domains=" + domain,
-		"--domains=*." + domain,
-		"--path=" + config.GetAsString("Certificates.certs_path"),
-	}
-	legoNewSiteArgs := append(legoBaseArgs, "run")
-	legoRenewSiteArgs := append(legoBaseArgs, "renew", "--days", "90")
-
-	subdomains := config.GetAsStrings("Certificates.subdomains")
-	if subdomains != nil {
-		for i, subdomain := range subdomains {
-			legoBaseArgs = insert(legoBaseArgs, 5+i, "--domains=*."+subdomain+"."+domain)
-		}
-	}
-
-	if hasDns {
-		legoBaseArgs = insert(legoBaseArgs, 3, "--dns.resolvers="+args[dnsIndex+1])
-	}
-
-	creds = &http.BasicAuth{
-		Username: config.GetAsString("Git.username"),
-		Password: config.GetAsString("Git.api_token"),
-	}
-	giteaClient = createGiteaClient()
-
-	storage = memory.NewStorage()
-	fs = memfs.New()
-
-	var cmd *exec.Cmd
-	switch args[len(args)-1] {
-	case "gen":
-		{
-			url := createGiteaRepo()
-			repo, workTree = cloneRepo(url)
-			cmd = exec.Command("lego", legoNewSiteArgs...)
-		}
-	case "renew":
-		{
-			repo, workTree = cloneRepo(config.GetAsString("Git.server") + "/" + config.GetAsString("Git.org_name") + "/" + domain + "-certificates.git")
-			cmd = exec.Command("lego", legoRenewSiteArgs...)
-		}
-	case "gen-cert-only":
-		{
-			cmd = exec.Command("lego", legoNewSiteArgs...)
-		}
-	case "renew-cert-only":
-		{
-			cmd = exec.Command("lego", legoRenewSiteArgs...)
-		}
-	case "git":
-		{
-			url := createGiteaRepo()
-			repo, workTree = cloneRepo(url)
-			addAndPushCerts()
-			os.Exit(0)
-		}
-	default:
-		{
-			fmt.Println("Missing arguments: conclude command with 'gen' or 'renew'")
-			os.Exit(1)
-		}
-	}
-	cmd.Env = append(cmd.Environ(),
-		"CLOUDFLARE_DNS_API_TOKEN="+config.GetAsString("Cloudflare.cf_api_token"),
-		"CLOUDFLARE_ZONE_API_TOKEN"+config.GetAsString("Cloudflare.cf_api_token"),
-		"CLOUDFLARE_EMAIL="+config.GetAsString("Cloudflare.cf_email"),
-	)
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		fmt.Printf("Error getting stdout from lego process: %v\n", err)
-		os.Exit(1)
-	}
-	err = cmd.Start()
-	if err != nil {
-		fmt.Printf("Error creating certs with lego: %v\n", err)
-		os.Exit(1)
-	}
-	scanner := bufio.NewScanner(stdout)
-	go func() {
-		for scanner.Scan() {
-			fmt.Println(scanner.Text())
-		}
-		if err := scanner.Err(); err != nil {
-			fmt.Fprintln(os.Stderr, "reading standard input:", err)
-		}
-	}()
-	err = cmd.Wait()
-	if err != nil {
-		fmt.Printf("Error waiting for lego command to finish: %v\n", err)
-		os.Exit(1)
-	}
-	addAndPushCerts()
-}
+//var legoBaseArgs []string
+//
+//func maindis() {
+//	config, err := ezconf.NewConfiguration("/etc/certman/certman.conf", "")
+//	var domain string
+//	if err != nil {
+//		log.Fatalf("Error loading configuration: %v\n", err)
+//	}
+//
+//	args := os.Args
+//
+//	// -d
+//	hasDomain, domainIndex := contains(args, "-d")
+//	if hasDomain {
+//		domain = args[domainIndex+1]
+//	} else {
+//		log.Fatalf("Error, no domain passed. Please add '-d domain.tld' to the command\n")
+//	}
+//
+//	hasDns, dnsIndex := contains(args, "--dns")
+//
+//	legoBaseArgs = []string{
+//		"-a",
+//		"--dns",
+//		"cloudflare",
+//		"--email=" + config.GetAsString("Cloudflare.cf_email"),
+//		"--domains=" + domain,
+//		"--domains=*." + domain,
+//		"--path=" + config.GetAsString("Certificates.certs_path"),
+//	}
+//	legoNewSiteArgs := append(legoBaseArgs, "run")
+//	legoRenewSiteArgs := append(legoBaseArgs, "renew", "--days", "90")
+//
+//	subdomains := config.GetAsStrings("Certificates.subdomains")
+//	if subdomains != nil {
+//		for i, subdomain := range subdomains {
+//			legoBaseArgs = insert(legoBaseArgs, 5+i, "--domains=*."+subdomain+"."+domain)
+//		}
+//	}
+//
+//	if hasDns {
+//		legoBaseArgs = insert(legoBaseArgs, 3, "--dns.resolvers="+args[dnsIndex+1])
+//	}
+//
+//	giteaClient = createGiteaClient()
+//	gitWorkspace := &GitWorkspace{
+//		Storage: memory.NewStorage(),
+//		FS:      memfs.New(),
+//	}
+//
+//	var cmd *exec.Cmd
+//	switch args[len(args)-1] {
+//	case "gen":
+//		{
+//			url := createGiteaRepo(domain)
+//			if url == "" {
+//				return
+//			}
+//			gitWorkspace.Repo, gitWorkspace.WorkTree = cloneRepo(url, gitWorkspace)
+//			if gitWorkspace.Repo == nil {
+//				return
+//			}
+//			cmd = exec.Command("lego", legoNewSiteArgs...)
+//		}
+//	case "renew":
+//		{
+//			gitWorkspace.Repo, gitWorkspace.WorkTree = cloneRepo(config.GetAsString("Git.server")+"/"+config.GetAsString("Git.org_name")+"/"+domain+"-certificates.git", gitWorkspace)
+//			if gitWorkspace.Repo == nil {
+//				return
+//			}
+//			cmd = exec.Command("lego", legoRenewSiteArgs...)
+//		}
+//	case "gen-cert-only":
+//		{
+//			cmd = exec.Command("lego", legoNewSiteArgs...)
+//		}
+//	case "renew-cert-only":
+//		{
+//			cmd = exec.Command("lego", legoRenewSiteArgs...)
+//		}
+//	case "git":
+//		{
+//			url := createGiteaRepo(domain)
+//			if url == "" {
+//				return
+//			}
+//			gitWorkspace.Repo, gitWorkspace.WorkTree = cloneRepo(url, gitWorkspace)
+//			if gitWorkspace.Repo == nil {
+//				return
+//			}
+//			err := addAndPushCerts(domain, gitWorkspace)
+//			if err != nil {
+//				return
+//			}
+//			os.Exit(0)
+//		}
+//	default:
+//		{
+//			fmt.Println("Missing arguments: conclude command with 'gen' or 'renew'")
+//			os.Exit(1)
+//		}
+//	}
+//	cmd.Env = append(cmd.Environ(),
+//		"CLOUDFLARE_DNS_API_TOKEN="+config.GetAsString("Cloudflare.cf_api_token"),
+//		"CLOUDFLARE_ZONE_API_TOKEN"+config.GetAsString("Cloudflare.cf_api_token"),
+//		"CLOUDFLARE_EMAIL="+config.GetAsString("Cloudflare.cf_email"),
+//	)
+//	stdout, err := cmd.StdoutPipe()
+//	if err != nil {
+//		fmt.Printf("Error getting stdout from lego process: %v\n", err)
+//		os.Exit(1)
+//	}
+//	err = cmd.Start()
+//	if err != nil {
+//		fmt.Printf("Error creating certs with lego: %v\n", err)
+//		os.Exit(1)
+//	}
+//	scanner := bufio.NewScanner(stdout)
+//	go func() {
+//		for scanner.Scan() {
+//			fmt.Println(scanner.Text())
+//		}
+//		if err := scanner.Err(); err != nil {
+//			fmt.Fprintln(os.Stderr, "reading standard input:", err)
+//		}
+//	}()
+//	err = cmd.Wait()
+//	if err != nil {
+//		fmt.Printf("Error waiting for lego command to finish: %v\n", err)
+//		os.Exit(1)
+//	}
+//	err = addAndPushCerts(domain, gitWorkspace)
+//	if err != nil {
+//		fmt.Printf("Error adding and pushing certs: %v\n", err)
+//		return
+//	}
+//}