Storage API Doc

POST watch container

{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/dynamic/watch/containers/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"))
    .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}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")
  .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}}/bcsstorage/v2/dynamic/watch/containers/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId';
const options = {method: 'POST'};

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}}/bcsstorage/v2/dynamic/watch/containers/:clusterId',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/watch/containers/:clusterId',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId');

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}}/bcsstorage/v2/dynamic/watch/containers/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId';
const options = {method: 'POST'};

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}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/dynamic/watch/containers/:clusterId" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/dynamic/watch/containers/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/dynamic/watch/containers/:clusterId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId

http POST {{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/watch/containers/:clusterId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 watch dynamic

{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType

QUERY PARAMS

clusterId

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"))
    .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}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")
  .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}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType';
const options = {method: 'POST'};

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}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType');

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}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType';
const options = {method: 'POST'};

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}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType

http POST {{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/watch/:clusterId/:resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 watch事件

{{baseUrl}}/bcsstorage/v2/events/watch

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/events/watch");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/events/watch")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/events/watch"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/events/watch"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/events/watch");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/events/watch"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/events/watch HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/events/watch")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/events/watch"))
    .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}}/bcsstorage/v2/events/watch")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/events/watch")
  .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}}/bcsstorage/v2/events/watch');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/bcsstorage/v2/events/watch'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/events/watch';
const options = {method: 'POST'};

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}}/bcsstorage/v2/events/watch',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/events/watch")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/events/watch',
  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: 'POST', url: '{{baseUrl}}/bcsstorage/v2/events/watch'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/events/watch');

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}}/bcsstorage/v2/events/watch'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/events/watch';
const options = {method: 'POST'};

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}}/bcsstorage/v2/events/watch"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/events/watch" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/events/watch",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/events/watch');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/events/watch');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/events/watch');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/events/watch' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/events/watch' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/events/watch")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/events/watch"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/events/watch"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/events/watch")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/events/watch') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/events/watch";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/events/watch

http POST {{baseUrl}}/bcsstorage/v2/events/watch

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/events/watch

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/events/watch")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 watch指标

{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type

QUERY PARAMS

clusterId

type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/metric/watch/:clusterId/:type HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type"))
    .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}}/bcsstorage/v2/metric/watch/:clusterId/:type")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type")
  .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}}/bcsstorage/v2/metric/watch/:clusterId/:type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type';
const options = {method: 'POST'};

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}}/bcsstorage/v2/metric/watch/:clusterId/:type',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/metric/watch/:clusterId/:type',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type');

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}}/bcsstorage/v2/metric/watch/:clusterId/:type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type';
const options = {method: 'POST'};

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}}/bcsstorage/v2/metric/watch/:clusterId/:type"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/metric/watch/:clusterId/:type" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/metric/watch/:clusterId/:type")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/metric/watch/:clusterId/:type') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type

http POST {{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/metric/watch/:clusterId/:type")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 修改watch资源

{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

QUERY PARAMS

clusterId

namespace

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

http PUT {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 修改或新增命名空间资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

QUERY PARAMS

clusterId

namespace

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

http PUT {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 修改或新增自定义资源

{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

QUERY PARAMS

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"))
    .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}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .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}}/bcsstorage/v2/dynamic/customresources/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');

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}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/dynamic/customresources/:resourceType" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

http PUT {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 修改或新增集群资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

QUERY PARAMS

clusterId

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

http PUT {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 修改指标

{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

QUERY PARAMS

clusterId

namespace

type

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"))
    .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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

http PUT {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 修改集群关系(增量)

{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/host/clusters/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"))
    .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}}/bcsstorage/v2/host/clusters/:clusterId")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .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}}/bcsstorage/v2/host/clusters/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId';
const options = {method: 'POST'};

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}}/bcsstorage/v2/host/clusters/:clusterId',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/host/clusters/:clusterId',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');

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}}/bcsstorage/v2/host/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId';
const options = {method: 'POST'};

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}}/bcsstorage/v2/host/clusters/:clusterId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/host/clusters/:clusterId" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/host/clusters/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/host/clusters/:clusterId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

http POST {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 修改集群关系(覆盖)

{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/host/clusters/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"))
    .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}}/bcsstorage/v2/host/clusters/:clusterId")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .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}}/bcsstorage/v2/host/clusters/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/host/clusters/:clusterId',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/host/clusters/:clusterId',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');

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}}/bcsstorage/v2/host/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/host/clusters/:clusterId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/host/clusters/:clusterId" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/host/clusters/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/host/clusters/:clusterId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

http PUT {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 创建主机配置

{{baseUrl}}/bcsstorage/v2/host/:ip

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/host/:ip");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/host/:ip")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/host/:ip"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/host/:ip"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/host/:ip");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/host/:ip"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/host/:ip HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/host/:ip")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/host/:ip"))
    .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}}/bcsstorage/v2/host/:ip")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/host/:ip")
  .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}}/bcsstorage/v2/host/:ip');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/bcsstorage/v2/host/:ip'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/host/:ip';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/host/:ip',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/host/:ip")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/host/:ip',
  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: 'PUT', url: '{{baseUrl}}/bcsstorage/v2/host/:ip'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/host/:ip');

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}}/bcsstorage/v2/host/:ip'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/host/:ip';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/host/:ip"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/host/:ip" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/host/:ip",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/host/:ip');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/host/:ip');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/host/:ip');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/host/:ip' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/host/:ip' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/host/:ip")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/host/:ip"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/host/:ip"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/host/:ip")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/host/:ip') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/host/:ip";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/host/:ip

http PUT {{baseUrl}}/bcsstorage/v2/host/:ip

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/host/:ip

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/host/:ip")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 创建事件

{{baseUrl}}/bcsstorage/v2/events

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/events");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/events")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/events"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/events");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/events"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/events"))
    .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}}/bcsstorage/v2/events")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/events")
  .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}}/bcsstorage/v2/events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/bcsstorage/v2/events'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/events';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/events',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/events")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/events',
  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: 'PUT', url: '{{baseUrl}}/bcsstorage/v2/events'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/events');

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}}/bcsstorage/v2/events'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/events';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/events"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/events" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/events');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/events');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/events');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/events' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/events' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/events")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/events"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/events"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/events")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/events') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/events";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/events

http PUT {{baseUrl}}/bcsstorage/v2/events

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/events")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 创建或修改集群配置

{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"))
    .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}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .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}}/bcsstorage/v2/cluster_config/clusters/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/cluster_config/clusters/:clusterId',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');

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}}/bcsstorage/v2/cluster_config/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/cluster_config/clusters/:clusterId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/cluster_config/clusters/:clusterId" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

http PUT {{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 创建稳定版本

{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

QUERY PARAMS

service

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/cluster_config/versions/:service HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"))
    .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}}/bcsstorage/v2/cluster_config/versions/:service")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")
  .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}}/bcsstorage/v2/cluster_config/versions/:service');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/cluster_config/versions/:service',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/cluster_config/versions/:service',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');

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}}/bcsstorage/v2/cluster_config/versions/:service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/cluster_config/versions/:service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/cluster_config/versions/:service" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/cluster_config/versions/:service")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/cluster_config/versions/:service') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

http PUT {{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 创建自定义资源索引

{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

QUERY PARAMS

resourceType

indexName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"))
    .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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName',
  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: 'PUT',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName';
const options = {method: 'PUT'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

http PUT {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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 删除watch资源

{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

QUERY PARAMS

clusterId

namespace

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

http DELETE {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 删除主机配置

{{baseUrl}}/bcsstorage/v2/host/:ip

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/host/:ip");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/host/:ip")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/host/:ip"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/host/:ip"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/host/:ip");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/host/:ip"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/host/:ip HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/host/:ip")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/host/:ip"))
    .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}}/bcsstorage/v2/host/:ip")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/host/:ip")
  .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}}/bcsstorage/v2/host/:ip');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/bcsstorage/v2/host/:ip'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/host/:ip';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/host/:ip',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/host/:ip")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/host/:ip',
  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: 'DELETE', url: '{{baseUrl}}/bcsstorage/v2/host/:ip'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/host/:ip');

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}}/bcsstorage/v2/host/:ip'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/host/:ip';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/host/:ip"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/host/:ip" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/host/:ip",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/host/:ip');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/host/:ip');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/host/:ip');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/host/:ip' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/host/:ip' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/host/:ip")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/host/:ip"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/host/:ip"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/host/:ip")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/host/:ip') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/host/:ip";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/host/:ip

http DELETE {{baseUrl}}/bcsstorage/v2/host/:ip

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/host/:ip

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/host/:ip")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 删除命名空间资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

QUERY PARAMS

clusterId

namespace

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

http DELETE {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 删除指标

{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

QUERY PARAMS

clusterId

namespace

type

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"))
    .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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

http DELETE {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 删除自定义资源

{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

QUERY PARAMS

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"))
    .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}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .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}}/bcsstorage/v2/dynamic/customresources/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');

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}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/dynamic/customresources/:resourceType" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

http DELETE {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 删除自定义资源索引

{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

QUERY PARAMS

resourceType

indexName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"))
    .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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

http DELETE {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType/index/:indexName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 删除集群资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

QUERY PARAMS

clusterId

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

http DELETE {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 批量删除命名空间资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

QUERY PARAMS

clusterId

namespace

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"))
    .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

http DELETE {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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)

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

QUERY PARAMS

clusterId

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"))
    .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

http DELETE {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 批量删除集群资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

QUERY PARAMS

clusterId

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"))
    .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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType',
  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: 'DELETE',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');

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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType';
const options = {method: 'DELETE'};

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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

http DELETE {{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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 批量查询watch资源

{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType

QUERY PARAMS

clusterId

namespace

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"

	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/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"))
    .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType';
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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType',
  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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType');

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType';
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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"]
                                                       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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType",
  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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType";

    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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType

http GET {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType")! 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 批量查询命名空间资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

QUERY PARAMS

clusterId

namespace

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

	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/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"))
    .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType';
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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType',
  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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType';
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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"]
                                                       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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType",
  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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType";

    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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

http GET {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType")! 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 批量查询集群资源 (GET)

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

QUERY PARAMS

clusterId

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

	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/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"))
    .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType';
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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType',
  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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType';
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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"]
                                                       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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType",
  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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType";

    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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

http GET {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType")! 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 批量查询集群资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

QUERY PARAMS

clusterId

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

	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/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"))
    .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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType';
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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType',
  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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');

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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType';
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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"]
                                                       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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType",
  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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType";

    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}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

http GET {{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/all_resources/clusters/:clusterId/:resourceType")! 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()

POST 接收告警数据

{{baseUrl}}/bcsstorage/v2/alarms

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/alarms");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/alarms")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/alarms"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/alarms"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/alarms");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/alarms"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/alarms HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/alarms")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/alarms"))
    .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}}/bcsstorage/v2/alarms")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/alarms")
  .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}}/bcsstorage/v2/alarms');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/bcsstorage/v2/alarms'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/alarms';
const options = {method: 'POST'};

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}}/bcsstorage/v2/alarms',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/alarms")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/alarms',
  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: 'POST', url: '{{baseUrl}}/bcsstorage/v2/alarms'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/alarms');

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}}/bcsstorage/v2/alarms'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/alarms';
const options = {method: 'POST'};

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}}/bcsstorage/v2/alarms"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/alarms" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/alarms",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/alarms');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/alarms');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/alarms');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/alarms' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/alarms' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/alarms")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/alarms"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/alarms"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/alarms")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/alarms') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/alarms";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/alarms

http POST {{baseUrl}}/bcsstorage/v2/alarms

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/alarms

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/alarms")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询ReplicaSet (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询ReplicaSet

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/replicaset")! 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()

POST 查询configMap (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询configMap

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/configmap")! 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()

POST 查询daemonSet (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询daemonSet

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/daemonset")! 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()

POST 查询deployment (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询deployment

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/deployment")! 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()

POST 查询endpoints (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询endpoints

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/endpoints")! 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()

POST 查询ingress (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询ingress

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ingress")! 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()

POST 查询job (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询job

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/job")! 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()

POST 查询k8s详细静态IP池 (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询k8s详细静态IP池

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstaticdetail")! 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()

POST 查询k8s静态IP池 (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询k8s静态IP池

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/ippoolstatic")! 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()

POST 查询node (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询node

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/node")! 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()

POST 查询pod (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询pod

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/pod")! 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()

POST 查询secret (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询secret

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/secret")! 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()

POST 查询service (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询service

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/service")! 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()

POST 查询statefulSet (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询statefulSet

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/statefulset")! 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 查询watch资源

{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

QUERY PARAMS

clusterId

namespace

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

	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/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"]
                                                       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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName",
  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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName";

    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}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

http GET {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/watch/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")! 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 查询主机配置 (GET)

{{baseUrl}}/bcsstorage/v2/host/:ip

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/host/:ip");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/host/:ip")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/host/:ip"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/host/:ip"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/host/:ip");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/host/:ip"

	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/bcsstorage/v2/host/:ip HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/host/:ip")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/host/:ip"))
    .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}}/bcsstorage/v2/host/:ip")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/host/:ip")
  .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}}/bcsstorage/v2/host/:ip');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bcsstorage/v2/host/:ip'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/host/:ip';
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}}/bcsstorage/v2/host/:ip',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/host/:ip")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/host/:ip',
  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}}/bcsstorage/v2/host/:ip'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/host/:ip');

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}}/bcsstorage/v2/host/:ip'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/host/:ip';
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}}/bcsstorage/v2/host/:ip"]
                                                       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}}/bcsstorage/v2/host/:ip" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/host/:ip",
  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}}/bcsstorage/v2/host/:ip');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/host/:ip');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/host/:ip');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/host/:ip' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/host/:ip' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/host/:ip")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/host/:ip"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/host/:ip"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/host/:ip")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/host/:ip') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/host/:ip";

    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}}/bcsstorage/v2/host/:ip

http GET {{baseUrl}}/bcsstorage/v2/host/:ip

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/host/:ip

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/host/:ip")! 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 查询主机配置

{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

	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/bcsstorage/v2/host/clusters/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"))
    .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}}/bcsstorage/v2/host/clusters/:clusterId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .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}}/bcsstorage/v2/host/clusters/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId';
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}}/bcsstorage/v2/host/clusters/:clusterId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/host/clusters/:clusterId',
  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}}/bcsstorage/v2/host/clusters/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');

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}}/bcsstorage/v2/host/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId';
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}}/bcsstorage/v2/host/clusters/:clusterId"]
                                                       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}}/bcsstorage/v2/host/clusters/:clusterId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId",
  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}}/bcsstorage/v2/host/clusters/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/host/clusters/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/host/clusters/:clusterId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId";

    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}}/bcsstorage/v2/host/clusters/:clusterId

http GET {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/host/clusters/:clusterId")! 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 查询事件

{{baseUrl}}/bcsstorage/v2/events

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/events");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/events")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/events"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/events"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/events"

	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/bcsstorage/v2/events HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/events")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/events"))
    .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}}/bcsstorage/v2/events")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/events")
  .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}}/bcsstorage/v2/events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bcsstorage/v2/events'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/events';
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}}/bcsstorage/v2/events',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/events")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/events',
  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}}/bcsstorage/v2/events'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/events');

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}}/bcsstorage/v2/events'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/events';
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}}/bcsstorage/v2/events"]
                                                       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}}/bcsstorage/v2/events" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/events",
  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}}/bcsstorage/v2/events');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/events');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/events' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/events' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/events")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/events"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/events")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/events') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/events";

    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}}/bcsstorage/v2/events

http GET {{baseUrl}}/bcsstorage/v2/events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/events")! 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 查询告警数据

{{baseUrl}}/bcsstorage/v2/alarms

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/alarms");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/alarms")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/alarms"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/alarms"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/alarms");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/alarms"

	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/bcsstorage/v2/alarms HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/alarms")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/alarms"))
    .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}}/bcsstorage/v2/alarms")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/alarms")
  .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}}/bcsstorage/v2/alarms');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bcsstorage/v2/alarms'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/alarms';
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}}/bcsstorage/v2/alarms',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/alarms")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/alarms',
  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}}/bcsstorage/v2/alarms'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/alarms');

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}}/bcsstorage/v2/alarms'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/alarms';
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}}/bcsstorage/v2/alarms"]
                                                       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}}/bcsstorage/v2/alarms" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/alarms",
  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}}/bcsstorage/v2/alarms');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/alarms');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/alarms');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/alarms' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/alarms' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/alarms")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/alarms"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/alarms"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/alarms")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/alarms') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/alarms";

    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}}/bcsstorage/v2/alarms

http GET {{baseUrl}}/bcsstorage/v2/alarms

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/alarms

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/alarms")! 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()

POST 查询命名空间 (POST)

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace',
  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: 'POST',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace';
const options = {method: 'POST'};

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

http POST {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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 查询命名空间

{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

	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/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"))
    .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace',
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');

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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace';
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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"]
                                                       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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace",
  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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace";

    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}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

http GET {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/query/k8s/dynamic/clusters/:clusterId/namespace")! 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 查询命名空间资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

QUERY PARAMS

clusterId

namespace

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

	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/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName',
  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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName';
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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"]
                                                       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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName",
  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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName";

    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}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

http GET {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/namespace_resources/clusters/:clusterId/namespaces/:namespace/:resourceType/:resourceName")! 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 查询指标(路径)

{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

QUERY PARAMS

clusterId

namespace

type

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

	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/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"))
    .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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name';
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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name',
  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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name';
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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"]
                                                       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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name",
  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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name";

    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}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

http GET {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId/namespaces/:namespace/:type/:name")! 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 查询指标

{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId"

	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/bcsstorage/v2/metric/clusters/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId"))
    .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}}/bcsstorage/v2/metric/clusters/:clusterId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId")
  .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}}/bcsstorage/v2/metric/clusters/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId';
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}}/bcsstorage/v2/metric/clusters/:clusterId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/metric/clusters/:clusterId',
  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}}/bcsstorage/v2/metric/clusters/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId');

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}}/bcsstorage/v2/metric/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId';
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}}/bcsstorage/v2/metric/clusters/:clusterId"]
                                                       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}}/bcsstorage/v2/metric/clusters/:clusterId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId",
  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}}/bcsstorage/v2/metric/clusters/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/metric/clusters/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/metric/clusters/:clusterId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId";

    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}}/bcsstorage/v2/metric/clusters/:clusterId

http GET {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/metric/clusters/:clusterId")! 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 查询指标表名

{{baseUrl}}/bcsstorage/v2/metric/clusters

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/metric/clusters");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/metric/clusters")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/metric/clusters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/metric/clusters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/metric/clusters"

	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/bcsstorage/v2/metric/clusters HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/metric/clusters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/metric/clusters"))
    .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}}/bcsstorage/v2/metric/clusters")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/metric/clusters")
  .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}}/bcsstorage/v2/metric/clusters');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/metric/clusters'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters';
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}}/bcsstorage/v2/metric/clusters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/metric/clusters")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/metric/clusters',
  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}}/bcsstorage/v2/metric/clusters'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/metric/clusters');

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}}/bcsstorage/v2/metric/clusters'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/metric/clusters';
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}}/bcsstorage/v2/metric/clusters"]
                                                       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}}/bcsstorage/v2/metric/clusters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/metric/clusters",
  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}}/bcsstorage/v2/metric/clusters');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/metric/clusters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/metric/clusters' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/metric/clusters")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/metric/clusters"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/metric/clusters"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/metric/clusters")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/metric/clusters') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/metric/clusters";

    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}}/bcsstorage/v2/metric/clusters

http GET {{baseUrl}}/bcsstorage/v2/metric/clusters

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/metric/clusters

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/metric/clusters")! 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 查询服务配置

{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service

QUERY PARAMS

service

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service"

	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/bcsstorage/v2/cluster_config/services/:service HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service"))
    .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}}/bcsstorage/v2/cluster_config/services/:service")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service")
  .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}}/bcsstorage/v2/cluster_config/services/:service');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service';
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}}/bcsstorage/v2/cluster_config/services/:service',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/cluster_config/services/:service',
  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}}/bcsstorage/v2/cluster_config/services/:service'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service');

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}}/bcsstorage/v2/cluster_config/services/:service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service';
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}}/bcsstorage/v2/cluster_config/services/:service"]
                                                       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}}/bcsstorage/v2/cluster_config/services/:service" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service",
  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}}/bcsstorage/v2/cluster_config/services/:service');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/cluster_config/services/:service")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/cluster_config/services/:service') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service";

    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}}/bcsstorage/v2/cluster_config/services/:service

http GET {{baseUrl}}/bcsstorage/v2/cluster_config/services/:service

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/cluster_config/services/:service

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/cluster_config/services/:service")! 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 查询自定义资源

{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

QUERY PARAMS

resourceType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

	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/bcsstorage/v2/dynamic/customresources/:resourceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"))
    .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}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .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}}/bcsstorage/v2/dynamic/customresources/:resourceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType';
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}}/bcsstorage/v2/dynamic/customresources/:resourceType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType',
  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}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');

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}}/bcsstorage/v2/dynamic/customresources/:resourceType'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType';
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}}/bcsstorage/v2/dynamic/customresources/:resourceType"]
                                                       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}}/bcsstorage/v2/dynamic/customresources/:resourceType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType",
  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}}/bcsstorage/v2/dynamic/customresources/:resourceType');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/dynamic/customresources/:resourceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType";

    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}}/bcsstorage/v2/dynamic/customresources/:resourceType

http GET {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/dynamic/customresources/:resourceType")! 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 查询集群资源

{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

QUERY PARAMS

clusterId

resourceType

resourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

	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/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"))
    .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName';
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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName',
  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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName';
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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"]
                                                       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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName",
  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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName";

    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}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

http GET {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/k8s/dynamic/cluster_resources/clusters/:clusterId/:resourceType/:resourceName")! 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 查询集群配置

{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

QUERY PARAMS

clusterId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

	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/bcsstorage/v2/cluster_config/clusters/:clusterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"))
    .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}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .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}}/bcsstorage/v2/cluster_config/clusters/:clusterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId';
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}}/bcsstorage/v2/cluster_config/clusters/:clusterId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId',
  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}}/bcsstorage/v2/cluster_config/clusters/:clusterId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');

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}}/bcsstorage/v2/cluster_config/clusters/:clusterId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId';
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}}/bcsstorage/v2/cluster_config/clusters/:clusterId"]
                                                       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}}/bcsstorage/v2/cluster_config/clusters/:clusterId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId",
  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}}/bcsstorage/v2/cluster_config/clusters/:clusterId');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/cluster_config/clusters/:clusterId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId";

    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}}/bcsstorage/v2/cluster_config/clusters/:clusterId

http GET {{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/cluster_config/clusters/:clusterId")! 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 获取稳定版本

{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

QUERY PARAMS

service

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")

require "http/client"

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

	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/bcsstorage/v2/cluster_config/versions/:service HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"))
    .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}}/bcsstorage/v2/cluster_config/versions/:service")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")
  .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}}/bcsstorage/v2/cluster_config/versions/:service');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service';
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}}/bcsstorage/v2/cluster_config/versions/:service',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bcsstorage/v2/cluster_config/versions/:service',
  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}}/bcsstorage/v2/cluster_config/versions/:service'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');

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}}/bcsstorage/v2/cluster_config/versions/:service'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service';
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}}/bcsstorage/v2/cluster_config/versions/:service"]
                                                       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}}/bcsstorage/v2/cluster_config/versions/:service" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service",
  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}}/bcsstorage/v2/cluster_config/versions/:service');

echo $response->getBody();

setUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bcsstorage/v2/cluster_config/versions/:service")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")

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_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bcsstorage/v2/cluster_config/versions/:service') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service";

    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}}/bcsstorage/v2/cluster_config/versions/:service

http GET {{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bcsstorage/v2/cluster_config/versions/:service")! 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()