// Do sends an API request and returns the API response. The API response is
// JSON decoded and stored in the value pointed to by v, or returned as an
// error if an API error has occurred. If v implements the io.Writer
// interface, the raw response body will be written to v, without attempting to
// first decode it.
func (c *Client) Do(req *http.Request, v interface{}) (*Response, error) {
var err error
if c.DebugHTTP {
// If the request is a multi-part form, then it's probably a
// file upload, in which case we don't want to spewing out the
// file contents into the debug log (especially if it's been
// gzipped)
var requestDump []byte
if strings.Contains(req.Header.Get("Content-Type"), "multipart/form-data") {
requestDump, err = httputil.DumpRequestOut(req, false)
} else {
requestDump, err = httputil.DumpRequestOut(req, true)
}
logger.Debug("ERR: %s\n%s", err, string(requestDump))
}
ts := time.Now()
logger.Debug("%s %s", req.Method, req.URL)
resp, err := c.client.Do(req)
if err != nil {
return nil, err
}
logger.Debug("↳ %s %s (%s %s)", req.Method, req.URL, resp.Status, time.Now().Sub(ts))
defer resp.Body.Close()
defer io.Copy(ioutil.Discard, resp.Body)
response := newResponse(resp)
if c.DebugHTTP {
responseDump, err := httputil.DumpResponse(resp, true)
logger.Debug("\nERR: %s\n%s", err, string(responseDump))
}
err = checkResponse(resp)
if err != nil {
// even though there was an error, we still return the response
// in case the caller wants to inspect it further
return response, err
}
if v != nil {
if w, ok := v.(io.Writer); ok {
io.Copy(w, resp.Body)
} else {
err = json.NewDecoder(resp.Body).Decode(v)
}
}
return response, err
}
func createNewFolder(authToken string, folder string, folderName string) string {
client := http.Client{}
rObj := Folder{DisplayName: folderName}
payload, err := xml.Marshal(rObj)
if *DEBUG {
fmt.Println("Posting to " + folder + " with:\n" + string(payload))
}
req, err := http.NewRequest("POST", folder, strings.NewReader(string(payload)))
req.Header.Set("Authorization", authToken)
if *DEBUG {
dump, _ := httputil.DumpRequestOut(req, true)
fmt.Println(string(dump))
}
res, err := client.Do(req)
if err != nil {
fmt.Println("ERROR: ")
fmt.Println(err)
}
defer res.Body.Close()
if *DEBUG {
dump, _ := httputil.DumpResponse(res, true)
fmt.Println(string(dump))
}
return res.Header.Get("Location")
}
func (c *BClient) get(url string, data, urlData interface{}) error {
rUrl := getUrl(url, urlData)
req, _ := http.NewRequest("GET", rUrl, nil)
signDataRequest(req, c.accessToken, c.ConsumerKey, c.ConsumerSecret)
if debugOn {
debug(httputil.DumpRequestOut(req, true))
}
resp, err := http.DefaultClient.Do(req)
defer resp.Body.Close()
if debugOn {
debug(httputil.DumpResponse(resp, true))
log.Println("response code:", resp.StatusCode)
}
if resp.StatusCode != 200 {
log.Println("response code:", resp.StatusCode, resp.Status)
return errors.New("Http Status != 200")
}
if err != nil {
return err
}
return json.NewDecoder(resp.Body).Decode(data)
}
// Request - Trace HTTP Request
func (t Trace) Request(req *http.Request) (err error) {
origAuth := req.Header.Get("Authorization")
// Authorization (S3 v4 signature) Format:
// Authorization: AWS4-HMAC-SHA256 Credential=AKIAJNACEGBGMXBHLEZA/20150524/us-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=bbfaa693c626021bcb5f911cd898a1a30206c1fad6bad1e0eb89e282173bd24c
// Strip out access-key-id from: Credential=<access-key-id>/<date>/<aws-region>/<aws-service>/aws4_request
regCred := regexp.MustCompile("Credential=([A-Z]+)/")
newAuth := regCred.ReplaceAllString(origAuth, "Credential=**REDACTED**/")
// Strip out 256-bit signature from: Signature=<256-bit signature>
regSign := regexp.MustCompile("Signature=([[0-9a-f]+)")
newAuth = regSign.ReplaceAllString(newAuth, "Signature=**REDACTED**")
// Set a temporary redacted auth
req.Header.Set("Authorization", newAuth)
reqTrace, err := httputil.DumpRequestOut(req, false) // Only display header
if err == nil {
console.Debug(string(reqTrace))
}
// Undo
req.Header.Set("Authorization", origAuth)
return err
}
// RoundTrip implements the RoundTripper interface.
func (t *TransportLogger) RoundTrip(req *http.Request) (res *http.Response, err error) {
transport := t.Transport
if transport == nil {
transport = http.DefaultTransport
}
writer := t.Writer
if writer == nil {
writer = os.Stdout
}
reqDump, err := httputil.DumpRequestOut(req, true)
writer.Write(reqDump)
writer.Write([]byte("\n"))
res, err = transport.RoundTrip(req)
if err != nil {
return
}
resDump, err := httputil.DumpResponse(res, true)
writer.Write(resDump)
writer.Write([]byte("\n"))
return
}
func DumpRequest(req *http.Request, name string) {
dump1, err := httputil.DumpRequestOut(req, true)
if err != nil {
log.WithField("tag", TAG).Errorf("dump of %v request failed", name)
}
ioutil.WriteFile(name, dump1, 0777)
}
func DumpRequest(req *http.Request) {
out, err := httputil.DumpRequestOut(req, true)
if err != nil {
panic(err)
}
fmt.Printf("%q\n", out)
}
// RoundTrip implements the RoundTripper interface.
func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error) {
// Force user agent
req.Header.Set("User-Agent", UserAgent)
// Log request
if t.logHeader || t.logBody {
buf, _ := httputil.DumpRequestOut(req, t.logBody)
Debug(nil, "%s", separatorReq)
Debug(nil, "%s", "HTTP REQUEST")
Debug(nil, "%s", string(buf))
Debug(nil, "%s", separatorReq)
}
// Do round trip
resp, err = t.Transport.RoundTrip(req)
// Log response
if t.logHeader || t.logBody {
Debug(nil, "%s", separatorResp)
Debug(nil, "%s", "HTTP RESPONSE")
if err != nil {
Debug(nil, "Error: %v", err)
} else {
buf, _ := httputil.DumpResponse(resp, t.logBody)
Debug(nil, "%s", string(buf))
}
Debug(nil, "%s", separatorResp)
}
if err == nil {
checkServerTime(req, resp)
}
return resp, err
}
func (ts *TestSuite) Run(server *httptest.Server) {
for _, test := range ts.Tests {
session := &TestSession{
Server: server,
Test: &test,
Request: &http.Request{},
}
work := func() {
for _, cr := range test.Criteria {
cr.Setup(session)
}
cl := http.Client{}
res, err := cl.Do(session.Request)
Check(err)
session.Response = res
for _, cr := range test.Criteria {
cr.Check(session)
}
}
err := Catch(work)
if err != nil {
rawReq, terr := httputil.DumpRequestOut(session.Request, true)
Check(terr)
rawRes, terr := httputil.DumpResponse(session.Response, true)
Check(terr)
ts.T.Errorf("Error running test: %#v\n\nTEST DESCRIPTION:\n\n%s\nREQUEST:\n\n%s\nRESPONSE:\n\n%s\n", err, test.Describe(), string(rawReq), string(rawRes))
}
}
}
func main() {
var body []byte
var response *http.Response
var request *http.Request
url := "http://api.open-notify.org/iss-now.json"
request, err := http.NewRequest("GET", url, nil)
if err == nil {
request.Header.Add("Content-Type", "application/json")
debug(httputil.DumpRequestOut(request, true))
response, err = (&http.Client{}).Do(request)
}
if err == nil {
defer response.Body.Close()
debug(httputil.DumpResponse(response, true))
body, err = ioutil.ReadAll(response.Body)
}
if err == nil {
fmt.Printf("%s\n\n", body)
} else {
log.Fatalf("Error: %s\n\n", err)
}
var data IssNow
err = json.Unmarshal(body, &data)
if err != nil {
panic(err)
}
// fmt.Printf("%v\n", data)
fmt.Printf("Time: %v | Lat./Long. : %v, %v\n", data.Timestamp, data.Position.Latitude, data.Position.Longitude)
}
// Main method, opens the connection, sets basic auth, applies headers,
// parses response json.
func (r *Resource) do(method string) (*Resource, error) {
url := *r.Api.BaseUrl
if len(url.Path) > 0 {
url.Path += "/" + r.Url
} else {
url.Path = r.Url
}
if r.Api.PathSuffix != "" {
url.Path += r.Api.PathSuffix
}
url.RawQuery = r.QueryValues.Encode()
req, err := http.NewRequest(method, url.String(), r.Payload)
if err != nil {
return r, err
}
if r.Api.BasicAuth != nil {
req.SetBasicAuth(r.Api.BasicAuth.Username, r.Api.BasicAuth.Password)
}
if r.Headers != nil {
for k, _ := range r.Headers {
req.Header.Set(k, r.Headers.Get(k))
}
}
b, _ := httputil.DumpRequestOut(req, true)
log.Printf("--- DUMP REQUEST:\n%s\n\n", string(b))
resp, err := r.Api.Client.Do(req)
if err != nil {
return r, err
}
// Read the content
var bodyBytes []byte
if resp.Body != nil {
bodyBytes, _ = ioutil.ReadAll(resp.Body)
resp.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
b, _ = httputil.DumpResponse(resp, true)
log.Printf("=== DUMP RESPONSE:\n%s\n\n", string(b))
resp.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
}
r.Raw = resp
if resp.StatusCode >= 400 {
return r, nil
}
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(r.Response)
if err != nil {
return r, err
}
return r, nil
}
func (tr debugTransport) logRequest(req *http.Request) {
dump, err := httputil.DumpRequestOut(req, true)
if err != nil {
fmt.Fprintf(tr.Writer, "%s: %s\n", "could not dump request", err)
}
fmt.Fprint(tr.Writer, string(dump))
}
// Perform the test of an individual server
func testFallbackServer(fb *client.ChainedServerInfo, workerID int) (output fullOutput) {
// Test connectivity
fb.Pipelined = true
dialer, err := fb.Dialer(DeviceID)
if err != nil {
output.err = fmt.Errorf("%v: error building dialer: %v", fb.Addr, err)
return
}
c := &http.Client{
Transport: &http.Transport{
Dial: dialer.Dial,
},
}
req, err := http.NewRequest("GET", "http://www.google.com/humans.txt", nil)
if err != nil {
output.err = fmt.Errorf("%v: NewRequest to humans.txt failed: %v", fb.Addr, err)
return
}
if *verbose {
reqStr, _ := httputil.DumpRequestOut(req, true)
output.info = []string{"\n" + string(reqStr)}
}
req.Header.Set("X-LANTERN-AUTH-TOKEN", fb.AuthToken)
resp, err := c.Do(req)
if err != nil {
output.err = fmt.Errorf("%v: requesting humans.txt failed: %v", fb.Addr, err)
return
}
if *verbose {
respStr, _ := httputil.DumpResponse(resp, true)
output.info = append(output.info, "\n"+string(respStr))
}
defer func() {
if err := resp.Body.Close(); err != nil {
log.Debugf("Unable to close response body: %v", err)
}
}()
if resp.StatusCode != 200 {
output.err = fmt.Errorf("%v: bad status code: %v", fb.Addr, resp.StatusCode)
return
}
bytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
output.err = fmt.Errorf("%v: error reading response body: %v", fb.Addr, err)
return
}
body := string(bytes)
if body != expectedBody {
output.err = fmt.Errorf("%v: wrong body: %s", fb.Addr, body)
return
}
log.Debugf("Worker %d: Fallback %v OK.\n", workerID, fb.Addr)
if *verify {
verifyFallback(fb, c)
}
return
}
func uploadFile(authToken string, fileLocation string, file string) {
client := http.Client{}
fData, err := ioutil.ReadFile(file)
if err != nil {
fmt.Println(err.Error())
}
req, err := http.NewRequest("PUT", fileLocation+"/data", strings.NewReader(string(fData)))
req.Header.Set("Authorization", authToken)
req.Header.Set("Content-Type", "application/octet-stream")
req.Header.Set("Content-Length", fmt.Sprint(len(fData)))
if *DEBUG {
dump, _ := httputil.DumpRequestOut(req, true)
fmt.Println(string(dump))
}
res, err := client.Do(req)
if err != nil {
fmt.Println("ERROR: ")
fmt.Println(err)
}
defer res.Body.Close()
if *DEBUG {
dump, _ := httputil.DumpResponse(res, true)
fmt.Println(string(dump))
}
}
func getNewFileLocation(authToken string, folder string, fileName string) string {
client := http.Client{}
payload := "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<file>\n" +
"<displayName>" + fileName + "</displayName>\n" +
"<mediaType>" + getFileTypeForFile(fileName) + "</mediaType>\n" +
"</file>\n"
if *DEBUG {
fmt.Println("Posting to " + REFRESH_URL + " with:\n" + payload)
}
req, err := http.NewRequest("POST", folder, strings.NewReader(string(payload)))
req.Header.Set("Authorization", authToken)
if *DEBUG {
dump, _ := httputil.DumpRequestOut(req, true)
fmt.Println(string(dump))
}
res, err := client.Do(req)
if err != nil {
fmt.Println("ERROR: ")
fmt.Println(err)
}
defer res.Body.Close()
if *DEBUG {
dump, _ := httputil.DumpResponse(res, true)
fmt.Println(string(dump))
}
return res.Header.Get("Location")
}
func (t *tracingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
var u http.RoundTripper
if t.Transport != nil {
u = t.Transport
} else {
u = http.DefaultTransport
}
reqBytes, err := httputil.DumpRequestOut(req, true)
if err != nil {
return nil, err
}
t.Writer.Write(reqBytes)
resp, err := u.RoundTrip(req)
if err != nil {
return nil, err
}
respBytes, err := httputil.DumpResponse(resp, true)
if err != nil {
return nil, err
}
t.Writer.Write(respBytes)
return resp, nil
}
func ExampleURL_opaque() {
// Sending a literal '%' in an HTTP request's Path
req := &http.Request{
Method: "GET",
Host: "example.com", // takes precedence over URL.Host
URL: &url.URL{
Host: "ignored",
Scheme: "https",
Opaque: "/%2f/",
},
Header: http.Header{
"User-Agent": {"godoc-example/0.1"},
},
}
out, err := httputil.DumpRequestOut(req, true)
if err != nil {
log.Fatal(err)
}
fmt.Println(strings.Replace(string(out), "\r", "", -1))
// Output:
// GET /%2f/ HTTP/1.1
// Host: example.com
// User-Agent: godoc-example/0.1
// Accept-Encoding: gzip
//
}
// Do executes a request against the Wavefront API
// and decodes the JSON into parseInto.
func (client Client) Do(req *http.Request, parseInto interface{}) (io.Reader, error) {
if client.debug == true {
d, err := httputil.DumpRequestOut(req, true)
if err != nil {
return nil, err
}
fmt.Printf("%s\n", d)
}
resp, err := client.httpClient.Do(req)
if err != nil {
return nil, err
}
if resp.StatusCode != 200 {
return nil, errors.New(fmt.Sprintf("Server returned %s\n", resp.Status))
}
body, err := ioutil.ReadAll(resp.Body)
// bytes.Reader implements Seek, which we need to use to 'rewind' the Body
r := bytes.NewReader(body)
resp.Body.Close()
if err := json.NewDecoder(r).Decode(&parseInto); err != nil {
return nil, err
}
// 'rewind' the raw response, to make it useful
r.Seek(0, 0)
return r, nil
}
func (lt loggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
dumpBody := false
if ct, ok := req.Header["Content-Type"]; ok && len(ct) == 1 && ct[0] != "application/octet-stream" {
dumpBody = true
}
dump, err := httputil.DumpRequestOut(req, dumpBody)
if err != nil {
// Don't report an error back from RoundTrip() just because
// DumpRequestOut() ran into trouble.
debug.Printf("error dumping http request: %v", err)
}
resp, err := lt.transport.RoundTrip(req)
if resp != nil && dumpBody {
respBody, _ := ioutil.ReadAll(resp.Body)
resp.Body.Close()
resp.Body = ioutil.NopCloser(bytes.NewReader(respBody))
log.Printf("http request: %s--->response: %+v\nresponse body: %s\n--->err: %v",
sanitize(string(dump)), resp, string(respBody), err)
} else {
log.Printf("http request: %s--->response: %+v\n--->err: %v", sanitize(string(dump)),
resp, err)
}
return resp, err
}
func (u *Downloader) Download(request_url, method string, postParam map[string]interface{}) (download *Downloader, err error) {
request, err := http.NewRequest(method, request_url, strings.NewReader(u.postBody(postParam)))
if err != nil {
return
}
u.HeaderConstructer(request)
if !u.Debug {
debug(httputil.DumpRequestOut(request, true))
}
/* proxyURL, err := url.Parse("http://133.130.48.180:8080")
if err != nil {
return
}
transport := &http.Transport{Proxy: http.ProxyURL(proxyURL)}*/
myClient := &http.Client{}
u.Response, err = myClient.Do(request)
return u, err
/* if err != nil {
return
}
defer u.Response.Body.Close()
u.Body, err = ioutil.ReadAll(u.Response.Body)
if err != nil {
return
}
return u, nil*/
}
func logReq(r *http.Request) {
if dump, err := httputil.DumpRequestOut(r, true); err != nil {
log.Println("reqlog: error dumping request:", err)
} else {
log.Println(string(dump))
}
}
func main() {
var body []byte
var response *http.Response
var request *http.Request
// NASA Open APIs
// https://api.nasa.gov/api.html#authentication
url := "https://api.nasa.gov/planetary/apod?api_key=DEMO_KEY&format=JSON"
request, err := http.NewRequest("GET", url, nil)
if err == nil {
request.Header.Add("Content-Type", "application/json")
debug(httputil.DumpRequestOut(request, true))
response, err = (&http.Client{}).Do(request)
}
if err == nil {
defer response.Body.Close()
debug(httputil.DumpResponse(response, true))
body, err = ioutil.ReadAll(response.Body)
}
if err == nil {
fmt.Printf("%s\n\n", body)
} else {
log.Fatalf("Error: %s\n\n", err)
}
}
// PostRequest is to request by POST using http.NewRequest
func PostRequest(reqURL string, bytesMessage []byte) (int, string, error) {
client := createClient()
req, err := http.NewRequest(
"POST",
reqURL,
bytes.NewBuffer(bytesMessage),
)
u.ShowErrorWhenError(err)
//Set Http Headers
setHTTPHeadersWithContentLength(req, strconv.Itoa(len(bytesMessage)))
//debug http request
//byte, err := httputil.DumpRequestOut(req, true)
debugHTTPRequest(httputil.DumpRequestOut(req, true))
req.Close = true //これを追加したらリクエスト可能な数が増えた。
//HTTP request
resp, err := client.Do(req)
if err != nil {
//err e.g.
//error: xxx socket: too many open files
//-> $ulimit -n 2048
return resp.StatusCode, "", err
}
//handle response
return resp.StatusCode, HandleResponse(resp), nil
}
func main() {
fmt.Println(len(os.Args))
if len(os.Args) < 2 {
fmt.Println("please, specify the value to set in foo")
os.Exit(1)
}
value := os.Args[1]
fmt.Println("value: ", value)
put := url.Values{}
put.Set("value", value)
put.Add("ttl", "")
encode := put.Encode()
req, err := http.NewRequest("PUT", "http://127.0.0.1:4001/v2/keys/foo", bytes.NewBufferString(encode))
if err != nil {
fmt.Println(err)
os.Exit(1)
}
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
//req.Header.Add("Content-Length",strconv.Itoa(len(encode)))
req.Header.Add("X-Content-Length", strconv.Itoa(len(encode)))
dump, err := httputil.DumpRequestOut(req, true)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
fmt.Println(string(dump))
}
func (s *Service) AddDebugHandlers() {
out := s.Config.Logger
if s.Config.LogLevel == 0 {
return
}
s.Handlers.Sign.PushBack(func(r *Request) {
dumpedBody, _ := httputil.DumpRequest(r.HTTPRequest, true)
fmt.Fprintf(out, "=> [%s] %s.%s(%+v)\n", r.Time,
r.Service.ServiceName, r.Operation.Name, r.Params)
fmt.Fprintf(out, "---[ REQUEST PRE-SIGN ]------------------------------\n")
fmt.Fprintf(out, "%s\n", string(dumpedBody))
fmt.Fprintf(out, "-----------------------------------------------------\n")
})
s.Handlers.Send.PushFront(func(r *Request) {
dumpedBody, _ := httputil.DumpRequestOut(r.HTTPRequest, true)
fmt.Fprintf(out, "---[ REQUEST POST-SIGN ]-----------------------------\n")
fmt.Fprintf(out, "%s\n", string(dumpedBody))
fmt.Fprintf(out, "-----------------------------------------------------\n")
})
s.Handlers.Send.PushBack(func(r *Request) {
fmt.Fprintf(out, "---[ RESPONSE ]--------------------------------------\n")
if r.HTTPResponse != nil {
dumpedBody, _ := httputil.DumpResponse(r.HTTPResponse, true)
fmt.Fprintf(out, "%s\n", string(dumpedBody))
} else if r.Error != nil {
fmt.Fprintf(out, "%s\n", r.Error)
}
fmt.Fprintf(out, "-----------------------------------------------------\n")
})
}
func dumpRequest(req *http.Request, name string) {
dump1, err := httputil.DumpRequestOut(req, true)
if err != nil {
panic(err.Error())
}
ioutil.WriteFile(name, dump1, 0777)
}
func verifyRedirectSites(fb *client.ChainedServerInfo, c *http.Client, url string) {
req, err := http.NewRequest("GET", url, nil)
if err != nil {
log.Errorf("error make request to %s: %v", url, err)
return
}
req.Header.Set("X-LANTERN-AUTH-TOKEN", fb.AuthToken)
resp, err := c.Do(req)
if err != nil {
log.Errorf("%v: requesting %s failed: %v", fb.Addr, url, err)
if *verbose {
reqStr, _ := httputil.DumpRequestOut(req, true)
log.Debug(string(reqStr))
}
return
}
defer func() {
if err := resp.Body.Close(); err != nil {
log.Debugf("Unable to close response body: %v", err)
}
}()
if resp.StatusCode != 200 {
log.Errorf("%v: bad status code %v for %s", fb.Addr, resp.StatusCode, url)
if *verbose {
respStr, _ := httputil.DumpResponse(resp, true)
log.Debug(string(respStr))
}
return
}
log.Debugf("%v via %s: OK.", fb.Addr, url)
}
func withRequestLogging() autorest.SendDecorator {
return func(s autorest.Sender) autorest.Sender {
return autorest.SenderFunc(func(r *http.Request) (*http.Response, error) {
// dump request to wire format
if dump, err := httputil.DumpRequestOut(r, true); err == nil {
log.Printf("[DEBUG] AzureRM Request: \n%s\n", dump)
} else {
// fallback to basic message
log.Printf("[DEBUG] AzureRM Request: %s to %s\n", r.Method, r.URL)
}
resp, err := s.Do(r)
if resp != nil {
// dump response to wire format
if dump, err := httputil.DumpResponse(resp, true); err == nil {
log.Printf("[DEBUG] AzureRM Response for %s: \n%s\n", r.URL, dump)
} else {
// fallback to basic message
log.Printf("[DEBUG] AzureRM Response: %s for %s\n", resp.Status, r.URL)
}
} else {
log.Printf("[DEBUG] Request to %s completed with no response", r.URL)
}
return resp, err
})
}
}
// AddDebugHandlers injects debug logging handlers into the service to log request
// debug information.
func (s *Service) AddDebugHandlers() {
out := s.Config.Logger
if s.Config.LogLevel == 0 {
return
}
s.Handlers.Send.PushFront(func(r *Request) {
logBody := r.Config.LogHTTPBody
dumpedBody, _ := httputil.DumpRequestOut(r.HTTPRequest, logBody)
fmt.Fprintf(out, "---[ REQUEST POST-SIGN ]-----------------------------\n")
fmt.Fprintf(out, "%s\n", string(dumpedBody))
fmt.Fprintf(out, "-----------------------------------------------------\n")
})
s.Handlers.Send.PushBack(func(r *Request) {
fmt.Fprintf(out, "---[ RESPONSE ]--------------------------------------\n")
if r.HTTPResponse != nil {
logBody := r.Config.LogHTTPBody
dumpedBody, _ := httputil.DumpResponse(r.HTTPResponse, logBody)
fmt.Fprintf(out, "%s\n", string(dumpedBody))
} else if r.Error != nil {
fmt.Fprintf(out, "%s\n", r.Error)
}
fmt.Fprintf(out, "-----------------------------------------------------\n")
})
}
// Processes an HTTP request to the Wit API
func processRequest(httpParams *HTTPParams) ([]byte, error) {
regex := regexp.MustCompile(`\?`)
if regex.MatchString(httpParams.Resource) {
httpParams.Resource += "&" + APIVersion
} else {
httpParams.Resource += "?" + APIVersion
}
reader := bytes.NewReader(httpParams.Data)
httpClient := &http.Client{}
req, err := http.NewRequest(httpParams.Verb, httpParams.Resource, reader)
if err != nil {
return nil, err
}
setHeaders(req, httpParams.ContentType)
if os.Getenv("GOWIT_DEBUG") == "true" {
debug(httputil.DumpRequestOut(req, true))
}
result, err := httpClient.Do(req)
if err != nil {
return nil, err
}
if os.Getenv("GOWIT_DEBUG") == "true" {
debug(httputil.DumpResponse(result, true))
}
body, err := ioutil.ReadAll(result.Body)
result.Body.Close()
if result.StatusCode != 200 {
return nil, errors.New(http.StatusText(result.StatusCode))
}
return body, nil
}
