1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/net/http/http.v

225 lines
6.4 KiB
V
Raw Normal View History

2022-01-04 12:21:08 +03:00
// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
2019-06-23 05:21:30 +03:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-06-22 21:20:28 +03:00
module http
2019-08-06 15:43:09 +03:00
import net.urllib
const (
2020-05-16 17:12:23 +03:00
max_redirects = 4
2020-01-16 20:16:11 +03:00
content_type_default = 'text/plain'
bufsize = 1536
)
// FetchConfig holds configuration data for the fetch function.
2020-01-16 20:16:11 +03:00
pub struct FetchConfig {
pub mut:
2021-08-17 09:16:59 +03:00
url string
method Method
header Header
data string
params map[string]string
cookies map[string]string
2020-05-20 09:58:57 +03:00
user_agent string = 'v.http'
verbose bool
//
2021-09-09 19:55:49 +03:00
validate bool // set this to true, if you want to stop requests, when their certificates are found to be invalid
verify string // the path to a rootca.pem file, containing trusted CA certificate(s)
cert string // the path to a cert.pem file, containing client certificate(s) for the request
cert_key string // the path to a key.pem file, containing private keys for the client certificate(s)
in_memory_verification bool // if true, verify, cert, and cert_key are read from memory, not from a file
allow_redirect bool = true // whether to allow redirect
2020-01-16 20:16:11 +03:00
}
// new_request creates a new Request given the request `method`, `url_`, and
// `data`.
2022-10-24 16:26:19 +03:00
pub fn new_request(method Method, url_ string, data string) ?Request {
url := if method == .get && !url_.contains('?') { url_ + '?' + data } else { url_ }
// println('new req() method=$method url="$url" dta="$data"')
return Request{
method: method
url: url
data: data
/*
headers: {
'Accept-Encoding': 'compress'
}
*/
}
}
// get sends a GET HTTP request to the give `url`.
pub fn get(url string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(method: .get, url: url)
2020-01-15 01:19:50 +03:00
}
// post sends the string `data` as an HTTP POST request to the given `url`.
pub fn post(url string, data string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(
method: .post
url: url
data: data
header: new_header(key: .content_type, value: http.content_type_default)
)
2020-01-15 01:19:50 +03:00
}
// post_json sends the JSON `data` as an HTTP POST request to the given `url`.
pub fn post_json(url string, data string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(
method: .post
url: url
data: data
header: new_header(key: .content_type, value: 'application/json')
)
}
// post_form sends the map `data` as X-WWW-FORM-URLENCODED data to an HTTP POST request
// to the given `url`.
pub fn post_form(url string, data map[string]string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(
method: .post
url: url
header: new_header(key: .content_type, value: 'application/x-www-form-urlencoded')
data: url_encode_form_data(data)
)
2020-01-15 01:19:50 +03:00
}
[params]
pub struct PostMultipartFormConfig {
pub mut:
form map[string]string
files map[string][]FileData
header Header
}
// post_multipart_form sends multipart form data `conf` as an HTTP POST
// request to the given `url`.
pub fn post_multipart_form(url string, conf PostMultipartFormConfig) !Response {
body, boundary := multipart_form_body(conf.form, conf.files)
mut header := conf.header
header.set(.content_type, 'multipart/form-data; boundary="${boundary}"')
return fetch(
method: .post
url: url
header: header
data: body
)
}
// put sends string `data` as an HTTP PUT request to the given `url`.
pub fn put(url string, data string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(
method: .put
url: url
data: data
header: new_header(key: .content_type, value: http.content_type_default)
)
2020-01-15 01:19:50 +03:00
}
// patch sends string `data` as an HTTP PATCH request to the given `url`.
pub fn patch(url string, data string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(
method: .patch
url: url
data: data
header: new_header(key: .content_type, value: http.content_type_default)
)
2019-07-29 20:18:26 +03:00
}
// head sends an HTTP HEAD request to the given `url`.
pub fn head(url string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(method: .head, url: url)
2019-06-22 21:20:28 +03:00
}
// delete sends an HTTP DELETE request to the given `url`.
pub fn delete(url string) !Response {
2021-08-17 09:16:59 +03:00
return fetch(method: .delete, url: url)
}
// fetch sends an HTTP request to the `url` with the given method and configuration.
pub fn fetch(config FetchConfig) !Response {
2021-08-17 09:16:59 +03:00
if config.url == '' {
2020-01-16 20:16:11 +03:00
return error('http.fetch: empty url')
2019-07-29 20:18:26 +03:00
}
url := build_url_from_fetch(config) or { return error('http.fetch: invalid url ${config.url}') }
2020-01-16 20:16:11 +03:00
req := Request{
method: config.method
url: url
2021-08-17 09:16:59 +03:00
data: config.data
header: config.header
2020-01-16 20:16:11 +03:00
cookies: config.cookies
user_agent: config.user_agent
2019-06-22 21:20:28 +03:00
user_ptr: 0
2020-01-16 20:16:11 +03:00
verbose: config.verbose
validate: config.validate
verify: config.verify
cert: config.cert
cert_key: config.cert_key
2021-09-09 19:55:49 +03:00
in_memory_verification: config.in_memory_verification
allow_redirect: config.allow_redirect
2019-06-22 21:20:28 +03:00
}
res := req.do()!
2020-01-16 20:16:11 +03:00
return res
2019-06-22 21:20:28 +03:00
}
// get_text sends an HTTP GET request to the given `url` and returns the text content of the response.
2019-07-31 23:10:28 +03:00
pub fn get_text(url string) string {
2021-08-17 09:16:59 +03:00
resp := fetch(url: url, method: .get) or { return '' }
return resp.body
2019-10-24 19:44:49 +03:00
}
2019-07-31 23:10:28 +03:00
// url_encode_form_data converts mapped data to a URL encoded string.
2020-01-16 20:16:11 +03:00
pub fn url_encode_form_data(data map[string]string) string {
2020-04-26 14:49:31 +03:00
mut pieces := []string{}
for key_, value_ in data {
key := urllib.query_escape(key_)
value := urllib.query_escape(value_)
pieces << '${key}=${value}'
2020-01-16 20:16:11 +03:00
}
return pieces.join('&')
}
2021-08-17 09:16:59 +03:00
[deprecated: 'use fetch()']
fn fetch_with_method(method Method, _config FetchConfig) !Response {
2020-01-16 20:16:11 +03:00
mut config := _config
config.method = method
2021-08-17 09:16:59 +03:00
return fetch(config)
2020-01-16 20:16:11 +03:00
}
fn build_url_from_fetch(config FetchConfig) !string {
mut url := urllib.parse(config.url)!
if config.params.len == 0 {
2020-01-16 20:16:11 +03:00
return url.str()
}
mut pieces := []string{cap: config.params.len}
for key, val in config.params {
pieces << '${key}=${val}'
2020-01-16 20:16:11 +03:00
}
mut query := pieces.join('&')
if url.raw_query.len > 1 {
query = url.raw_query + '&' + query
}
url.raw_query = query
return url.str()
}
[deprecated: 'unescape_url is deprecated, use urllib.query_unescape() instead']
pub fn unescape_url(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.unescape_url() was replaced with urllib.query_unescape()')
}
[deprecated: 'escape_url is deprecated, use urllib.query_escape() instead']
pub fn escape_url(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.escape_url() was replaced with urllib.query_escape()')
}
[deprecated: 'unescape is deprecated, use urllib.query_escape() instead']
pub fn unescape(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.unescape() was replaced with http.unescape_url()')
}
[deprecated: 'escape is deprecated, use urllib.query_unescape() instead']
pub fn escape(s string) string {
2019-10-24 19:44:49 +03:00
panic('http.escape() was replaced with http.escape_url()')
}