forgepb/patchset.http.go

// 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, 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) HttpPostVerbose(baseURL string, route string) (*Patchsets, 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
}