Esempio n. 1
0
func GetQueue() (Q *sqs.Queue, err os.Error) {
	proxyURL, err := GetProxyURL()
	if err != nil {
		return
	}
	id, err := GetAWSIdentity()
	if err != nil {
		return
	}
	if queueURL != nil && *queueURL != "" {
		qrl, err := http.ParseURL(*queueURL)
		if err == nil {
			ep := awsconn.NewEndpoint(qrl, proxyURL)
			Q = sqs.NewQueueURL(ep)
		}
	} else if queueName != nil && *queueName != "" {
		ep, err := http.ParseURL(*sqsEndpoint)
		if err == nil {
			log.Printf("Parsed EP url: %v", ep)
			ep := awsconn.NewEndpoint(ep, proxyURL)
			_sqs := sqs.NewService(ep)
			Q, err = _sqs.CreateQueue(id, *queueName, 90)
			if err != nil {
				log.Fatalf("Qerr: [%v]", err)
			}
		}
	} else {
		err = os.NewError("Either Queue(+Endpoint) or QueueURL are required")
	}
	return
}
Esempio n. 2
0
func NewWaveUrl(url string) (result *WaveUrl, err os.Error) {
	u, err := http.ParseURL(url)
	if err != nil {
		return nil, err
	}
	if u.Scheme != "wave" {
		return nil, os.NewError("Not a wave url")
	}
	result = &WaveUrl{WaveletDomain: u.Host}

	wave := u.Path[1:]
	i := strings.Index(wave, "/")
	if i == -1 || i == len(wave)-1 {
		return nil, os.NewError("Malformed wave url")
	}
	result.WaveletId = wave[i+1:]
	wave = wave[:i]
	i = strings.Index(wave, "$")
	if i == -1 {
		result.WaveDomain = result.WaveletDomain
		result.WaveId = wave
	} else {
		result.WaveDomain = wave[:i]
		result.WaveId = wave[i+1:]
	}
	// TODO: Check that only allowed characters are used
	return result, nil
}
Esempio n. 3
0
func (self *Federation) Forward(blobref string, users []string) {
	// Determine the servers that have to be informed
	urls := make(map[string]vec.StringVector)
	for _, user := range users {
		if user == self.userID {
			continue
		}
		rawurl, err := self.ns.Lookup(user)
		if err != nil {
			log.Print("Unknown user", err)
			continue
		}
		_, err = http.ParseURL(rawurl)
		if err != nil {
			log.Printf("Malformed URL: %v\n", rawurl)
			continue
		}
		urlList, _ := urls[rawurl]
		urlList.Push(user[strings.Index(user, "@")+1:])
		urls[rawurl] = urlList
	}

	if len(urls) > 0 {
		log.Printf("Forwarding %v to %v\n", blobref, users)
	}

	for url, urlUsers := range urls {
		q := self.getQueue(url)
		q <- queueEntry{urlUsers, blobref}
	}
}
Esempio n. 4
0
func TestGetConnectionMethodWorks(*testing.T) {
	drv := new(DummyDriver)
	func(d Driver) {
		url, _ := http.ParseURL("foo://root@localhost/testdb")
		_, _ = d.Connect(url)
	}(drv)
}
Esempio n. 5
0
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
}
Esempio n. 6
0
/*
Dial opens a new client connection to a Web Socket.

A trivial example client:

	package main

	import (
		"websocket"
		"strings"
	)

	func main() {
	 	ws, err := websocket.Dial("ws://localhost/ws", "", "http://localhost/");
	 	if err != nil {
			panic("Dial: " + err.String())
		}
		if _, err := ws.Write([]byte("hello, world!\n")); err != nil {
			panic("Write: " + err.String())
		}
		var msg = make([]byte, 512);
		if n, err := ws.Read(msg); err != nil {
			panic("Read: " + err.String())
		}
		// use msg[0:n]
	}
*/
func Dial(url, protocol, origin string) (ws *Conn, err os.Error) {
	var client net.Conn

	parsedUrl, err := http.ParseURL(url)
	if err != nil {
		goto Error
	}

	switch parsedUrl.Scheme {
	case "ws":
		client, err = net.Dial("tcp", "", parsedUrl.Host)

	case "wss":
		client, err = tls.Dial("tcp", "", parsedUrl.Host)

	default:
		err = ErrBadScheme
	}
	if err != nil {
		goto Error
	}

	ws, err = newClient(parsedUrl.RawPath, parsedUrl.Host, origin, url, protocol, client, handshake)
	if err != nil {
		goto Error
	}
	return

Error:
	return nil, &DialError{url, protocol, origin, err}
}
Esempio n. 7
0
func (w *Worker) AskRobots(url *http.URL) (bool, *FetchResult) {
	robots_url_str := fmt.Sprintf("%s://%s/robots.txt", url.Scheme, url.Host)
	robots_url, err := http.ParseURL(robots_url_str)
	if err != nil {
		return false, ErrorResult(url.Raw, err.String())
	}

	fetch_result := w.Fetch(robots_url)

	if !fetch_result.Success {
		fetch_result.Status = "Robots download error: " + fetch_result.Status
		return false, fetch_result
	}

	var robots *robotstxt.RobotsData
	robots, err = robotstxt.FromResponseBytes(fetch_result.StatusCode, fetch_result.Body, false)
	if err != nil {
		fetch_result.Status = "Robots parse error: " + err.String()
		return false, fetch_result
	}

	robots.DefaultAgent = "HeroshiBot"

	var allow bool
	allow, err = robots.Test(url.RawPath)
	if err != nil {
		return false, ErrorResult(url.Raw, "Robots test error: "+err.String())
	}

	if !allow {
		return allow, ErrorResult(url.Raw, "Robots disallow")
	}

	return allow, nil
}
Esempio n. 8
0
// List all queues available at an endpoint.
func (self *Service) ListQueues(id cryptools.NamedSigner, prefix string) (out []*Queue, err os.Error) {
	sqsReq, err := self.signedRequest(id, "/", map[string]string{
		"Action": "ListQueues",
	})
	if err != nil {
		return
	}
	xresp := &listQueuesResponse{}
	xerr := &errorResponse{}
	err = self.Endpoint.SendParsable(sqsReq, xresp, xerr)
	if err != nil {
		return
	}
	out = make([]*Queue, len(xresp.ListQueuesResult.QueueUrl))
	for i := range xresp.ListQueuesResult.QueueUrl {
		url, err := http.ParseURL(xresp.ListQueuesResult.QueueUrl[i])
		if err != nil {
			break
		}
		ep := awsconn.NewEndpoint(url, self.Endpoint.ProxyURL)
		out[i] = NewQueueURL(ep)
	}
	//log.Printf("ListQueue: %v",  out)
	return
}
Esempio n. 9
0
// sent a request off to twitter. Returns the response's body or an error.
func send(url, method string, form map[string][]string, client *Client, body string) (result string, err os.Error) {
	req := new(http.Request)
	req.Method = method
	req.RawURL = url
	req.Host = URLHost
	req.Referer = "none"
	req.UserAgent = HTTPUserAgent
	req.Form = form
	req.Header = map[string]string{
		"Connection":    "Keep Alive",
		"Authorization": getAuthHeader(client),
	}
	req.Body = strings.NewReader(body)
	req.URL, err = http.ParseURL(req.RawURL)
	if err != nil {
		return "", err
	}

	// send request
	resp := new(http.Response)
	resp, err = http.Send(req)
	if err != nil {
		return "", err
	}
	result = getResponseBody(resp)
	return result, nil
}
Esempio n. 10
0
func TestURL(t *testing.T) {
	for _, ex := range examples {
		req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(ex.request)))
		if err != nil {
			t.Error(err)
		}

		if len(req.Header) > 1 {
			// Only works on requests without any headers
			// Host header has been removed
			continue
		}

		date := req.Header.Get("Date")

		url, err := http.ParseURL("http://" + req.Host + req.URL.RawPath)
		if err != nil {
			t.Error(err)
		}

		signed, err := URL(url, AWSAccessKeyId, AWSSecretAccessKey, req.Method, date)
		if err != nil {
			t.Error(err)
		}

		// Fudge a bit on this test.  The date should be in Unix timestamp
		// but we can only compare against known signatures for now so use
		// the existing date.

		if auth := addAuth(url.Raw, ex.auth, date); auth != signed.Raw {
			t.Error("Fail URL:", ex.name, "got:", signed.Raw, "want:", auth, "headers:", len(req.Header))
		}
	}
}
Esempio n. 11
0
func buildTestRequest(method string, path string, body string, headers map[string]string) *Request {
	host := "127.0.0.1"
	port := "80"
	rawurl := "http://" + host + ":" + port + path
	url, _ := http.ParseURL(rawurl)

	proto := "HTTP/1.1"
	useragent := "web.go test framework"

	if headers == nil {
		headers = map[string]string{}
	}

	if method == "POST" {
		headers["Content-Length"] = fmt.Sprintf("%d", len(body))
		headers["Content-Type"] = "text/plain"
	}

	req := Request{Method: method,
		RawURL:    rawurl,
		URL:       url,
		Proto:     proto,
		Host:      host,
		UserAgent: useragent,
		Headers:   headers,
		Body:      bytes.NewBufferString(body),
	}

	return &req
}
Esempio n. 12
0
// Create a queue, returning the Queue object.
func (self *Service) CreateQueue(id *aws.Signer, name string, dvtimeout int) (mq *Queue, err os.Error) {
	var resp *http.Response
	parms := http.Values{}
	parms.Set("Action", "CreateQueue")
	parms.Set("QueueName", name)
	parms.Set("DefaultVisibilityTimeout", strconv.Itoa(dvtimeout))

	req := aws.NewRequest(self.URL, "GET", nil, parms)
	err = id.SignRequestV2(req, aws.Canonicalize, DEFAULT_VERSION, 15)
	if err == nil {
		resp, err = self.conn.Request(req)
		if err == nil {
			defer resp.Body.Close()
			if resp.StatusCode == http.StatusOK {
				xmlresp := createQueueResponse{}
				err = xml.Unmarshal(resp.Body, &xmlresp)
				if err == nil {
					var qrl *http.URL
					qrl, err = http.ParseURL(xmlresp.QueueURL)
					if err == nil {
						mq = NewQueue(qrl)
					}
				}
			} else {
				err = os.NewError("Unexpected response")
			}
		}
	}

	return
}
Esempio n. 13
0
File: http.go Progetto: vdobler/ft
// 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
}
Esempio n. 14
0
func ParseURL(url string) (parsed_url *http.URL) {
	parsed_url, err := http.ParseURL(url)
	if err != nil {
		log.Fatal(err)
	}
	return parsed_url
}
Esempio n. 15
0
func dial(host string) (conn *http.ClientConn) {
	var tcp net.Conn
	var err os.Error
	fmt.Fprintf(os.Stderr, "http-gonsole: establishing a TCP connection ...\n")
	proxy := os.Getenv("HTTP_PROXY")
	if len(proxy) > 0 {
		proxy_url, _ := http.ParseURL(proxy)
		tcp, err = net.Dial("tcp", proxy_url.Host)
	} else {
		tcp, err = net.Dial("tcp", host)
	}
	if err != nil {
		fmt.Fprintln(os.Stderr, "http-gonsole:", err)
		os.Exit(1)
	}
	if *useSSL {
		cf := &tls.Config{Rand: rand.Reader, Time: time.Nanoseconds}
		ssl := tls.Client(tcp, cf)
		conn = http.NewClientConn(ssl, nil)
		if len(proxy) > 0 {
			tcp.Write([]byte("CONNECT " + host + " HTTP/1.0\r\n\r\n"))
			b := make([]byte, 1024)
			tcp.Read(b)
		}
	} else {
		conn = http.NewClientConn(tcp, nil)
	}
	return
}
Esempio n. 16
0
func main() {
	scheme := "http"
	host := "localhost:80"
	headers := make(http.Header)
	cookies := new([]*Cookie)
	p := "/"
	flag.Parse()
	if flag.NArg() > 0 {
		tmp := flag.Arg(0)
		if match, _ := regexp.MatchString("^[^:]+(:[0-9]+)?$", tmp); match {
			tmp = "http://" + tmp
		}
		targetURL, err := http.ParseURL(tmp)
		if err != nil {
			fmt.Fprintln(os.Stderr, "malformed URL")
			os.Exit(-1)
		}
		host = targetURL.Host
		if len(host) == 0 {
			fmt.Fprintln(os.Stderr, "invalid host name")
			os.Exit(-1)
		}
		if match, _ := regexp.MatchString("^[^:]+:[0-9]+$", host); !match {
			host = host + ":80"
		}
		if *useSSL || targetURL.Scheme == "https" {
			*useSSL = true
			scheme = "https"
		}
		scheme = targetURL.Scheme
		info := targetURL.RawUserinfo
		if len(info) > 0 {
			enc := base64.URLEncoding
			encoded := make([]byte, enc.EncodedLen(len(info)))
			enc.Encode(encoded, []byte(info))
			headers.Set("Authorization", "Basic "+string(encoded))
		}
		p = strings.Replace(path.Clean(targetURL.Path), "\\", "/", -1)
		if p == "." {
			p = "/"
		}
	} else if *useSSL {
		scheme = "https"
		host = "localhost:443"
	}
	headers.Set("Host", host)
	session := &Session{
		scheme:  scheme,
		host:    host,
		conn:    dial(host),
		headers: headers,
		cookies: cookies,
		path:    &p,
	}
	defer session.conn.Close()
	done := false
	for !done {
		done = session.repl()
	}
}
Esempio n. 17
0
func GetEndpoint(region string, proxy *http.URL) (ep *awsconn.Endpoint, err os.Error) {
	url, err := http.ParseURL("http://elasticloadbalancing." + region + ".amazonaws.com")
	if err == nil {
		ep = awsconn.NewEndpoint(url, proxy)
	}
	return
}
Esempio n. 18
0
File: pacman.go Progetto: juster/maw
func (pf *PacmanFetcher) Fetch(pkgname string) ([]string, FetchError) {
	urltext, err := pf.findPackageUrl(pkgname)
	if err != nil {
		return nil, err
	}

	url, oserr := http.ParseURL(urltext)
	if oserr != nil {
		return nil, FetchErrorWrap(pkgname, oserr)
	}

	var pkgpath string

	switch url.Scheme {
	case "http":
		fallthrough
	case "https":
		pkgpath, oserr = pf.httpDownload(url)
	case "ftp":
		pkgpath, oserr = pf.ftpDownload(url)
	default:
		return nil, NewFetchError(pkgname, "Unrecognized URL scheme: "+url.Scheme)
	}

	if oserr != nil {
		return nil, FetchErrorWrap(pkgname, oserr)
	}

	return []string{pkgpath}, nil
}
Esempio n. 19
0
// Create a queue, returning the Queue object.
func (self *Service) CreateQueue(id cryptools.NamedSigner, name string, dvtimeout int) (mq *Queue, err os.Error) {
	sqsReq, err := self.signedRequest(id, "/", map[string]string{
		"Action":                   "CreateQueue",
		"QueueName":                name,
		"DefaultVisibilityTimeout": strconv.Itoa(dvtimeout),
	})
	if err != nil {
		return
	}

	xresp := &createQueueResponse{}
	xerr := &errorResponse{}
	err = self.Endpoint.SendParsable(sqsReq, xresp, xerr)

	if err != nil {
		return
	}
	qrl, err := http.ParseURL(xresp.CreateQueueResult.QueueUrl)
	if err != nil {
		return
	}
	ep := awsconn.NewEndpoint(qrl, self.Endpoint.ProxyURL)
	mq = NewQueueURL(ep)
	return
}
Esempio n. 20
0
func HttpGet(url string) (*http.Response, os.Error) {
	var r *http.Response
	var err os.Error
	if proxy := os.Getenv("HTTP_PROXY"); len(proxy) > 0 {
		proxy_url, _ := http.ParseURL(proxy)
		tcp, _ := net.Dial("tcp", "", proxy_url.Host)
		conn := http.NewClientConn(tcp, nil)
		var req http.Request
		req.URL, _ = http.ParseURL(url)
		req.Method = "GET"
		err = conn.Write(&req)
		r, err = conn.Read()
	} else {
		r, _, err = http.Get(url)
	}
	return r, err
}
Esempio n. 21
0
func TestBuildAuthUrlNoAuth(t *testing.T) {
	url, err := goget.BuildAuthUrl("http://example.com", "", "")
	AssertNil(t, err)

	urlObj, err := http.ParseURL(url)
	AssertNil(t, err)
	AssertEquals(t, "", urlObj.Userinfo)
}
Esempio n. 22
0
func NewTHttpPostClient(url string) (TTransport, os.Error) {
	parsedURL, err := http.ParseURL(url)
	if err != nil {
		return nil, err
	}
	buf := make([]byte, 0, 1024)
	return &THttpClient{url: parsedURL, requestBuffer: bytes.NewBuffer(buf)}, nil
}
Esempio n. 23
0
func (c *conn) prepare() (err os.Error) {

	method, rawURL, version, err := parseRequestLine(c.br)
	if err != nil {
		return err
	}

	header, err := parseHeader(c.br)
	if err != nil {
		return err
	}

	url, err := http.ParseURL(rawURL)
	if err != nil {
		return err
	}

	if url.Host == "" {
		url.Host = header.GetDef(web.HeaderHost, "")
		if url.Host == "" {
			url.Host = c.serverName
		}
	}

	if c.secure {
		url.Scheme = "https"
	} else {
		url.Scheme = "http"
	}

	req, err := web.NewRequest(c.netConn.RemoteAddr().String(), method, url, version, header)
	if err != nil {
		return
	}
	c.req = req

	c.requestAvail = req.ContentLength
	if c.requestAvail < 0 {
		c.requestAvail = 0
	}

	if s, found := req.Header.Get(web.HeaderExpect); found {
		c.write100Continue = strings.ToLower(s) == "100-continue"
	}

	connection := strings.ToLower(req.Header.GetDef(web.HeaderConnection, ""))
	if version >= web.ProtocolVersion(1, 1) {
		c.closeAfterResponse = connection == "close"
	} else if version == web.ProtocolVersion(1, 0) && req.ContentLength >= 0 {
		c.closeAfterResponse = connection != "keep-alive"
	} else {
		c.closeAfterResponse = true
	}

	req.Responder = c
	req.Body = requestReader{c}
	return nil
}
Esempio n. 24
0
func (bucket *Bucket) GetFile(file *os.FileInfo) (err os.Error) {
	url, e := http.ParseURL(bucket.Url + "/" + file.Name)
	if e != nil {
		return err
	}
	req := &http.Request{Method: "GET", RawURL: bucket.Url + "/" + file.Name, URL: url, Header: make(map[string]string)}
	date := time.LocalTime().Format(time.RFC1123)
	req.Header["Date"] = date
	bucket.sign(req)
	//req.Write(os.Stdout)

	conn, err := net.Dial("tcp", "", req.URL.Host+":"+req.URL.Scheme)
	if err != nil {
		return err
	}
	req.Write(conn)
	reader := bufio.NewReader(conn)
	resp, _ := http.ReadResponse(reader, req.Method)
	//resp.Write(os.Stdout)
	filename := strings.TrimLeft(url.Path, "/")
	path := strings.SplitAfter(filename, "/", -1)
	//pid := os.GetPid()

	var b []byte
	b, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	mode := (file.Mode & 0777)
	fmt.Printf("0%o\n", mode)
	//var dirmode uint32
	//dirmode = (syscall.S_IFDIR^0666)&0777
	resp.Body.Close()

	//create file or dir
	for i := 0; i < len(path); i++ {
		f := i + 1
		if f == len(path) {
			openfile, err := os.Open(filename, syscall.O_WRONLY|syscall.O_CREAT|syscall.O_EXCL, mode)
			if err != nil {
				return err
			} else {
				openfile.Chown(file.Uid, file.Gid)
				openfile.Write(b)
				openfile.Close()
				os.Chtimes(filename, file.Mtime_ns, file.Mtime_ns)
			}
		} else {
			err := os.Mkdir(path[i], 0755)
			if err != nil {
				return err
			}
		}
	}

	return nil
}
Esempio n. 25
0
// Parse a response-Location-URI to get the ID of the worked-on snip
func (client *Client) IdFromURL(urlString string) (string, os.Error) {
	var url *http.URL
	var err os.Error
	if url, err = http.ParseURL(urlString); err != nil {
		return "", err
	}

	return string(url.Path[len(client.resource.Path):]), nil
}
Esempio n. 26
0
func oauthGet(accessToken string, urlString string) (*http.Response, os.Error) {
	url, _ := http.ParseURL(urlString)
	conn, _ := net.Dial("tcp", url.Host+":80")

	clientConn := http.NewClientConn(conn, nil)
	header := map[string][]string{"Authorization": {"OAuth " + accessToken}}
	request := http.Request{Method: "GET", URL: url, Header: header}
	clientConn.Write(&request)
	return clientConn.Read(&request)
}
Esempio n. 27
0
func NewRequest(url, authToken, method string) (req *http.Request) {
	req = new(http.Request)
	req.RawURL = url
	req.URL, _ = http.ParseURL(req.RawURL)
	req.Method = method
	req.Header = make(map[string][]string)
	// Set the authorization header with the token (required for picasa authentication).
	req.Header.Add("Authorization", "AuthSub  token="+authToken+"")
	return
}
Esempio n. 28
0
// Convenience method to clean up calls.
func DefaultS3Service() (id *aws.Signer, s *s3.Service, err os.Error) {
	id, err = DefaultSigner()
	if err == nil {
		url, err := http.ParseURL(flag_endpoint_url)
		if err == nil {
			s = s3.NewService(url)
		}
	}
	return
}
// UploadURL creates an upload URL for the form that the user will fill out,
// passing the application path to load when the POST of the form is
// completed. These URLs expire and should not be reused.
func UploadURL(c appengine.Context, successPath string) (*http.URL, os.Error) {
	req := &pb.CreateUploadURLRequest{
		SuccessPath: proto.String(successPath),
	}
	res := &pb.CreateUploadURLResponse{}
	if err := c.Call("blobstore", "CreateUploadURL", req, res); err != nil {
		return nil, err
	}
	return http.ParseURL(*res.Url)
}
Esempio n. 30
-1
// Put issues a PUT to the specified URL.
//
// Caller should close r.Body when done reading it.
func authPut(url, user, pwd, client, clientURL, version, agent, bodyType string,
	body io.Reader) (r *http.Response, err os.Error) {
	var req http.Request
	req.Method = "PUT"
	req.Body = body.(io.ReadCloser)
	if user != "" && pwd != "" {
		req.Header = map[string][]string{
			"Content-Type":         {bodyType},
			"Transfer-Encoding":    {"chunked"},
			"User-Agent":           {agent},
			"X-FluidDB-Client":     {client},
			"X-FluidDB-Client-URL": {clientURL},
			"X-FluidDB-Version":    {version},
			"Authorization":        {"Basic " + encodedUsernameAndPassword(user, pwd)},
		}
	} else {
		req.Header = map[string][]string{
			"Content-Type":         {bodyType},
			"Transfer-Encoding":    {"chunked"},
			"User-Agent":           {agent},
			"X-FluidDB-Client":     {client},
			"X-FluidDB-Client-URL": {clientURL},
			"X-FluidDB-Version":    {version},
		}
	}

	req.URL, err = http.ParseURL(url)
	if err != nil {
		return nil, err
	}

	return send(&req)
}