diff --git a/Makefile b/Makefile index a58aff9..60ef21f 100644 --- a/Makefile +++ b/Makefile @@ -4,13 +4,13 @@ VERSION = $(shell git describe --tags) BUILDTIME = $(shell date +%Y.%m.%d_%H%M) all: build-verbose - ./forged merge + # ./forged merge build: goimports GO111MODULE=off go build \ -ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}" -build-verbose: +build-verbose: goimports GO111MODULE=off go build -v -x \ -ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}" diff --git a/doPatchsets.go b/doPatchsets.go index 19e4815..67e81dc 100644 --- a/doPatchsets.go +++ b/doPatchsets.go @@ -54,7 +54,7 @@ func savePatchset(w http.ResponseWriter, msg []byte) error { log.Info("error =", err) return err } - log.Info("GOT patchset:", len(msg)) + log.Info("GOT patchset: m.Len() =", 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 diff --git a/handlePatches.go b/handlePatches.go index 730d04f..5d07924 100644 --- a/handlePatches.go +++ b/handlePatches.go @@ -5,10 +5,30 @@ import ( "strings" "go.wit.com/lib/protobuf/forgepb" + "go.wit.com/lib/protobuf/gitpb" "go.wit.com/lib/protobuf/httppb" "go.wit.com/log" ) +func addNewPatches(pb *forgepb.Patches, reqPB *httppb.HttpRequest) *forgepb.Patches { + newPatchesPB := new(forgepb.Patches) + for newpatch := range pb.IterAll() { + me.forge.AddNewPatch(newpatch) + newPatchesPB.Append(newpatch) + } + return newPatchesPB +} + +func sendPendingPatches(pb *forgepb.Patches, reqPB *httppb.HttpRequest) *forgepb.Patches { + allPatchesPB := new(forgepb.Patches) + for pset := range me.forge.Patchsets.IterAll() { + for newpatch := range pset.Patches.IterAll() { + allPatchesPB.Append(newpatch) + } + } + return allPatchesPB +} + func handlePatches(w http.ResponseWriter, pb *forgepb.Patches) error { route := pb.HttpRequest.Route @@ -23,6 +43,12 @@ func handlePatches(w http.ResponseWriter, pb *forgepb.Patches) error { return nil } +func makeReposPB(reqPB *httppb.HttpRequest) (*gitpb.Repos, error) { + pb := gitpb.NewRepos() + err := pb.Unmarshal(reqPB.Body) + return pb, err +} + func makePatchesPB(reqPB *httppb.HttpRequest) (*forgepb.Patches, error) { pb := forgepb.NewPatches() err := pb.Unmarshal(reqPB.Body) diff --git a/handleRepos.go b/handleRepos.go new file mode 100644 index 0000000..bf49a46 --- /dev/null +++ b/handleRepos.go @@ -0,0 +1,61 @@ +package main + +import ( + "strings" + + "go.wit.com/lib/protobuf/gitpb" + "go.wit.com/lib/protobuf/httppb" + "go.wit.com/log" +) + +func handleRepos(pb *gitpb.Repos, route string) error { + log.Info("GOT PATCHES ROUTE", route, "with # patches =", pb.Len()) + if strings.HasPrefix(route, "/patches/old") { + } else if strings.HasPrefix(route, "/patches/new") { + log.Info("add new patches") + } else { + log.Info("unknown route", route) + } + + return nil +} + +// returns a repo PB with just the master and devel branch versions +// is just this information so it keeps things small when it's sent over the wire +func getCurrentRepoVersions(namespace string) *gitpb.Repo { + newrepo := new(gitpb.Repo) + newrepo.Namespace = namespace + found := me.forge.Repos.FindByNamespace(namespace) + if found == nil { + // todo: clone repo here + return newrepo + } + newrepo.MasterHash = found.MasterHash + newrepo.DevelHash = found.DevelHash + newrepo.URL = found.URL + return newrepo +} + +func pullRequest(pb *gitpb.Repos, reqPB *httppb.HttpRequest) *gitpb.Repos { + versionsPB := gitpb.NewRepos() + for repo := range pb.IterAll() { + found := getCurrentRepoVersions(repo.Namespace) + versionsPB.Append(found) + } + return versionsPB +} + +func addRequest(pb *gitpb.Repos, reqPB *httppb.HttpRequest) *gitpb.Repos { + newReposPB := gitpb.NewRepos() + for repo := range pb.IterAll() { + if found := me.forge.Repos.FindByNamespace(repo.Namespace); found != nil { + // already know about this namespace + continue + } + newrepo := new(gitpb.Repo) + newrepo.Namespace = repo.Namespace + newrepo.URL = repo.URL + newReposPB.Append(newrepo) + } + return newReposPB +} diff --git a/http.go b/http.go index 8637d14..99f02d2 100644 --- a/http.go +++ b/http.go @@ -5,9 +5,9 @@ import ( "net" "net/http" "strings" - "time" - "go.wit.com/lib/gui/shell" + "go.wit.com/lib/protobuf/forgepb" + "go.wit.com/lib/protobuf/gitpb" "go.wit.com/lib/protobuf/httppb" "go.wit.com/log" ) @@ -58,7 +58,6 @@ func okHandler(w http.ResponseWriter, r *http.Request) { route := reqPB.Route parts := strings.Split(route, "?") - // log.Info("client sent url =", route, parts) requrl := parts[0] if route == "/" { @@ -76,153 +75,143 @@ func okHandler(w http.ResponseWriter, r *http.Request) { log.Warn("forged REQUEST URL =", requrl, "from =", who) + if strings.HasPrefix(route, "/repos/") { + pb, err := makeReposPB(reqPB) + if err != nil { + reqPB.Errors = append(reqPB.Errors, log.Sprintf("%v", err)) + } + result := gitpb.NewRepos() + switch route { + case "/repos/pull": + result = pullRequest(pb, reqPB) + case "/repos/add": + result = addRequest(pb, reqPB) + default: + result = pullRequest(pb, reqPB) + } + if err := result.SendReply(w, reqPB); err != nil { + log.Info("Oh well, Send to client failed. err =", err) + } + // todo: logReq(reqPB) + return + } if strings.HasPrefix(route, "/patches/") { pb, err := makePatchesPB(reqPB) - log.Info("err", err, "len", pb.Len()) - return - } - - if strings.HasPrefix(route, "/patches/applied") { - log.Info("todo: handle applied patches") - return - } - - if route == "/patchset" { - if err := savePatchset(w, reqPB.Body); err != nil { - log.Warn("forged /patchset error", err) - return - } - if err := me.forge.SavePatchsets(); err != nil { - log.Warn("savePatchsets() failed", err) - return - } - return - } - - if route == "/lookup" { - log.Info("doing lookup len(reqPB.Body) =", len(reqPB.Body)) - found, err := lookupRepos(reqPB.Body) if err != nil { - return + reqPB.Errors = append(reqPB.Errors, log.Sprintf("%v", err)) } - - /* - for repo := range repos.IterAll() { - repo.Namespace += "good" - log.Infof("repo:%s,%s\n", repo.Namespace, repo.FullPath) - } - */ - found.SendPB(w) + result := forgepb.NewPatches() + switch route { + case "/patches/new": + result = addNewPatches(pb, reqPB) + log.Infof("addNewPatches() pb.Len()=%d result.Len()=%d\n", pb.Len(), result.Len()) + case "/patches/get": + result = sendPendingPatches(pb, reqPB) + default: + result = addNewPatches(pb, reqPB) + } + if err := result.SendReply(w, reqPB); err != nil { + log.Info("Oh well, Send to client failed. err =", err) + } + // todo: logReq(reqPB) return } - if strings.HasPrefix(route, "/patches/") { - /* - pb, err := forgepb.GetPatchesFromHttp(reqPB) - if err != nil { - log.Info("error converting to patches PB") + /* + if route == "/patchset" { + if err := savePatchset(w, reqPB.Body); err != nil { + log.Warn("forged /patchset error", err) return } - handlePatches(w, pb) - */ - return - } - - if route == "/patchset" { - if err := savePatchset(w, reqPB.Body); err != nil { - log.Warn("forged /patchset error", err) - return - } - if err := me.forge.SavePatchsets(); err != nil { - log.Warn("savePatchsets() failed", err) - return - } - return - } - - if route == "/lookup" { - log.Info("doing lookup len(reqPB.Body) =", len(reqPB.Body)) - found, err := lookupRepos(reqPB.Body) - if err != nil { - return - } - - /* - for repo := range repos.IterAll() { - repo.Namespace += "good" - log.Infof("repo:%s,%s\n", repo.Namespace, repo.FullPath) + if err := me.forge.SavePatchsets(); err != nil { + log.Warn("savePatchsets() failed", err) + return } - */ - found.SendPB(w) - return - } - - if route == "/patchset" { - if err := savePatchset(w, reqPB.Body); err != nil { - log.Warn("forged /patchset error", err) - return - } - if err := me.forge.SavePatchsets(); err != nil { - log.Warn("savePatchsets() failed", err) - return - } - return - } - - if route == "/lookup" { - log.Info("doing lookup len(reqPB.Body) =", len(reqPB.Body)) - found, err := lookupRepos(reqPB.Body) - if err != nil { return } - /* - for repo := range repos.IterAll() { - repo.Namespace += "good" - log.Infof("repo:%s,%s\n", repo.Namespace, repo.FullPath) + if route == "/lookup" { + log.Info("doing lookup len(reqPB.Body) =", len(reqPB.Body)) + found, err := lookupRepos(reqPB.Body) + if err != nil { + return } - */ - found.SendPB(w) - return - } - if route == "/update" { - log.Info("doing update len(reqPB.Body) =", len(reqPB.Body)) - found, err := updateRepos(reqPB.Body) - if err != nil { + found.SendPB(w) + return + } + */ + /* + if strings.HasPrefix(route, "/patches/") { + pb, err := forgepb.GetPatchesFromHttp(reqPB) + if err != nil { + log.Info("error converting to patches PB") + return + } + handlePatches(w, pb) + return + } + */ + + /* + if route == "/patchset" { + if err := savePatchset(w, reqPB.Body); err != nil { + log.Warn("forged /patchset error", err) + return + } + if err := me.forge.SavePatchsets(); err != nil { + log.Warn("savePatchsets() failed", err) + return + } return } - found.SendPB(w) - return - } + if route == "/lookup" { + log.Info("doing lookup len(reqPB.Body) =", len(reqPB.Body)) + found, err := lookupRepos(reqPB.Body) + if err != nil { + return + } - if route == "/GetPatchsets" || route == "/patchsets/get" { - data, err := me.forge.Patchsets.Marshal() - if err != nil { - log.Info("patchsets.Marshal() to wire failed", err) + found.SendPB(w) return } - start := time.Now() - log.Info("going to w.Write(data) with len", len(data)) - w.Write(data) + if route == "/update" { + log.Info("doing update len(reqPB.Body) =", len(reqPB.Body)) + found, err := updateRepos(reqPB.Body) + if err != nil { + return + } + + found.SendPB(w) + return + } + */ + + /* + if route == "/GetPatchsets" || route == "/patchsets/get" { + data, err := me.forge.Patchsets.Marshal() + if err != nil { + log.Info("patchsets.Marshal() to wire failed", err) + return + } - /* start := time.Now() - log.Info("going to w.Write(reqPB.Body) with len", len(reqPB.Body)) - w.Write(reqPB.Body) - */ - age := shell.FormatDuration(time.Since(start)) - log.Printf("Done with xfer in (%s). happy hacking!\n", age) - return - } + log.Info("going to w.Write(data) with len", len(data)) + w.Write(data) - if route == "/patchsetget" { - filename := r.URL.Query().Get("filename") - getPatchset(w, filename) - return - } + age := shell.FormatDuration(time.Since(start)) + log.Printf("Done with xfer in (%s). happy hacking!\n", age) + return + } + + if route == "/patchsetget" { + filename := r.URL.Query().Get("filename") + getPatchset(w, filename) + return + } + */ if route == "/goReference.svg" { w.Header().Set("Content-Type", "image/svg+xml") diff --git a/main.go b/main.go index 62b4241..dc59f3e 100644 --- a/main.go +++ b/main.go @@ -22,8 +22,8 @@ var ARGNAME string = "forged" var resources embed.FS var HOSTNAME string = "forge.wit.com" -var LIBDIR string = "/var/lib/forged/" -var FORGEDIR string = "/home/forge" +var LIBDIR string = "/var/lib/forged/" // need to deprecate this +// var FORGEDIR string = "/home/forge" // deprecated? func main() { me = new(mainType) diff --git a/middleware.go b/middleware.go index 803e162..10048cd 100644 --- a/middleware.go +++ b/middleware.go @@ -1,13 +1,8 @@ package main -import ( - "bytes" - "context" - "io/ioutil" - "log" - "net/http" -) +// a middleware example. probably not interesting since we only pass protobufs +/* // Define a key type to avoid context key collisions. type contextKey string @@ -42,7 +37,6 @@ func bufferBodyMiddleware(next http.Handler) http.Handler { }) } -/* // okHandler is the final handler. It can now safely access the body from the context, // knowing that other middleware might have also read it. func okHandler(w http.ResponseWriter, r *http.Request) {