git-vc/main.go

package main

import (
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"strings"
	"time"
)

var Error *log.Logger
var Warning *log.Logger

func init() {
	log.SetFlags(log.Ldate | log.Ltime)
	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, logFile)
	log.SetOutput(logger)

	Error = log.New(io.MultiWriter(logFile, os.Stderr, os.Stdout),
		fmt.Sprintf("%sERROR:%s ", "\033[0;101m", "\033[0m"),
		log.Ldate|log.Ltime)
	Warning = log.New(io.MultiWriter(logFile, os.Stdout),
		fmt.Sprintf("%sWarning:%s ", "\033[0;93m", "\033[0m"),
		log.Ldate|log.Ltime)
}

func getEnv(key, def string) string {
	var value, exists = os.LookupEnv(key)
	if exists {
		return value
	}
	return def
}

var ROOT string

func main() {
	log.SetFlags(log.Lmicroseconds)

	ROOT = filepath.ToSlash(strings.TrimSpace(getEnv("ROOT", "/tmp")))
	ROOT = path.Clean(ROOT)
	scanInterval, err := time.ParseDuration(getEnv("SCAN_INTERVAL", "1m"))
	if err != nil {
		Error.Printf("error parsing SCAN_INTERVAL: %v", err)
		return
	}

	log.Printf("Input args parsed as:")
	log.Printf("ROOT: %s", ROOT)
	log.Printf("SCAN_INTERVAL: %.0fs", scanInterval.Seconds())

	// This shit DOES NOT run correctly on windows
	// It absolutely butchers CRLF -> LF
	// And shits the bed
	// Thinking there are changed files
	// Making empty commits
	// And other stupid shit
	// It does run on unix though
	for {
		log.Printf("Running at %s", time.Now().Format(time.RFC3339))
		doRun()
		time.Sleep(scanInterval)
	}
}

func doRun() {
	err := os.Remove(filepath.Join(ROOT, ".git/index.lock"))
	if err != nil {
		Error.Printf("Error removing index.lock: %v", err)
	}

	status, err := doStatus()
	if err != nil {
		Error.Printf("Error executing doStatus code %v with out: %v", err, status)
		return
	}
	if status == "" {
		log.Printf("Nothing to commit")
		return
	}
	log.Printf("Changes detected")

	res, err := doAddAll()
	if err != nil {
		Error.Printf("Error executing doAddAll with code %v and out: %v", err, res)
		return
	}
	log.Printf("Changes added to index: %v", res)

	res, err = setIdentity()
	if err != nil {
		Error.Printf("Error setting identity with code %v and out: %v", err, res)
	}

	res, err = doCommit()
	if err != nil {
		Error.Printf("Error executing doCommitAll with code %v and out: %v", err, res)
		return
	}
	log.Printf("Changes committed: %v", res)
}

func doStatus() (string, error) {
	gitStatus := exec.Command("git", "status", "-s")
	gitStatus.Dir = ROOT
	out, err := gitStatus.CombinedOutput()
	if err != nil {
		return string(out), err
	}
	return string(out), nil
}
func doAddAll() (string, error) {
	gitAdd := exec.Command("git", "add", ".")
	gitAdd.Dir = ROOT
	out, err := gitAdd.CombinedOutput()
	if err != nil {
		return string(out), err
	}
	return string(out), nil
}

func doCommit() (string, error) {
	gitCommit := exec.Command("git", "commit", "-am", "Update")
	gitCommit.Dir = ROOT
	out, err := gitCommit.CombinedOutput()
	if err != nil {
		return string(out), err
	}
	return string(out), nil
}

func setIdentity() (string, error) {
	res, err := setUsername()
	if err != nil {
		log.Println("Error executing setUsername:", err)
		return string(res), err
	}
	res, err = setEmail()
	if err != nil {
		log.Println("Error executing setEmail:", err)
		return string(res), err
	}
	return "", nil
}
func setUsername() (string, error) {
	gitConfig := exec.Command("git", "config", "user.name", "system")
	gitConfig.Dir = ROOT
	out, err := gitConfig.CombinedOutput()
	if err != nil {
		return string(out), err
	}
	return string(out), nil
}
func setEmail() (string, error) {
	gitConfig := exec.Command("git", "config", "user.email", "system@localhost")
	gitConfig.Dir = ROOT
	out, err := gitConfig.CombinedOutput()
	if err != nil {
		return string(out), err
	}
	return string(out), nil
}