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
|
// Copyright 1994-2025 WIT.COM Inc Licensed GPL 3.0
package httppb
import (
"bytes"
"io/ioutil"
"net/http"
"net/url"
"os"
"os/user"
"go.wit.com/log"
)
// standard protobuf POST
// returns *HttpRequst protobuf
func DoPost(baseURL string, route string, data []byte) (*HttpRequest, 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(route) // Correctly produces ...:2520/patches
var err error
var req *http.Request
log.Info("httppb.HttpPost to", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err
}
username := os.Getenv("GIT_AUTHOR_NAME")
if username == "" {
usr, _ := user.Current()
username = usr.Username
}
req.Header.Set("author", username)
hostname, _ := os.Hostname()
req.Header.Set("hostname", hostname)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
reqPB, err := ReqToPB(req)
reqPB.URL = finalURL.String()
reqPB.ClientData = data
reqPB.ClientDataLen = int64(len(data))
reqPB.ServerData = body
reqPB.ServerDataLen = int64(len(body))
return reqPB, nil
}
/*
// HTTPRequestToProto converts an *http.Request to our custom HttpRequest protobuf message.
func (pb *Patches) AddHttpToPB(r *http.Request) error {
if pb == nil {
return log.Errorf("AddHttpToPB() pb was nil")
}
// Convert the header map. http.Header is a map[string][]string.
// We'll just take the first value for each header for simplicity.
headers := make(map[string]string)
for name, values := range r.Header {
if len(values) > 0 {
headers[name] = strings.Join(values, "\n")
}
}
pb.HttpRequest = &httppb.HttpRequest{
Method: r.Method,
URL: r.URL.String(),
Proto: r.Proto,
Headers: headers,
IP: getClientIP(r),
Host: r.Host,
Hostname: r.Header.Get("hostname"),
}
// pb.HttpRequest.Route = cleanURL(r.URL.Path)
return nil
}
*/
func HttpPost(baseURL string, route string, data []byte) ([]byte, error) {
// Fix using url.JoinPath (Best Practice)
tmpURL, _ := url.Parse(baseURL) // "http://forge.grid.wit.com:2520")
finalURL := tmpURL.JoinPath(route) // Correctly produces ...:2520/patches
var err error
var req *http.Request
log.Info("httppb.HttpPost to", finalURL.String())
req, err = http.NewRequest(http.MethodPost, finalURL.String(), bytes.NewBuffer(data))
if req == nil {
return nil, err
}
username := os.Getenv("GIT_AUTHOR_NAME")
if username == "" {
usr, _ := user.Current()
username = usr.Username
}
req.Header.Set("author", username)
hostname, _ := os.Hostname()
req.Header.Set("hostname", hostname)
return PostReq(req)
}
// Posts a reqest and returns the bytes returned
func PostReq(req *http.Request) ([]byte, error) {
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return []byte("client.Do(req) error"), err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return body, err
}
return body, nil
}
|
