IBM Containers API
GET
List latest API version
{{baseUrl}}/containers/version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/version");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/version")require "http/client"
url = "{{baseUrl}}/containers/version"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/version"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/version");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/version"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/version HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/version")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/version"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/version")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/version")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/version');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/containers/version'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/version';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/version',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/version")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/version',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/containers/version'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/version');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/containers/version'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/version';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/version"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/version" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/version",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/version');
echo $response->getBody();setUrl('{{baseUrl}}/containers/version');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/version');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/version' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/version' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/containers/version")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/version"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/version"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/version")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/version') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/version";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/versionhttp GET {{baseUrl}}/containers/versionwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/containers/versionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/version")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List messages for the user
{{baseUrl}}/containers/messages
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/messages");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/messages" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/messages"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/messages"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/messages");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/messages"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/messages HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/messages")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/messages"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/messages")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/messages")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/messages');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/messages',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/messages';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/messages',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/messages")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/messages',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/messages',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/messages');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/messages',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/messages';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/messages"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/messages" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/messages",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/messages', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/messages');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/messages');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/messages' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/messages' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/messages", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/messages"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/messages"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/messages")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/messages') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/messages";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/messages \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/messages \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/messagesimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/messages")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Refresh the TLS Certificate
{{baseUrl}}/tlskey/refresh
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tlskey/refresh");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/tlskey/refresh" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/tlskey/refresh"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/tlskey/refresh"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tlskey/refresh");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tlskey/refresh"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/tlskey/refresh HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/tlskey/refresh")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tlskey/refresh"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tlskey/refresh")
.put(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/tlskey/refresh")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/tlskey/refresh');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/tlskey/refresh',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tlskey/refresh';
const options = {method: 'PUT', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tlskey/refresh',
method: 'PUT',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tlskey/refresh")
.put(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/tlskey/refresh',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/tlskey/refresh',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/tlskey/refresh');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/tlskey/refresh',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tlskey/refresh';
const options = {method: 'PUT', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tlskey/refresh"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tlskey/refresh" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tlskey/refresh",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/tlskey/refresh', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tlskey/refresh');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tlskey/refresh');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tlskey/refresh' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tlskey/refresh' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("PUT", "/baseUrl/tlskey/refresh", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tlskey/refresh"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tlskey/refresh"
response <- VERB("PUT", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tlskey/refresh")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/tlskey/refresh') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tlskey/refresh";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/tlskey/refresh \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http PUT {{baseUrl}}/tlskey/refresh \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method PUT \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/tlskey/refreshimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tlskey/refresh")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the TLS Certificate
{{baseUrl}}/tlskey
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tlskey");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tlskey" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/tlskey"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tlskey"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tlskey");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tlskey"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tlskey HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tlskey")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tlskey"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tlskey")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tlskey")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tlskey');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tlskey',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tlskey';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tlskey',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tlskey")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tlskey',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tlskey',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tlskey');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tlskey',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tlskey';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tlskey"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tlskey" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tlskey",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tlskey', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tlskey');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tlskey');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tlskey' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tlskey' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/tlskey", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tlskey"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tlskey"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tlskey")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tlskey') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tlskey";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/tlskey \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/tlskey \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/tlskeyimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tlskey")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create and start a container group.
{{baseUrl}}/containers/groups
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/groups" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/groups"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/groups"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/groups HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/groups")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/groups")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/groups');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/groups');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/groups', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/groups');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/groups", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/groups') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/groups \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/groups \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/groupsimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Inspect a container group.
{{baseUrl}}/containers/groups/:name_or_id
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups/:name_or_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/groups/:name_or_id" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/groups/:name_or_id"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/groups/:name_or_id"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups/:name_or_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups/:name_or_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/groups/:name_or_id HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/groups/:name_or_id")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups/:name_or_id"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/groups/:name_or_id")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/groups/:name_or_id');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups/:name_or_id';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups/:name_or_id',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups/:name_or_id',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/groups/:name_or_id');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups/:name_or_id';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups/:name_or_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups/:name_or_id" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups/:name_or_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/groups/:name_or_id', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups/:name_or_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/groups/:name_or_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups/:name_or_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups/:name_or_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/groups/:name_or_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups/:name_or_id"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups/:name_or_id"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups/:name_or_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/groups/:name_or_id') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups/:name_or_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/groups/:name_or_id \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/groups/:name_or_id \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/groups/:name_or_idimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups/:name_or_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List all container groups in a space
{{baseUrl}}/containers/groups
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/groups" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/groups"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/groups"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/groups HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/groups")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/groups")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/groups');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/groups',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/groups',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/groups');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/groups',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/groups', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/groups');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/groups", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/groups') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/groups \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/groups \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/groupsimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Map a public route to a container group.
{{baseUrl}}/containers/groups/:name_or_id/maproute
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
BODY json
{
"domain": "",
"host": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups/:name_or_id/maproute");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"domain\": \"\",\n \"host\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/groups/:name_or_id/maproute" {:headers {:x-auth-token ""
:x-auth-project-id ""}
:content-type :json
:form-params {:domain ""
:host ""}})require "http/client"
url = "{{baseUrl}}/containers/groups/:name_or_id/maproute"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
"content-type" => "application/json"
}
reqBody = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/groups/:name_or_id/maproute"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
Content = new StringContent("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups/:name_or_id/maproute");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"domain\": \"\",\n \"host\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups/:name_or_id/maproute"
payload := strings.NewReader("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/groups/:name_or_id/maproute HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Content-Type: application/json
Host: example.com
Content-Length: 32
{
"domain": "",
"host": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/groups/:name_or_id/maproute")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.setHeader("content-type", "application/json")
.setBody("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups/:name_or_id/maproute"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"domain\": \"\",\n \"host\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"domain\": \"\",\n \"host\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id/maproute")
.post(body)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/groups/:name_or_id/maproute")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.header("content-type", "application/json")
.body("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
.asString(); const data = JSON.stringify({
domain: '',
host: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/groups/:name_or_id/maproute');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups/:name_or_id/maproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
data: {domain: '', host: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups/:name_or_id/maproute';
const options = {
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: '{"domain":"","host":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups/:name_or_id/maproute',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
processData: false,
data: '{\n "domain": "",\n "host": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"domain\": \"\",\n \"host\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id/maproute")
.post(body)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups/:name_or_id/maproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({domain: '', host: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups/:name_or_id/maproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: {domain: '', host: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/groups/:name_or_id/maproute');
req.headers({
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
});
req.type('json');
req.send({
domain: '',
host: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups/:name_or_id/maproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
data: {domain: '', host: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups/:name_or_id/maproute';
const options = {
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: '{"domain":"","host":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
@"host": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups/:name_or_id/maproute"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups/:name_or_id/maproute" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"domain\": \"\",\n \"host\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups/:name_or_id/maproute",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'domain' => '',
'host' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json",
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/groups/:name_or_id/maproute', [
'body' => '{
"domain": "",
"host": ""
}',
'headers' => [
'content-type' => 'application/json',
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups/:name_or_id/maproute');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => '',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'domain' => '',
'host' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'domain' => '',
'host' => ''
]));
$request->setRequestUrl('{{baseUrl}}/containers/groups/:name_or_id/maproute');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => '',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups/:name_or_id/maproute' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"domain": "",
"host": ""
}'$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups/:name_or_id/maproute' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"domain": "",
"host": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
headers = {
'x-auth-token': "",
'x-auth-project-id': "",
'content-type': "application/json"
}
conn.request("POST", "/baseUrl/containers/groups/:name_or_id/maproute", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups/:name_or_id/maproute"
payload = {
"domain": "",
"host": ""
}
headers = {
"x-auth-token": "",
"x-auth-project-id": "",
"content-type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups/:name_or_id/maproute"
payload <- "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups/:name_or_id/maproute")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
request["content-type"] = 'application/json'
request.body = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/containers/groups/:name_or_id/maproute') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
req.body = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups/:name_or_id/maproute";
let payload = json!({
"domain": "",
"host": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/groups/:name_or_id/maproute \
--header 'content-type: application/json' \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: ' \
--data '{
"domain": "",
"host": ""
}'echo '{
"domain": "",
"host": ""
}' | \
http POST {{baseUrl}}/containers/groups/:name_or_id/maproute \
content-type:application/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--header 'content-type: application/json' \
--body-data '{\n "domain": "",\n "host": ""\n}' \
--output-document \
- {{baseUrl}}/containers/groups/:name_or_id/maprouteimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": "",
"content-type": "application/json"
]
let parameters = [
"domain": "",
"host": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups/:name_or_id/maproute")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Stop and delete all container instances in a container group.
{{baseUrl}}/containers/groups/:name_or_id
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups/:name_or_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/containers/groups/:name_or_id" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/groups/:name_or_id"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/containers/groups/:name_or_id"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups/:name_or_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups/:name_or_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/containers/groups/:name_or_id HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/containers/groups/:name_or_id")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups/:name_or_id"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/containers/groups/:name_or_id")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/containers/groups/:name_or_id');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups/:name_or_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups/:name_or_id',
method: 'DELETE',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups/:name_or_id',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/containers/groups/:name_or_id');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups/:name_or_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups/:name_or_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups/:name_or_id" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups/:name_or_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/containers/groups/:name_or_id', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups/:name_or_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/groups/:name_or_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups/:name_or_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups/:name_or_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("DELETE", "/baseUrl/containers/groups/:name_or_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups/:name_or_id"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups/:name_or_id"
response <- VERB("DELETE", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups/:name_or_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/containers/groups/:name_or_id') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups/:name_or_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/containers/groups/:name_or_id \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http DELETE {{baseUrl}}/containers/groups/:name_or_id \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method DELETE \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/groups/:name_or_idimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups/:name_or_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Unmap a public route from a container group
{{baseUrl}}/containers/groups/:name_or_id/unmaproute
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
BODY json
{
"domain": "",
"host": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups/:name_or_id/unmaproute");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"domain\": \"\",\n \"host\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/groups/:name_or_id/unmaproute" {:headers {:x-auth-token ""
:x-auth-project-id ""}
:content-type :json
:form-params {:domain ""
:host ""}})require "http/client"
url = "{{baseUrl}}/containers/groups/:name_or_id/unmaproute"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
"content-type" => "application/json"
}
reqBody = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/groups/:name_or_id/unmaproute"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
Content = new StringContent("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups/:name_or_id/unmaproute");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"domain\": \"\",\n \"host\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups/:name_or_id/unmaproute"
payload := strings.NewReader("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/groups/:name_or_id/unmaproute HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Content-Type: application/json
Host: example.com
Content-Length: 32
{
"domain": "",
"host": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/groups/:name_or_id/unmaproute")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.setHeader("content-type", "application/json")
.setBody("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups/:name_or_id/unmaproute"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"domain\": \"\",\n \"host\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"domain\": \"\",\n \"host\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id/unmaproute")
.post(body)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/groups/:name_or_id/unmaproute")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.header("content-type", "application/json")
.body("{\n \"domain\": \"\",\n \"host\": \"\"\n}")
.asString(); const data = JSON.stringify({
domain: '',
host: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/groups/:name_or_id/unmaproute');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups/:name_or_id/unmaproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
data: {domain: '', host: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups/:name_or_id/unmaproute';
const options = {
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: '{"domain":"","host":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups/:name_or_id/unmaproute',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
processData: false,
data: '{\n "domain": "",\n "host": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"domain\": \"\",\n \"host\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id/unmaproute")
.post(body)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups/:name_or_id/unmaproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({domain: '', host: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups/:name_or_id/unmaproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: {domain: '', host: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/groups/:name_or_id/unmaproute');
req.headers({
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
});
req.type('json');
req.send({
domain: '',
host: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/groups/:name_or_id/unmaproute',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
data: {domain: '', host: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups/:name_or_id/unmaproute';
const options = {
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: '{"domain":"","host":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
@"host": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups/:name_or_id/unmaproute"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups/:name_or_id/unmaproute" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"domain\": \"\",\n \"host\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups/:name_or_id/unmaproute",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'domain' => '',
'host' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json",
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/groups/:name_or_id/unmaproute', [
'body' => '{
"domain": "",
"host": ""
}',
'headers' => [
'content-type' => 'application/json',
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups/:name_or_id/unmaproute');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => '',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'domain' => '',
'host' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'domain' => '',
'host' => ''
]));
$request->setRequestUrl('{{baseUrl}}/containers/groups/:name_or_id/unmaproute');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => '',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups/:name_or_id/unmaproute' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"domain": "",
"host": ""
}'$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups/:name_or_id/unmaproute' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"domain": "",
"host": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
headers = {
'x-auth-token': "",
'x-auth-project-id': "",
'content-type': "application/json"
}
conn.request("POST", "/baseUrl/containers/groups/:name_or_id/unmaproute", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups/:name_or_id/unmaproute"
payload = {
"domain": "",
"host": ""
}
headers = {
"x-auth-token": "",
"x-auth-project-id": "",
"content-type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups/:name_or_id/unmaproute"
payload <- "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups/:name_or_id/unmaproute")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
request["content-type"] = 'application/json'
request.body = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/containers/groups/:name_or_id/unmaproute') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
req.body = "{\n \"domain\": \"\",\n \"host\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups/:name_or_id/unmaproute";
let payload = json!({
"domain": "",
"host": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/groups/:name_or_id/unmaproute \
--header 'content-type: application/json' \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: ' \
--data '{
"domain": "",
"host": ""
}'echo '{
"domain": "",
"host": ""
}' | \
http POST {{baseUrl}}/containers/groups/:name_or_id/unmaproute \
content-type:application/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--header 'content-type: application/json' \
--body-data '{\n "domain": "",\n "host": ""\n}' \
--output-document \
- {{baseUrl}}/containers/groups/:name_or_id/unmaprouteimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": "",
"content-type": "application/json"
]
let parameters = [
"domain": "",
"host": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups/:name_or_id/unmaproute")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a container group.
{{baseUrl}}/containers/groups/:name_or_id
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/groups/:name_or_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/containers/groups/:name_or_id" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/groups/:name_or_id"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.patch url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/containers/groups/:name_or_id"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/groups/:name_or_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/groups/:name_or_id"
req, _ := http.NewRequest("PATCH", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/containers/groups/:name_or_id HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/containers/groups/:name_or_id")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/groups/:name_or_id"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id")
.patch(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/containers/groups/:name_or_id")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/containers/groups/:name_or_id');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/groups/:name_or_id';
const options = {method: 'PATCH', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/groups/:name_or_id',
method: 'PATCH',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/groups/:name_or_id")
.patch(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/groups/:name_or_id',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/containers/groups/:name_or_id');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/containers/groups/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/groups/:name_or_id';
const options = {method: 'PATCH', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/groups/:name_or_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/groups/:name_or_id" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/groups/:name_or_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/containers/groups/:name_or_id', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/groups/:name_or_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/groups/:name_or_id');
$request->setRequestMethod('PATCH');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/groups/:name_or_id' -Method PATCH -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/groups/:name_or_id' -Method PATCH -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("PATCH", "/baseUrl/containers/groups/:name_or_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/groups/:name_or_id"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.patch(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/groups/:name_or_id"
response <- VERB("PATCH", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/groups/:name_or_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/containers/groups/:name_or_id') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/groups/:name_or_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/containers/groups/:name_or_id \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http PATCH {{baseUrl}}/containers/groups/:name_or_id \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method PATCH \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/groups/:name_or_idimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/groups/:name_or_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/fs/create");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/volumes/fs/create" {:headers {:x-auth-token ""
:x-auth-project-id ""}
:content-type :json
:form-params {:fsIOPS ""
:fsName ""
:fsSize 0}})require "http/client"
url = "{{baseUrl}}/volumes/fs/create"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
"content-type" => "application/json"
}
reqBody = "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/volumes/fs/create"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
Content = new StringContent("{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/fs/create");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/fs/create"
payload := strings.NewReader("{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/volumes/fs/create HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Content-Type: application/json
Host: example.com
Content-Length: 49
{
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/volumes/fs/create")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.setHeader("content-type", "application/json")
.setBody("{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/fs/create"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/fs/create")
.post(body)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/volumes/fs/create")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.header("content-type", "application/json")
.body("{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}")
.asString(); const data = JSON.stringify({
fsIOPS: '',
fsName: '',
fsSize: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/volumes/fs/create');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/fs/create',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
data: {fsIOPS: '', fsName: '', fsSize: 0}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/fs/create';
const options = {
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: '{"fsIOPS":"","fsName":"","fsSize":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/fs/create',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
processData: false,
data: '{\n "fsIOPS": "",\n "fsName": "",\n "fsSize": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/volumes/fs/create")
.post(body)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/fs/create',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({fsIOPS: '', fsName: '', fsSize: 0}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/fs/create',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: {fsIOPS: '', fsName: '', fsSize: 0},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/volumes/fs/create');
req.headers({
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
});
req.type('json');
req.send({
fsIOPS: '',
fsName: '',
fsSize: 0
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/fs/create',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
data: {fsIOPS: '', fsName: '', fsSize: 0}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/fs/create';
const options = {
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': '',
'content-type': 'application/json'
},
body: '{"fsIOPS":"","fsName":"","fsSize":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"fsIOPS": @"",
@"fsName": @"",
@"fsSize": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/fs/create"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/fs/create" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/fs/create",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'fsIOPS' => '',
'fsName' => '',
'fsSize' => 0
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json",
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/volumes/fs/create', [
'body' => '{
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}',
'headers' => [
'content-type' => 'application/json',
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/fs/create');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => '',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'fsIOPS' => '',
'fsName' => '',
'fsSize' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'fsIOPS' => '',
'fsName' => '',
'fsSize' => 0
]));
$request->setRequestUrl('{{baseUrl}}/volumes/fs/create');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => '',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/fs/create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}'$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/fs/create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}"
headers = {
'x-auth-token': "",
'x-auth-project-id': "",
'content-type': "application/json"
}
conn.request("POST", "/baseUrl/volumes/fs/create", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/fs/create"
payload = {
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}
headers = {
"x-auth-token": "",
"x-auth-project-id": "",
"content-type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/fs/create"
payload <- "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/fs/create")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
request["content-type"] = 'application/json'
request.body = "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/volumes/fs/create') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
req.body = "{\n \"fsIOPS\": \"\",\n \"fsName\": \"\",\n \"fsSize\": 0\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/fs/create";
let payload = json!({
"fsIOPS": "",
"fsName": "",
"fsSize": 0
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/volumes/fs/create \
--header 'content-type: application/json' \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: ' \
--data '{
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}'echo '{
"fsIOPS": "",
"fsName": "",
"fsSize": 0
}' | \
http POST {{baseUrl}}/volumes/fs/create \
content-type:application/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--header 'content-type: application/json' \
--body-data '{\n "fsIOPS": "",\n "fsName": "",\n "fsSize": 0\n}' \
--output-document \
- {{baseUrl}}/volumes/fs/createimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": "",
"content-type": "application/json"
]
let parameters = [
"fsIOPS": "",
"fsName": "",
"fsSize": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/fs/create")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/fs/:name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/volumes/fs/:name" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/fs/:name"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/volumes/fs/:name"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/fs/:name");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/fs/:name"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/volumes/fs/:name HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/volumes/fs/:name")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/fs/:name"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/fs/:name")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/volumes/fs/:name")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/volumes/fs/:name');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/volumes/fs/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/fs/:name';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/fs/:name',
method: 'DELETE',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/fs/:name")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/fs/:name',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/volumes/fs/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/volumes/fs/:name');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/volumes/fs/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/fs/:name';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/fs/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/fs/:name" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/fs/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/volumes/fs/:name', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/fs/:name');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/fs/:name');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/fs/:name' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/fs/:name' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("DELETE", "/baseUrl/volumes/fs/:name", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/fs/:name"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/fs/:name"
response <- VERB("DELETE", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/fs/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/volumes/fs/:name') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/fs/:name";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/volumes/fs/:name \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http DELETE {{baseUrl}}/volumes/fs/:name \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method DELETE \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/fs/:nameimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/fs/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/fs/:name/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/volumes/fs/:name/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/fs/:name/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/volumes/fs/:name/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/fs/:name/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/fs/:name/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/volumes/fs/:name/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/volumes/fs/:name/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/fs/:name/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/fs/:name/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/volumes/fs/:name/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/volumes/fs/:name/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/:name/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/fs/:name/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/fs/:name/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/fs/:name/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/fs/:name/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/:name/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/volumes/fs/:name/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/:name/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/fs/:name/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/fs/:name/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/fs/:name/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/fs/:name/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/volumes/fs/:name/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/fs/:name/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/fs/:name/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/fs/:name/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/fs/:name/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/volumes/fs/:name/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/fs/:name/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/fs/:name/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/fs/:name/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/volumes/fs/:name/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/fs/:name/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/volumes/fs/:name/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/volumes/fs/:name/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/fs/:name/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/fs/:name/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/fs/flavors/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/volumes/fs/flavors/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/fs/flavors/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/volumes/fs/flavors/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/fs/flavors/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/fs/flavors/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/volumes/fs/flavors/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/volumes/fs/flavors/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/fs/flavors/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/fs/flavors/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/volumes/fs/flavors/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/volumes/fs/flavors/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/flavors/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/fs/flavors/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/fs/flavors/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/fs/flavors/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/fs/flavors/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/flavors/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/volumes/fs/flavors/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/flavors/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/fs/flavors/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/fs/flavors/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/fs/flavors/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/fs/flavors/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/volumes/fs/flavors/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/fs/flavors/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/fs/flavors/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/fs/flavors/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/fs/flavors/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/volumes/fs/flavors/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/fs/flavors/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/fs/flavors/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/fs/flavors/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/volumes/fs/flavors/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/fs/flavors/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/volumes/fs/flavors/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/volumes/fs/flavors/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/fs/flavors/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/fs/flavors/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/fs/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/volumes/fs/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/fs/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/volumes/fs/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/fs/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/fs/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/volumes/fs/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/volumes/fs/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/fs/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/fs/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/volumes/fs/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/volumes/fs/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/fs/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/fs/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/fs/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/fs/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/volumes/fs/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/fs/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/fs/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/fs/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/fs/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/fs/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/volumes/fs/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/fs/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/fs/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/fs/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/fs/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/volumes/fs/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/fs/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/fs/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/fs/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/volumes/fs/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/fs/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/volumes/fs/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/volumes/fs/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/fs/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/fs/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Build a Docker image from a Dockerfile
{{baseUrl}}/build
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
t
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/build?t=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/build" {:headers {:x-auth-token ""
:x-auth-project-id ""}
:query-params {:t ""}})require "http/client"
url = "{{baseUrl}}/build?t="
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/build?t="),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/build?t=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/build?t="
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/build?t= HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/build?t=")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/build?t="))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/build?t=")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/build?t=")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/build?t=');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/build',
params: {t: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/build?t=';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/build?t=',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/build?t=")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/build?t=',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/build',
qs: {t: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/build');
req.query({
t: ''
});
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/build',
params: {t: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/build?t=';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/build?t="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/build?t=" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/build?t=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/build?t=', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/build');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
't' => ''
]);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/build');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
't' => ''
]));
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/build?t=' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/build?t=' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/build?t=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/build"
querystring = {"t":""}
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/build"
queryString <- list(t = "")
response <- VERB("POST", url, query = queryString, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/build?t=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/build') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
req.params['t'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/build";
let querystring = [
("t", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/build?t=' \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST '{{baseUrl}}/build?t=' \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- '{{baseUrl}}/build?t='import Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/build?t=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Inspect a Docker image in private Bluemix registry
{{baseUrl}}/images/:name_or_id/json
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/images/:name_or_id/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/images/:name_or_id/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/images/:name_or_id/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/images/:name_or_id/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/images/:name_or_id/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/images/:name_or_id/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/images/:name_or_id/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/images/:name_or_id/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/images/:name_or_id/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/images/:name_or_id/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/images/:name_or_id/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/images/:name_or_id/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/images/:name_or_id/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/images/:name_or_id/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/images/:name_or_id/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/images/:name_or_id/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/images/:name_or_id/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/images/:name_or_id/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/images/:name_or_id/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/images/:name_or_id/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/images/:name_or_id/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/images/:name_or_id/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/images/:name_or_id/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/images/:name_or_id/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/images/:name_or_id/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/images/:name_or_id/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/images/:name_or_id/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/images/:name_or_id/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/images/:name_or_id/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/images/:name_or_id/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/images/:name_or_id/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/images/:name_or_id/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/images/:name_or_id/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/images/:name_or_id/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/images/:name_or_id/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/images/:name_or_id/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/images/:name_or_id/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/images/:name_or_id/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/images/:name_or_id/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List all Docker images that are available in your private Bluemix registry.
{{baseUrl}}/images/json
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/images/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/images/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/images/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/images/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/images/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/images/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/images/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/images/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/images/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/images/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/images/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/images/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/images/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/images/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/images/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/images/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/images/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/images/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/images/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/images/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/images/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/images/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/images/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/images/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/images/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/images/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/images/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/images/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/images/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/images/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/images/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/images/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/images/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/images/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/images/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/images/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/images/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/images/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/images/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Remove a Docker image.
{{baseUrl}}/images/:id
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/images/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/images/:id" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/images/:id"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/images/:id"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/images/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/images/:id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/images/:id HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/images/:id")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/images/:id"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/images/:id")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/images/:id")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/images/:id');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/images/:id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/images/:id';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/images/:id',
method: 'DELETE',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/images/:id")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/images/:id',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/images/:id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/images/:id');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/images/:id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/images/:id';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/images/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/images/:id" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/images/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/images/:id', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/images/:id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/images/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/images/:id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/images/:id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("DELETE", "/baseUrl/images/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/images/:id"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/images/:id"
response <- VERB("DELETE", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/images/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/images/:id') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/images/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/images/:id \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http DELETE {{baseUrl}}/images/:id \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method DELETE \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/images/:idimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/images/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Check the availability of a namespace
{{baseUrl}}/registry/namespaces/:namespace
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
namespace
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/registry/namespaces/:namespace");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/registry/namespaces/:namespace" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/registry/namespaces/:namespace"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/registry/namespaces/:namespace"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/registry/namespaces/:namespace");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/registry/namespaces/:namespace"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/registry/namespaces/:namespace HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/registry/namespaces/:namespace")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/registry/namespaces/:namespace"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/registry/namespaces/:namespace")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/registry/namespaces/:namespace")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/registry/namespaces/:namespace');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/registry/namespaces/:namespace',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/registry/namespaces/:namespace';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/registry/namespaces/:namespace',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/registry/namespaces/:namespace")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/registry/namespaces/:namespace',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/registry/namespaces/:namespace',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/registry/namespaces/:namespace');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/registry/namespaces/:namespace',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/registry/namespaces/:namespace';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/registry/namespaces/:namespace"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/registry/namespaces/:namespace" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/registry/namespaces/:namespace",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/registry/namespaces/:namespace', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/registry/namespaces/:namespace');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/registry/namespaces/:namespace');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/registry/namespaces/:namespace' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/registry/namespaces/:namespace' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/registry/namespaces/:namespace", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/registry/namespaces/:namespace"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/registry/namespaces/:namespace"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/registry/namespaces/:namespace")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/registry/namespaces/:namespace') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/registry/namespaces/:namespace";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/registry/namespaces/:namespace \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/registry/namespaces/:namespace \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/registry/namespaces/:namespaceimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/registry/namespaces/:namespace")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the namespace of an organization.
{{baseUrl}}/registry/namespaces
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/registry/namespaces");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/registry/namespaces" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/registry/namespaces"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/registry/namespaces"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/registry/namespaces");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/registry/namespaces"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/registry/namespaces HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/registry/namespaces")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/registry/namespaces"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/registry/namespaces")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/registry/namespaces")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/registry/namespaces');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/registry/namespaces',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/registry/namespaces';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/registry/namespaces',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/registry/namespaces")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/registry/namespaces',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/registry/namespaces',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/registry/namespaces');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/registry/namespaces',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/registry/namespaces';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/registry/namespaces"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/registry/namespaces" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/registry/namespaces",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/registry/namespaces', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/registry/namespaces');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/registry/namespaces');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/registry/namespaces' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/registry/namespaces' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/registry/namespaces", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/registry/namespaces"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/registry/namespaces"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/registry/namespaces")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/registry/namespaces') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/registry/namespaces";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/registry/namespaces \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/registry/namespaces \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/registry/namespacesimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/registry/namespaces")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Set a namespace for your private Bluemix registry.
{{baseUrl}}/registry/namespaces/:namespace
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
namespace
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/registry/namespaces/:namespace");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/registry/namespaces/:namespace" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/registry/namespaces/:namespace"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/registry/namespaces/:namespace"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/registry/namespaces/:namespace");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/registry/namespaces/:namespace"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/registry/namespaces/:namespace HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/registry/namespaces/:namespace")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/registry/namespaces/:namespace"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/registry/namespaces/:namespace")
.put(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/registry/namespaces/:namespace")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/registry/namespaces/:namespace');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/registry/namespaces/:namespace',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/registry/namespaces/:namespace';
const options = {method: 'PUT', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/registry/namespaces/:namespace',
method: 'PUT',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/registry/namespaces/:namespace")
.put(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/registry/namespaces/:namespace',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/registry/namespaces/:namespace',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/registry/namespaces/:namespace');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/registry/namespaces/:namespace',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/registry/namespaces/:namespace';
const options = {method: 'PUT', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/registry/namespaces/:namespace"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/registry/namespaces/:namespace" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/registry/namespaces/:namespace",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/registry/namespaces/:namespace', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/registry/namespaces/:namespace');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/registry/namespaces/:namespace');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/registry/namespaces/:namespace' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/registry/namespaces/:namespace' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("PUT", "/baseUrl/registry/namespaces/:namespace", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/registry/namespaces/:namespace"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/registry/namespaces/:namespace"
response <- VERB("PUT", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/registry/namespaces/:namespace")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/registry/namespaces/:namespace') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/registry/namespaces/:namespace";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/registry/namespaces/:namespace \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http PUT {{baseUrl}}/registry/namespaces/:namespace \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method PUT \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/registry/namespaces/:namespaceimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/registry/namespaces/:namespace")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Bind a public IP address to a single container
{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
ip
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/floating-ips/:ip/bind HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/floating-ips/:ip/bind',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/floating-ips/:ip/bind", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/floating-ips/:ip/bind') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bindimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/bind")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List available public IP addresses in a space
{{baseUrl}}/containers/floating-ips
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/floating-ips");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/floating-ips" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/floating-ips"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/floating-ips"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/floating-ips");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/floating-ips"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/floating-ips HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/floating-ips")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/floating-ips"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/floating-ips")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/floating-ips")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/floating-ips');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/floating-ips',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/floating-ips';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/floating-ips',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/floating-ips")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/floating-ips',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/floating-ips',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/floating-ips');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/floating-ips',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/floating-ips';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/floating-ips"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/floating-ips" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/floating-ips",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/floating-ips', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/floating-ips');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/floating-ips');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/floating-ips' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/floating-ips' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/floating-ips", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/floating-ips"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/floating-ips"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/floating-ips")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/floating-ips') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/floating-ips";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/floating-ips \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/floating-ips \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/floating-ipsimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/floating-ips")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Release public IP address
{{baseUrl}}/containers/floating-ips/:ip/release
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
ip
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/floating-ips/:ip/release");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/floating-ips/:ip/release" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/floating-ips/:ip/release"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/floating-ips/:ip/release"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/floating-ips/:ip/release");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/floating-ips/:ip/release"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/floating-ips/:ip/release HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/floating-ips/:ip/release")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/floating-ips/:ip/release"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/floating-ips/:ip/release")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/floating-ips/:ip/release")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/floating-ips/:ip/release');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/floating-ips/:ip/release',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/floating-ips/:ip/release';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/floating-ips/:ip/release',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/floating-ips/:ip/release")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/floating-ips/:ip/release',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/floating-ips/:ip/release',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/floating-ips/:ip/release');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/floating-ips/:ip/release',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/floating-ips/:ip/release';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/floating-ips/:ip/release"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/floating-ips/:ip/release" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/floating-ips/:ip/release",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/floating-ips/:ip/release', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/floating-ips/:ip/release');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/floating-ips/:ip/release');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/floating-ips/:ip/release' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/floating-ips/:ip/release' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/floating-ips/:ip/release", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/floating-ips/:ip/release"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/floating-ips/:ip/release"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/floating-ips/:ip/release")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/floating-ips/:ip/release') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/floating-ips/:ip/release";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/floating-ips/:ip/release \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/floating-ips/:ip/release \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/floating-ips/:ip/releaseimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/floating-ips/:ip/release")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Request a public IP address for a space
{{baseUrl}}/containers/floating-ips/request
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/floating-ips/request");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/floating-ips/request" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/floating-ips/request"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/floating-ips/request"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/floating-ips/request");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/floating-ips/request"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/floating-ips/request HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/floating-ips/request")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/floating-ips/request"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/floating-ips/request")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/floating-ips/request")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/floating-ips/request');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/floating-ips/request',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/floating-ips/request';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/floating-ips/request',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/floating-ips/request")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/floating-ips/request',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/floating-ips/request',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/floating-ips/request');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/floating-ips/request',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/floating-ips/request';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/floating-ips/request"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/floating-ips/request" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/floating-ips/request",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/floating-ips/request', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/floating-ips/request');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/floating-ips/request');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/floating-ips/request' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/floating-ips/request' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/floating-ips/request", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/floating-ips/request"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/floating-ips/request"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/floating-ips/request")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/floating-ips/request') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/floating-ips/request";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/floating-ips/request \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/floating-ips/request \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/floating-ips/requestimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/floating-ips/request")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Unbind a public IP address from a container
{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
ip
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/floating-ips/:ip/unbind HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/floating-ips/:ip/unbind',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/floating-ips/:ip/unbind", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/floating-ips/:ip/unbind') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbindimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/floating-ips/:ip/unbind")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List container sizes and quota limits
{{baseUrl}}/containers/usage
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/usage");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/usage" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/usage"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/usage"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/usage");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/usage"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/usage HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/usage")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/usage"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/usage")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/usage")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/usage');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/usage',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/usage';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/usage',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/usage")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/usage',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/usage',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/usage');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/usage',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/usage';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/usage"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/usage" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/usage",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/usage', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/usage');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/usage');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/usage' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/usage' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/usage", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/usage"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/usage"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/usage")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/usage') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/usage";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/usage \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/usage \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/usageimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/usage")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve organization and space specific quota
{{baseUrl}}/containers/quota
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/quota");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/quota" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/quota"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/quota"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/quota");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/quota"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/quota HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/quota")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/quota"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/quota")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/quota")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/quota');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/quota',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/quota';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/quota',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/quota")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/quota',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/quota',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/quota');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/quota',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/quota';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/quota"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/quota" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/quota",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/quota', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/quota');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/quota');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/quota' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/quota' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/quota", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/quota"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/quota"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/quota")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/quota') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/quota";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/quota \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/quota \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/quotaimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/quota")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Update space quota
{{baseUrl}}/containers/quota
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/quota");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/containers/quota" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/quota"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/containers/quota"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/quota");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/quota"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/containers/quota HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/containers/quota")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/quota"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/quota")
.put(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/containers/quota")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/containers/quota');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/containers/quota',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/quota';
const options = {method: 'PUT', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/quota',
method: 'PUT',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/quota")
.put(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/quota',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/containers/quota',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/containers/quota');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/containers/quota',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/quota';
const options = {method: 'PUT', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/quota"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/quota" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/quota",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/containers/quota', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/quota');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/quota');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/quota' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/quota' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("PUT", "/baseUrl/containers/quota", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/quota"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/quota"
response <- VERB("PUT", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/quota")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/containers/quota') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/quota";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/containers/quota \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http PUT {{baseUrl}}/containers/quota \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method PUT \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/quotaimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/quota")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create and start a single container
{{baseUrl}}/containers/create
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/create");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/create" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/create"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/create"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/create");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/create"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/create HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/create")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/create"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/create")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/create")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/create');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/create',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/create';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/create',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/create")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/create',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/create',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/create');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/create',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/create';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/create"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/create" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/create",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/create', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/create');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/create');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/create' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/create' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/create", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/create"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/create"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/create")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/create') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/create";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/create \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/create \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/createimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/create")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Inspect a single container
{{baseUrl}}/containers/:name_or_id/json
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/:name_or_id/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/:name_or_id/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/:name_or_id/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/:name_or_id/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/:name_or_id/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/:name_or_id/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/:name_or_id/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/:name_or_id/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/:name_or_id/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/:name_or_id/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/:name_or_id/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/:name_or_id/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/:name_or_id/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/:name_or_id/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List single containers in a space.
{{baseUrl}}/containers/json
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List the current state of a container.
{{baseUrl}}/containers/:id/status
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:id/status");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/containers/:id/status" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:id/status"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/containers/:id/status"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:id/status");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:id/status"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/containers/:id/status HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/containers/:id/status")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:id/status"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:id/status")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/containers/:id/status")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/containers/:id/status');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/:id/status',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:id/status';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:id/status',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:id/status")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:id/status',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/:id/status',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/containers/:id/status');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/containers/:id/status',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:id/status';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:id/status"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:id/status" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:id/status",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/containers/:id/status', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:id/status');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:id/status');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:id/status' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:id/status' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/containers/:id/status", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:id/status"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:id/status"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:id/status")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/containers/:id/status') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:id/status";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/containers/:id/status \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/containers/:id/status \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:id/statusimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:id/status")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Pause a single container
{{baseUrl}}/containers/:name_or_id/pause
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/pause");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/pause" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/pause"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/pause"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/pause");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/pause"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/pause HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/pause")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/pause"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/pause")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/pause")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/pause');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/pause',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/pause';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/pause',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/pause")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/pause',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/pause',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/pause');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/pause',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/pause';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/pause"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/pause" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/pause",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/pause', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/pause');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/pause');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/pause' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/pause' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/pause", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/pause"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/pause"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/pause")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/pause') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/pause";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/pause \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/pause \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/pauseimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/pause")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Remove a single container
{{baseUrl}}/containers/:name_or_id
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/containers/:name_or_id" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/containers/:name_or_id HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/containers/:name_or_id")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/containers/:name_or_id")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/containers/:name_or_id');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/containers/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id',
method: 'DELETE',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/containers/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/containers/:name_or_id');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/containers/:name_or_id',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/containers/:name_or_id', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("DELETE", "/baseUrl/containers/:name_or_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id"
response <- VERB("DELETE", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/containers/:name_or_id') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/containers/:name_or_id \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http DELETE {{baseUrl}}/containers/:name_or_id \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method DELETE \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_idimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Rename a single container
{{baseUrl}}/containers/:name_or_id/rename
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/rename?name=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/rename" {:headers {:x-auth-token ""
:x-auth-project-id ""}
:query-params {:name ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/rename?name="
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/rename?name="),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/rename?name=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/rename?name="
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/rename?name= HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/rename?name=")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/rename?name="))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/rename?name=")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/rename?name=")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/rename?name=');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/rename',
params: {name: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/rename?name=';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/rename?name=',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/rename?name=")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/rename?name=',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/rename',
qs: {name: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/rename');
req.query({
name: ''
});
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/rename',
params: {name: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/rename?name=';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/rename?name="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/rename?name=" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/rename?name=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/rename?name=', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/rename');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'name' => ''
]);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/rename');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'name' => ''
]));
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/rename?name=' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/rename?name=' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/rename?name=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/rename"
querystring = {"name":""}
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/rename"
queryString <- list(name = "")
response <- VERB("POST", url, query = queryString, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/rename?name=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/rename') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
req.params['name'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/rename";
let querystring = [
("name", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/containers/:name_or_id/rename?name=' \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST '{{baseUrl}}/containers/:name_or_id/rename?name=' \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- '{{baseUrl}}/containers/:name_or_id/rename?name='import Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/rename?name=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Restart a single container
{{baseUrl}}/containers/:name_or_id/restart
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/restart");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/restart" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/restart"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/restart"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/restart");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/restart"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/restart HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/restart")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/restart"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/restart")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/restart")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/restart');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/restart',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/restart';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/restart',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/restart")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/restart',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/restart',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/restart');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/restart',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/restart';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/restart"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/restart" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/restart",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/restart', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/restart');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/restart');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/restart' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/restart' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/restart", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/restart"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/restart"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/restart")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/restart') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/restart";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/restart \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/restart \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/restartimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/restart")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Start a single container
{{baseUrl}}/containers/:name_or_id/start
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/start");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/start" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/start"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/start"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/start");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/start"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/start HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/start")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/start"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/start")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/start")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/start');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/start',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/start';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/start',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/start")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/start',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/start',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/start');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/start',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/start';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/start"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/start" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/start",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/start', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/start');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/start');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/start' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/start' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/start", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/start"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/start"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/start")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/start') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/start";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/start \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/start \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/startimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/start")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Stop a single container
{{baseUrl}}/containers/:name_or_id/stop
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/stop");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/stop" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/stop"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/stop"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/stop");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/stop"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/stop HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/stop")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/stop"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/stop")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/stop")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/stop');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/stop',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/stop';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/stop',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/stop")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/stop',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/stop',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/stop');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/stop',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/stop';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/stop"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/stop" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/stop",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/stop', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/stop');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/stop');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/stop' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/stop' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/stop", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/stop"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/stop"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/stop")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/stop') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/stop";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/stop \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/stop \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/stopimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/stop")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Unpause a single container
{{baseUrl}}/containers/:name_or_id/unpause
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name_or_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/containers/:name_or_id/unpause");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/containers/:name_or_id/unpause" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/containers/:name_or_id/unpause"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/containers/:name_or_id/unpause"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/containers/:name_or_id/unpause");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/containers/:name_or_id/unpause"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/containers/:name_or_id/unpause HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/containers/:name_or_id/unpause")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/containers/:name_or_id/unpause"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/unpause")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/containers/:name_or_id/unpause")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/containers/:name_or_id/unpause');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/unpause',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/containers/:name_or_id/unpause';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/containers/:name_or_id/unpause',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/containers/:name_or_id/unpause")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/containers/:name_or_id/unpause',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/unpause',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/containers/:name_or_id/unpause');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/containers/:name_or_id/unpause',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/containers/:name_or_id/unpause';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/containers/:name_or_id/unpause"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/containers/:name_or_id/unpause" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/containers/:name_or_id/unpause",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/containers/:name_or_id/unpause', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/containers/:name_or_id/unpause');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/containers/:name_or_id/unpause');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/containers/:name_or_id/unpause' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/containers/:name_or_id/unpause' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/containers/:name_or_id/unpause", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/containers/:name_or_id/unpause"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/containers/:name_or_id/unpause"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/containers/:name_or_id/unpause")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/containers/:name_or_id/unpause') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/containers/:name_or_id/unpause";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/containers/:name_or_id/unpause \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/containers/:name_or_id/unpause \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/containers/:name_or_id/unpauseimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/containers/:name_or_id/unpause")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a volume in a space
{{baseUrl}}/volumes/create
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/create?name=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/volumes/create" {:headers {:x-auth-token ""
:x-auth-project-id ""}
:query-params {:name ""}})require "http/client"
url = "{{baseUrl}}/volumes/create?name="
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/volumes/create?name="),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/create?name=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/create?name="
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/volumes/create?name= HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/volumes/create?name=")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/create?name="))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/create?name=")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/volumes/create?name=")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/volumes/create?name=');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/create',
params: {name: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/create?name=';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/create?name=',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/create?name=")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/create?name=',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/create',
qs: {name: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/volumes/create');
req.query({
name: ''
});
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/create',
params: {name: ''},
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/create?name=';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/create?name="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/create?name=" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/create?name=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/volumes/create?name=', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/create');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'name' => ''
]);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/create');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'name' => ''
]));
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/create?name=' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/create?name=' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/volumes/create?name=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/create"
querystring = {"name":""}
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/create"
queryString <- list(name = "")
response <- VERB("POST", url, query = queryString, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/create?name=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/volumes/create') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
req.params['name'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/create";
let querystring = [
("name", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/volumes/create?name=' \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST '{{baseUrl}}/volumes/create?name=' \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- '{{baseUrl}}/volumes/create?name='import Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/create?name=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a volume
{{baseUrl}}/volumes/:name
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/:name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/volumes/:name" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/:name"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/volumes/:name"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/:name");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/:name"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/volumes/:name HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/volumes/:name")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/:name"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/:name")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/volumes/:name")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/volumes/:name');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/volumes/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/:name';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/:name',
method: 'DELETE',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/:name")
.delete(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/:name',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/volumes/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/volumes/:name');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/volumes/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/:name';
const options = {method: 'DELETE', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/:name" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/volumes/:name', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/:name');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/:name');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/:name' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/:name' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("DELETE", "/baseUrl/volumes/:name", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/:name"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/:name"
response <- VERB("DELETE", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/volumes/:name') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/:name";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/volumes/:name \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http DELETE {{baseUrl}}/volumes/:name \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method DELETE \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/:nameimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List all volumes for a space
{{baseUrl}}/volumes/json
HEADERS
X-Auth-Token
X-Auth-Project-Id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/volumes/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/volumes/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/volumes/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/volumes/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/volumes/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/volumes/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/volumes/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/volumes/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/volumes/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/volumes/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/volumes/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/volumes/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve detailed information about a volume.
{{baseUrl}}/volumes/:name/json
HEADERS
X-Auth-Token
X-Auth-Project-Id
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/:name/json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/volumes/:name/json" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/:name/json"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/volumes/:name/json"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/:name/json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/:name/json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/volumes/:name/json HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/volumes/:name/json")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/:name/json"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/:name/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/volumes/:name/json")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/volumes/:name/json');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/:name/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/:name/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/:name/json',
method: 'GET',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/:name/json")
.get()
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/:name/json',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/:name/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/volumes/:name/json');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/volumes/:name/json',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/:name/json';
const options = {method: 'GET', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/:name/json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/:name/json" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/:name/json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/volumes/:name/json', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/:name/json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/:name/json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/:name/json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/:name/json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("GET", "/baseUrl/volumes/:name/json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/:name/json"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/:name/json"
response <- VERB("GET", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/:name/json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/volumes/:name/json') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/:name/json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/volumes/:name/json \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http GET {{baseUrl}}/volumes/:name/json \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method GET \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/:name/jsonimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/:name/json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/volumes/:name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-auth-token: ");
headers = curl_slist_append(headers, "x-auth-project-id: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/volumes/:name" {:headers {:x-auth-token ""
:x-auth-project-id ""}})require "http/client"
url = "{{baseUrl}}/volumes/:name"
headers = HTTP::Headers{
"x-auth-token" => ""
"x-auth-project-id" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/volumes/:name"),
Headers =
{
{ "x-auth-token", "" },
{ "x-auth-project-id", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/volumes/:name");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-auth-token", "");
request.AddHeader("x-auth-project-id", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/volumes/:name"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-auth-token", "")
req.Header.Add("x-auth-project-id", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/volumes/:name HTTP/1.1
X-Auth-Token:
X-Auth-Project-Id:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/volumes/:name")
.setHeader("x-auth-token", "")
.setHeader("x-auth-project-id", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/volumes/:name"))
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/volumes/:name")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/volumes/:name")
.header("x-auth-token", "")
.header("x-auth-project-id", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/volumes/:name');
xhr.setRequestHeader('x-auth-token', '');
xhr.setRequestHeader('x-auth-project-id', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/volumes/:name';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/volumes/:name',
method: 'POST',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/volumes/:name")
.post(null)
.addHeader("x-auth-token", "")
.addHeader("x-auth-project-id", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/volumes/:name',
headers: {
'x-auth-token': '',
'x-auth-project-id': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/volumes/:name');
req.headers({
'x-auth-token': '',
'x-auth-project-id': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/volumes/:name',
headers: {'x-auth-token': '', 'x-auth-project-id': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/volumes/:name';
const options = {method: 'POST', headers: {'x-auth-token': '', 'x-auth-project-id': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-auth-token": @"",
@"x-auth-project-id": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/volumes/:name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/volumes/:name" in
let headers = Header.add_list (Header.init ()) [
("x-auth-token", "");
("x-auth-project-id", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/volumes/:name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-auth-project-id: ",
"x-auth-token: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/volumes/:name', [
'headers' => [
'x-auth-project-id' => '',
'x-auth-token' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/volumes/:name');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/volumes/:name');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-auth-token' => '',
'x-auth-project-id' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/volumes/:name' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-auth-token", "")
$headers.Add("x-auth-project-id", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/volumes/:name' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-auth-token': "",
'x-auth-project-id': ""
}
conn.request("POST", "/baseUrl/volumes/:name", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/volumes/:name"
headers = {
"x-auth-token": "",
"x-auth-project-id": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/volumes/:name"
response <- VERB("POST", url, add_headers('x-auth-token' = '', 'x-auth-project-id' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/volumes/:name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-auth-token"] = ''
request["x-auth-project-id"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/volumes/:name') do |req|
req.headers['x-auth-token'] = ''
req.headers['x-auth-project-id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/volumes/:name";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-auth-token", "".parse().unwrap());
headers.insert("x-auth-project-id", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/volumes/:name \
--header 'x-auth-project-id: ' \
--header 'x-auth-token: 'http POST {{baseUrl}}/volumes/:name \
x-auth-project-id:'' \
x-auth-token:''wget --quiet \
--method POST \
--header 'x-auth-token: ' \
--header 'x-auth-project-id: ' \
--output-document \
- {{baseUrl}}/volumes/:nameimport Foundation
let headers = [
"x-auth-token": "",
"x-auth-project-id": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/volumes/:name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()