296 lines
8.2 KiB
Go
296 lines
8.2 KiB
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"
|
|
)
|
|
|
|
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) {
|
|
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
|
|
}
|
|
log.Info("GOT patchset:", len(msg))
|
|
fmt.Fprintln(w, "GOT patchset:", len(msg))
|
|
all := m.Patches.SortByFilename()
|
|
for all.Scan() {
|
|
repo := all.Next()
|
|
log.Info("filename:", repo.Filename)
|
|
fmt.Fprintln(w, "filename:", repo.Filename)
|
|
}
|
|
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
|
|
}
|
|
regfile.Write(msg)
|
|
regfile.Close()
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
/* save the git.pb files
|
|
+ if repo.Namespace == "" {
|
|
+ log.Infof("repo: ERROR. no namespace. %s\n", repo.FullPath)
|
|
+ continue
|
|
+ }
|
|
+
|
|
+ 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")
|
|
+ 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)
|
|
*/
|
|
|
|
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
|
|
}
|