1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// 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
}
|
