func post(url_ string, oauthHeaders map[string]string) (r *http.Response, err os.Error) {
var req http.Request
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Header = map[string][]string{
"Authorization": {"OAuth "},
}
req.TransferEncoding = []string{"chunked"}
first := true
for k, v := range oauthHeaders {
if first {
first = false
} else {
req.Header["Authorization"][0] += ",\n "
}
req.Header["Authorization"][0] += k + "=\"" + v + "\""
}
req.URL, err = url.Parse(url_)
if err != nil {
return nil, err
}
return send(&req)
}
func post(theUrl string, oauthHeaders map[string]string) (r *http.Response, err os.Error) {
var req http.Request
var authorization string = "OAuth "
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Header = http.Header{}
req.TransferEncoding = []string{"chunked"}
first := true
for k, v := range oauthHeaders {
if first {
first = false
} else {
authorization += ",\n "
}
authorization += k + "=\"" + v + "\""
}
req.Header.Add("Authorization", authorization)
req.URL, err = url.Parse(theUrl)
if err != nil {
return nil, err
}
return send(&req)
}
func NewRequest(method string, url string, doc IDocument) *http.Request {
var req http.Request
req.Method = method
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Header = map[string]string{
"Content-Type": "application/json",
"X-Riak-ClientId": "riak.go",
}
if doc.VectorClock() != "" {
req.Header["X-Riak-Vclock"] = doc.VectorClock()
}
req.TransferEncoding = []string{"chunked"}
req.URL, _ = http.ParseURL(url)
if doc.Json() != "" {
cb := &ClosingBuffer{bytes.NewBufferString(doc.Json())}
var rc io.ReadCloser
rc = cb
req.Body = rc
}
fmt.Println(req.URL)
return &req
}
// Perform a GET request for the test t.
func Get(t *Test) (r *http.Response, finalUrl string, cookies []*http.Cookie, err os.Error) {
var url = t.Url // <-- Patched
var req http.Request
req.Method = "GET"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Header = http.Header{}
if len(t.Param) > 0 {
ep := http.EncodeQuery(t.Param)
if strings.Contains(url, "?") {
url = url + "&" + ep
} else {
url = url + "?" + ep
}
}
req.URL, err = http.ParseURL(url)
if err != nil {
err = &http.URLError{"Get", url, err}
return
}
addHeadersAndCookies(&req, t)
url = req.URL.String()
debug("Will get from %s", req.URL.String())
r, finalUrl, cookies, err = DoAndFollow(&req, t.Dump)
return
}
func Send(s Sender, req *http.Request) (resp *http.Response, err os.Error) {
if s == nil {
s = DefaultSender
}
req.ProtoMajor = 1
req.ProtoMinor = 1
header := req.Header
req.Header = map[string]string{}
for k, v := range header {
req.Header[http.CanonicalHeaderKey(k)] = v
}
return s.Send(req)
}
func YadisRequest(url_ string, method string) (resp *http.Response, err os.Error) {
resp = nil
var request = new(http.Request)
var client = new(http.Client)
var Header = make(http.Header)
request.Method = method
request.RawURL = url_
request.URL, err = url.Parse(url_)
if err != nil {
return
}
// Common parameters
request.Proto = "HTTP/1.0"
request.ProtoMajor = 1
request.ProtoMinor = 0
request.ContentLength = 0
request.Close = true
Header.Add("Accept", "application/xrds+xml")
request.Header = Header
// Follow a maximum of 5 redirections
for i := 0; i < 5; i++ {
response, err := client.Do(request)
if err != nil {
return nil, err
}
if response.StatusCode == 301 || response.StatusCode == 302 || response.StatusCode == 303 || response.StatusCode == 307 {
location := response.Header.Get("Location")
request.RawURL = location
request.URL, err = url.Parse(location)
if err != nil {
return
}
} else {
return response, nil
}
}
return nil, os.NewError("Too many redirections")
}
// General Request method used by the specialized request methods to create a request
func (client *Client) newRequest(method string, id string) (*http.Request, os.Error) {
request := new(http.Request)
var err os.Error
request.ProtoMajor = 1
request.ProtoMinor = 1
request.TransferEncoding = []string{"chunked"}
request.Method = method
// Generate Resource-URI and parse it
url := client.resource.String() + id
if request.URL, err = http.ParseURL(url); err != nil {
return nil, err
}
return request, nil
}
func nmcPOST(body *bytes.Buffer) (response *http.Response, err os.Error) {
client := http.Client{}
var req http.Request
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Body = ioutil.NopCloser(body)
req.Header = http.Header{
"Content-Type": []string{"text/plain"},
"Content-Length": []string{strconv.Itoa(body.Len())},
}
req.ContentLength = int64(body.Len())
req.URL = options.nmcURL
return client.Do(&req)
}
// post taken from Golang modified to allow Headers to be pased
func post(url string, headers map[string]string, body io.Reader) (r *http.Response, err os.Error) {
var req http.Request
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Body = nopCloser{body}
for k, v := range headers {
req.Header.Add(k, v)
}
req.TransferEncoding = []string{"chunked"}
req.URL, err = http.ParseURL(url)
if err != nil {
return nil, err
}
return send(&req)
}
// PostForm issues a POST to the specified URL,
// with data's keys and values urlencoded as the request body.
//
// Caller should close r.Body when done reading from it.
func Post(t *Test) (r *http.Response, finalUrl string, cookies []*http.Cookie, err os.Error) {
var req http.Request
var url = t.Url
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
var body *bytes.Buffer
var contentType string
if hasFile(&t.Param) || t.Method == "POST:mp" {
var boundary string
body, boundary = multipartBody(&t.Param)
contentType = "multipart/form-data; boundary=" + boundary
} else {
contentType = "application/x-www-form-urlencoded"
bodystr := http.EncodeQuery(t.Param)
body = bytes.NewBuffer([]byte(bodystr))
}
req.Body = nopCloser{body}
req.Header = http.Header{
"Content-Type": {contentType},
"Content-Length": {strconv.Itoa(body.Len())},
}
addHeadersAndCookies(&req, t)
req.ContentLength = int64(body.Len())
req.URL, err = http.ParseURL(url)
if err != nil {
return nil, url, cookies, err
}
debug("Will post to %s", req.URL.String())
r, finalUrl, cookies, err = DoAndFollow(&req, t.Dump)
return
}
// Perform the request and follow up to 10 redirects.
// All cookie setting are collected, the final URL is reported.
func DoAndFollow(req *http.Request, dump io.Writer) (response *http.Response, finalUrl string, cookies []*http.Cookie, err os.Error) {
// TODO: set referrer header on redirects.
// Move User-Agent from Header to Request
if ua := req.Header.Get("User-Agent"); ua != "" {
req.UserAgent = ua
req.Header.Del("User-Agent")
}
info("%s %s", req.Method, req.URL.String())
dumpReq(req, dump)
response, err = http.DefaultClient.Do(req)
if err != nil {
return
}
dumpRes(response, dump)
finalUrl = req.URL.String()
cookies = updateCookies(cookies, response.SetCookie)
req.Cookie = updateCookies(req.Cookie, response.SetCookie)
if !shouldRedirect(response.StatusCode) {
return
}
// Start redirecting to final destination
response.Body.Close()
var base = req.URL
// Following the redirect chain is done with a cleaned/empty GET request.
req.Method = "GET"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Header.Del("Content-Type")
req.Header.Del("Content-Length")
req.Header.Del("Accept-Encoding")
req.Header.Del("Connection")
req.Body = nil
for redirect := 0; redirect < 10; redirect++ {
var url string
if url = response.Header.Get("Location"); url == "" {
fmt.Printf("Header:\n%v", response.Header)
err = os.ErrorString(fmt.Sprintf("%d response missing Location header", response.StatusCode))
return
}
if base == nil {
req.URL, err = http.ParseURL(url)
} else {
req.URL, err = base.ParseURL(url)
}
if err != nil {
return
}
url = req.URL.String()
info("GET %s", url)
dumpReq(req, dump)
if response, err = http.DefaultClient.Do(req); err != nil {
return
}
dumpRes(response, dump)
finalUrl = url
cookies = updateCookies(cookies, response.SetCookie)
req.Cookie = updateCookies(req.Cookie, response.SetCookie)
if !shouldRedirect(response.StatusCode) {
return
}
response.Body.Close()
base = req.URL
}
err = os.ErrorString("Too many redirects.")
return
}
func requestFromEnvironment(env map[string]string) (*http.Request, os.Error) {
r := new(http.Request)
r.Method = env["REQUEST_METHOD"]
if r.Method == "" {
return nil, os.NewError("cgi: no REQUEST_METHOD in environment")
}
r.Close = true
r.Trailer = http.Header{}
r.Header = http.Header{}
r.Host = env["HTTP_HOST"]
r.Referer = env["HTTP_REFERER"]
r.UserAgent = env["HTTP_USER_AGENT"]
// CGI doesn't allow chunked requests, so these should all be accurate:
r.Proto = "HTTP/1.0"
r.ProtoMajor = 1
r.ProtoMinor = 0
r.TransferEncoding = nil
if lenstr := env["CONTENT_LENGTH"]; lenstr != "" {
clen, err := strconv.Atoi64(lenstr)
if err != nil {
return nil, os.NewError("cgi: bad CONTENT_LENGTH in environment: " + lenstr)
}
r.ContentLength = clen
r.Body = ioutil.NopCloser(io.LimitReader(os.Stdin, clen))
}
// Copy "HTTP_FOO_BAR" variables to "Foo-Bar" Headers
for k, v := range env {
if !strings.HasPrefix(k, "HTTP_") || skipHeader[k] {
continue
}
r.Header.Add(strings.Replace(k[5:], "_", "-", -1), v)
}
// TODO: cookies. parsing them isn't exported, though.
if r.Host != "" {
// Hostname is provided, so we can reasonably construct a URL,
// even if we have to assume 'http' for the scheme.
r.RawURL = "http://" + r.Host + env["REQUEST_URI"]
url, err := http.ParseURL(r.RawURL)
if err != nil {
return nil, os.NewError("cgi: failed to parse host and REQUEST_URI into a URL: " + r.RawURL)
}
r.URL = url
}
// Fallback logic if we don't have a Host header or the URL
// failed to parse
if r.URL == nil {
r.RawURL = env["REQUEST_URI"]
url, err := http.ParseURL(r.RawURL)
if err != nil {
return nil, os.NewError("cgi: failed to parse REQUEST_URI into a URL: " + r.RawURL)
}
r.URL = url
}
return r, nil
}
