jcarr
/
forgepb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

code is autogen'd now

This commit is contained in:
Jeff Carr 2025-09-08 04:35:10 -05:00
parent 556c549265
commit e2e30d02d1
2 changed files with 11 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
patchset.Make.go
View File

@ -10,10 +10,21 @@ import (
"github.com/google/uuid" "github.com/google/uuid"
"go.wit.com/lib/protobuf/gitpb" "go.wit.com/lib/protobuf/gitpb"
"go.wit.com/lib/protobuf/httppb"
"go.wit.com/log" "go.wit.com/log"
timestamppb "google.golang.org/protobuf/types/known/timestamppb" timestamppb "google.golang.org/protobuf/types/known/timestamppb"
) )
func (p *Patches) HttpPostVerbose(baseURL string, route string) (*Patches, *httppb.HttpRequest, error) {
p.PrintTable()
return p.HttpPost(baseURL, route)
}
func (p *Patchsets) HttpPostVerbose(baseURL string, route string) (*Patchsets, *httppb.HttpRequest, error) {
p.PrintTable()
return p.HttpPost(baseURL, route)
}
func newPatchset(name string) *Patchset { func newPatchset(name string) *Patchset {
pset := new(Patchset) pset := new(Patchset)
pset.Name = name pset.Name = name

171
patchset.http.go
View File

@ -1,171 +0,0 @@
// Copyright 1994-2025 WIT.COM Inc Licensed GPL 3.0
package forgepb
import (
"bytes"
"net/http"
"net/url"
"os"
"os/user"
"go.wit.com/lib/protobuf/httppb"
"go.wit.com/log"
)
func (p *Patches) HttpPostVerbose(baseURL string, route string) (*Patches, *httppb.HttpRequest, error) {
p.PrintTable()
return p.HttpPost(baseURL, route)
}
/*
func (p *Patches) HttpPost(baseURL string, route string) (*Patches, error) {
if p == nil {
log.Info("can't post a nil PB")
return nil, log.Errorf("can't post a nil PB")
}
// if you ever have "http://www.wit.com//" GO will regect the server recieving it.
// Even though the linux kernel gets the network payload
// also it never gives you an error about that, it just goes away invisably inside GO
tmpURL, _ := url.Parse(baseURL) // "http://forge.grid.wit.com:2520")
finalURL := tmpURL.JoinPath("/patches/", route) // Correctly produces ...:2520/patches
data, _ := p.Marshal()
var err error
var req *http.Request
log.Info("patches PB HttpPost", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err
}
usr, _ := user.Current()
req.Header.Set("author", usr.Username)
hostname, _ := os.Hostname()
req.Header.Set("hostname", hostname)
newdata, err := rawHttpPost(req)
newpb := NewPatches()
err = newpb.Unmarshal(newdata)
if newpb == nil {
log.Info("HttpPost() newpb WAS NIL")
}
if err != nil {
log.Info("HttpPost() err =", err)
} else {
log.Infof("patchset PB HttpPost %s sent len(%d) got len(%d)\n", finalURL.String(), p.Len(), newpb.Len())
}
return newpb, err
}
*/
func (p *Patchset) HttpPost(baseURL string, route string) (*Patchset, error) {
// if you ever have "http://www.wit.com//" GO will regect the server recieving it.
// Even though the linux kernel gets the network payload
// also it never gives you an error about that, it just goes away invisably inside GO
tmpURL, _ := url.Parse(baseURL) // "http://forge.grid.wit.com:2520")
finalURL := tmpURL.JoinPath("/patchset/", route) // Correctly produces ...:2520/patches
data, _ := p.Marshal()
var err error
var req *http.Request
log.Info("patchset PB HttpPost", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err
}
usr, _ := user.Current()
req.Header.Set("author", usr.Username)
hostname, _ := os.Hostname()
req.Header.Set("hostname", hostname)
newdata, err := rawHttpPost(req)
newpb := new(Patchset)
err = newpb.Unmarshal(newdata)
log.Infof("patchset PB HttpPost %s sent (%d)bytes got (%d)bytes\n", finalURL.String(), len(data), len(newdata))
return newpb, err
}
/*
func (p *Patches) SendReply(w http.ResponseWriter, reqPB *httppb.HttpRequest) error {
data, err := p.Marshal()
if err != nil {
reqPB.Errors = append(reqPB.Errors, log.Sprintf("%v", err))
}
if len(data) == 0 {
reqPB.Errors = append(reqPB.Errors, "Patches PB data was nil/emtpy without Marsha() error")
return nil
}
i, err := w.Write(data)
if err != nil {
reqPB.Errors = append(reqPB.Errors, log.Sprintf("i=%d %v", i, err))
}
return err
}
func (p *Patchsets) SendReply(w http.ResponseWriter, reqPB *httppb.HttpRequest) error {
data, err := p.Marshal()
if err != nil {
reqPB.Errors = append(reqPB.Errors, log.Sprintf("%v", err))
}
if len(data) == 0 {
reqPB.Errors = append(reqPB.Errors, "Patchsets PB data was nil/emtpy without Marsha() error")
return nil
}
i, err := w.Write(data)
if err != nil {
reqPB.Errors = append(reqPB.Errors, log.Sprintf("i=%d %v", i, err))
} else {
reqPB.Errors = append(reqPB.Errors, log.Sprintf("sent %d bytes back to client ok", i))
}
return err
}
*/
func (p *Patchsets) HttpPostVerbose(baseURL string, route string) (*Patchsets, *httppb.HttpRequest, error) {
p.PrintTable()
return p.HttpPost(baseURL, route)
}
/*
func (p *Patchsets) HttpPost(baseURL string, route string) (*Patchsets, error) {
// if you ever have "http://www.wit.com//" GO will regect the server recieving it.
// Even though the linux kernel gets the network payload
// also it never gives you an error about that, it just goes away invisably inside GO
tmpURL, _ := url.Parse(baseURL) // "http://forge.grid.wit.com:2520")
finalURL := tmpURL.JoinPath("/patchsets/", route) // Correctly produces ...:2520/patches
data, _ := p.Marshal()
var err error
var req *http.Request
log.Info("patchsets PB HttpPost", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err
}
usr, _ := user.Current()
req.Header.Set("author", usr.Username)
hostname, _ := os.Hostname()
req.Header.Set("hostname", hostname)
newdata, err := rawHttpPost(req)
newpb := NewPatchsets()
err = newpb.Unmarshal(newdata)
log.Infof("patchset PB HttpPost %s sent len(%d) got len(%d)\n", finalURL.String(), p.Len(), newpb.Len())
return newpb, err
}
*/