path: root/doPatchsets.go

package main

import (
	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"time"

	"go.wit.com/lib/gui/shell"
	"go.wit.com/lib/protobuf/forgepb"
	"go.wit.com/lib/protobuf/gitpb"
	"go.wit.com/log"
	"google.golang.org/protobuf/proto"
)

func doSendPatchsets(w http.ResponseWriter) {
	// log.HttpMode(w)
	// defer log.HttpMode(nil)

	dirname := filepath.Join(LIBDIR, "patchset/")
	// Open the directory
	entries, err := os.ReadDir(dirname)
	if err != nil {
		log.Printf("Error reading directory: %v\n", err)
		return
	}

	var psets *forgepb.Patchsets
	psets = forgepb.NewPatchsets() // this sets the proper handshake protobuf UUID

	// Iterate through the directory entries
	for _, entry := range entries {
		// Check if the entry is a file and matches the *.pb pattern
		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".pb" {
			bytes, err := os.ReadFile(filepath.Join(dirname, entry.Name()))
			if err != nil {
				fmt.Fprintln(w, entry.Name(), err)
				fmt.Println(entry.Name(), err)
				continue
			}
			var p *forgepb.Patchset
			p = new(forgepb.Patchset)
			err = p.Unmarshal(bytes)
			if err != nil {
				fmt.Fprintln(w, entry.Name(), err)
				fmt.Println(entry.Name(), err)
				continue
			}

			psets.Append(p)
		}
	}

	// marshal the protobuf to xfer over the socket
	data, err := psets.Marshal()
	if err != nil {
		log.Info("patchsets.Marshal() to wire failed", err)
		return
	}

	start := time.Now()
	log.Info("going to w.Write(data) with len", len(data))
	w.Write(data)
	age := shell.FormatDuration(time.Since(start))
	log.Printf("Done with xfer in (%s). happy hacking!\n", age)
}

func getPatchset(w http.ResponseWriter, pbname string) {
	if pbname == "" {
		fmt.Fprintf(w, "filename was empty")
		return
	}
	msg := fmt.Sprintf("filename = %s\n", pbname)
	log.Info(msg)

	filename := filepath.Join(LIBDIR, "patchset/", pbname)
	data, err := os.ReadFile(filename)
	if err != nil {
		msg := fmt.Sprintf("Error reading file %s: %v\n", filename, err)
		fmt.Printf(msg)
		fmt.Fprintf(w, msg)
		return
	}
	var m *forgepb.Patchset
	m = new(forgepb.Patchset)
	if err := m.Unmarshal(data); err != nil {
		msg := fmt.Sprintf("proto.Unmarshal() failed on %s len=%d\n", filename, len(data))
		fmt.Printf(msg)
		fmt.Fprintf(w, msg)
		msg = fmt.Sprintf("proto.Unmarshal() error %v\n", err)
		fmt.Printf(msg)
		fmt.Fprintf(w, msg)
		return
	}
	log.Info("going to w.Write(data) with len", len(data))
	w.Write(data)
}

func listPatchsets(w http.ResponseWriter) {
	dirname := filepath.Join(LIBDIR, "patchset/")
	// Open the directory
	entries, err := os.ReadDir(dirname)
	if err != nil {
		fmt.Printf("Error reading directory: %v\n", err)
		fmt.Fprintf(w, "Error reading directory: %v\n", err)
		return
	}

	// Iterate through the directory entries
	for _, entry := range entries {
		// Check if the entry is a file and matches the *.pb pattern
		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".pb" {
			bytes, err := os.ReadFile(filepath.Join(dirname, entry.Name()))
			if err != nil {
				fmt.Fprintln(w, entry.Name(), err)
				fmt.Println(entry.Name(), err)
				continue
			}
			var p *forgepb.Patchset
			p = new(forgepb.Patchset)
			err = p.Unmarshal(bytes)
			if err != nil {
				fmt.Fprintln(w, entry.Name(), err)
				fmt.Println(entry.Name(), err)
				continue
			}
			author := "Author: " + p.GitAuthorName
			author += " <" + p.GitAuthorEmail + ">"

			// author := "Author: " + os.Getenv("GIT_AUTHOR_NAME")
			// author += " <" + os.Getenv("GIT_AUTHOR_EMAIL") + ">"
			fmt.Fprintln(w, entry.Name(), p.Name, p.Comment, author)
			fmt.Println(entry.Name(), p.Name, p.Comment, author)
		}
	}
}

func savePatchset(w http.ResponseWriter, msg []byte) error {
	// log.Info("proto.Unmarshal() try message len", len(msg))
	var m *forgepb.Patchset
	m = new(forgepb.Patchset)
	if err := m.Unmarshal(msg); err != nil {
		log.Info("proto.Unmarshal() failed on wire message len", len(msg))
		log.Info("error =", err)
		return err
	}
	log.Info("GOT patchset:", len(msg))
	// fmt.Fprintln(w, "GOT patchset:", len(msg))
	now := time.Now()
	// timestamp := now.Format("2022.07.18.190545") // 50yr shout out to K&R
	timestamp := now.Format("2006.01.02.150405") // bummer. other date doesn't work?
	filename := filepath.Join(LIBDIR, "patchset/", timestamp+".submitted.pb")
	regfile, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
	if err != nil {
		log.Info("filename open error:", filename, err)
		// fmt.Fprintln(w, "filename open error:", filename, err)
		return err
	}
	regfile.Write(msg)
	regfile.Close()

	response := forgepb.NewPatches() // this sets the proper handshake protobuf UUID
	all := m.Patches.SortByFilename()
	for all.Scan() {
		p := all.Next()
		log.Info("filename:", p.Filename)
		var newp *forgepb.Patch
		newp = p
		newp = proto.Clone(p).(*forgepb.Patch)
		// fmt.Fprintln(w, "filename:", repo.Filename)
		response.Append(newp)
	}
	data, err := response.Marshal()
	if err != nil {
		log.Infof("savePatchset() proto.Marshal() error %v\n", err)
		return err
	}
	log.Infof("savePatchset() proto.Unmarshal() try to send len(msg)=%d back to the client forge\n", len(data))
	w.Write(data)
	return nil
}

func lookupRepos(msg []byte) (*gitpb.Repos, error) {
	log.Info("proto.Unmarshal() try message len", len(msg))
	m := gitpb.NewRepos()
	if err := m.Unmarshal(msg); err != nil {
		log.Info("gitpb.Repos.Unmarshal() failed. len(msg) =", len(msg), err)
		return m, err
	}
	newpb := gitpb.NewRepos()
	log.Info("GOT repos:", len(msg))
	for repo := range m.IterAll() {
		log.Infof("repo:%s,%s\n", repo.Namespace, repo.FullPath)
		if repo.Namespace == "" {
			log.Info("todo: namespace empty for", repo.FullPath)
			continue
			// return nil, fmt.Errorf("todo: namespace empty for " + repo.FullPath)
		}
		// fmt.Fprintln(w, "repo:", repo.FullPath, repo.Namespace)
		bytes, err := os.ReadFile(filepath.Join("/home/forge", repo.Namespace, "git.pb"))
		if err != nil {
			log.Info("todo: git.pb non-existant:", repo.FullPath)
			// return nil, err
			continue
		}
		newr := new(gitpb.Repo)
		if err := newr.Unmarshal(bytes); err != nil {
			log.Info("todo: unmarshal failed for git.pb:", repo.FullPath)
			// return nil, fmt.Errorf("todo: generate git.pb for " + repo.Namespace)
			continue
		}
		// log.Infof("repo unmarshal worked:%s,%s\n", repo.Namespace, repo.FullPath)
		newpb.Append(newr)
	}

	// print out found git.pb files
	for repo := range newpb.IterAll() {
		log.Infof("found repo:%-14s,%s\n", repo.GetMasterVersion(), repo.Namespace)
	}
	return newpb, nil
}

func updateRepos(msg []byte) (*gitpb.Repos, error) {
	log.Info("proto.Unmarshal() try message len", len(msg))
	m := gitpb.NewRepos()
	if err := m.Unmarshal(msg); err != nil {
		log.Info("gitpb.Repos.Unmarshal() failed. len(msg) =", len(msg), err)
		return m, err
	}
	newpb := gitpb.NewRepos()
	log.Info("GOT repos:", len(msg))
	for repo := range m.IterAll() {
		log.Infof("repo:%s,%s\n", repo.Namespace, repo.FullPath)
		if repo.Namespace == "" {
			log.Info("todo: namespace empty for", repo.FullPath)
			continue
			// return nil, fmt.Errorf("todo: namespace empty for " + repo.FullPath)
		}

		// save the git.pb files
		repopath := filepath.Join("/home/forge", repo.Namespace)
		if !shell.IsDir(repopath) {
			if err := os.MkdirAll(repopath, os.ModePerm); err != nil {
				log.Warn("mkdir fail", repo.Namespace, err)
				continue
			}
		}

		filename := filepath.Join(repopath, "git.pb")
		log.Infof("update repo file %s\n", repopath)
		// if !shell.Exists(filename) {
		data, err := repo.Marshal()
		if err != nil {
			log.Info("patchsets.Marshal() to wire failed", err)
			continue
		}
		gitpbf, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
		defer gitpbf.Close()
		if err != nil {
			log.Info("filename open error:", filename, err)
			continue
		}
		gitpbf.Write(data)
		// }

		// log.Infof("repo path: %s\n", repopath)
	}

	/*
		// print out found git.pb files
		for repo := range newpb.IterAll() {
			log.Infof("updated repo:%-14s,%s\n", repo.GetMasterVersion(), repo.Namespace)
		}
	*/
	return newpb, nil
}