Airflow API (Stable)
GET
Get current configuration
{{baseUrl}}/config
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/config");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/config")require "http/client"
url = "{{baseUrl}}/config"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/config"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/config"
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/config HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/config")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/config"))
.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}}/config")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/config")
.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}}/config');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/config'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/config';
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}}/config',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/config")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/config',
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}}/config'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/config');
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}}/config'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/config';
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}}/config"]
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}}/config" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/config",
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}}/config');
echo $response->getBody();setUrl('{{baseUrl}}/config');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/config' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/config' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/config")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/config"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/config"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/config")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/config') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/config";
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}}/confighttp GET {{baseUrl}}/configwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/configimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/config")! 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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"sections": [
{
"name": "core",
"options": [
{
"key": "dags_folder",
"value": "/home/user/my-dags-folder"
}
]
},
{
"name": "smtp",
"options": [
{
"key": "smtp_host",
"value": "localhost"
},
{
"key": "smtp_mail_from",
"value": "airflow@example.com"
}
]
}
]
}RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
[core]
dags_folder = /home/user/my-dags-folder
[smtp]
smtp_host = localhost
smtp_mail_from = airflow@example.com
POST
Create a connection
{{baseUrl}}/connections
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/connections")require "http/client"
url = "{{baseUrl}}/connections"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/connections"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connections");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connections"
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/connections HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/connections")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connections"))
.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}}/connections")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/connections")
.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}}/connections');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/connections'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connections';
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}}/connections',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connections")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/connections',
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}}/connections'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/connections');
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}}/connections'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connections';
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}}/connections"]
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}}/connections" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connections",
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}}/connections');
echo $response->getBody();setUrl('{{baseUrl}}/connections');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connections');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/connections' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/connections")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connections"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/connections"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connections")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/connections') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connections";
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}}/connectionshttp POST {{baseUrl}}/connectionswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/connectionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections")! 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()
DELETE
Delete a connection
{{baseUrl}}/connections/:connection_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections/:connection_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/connections/:connection_id")require "http/client"
url = "{{baseUrl}}/connections/:connection_id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/connections/:connection_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connections/:connection_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connections/:connection_id"
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/connections/:connection_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/connections/:connection_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connections/:connection_id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/connections/:connection_id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/connections/:connection_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/connections/:connection_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/connections/:connection_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connections/:connection_id';
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}}/connections/:connection_id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connections/:connection_id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/connections/:connection_id',
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}}/connections/:connection_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/connections/:connection_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/connections/:connection_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connections/:connection_id';
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}}/connections/:connection_id"]
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}}/connections/:connection_id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connections/:connection_id",
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}}/connections/:connection_id');
echo $response->getBody();setUrl('{{baseUrl}}/connections/:connection_id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connections/:connection_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections/:connection_id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/connections/:connection_id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/connections/:connection_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connections/:connection_id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/connections/:connection_id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connections/:connection_id")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/connections/:connection_id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connections/:connection_id";
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}}/connections/:connection_idhttp DELETE {{baseUrl}}/connections/:connection_idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/connections/:connection_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections/:connection_id")! 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
Get a connection
{{baseUrl}}/connections/:connection_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections/:connection_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/connections/:connection_id")require "http/client"
url = "{{baseUrl}}/connections/:connection_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/connections/:connection_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connections/:connection_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connections/:connection_id"
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/connections/:connection_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/connections/:connection_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connections/:connection_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/connections/:connection_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/connections/:connection_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/connections/:connection_id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/connections/:connection_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connections/:connection_id';
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}}/connections/:connection_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connections/:connection_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/connections/:connection_id',
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}}/connections/:connection_id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/connections/:connection_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/connections/:connection_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connections/:connection_id';
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}}/connections/:connection_id"]
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}}/connections/:connection_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connections/:connection_id",
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}}/connections/:connection_id');
echo $response->getBody();setUrl('{{baseUrl}}/connections/:connection_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connections/:connection_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections/:connection_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/connections/:connection_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/connections/:connection_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connections/:connection_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/connections/:connection_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connections/:connection_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/connections/:connection_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connections/:connection_id";
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}}/connections/:connection_idhttp GET {{baseUrl}}/connections/:connection_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/connections/:connection_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections/:connection_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List connections
{{baseUrl}}/connections
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/connections")require "http/client"
url = "{{baseUrl}}/connections"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/connections"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connections");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connections"
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/connections HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/connections")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connections"))
.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}}/connections")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/connections")
.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}}/connections');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/connections'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connections';
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}}/connections',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connections")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/connections',
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}}/connections'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/connections');
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}}/connections'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connections';
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}}/connections"]
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}}/connections" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connections",
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}}/connections');
echo $response->getBody();setUrl('{{baseUrl}}/connections');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connections');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/connections' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/connections")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connections"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/connections"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connections")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/connections') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connections";
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}}/connectionshttp GET {{baseUrl}}/connectionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/connectionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections")! 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
Test a connection
{{baseUrl}}/connections/test
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections/test");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/connections/test")require "http/client"
url = "{{baseUrl}}/connections/test"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/connections/test"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connections/test");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connections/test"
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/connections/test HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/connections/test")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connections/test"))
.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}}/connections/test")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/connections/test")
.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}}/connections/test');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/connections/test'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connections/test';
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}}/connections/test',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connections/test")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/connections/test',
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}}/connections/test'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/connections/test');
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}}/connections/test'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connections/test';
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}}/connections/test"]
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}}/connections/test" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connections/test",
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}}/connections/test');
echo $response->getBody();setUrl('{{baseUrl}}/connections/test');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connections/test');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections/test' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/connections/test' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/connections/test")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connections/test"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/connections/test"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connections/test")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/connections/test') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connections/test";
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}}/connections/testhttp POST {{baseUrl}}/connections/testwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/connections/testimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections/test")! 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()
PATCH
Update a connection
{{baseUrl}}/connections/:connection_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections/:connection_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/connections/:connection_id")require "http/client"
url = "{{baseUrl}}/connections/:connection_id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/connections/:connection_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connections/:connection_id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connections/:connection_id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/connections/:connection_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/connections/:connection_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connections/:connection_id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/connections/:connection_id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/connections/:connection_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/connections/:connection_id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/connections/:connection_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connections/:connection_id';
const options = {method: 'PATCH'};
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}}/connections/:connection_id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connections/:connection_id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/connections/:connection_id',
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: 'PATCH', url: '{{baseUrl}}/connections/:connection_id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/connections/:connection_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/connections/:connection_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connections/:connection_id';
const options = {method: 'PATCH'};
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}}/connections/:connection_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
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}}/connections/:connection_id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connections/:connection_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/connections/:connection_id');
echo $response->getBody();setUrl('{{baseUrl}}/connections/:connection_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connections/:connection_id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections/:connection_id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/connections/:connection_id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/connections/:connection_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connections/:connection_id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/connections/:connection_id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connections/:connection_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/connections/:connection_id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connections/:connection_id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/connections/:connection_idhttp PATCH {{baseUrl}}/connections/:connection_idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/connections/:connection_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections/:connection_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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
Clear a set of task instances
{{baseUrl}}/dags/:dag_id/clearTaskInstances
BODY json
{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/clearTaskInstances");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/dags/:dag_id/clearTaskInstances" {:content-type :json
:form-params {:dag_run_id ""
:dry_run false
:end_date ""
:include_downstream false
:include_future false
:include_parentdag false
:include_past false
:include_subdags false
:include_upstream false
:only_failed false
:only_running false
:reset_dag_runs false
:start_date ""
:task_ids []}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/clearTaskInstances"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/clearTaskInstances"),
Content = new StringContent("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/clearTaskInstances");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/clearTaskInstances"
payload := strings.NewReader("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/dags/:dag_id/clearTaskInstances HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 344
{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dags/:dag_id/clearTaskInstances")
.setHeader("content-type", "application/json")
.setBody("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/clearTaskInstances"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/clearTaskInstances")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/dags/:dag_id/clearTaskInstances")
.header("content-type", "application/json")
.body("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}")
.asString(); const data = JSON.stringify({
dag_run_id: '',
dry_run: false,
end_date: '',
include_downstream: false,
include_future: false,
include_parentdag: false,
include_past: false,
include_subdags: false,
include_upstream: false,
only_failed: false,
only_running: false,
reset_dag_runs: false,
start_date: '',
task_ids: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/dags/:dag_id/clearTaskInstances');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/clearTaskInstances',
headers: {'content-type': 'application/json'},
data: {
dag_run_id: '',
dry_run: false,
end_date: '',
include_downstream: false,
include_future: false,
include_parentdag: false,
include_past: false,
include_subdags: false,
include_upstream: false,
only_failed: false,
only_running: false,
reset_dag_runs: false,
start_date: '',
task_ids: []
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/clearTaskInstances';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_run_id":"","dry_run":false,"end_date":"","include_downstream":false,"include_future":false,"include_parentdag":false,"include_past":false,"include_subdags":false,"include_upstream":false,"only_failed":false,"only_running":false,"reset_dag_runs":false,"start_date":"","task_ids":[]}'
};
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}}/dags/:dag_id/clearTaskInstances',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dag_run_id": "",\n "dry_run": false,\n "end_date": "",\n "include_downstream": false,\n "include_future": false,\n "include_parentdag": false,\n "include_past": false,\n "include_subdags": false,\n "include_upstream": false,\n "only_failed": false,\n "only_running": false,\n "reset_dag_runs": false,\n "start_date": "",\n "task_ids": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/clearTaskInstances")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/clearTaskInstances',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
dag_run_id: '',
dry_run: false,
end_date: '',
include_downstream: false,
include_future: false,
include_parentdag: false,
include_past: false,
include_subdags: false,
include_upstream: false,
only_failed: false,
only_running: false,
reset_dag_runs: false,
start_date: '',
task_ids: []
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/clearTaskInstances',
headers: {'content-type': 'application/json'},
body: {
dag_run_id: '',
dry_run: false,
end_date: '',
include_downstream: false,
include_future: false,
include_parentdag: false,
include_past: false,
include_subdags: false,
include_upstream: false,
only_failed: false,
only_running: false,
reset_dag_runs: false,
start_date: '',
task_ids: []
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/dags/:dag_id/clearTaskInstances');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dag_run_id: '',
dry_run: false,
end_date: '',
include_downstream: false,
include_future: false,
include_parentdag: false,
include_past: false,
include_subdags: false,
include_upstream: false,
only_failed: false,
only_running: false,
reset_dag_runs: false,
start_date: '',
task_ids: []
});
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}}/dags/:dag_id/clearTaskInstances',
headers: {'content-type': 'application/json'},
data: {
dag_run_id: '',
dry_run: false,
end_date: '',
include_downstream: false,
include_future: false,
include_parentdag: false,
include_past: false,
include_subdags: false,
include_upstream: false,
only_failed: false,
only_running: false,
reset_dag_runs: false,
start_date: '',
task_ids: []
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/clearTaskInstances';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_run_id":"","dry_run":false,"end_date":"","include_downstream":false,"include_future":false,"include_parentdag":false,"include_past":false,"include_subdags":false,"include_upstream":false,"only_failed":false,"only_running":false,"reset_dag_runs":false,"start_date":"","task_ids":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dag_run_id": @"",
@"dry_run": @NO,
@"end_date": @"",
@"include_downstream": @NO,
@"include_future": @NO,
@"include_parentdag": @NO,
@"include_past": @NO,
@"include_subdags": @NO,
@"include_upstream": @NO,
@"only_failed": @NO,
@"only_running": @NO,
@"reset_dag_runs": @NO,
@"start_date": @"",
@"task_ids": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/clearTaskInstances"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/clearTaskInstances" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/clearTaskInstances",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'dag_run_id' => '',
'dry_run' => null,
'end_date' => '',
'include_downstream' => null,
'include_future' => null,
'include_parentdag' => null,
'include_past' => null,
'include_subdags' => null,
'include_upstream' => null,
'only_failed' => null,
'only_running' => null,
'reset_dag_runs' => null,
'start_date' => '',
'task_ids' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/dags/:dag_id/clearTaskInstances', [
'body' => '{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/clearTaskInstances');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dag_run_id' => '',
'dry_run' => null,
'end_date' => '',
'include_downstream' => null,
'include_future' => null,
'include_parentdag' => null,
'include_past' => null,
'include_subdags' => null,
'include_upstream' => null,
'only_failed' => null,
'only_running' => null,
'reset_dag_runs' => null,
'start_date' => '',
'task_ids' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dag_run_id' => '',
'dry_run' => null,
'end_date' => '',
'include_downstream' => null,
'include_future' => null,
'include_parentdag' => null,
'include_past' => null,
'include_subdags' => null,
'include_upstream' => null,
'only_failed' => null,
'only_running' => null,
'reset_dag_runs' => null,
'start_date' => '',
'task_ids' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/clearTaskInstances');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/clearTaskInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/clearTaskInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/dags/:dag_id/clearTaskInstances", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/clearTaskInstances"
payload = {
"dag_run_id": "",
"dry_run": False,
"end_date": "",
"include_downstream": False,
"include_future": False,
"include_parentdag": False,
"include_past": False,
"include_subdags": False,
"include_upstream": False,
"only_failed": False,
"only_running": False,
"reset_dag_runs": False,
"start_date": "",
"task_ids": []
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/clearTaskInstances"
payload <- "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/clearTaskInstances")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/dags/:dag_id/clearTaskInstances') do |req|
req.body = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"end_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_parentdag\": false,\n \"include_past\": false,\n \"include_subdags\": false,\n \"include_upstream\": false,\n \"only_failed\": false,\n \"only_running\": false,\n \"reset_dag_runs\": false,\n \"start_date\": \"\",\n \"task_ids\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/clearTaskInstances";
let payload = json!({
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": ()
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/dags/:dag_id/clearTaskInstances \
--header 'content-type: application/json' \
--data '{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}'echo '{
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
}' | \
http POST {{baseUrl}}/dags/:dag_id/clearTaskInstances \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "dag_run_id": "",\n "dry_run": false,\n "end_date": "",\n "include_downstream": false,\n "include_future": false,\n "include_parentdag": false,\n "include_past": false,\n "include_subdags": false,\n "include_upstream": false,\n "only_failed": false,\n "only_running": false,\n "reset_dag_runs": false,\n "start_date": "",\n "task_ids": []\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/clearTaskInstancesimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dag_run_id": "",
"dry_run": false,
"end_date": "",
"include_downstream": false,
"include_future": false,
"include_parentdag": false,
"include_past": false,
"include_subdags": false,
"include_upstream": false,
"only_failed": false,
"only_running": false,
"reset_dag_runs": false,
"start_date": "",
"task_ids": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/clearTaskInstances")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a DAG
{{baseUrl}}/dags/:dag_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/dags/:dag_id")require "http/client"
url = "{{baseUrl}}/dags/:dag_id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id"
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/dags/:dag_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dags/:dag_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/dags/:dag_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/dags/:dag_id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/dags/:dag_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id';
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}}/dags/:dag_id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id',
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}}/dags/:dag_id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/dags/:dag_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/dags/:dag_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id';
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}}/dags/:dag_id"]
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}}/dags/:dag_id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id",
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}}/dags/:dag_id');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/dags/:dag_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/dags/:dag_id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id";
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}}/dags/:dag_idhttp DELETE {{baseUrl}}/dags/:dag_idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/dags/:dag_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id")! 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
Get a simplified representation of DAG
{{baseUrl}}/dags/:dag_id/details
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/details");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/details")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/details"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/details"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/details");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/details"
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/dags/:dag_id/details HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/details")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/details"))
.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}}/dags/:dag_id/details")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/details")
.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}}/dags/:dag_id/details');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id/details'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/details';
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}}/dags/:dag_id/details',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/details")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/details',
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}}/dags/:dag_id/details'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/details');
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}}/dags/:dag_id/details'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/details';
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}}/dags/:dag_id/details"]
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}}/dags/:dag_id/details" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/details",
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}}/dags/:dag_id/details');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/details');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/details');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/details' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/details' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/details")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/details"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/details"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/details")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/details') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/details";
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}}/dags/:dag_id/detailshttp GET {{baseUrl}}/dags/:dag_id/detailswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/detailsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/details")! 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 a source code
{{baseUrl}}/dagSources/:file_token
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dagSources/:file_token");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dagSources/:file_token")require "http/client"
url = "{{baseUrl}}/dagSources/:file_token"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dagSources/:file_token"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dagSources/:file_token");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dagSources/:file_token"
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/dagSources/:file_token HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dagSources/:file_token")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dagSources/:file_token"))
.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}}/dagSources/:file_token")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dagSources/:file_token")
.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}}/dagSources/:file_token');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dagSources/:file_token'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dagSources/:file_token';
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}}/dagSources/:file_token',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dagSources/:file_token")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dagSources/:file_token',
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}}/dagSources/:file_token'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dagSources/:file_token');
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}}/dagSources/:file_token'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dagSources/:file_token';
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}}/dagSources/:file_token"]
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}}/dagSources/:file_token" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dagSources/:file_token",
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}}/dagSources/:file_token');
echo $response->getBody();setUrl('{{baseUrl}}/dagSources/:file_token');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dagSources/:file_token');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dagSources/:file_token' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dagSources/:file_token' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dagSources/:file_token")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dagSources/:file_token"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dagSources/:file_token"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dagSources/:file_token")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dagSources/:file_token') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dagSources/:file_token";
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}}/dagSources/:file_tokenhttp GET {{baseUrl}}/dagSources/:file_tokenwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dagSources/:file_tokenimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dagSources/:file_token")! 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 basic information about a DAG
{{baseUrl}}/dags/:dag_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id")require "http/client"
url = "{{baseUrl}}/dags/:dag_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id"
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/dags/:dag_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/dags/:dag_id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id';
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}}/dags/:dag_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id',
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}}/dags/:dag_id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id';
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}}/dags/:dag_id"]
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}}/dags/:dag_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id",
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}}/dags/:dag_id');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id";
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}}/dags/:dag_idhttp GET {{baseUrl}}/dags/:dag_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id")! 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 simplified representation of a task
{{baseUrl}}/dags/:dag_id/tasks/:task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/tasks/:task_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/tasks/:task_id")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/tasks/:task_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/tasks/:task_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/tasks/:task_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/tasks/:task_id"
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/dags/:dag_id/tasks/:task_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/tasks/:task_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/tasks/:task_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/tasks/:task_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/tasks/:task_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/dags/:dag_id/tasks/:task_id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id/tasks/:task_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/tasks/:task_id';
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}}/dags/:dag_id/tasks/:task_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/tasks/:task_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/tasks/:task_id',
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}}/dags/:dag_id/tasks/:task_id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/tasks/:task_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id/tasks/:task_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/tasks/:task_id';
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}}/dags/:dag_id/tasks/:task_id"]
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}}/dags/:dag_id/tasks/:task_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/tasks/:task_id",
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}}/dags/:dag_id/tasks/:task_id');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/tasks/:task_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/tasks/:task_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/tasks/:task_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/tasks/:task_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/tasks/:task_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/tasks/:task_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/tasks/:task_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/tasks/:task_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/tasks/:task_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/tasks/:task_id";
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}}/dags/:dag_id/tasks/:task_idhttp GET {{baseUrl}}/dags/:dag_id/tasks/:task_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/tasks/:task_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/tasks/:task_id")! 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 tasks for DAG
{{baseUrl}}/dags/:dag_id/tasks
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/tasks");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/tasks")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/tasks"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/tasks"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/tasks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/tasks"
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/dags/:dag_id/tasks HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/tasks")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/tasks"))
.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}}/dags/:dag_id/tasks")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/tasks")
.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}}/dags/:dag_id/tasks');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id/tasks'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/tasks';
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}}/dags/:dag_id/tasks',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/tasks")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/tasks',
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}}/dags/:dag_id/tasks'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/tasks');
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}}/dags/:dag_id/tasks'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/tasks';
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}}/dags/:dag_id/tasks"]
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}}/dags/:dag_id/tasks" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/tasks",
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}}/dags/:dag_id/tasks');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/tasks');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/tasks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/tasks' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/tasks' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/tasks")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/tasks"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/tasks"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/tasks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/tasks') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/tasks";
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}}/dags/:dag_id/taskshttp GET {{baseUrl}}/dags/:dag_id/taskswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/tasksimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/tasks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List DAGs
{{baseUrl}}/dags
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags")require "http/client"
url = "{{baseUrl}}/dags"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags"
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/dags HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags"))
.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}}/dags")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags")
.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}}/dags');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dags'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags';
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}}/dags',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags',
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}}/dags'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags');
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}}/dags'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags';
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}}/dags"]
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}}/dags" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags",
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}}/dags');
echo $response->getBody();setUrl('{{baseUrl}}/dags');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags";
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}}/dagshttp GET {{baseUrl}}/dagswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dagsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags")! 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
Set a state of task instances
{{baseUrl}}/dags/:dag_id/updateTaskInstancesState
BODY json
{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState" {:content-type :json
:form-params {:dag_run_id ""
:dry_run false
:execution_date ""
:include_downstream false
:include_future false
:include_past false
:include_upstream false
:new_state ""
:task_id ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"),
Content = new StringContent("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"
payload := strings.NewReader("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/dags/:dag_id/updateTaskInstancesState HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 214
{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState")
.setHeader("content-type", "application/json")
.setBody("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState")
.header("content-type", "application/json")
.body("{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}")
.asString(); const data = JSON.stringify({
dag_run_id: '',
dry_run: false,
execution_date: '',
include_downstream: false,
include_future: false,
include_past: false,
include_upstream: false,
new_state: '',
task_id: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState',
headers: {'content-type': 'application/json'},
data: {
dag_run_id: '',
dry_run: false,
execution_date: '',
include_downstream: false,
include_future: false,
include_past: false,
include_upstream: false,
new_state: '',
task_id: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_run_id":"","dry_run":false,"execution_date":"","include_downstream":false,"include_future":false,"include_past":false,"include_upstream":false,"new_state":"","task_id":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dag_run_id": "",\n "dry_run": false,\n "execution_date": "",\n "include_downstream": false,\n "include_future": false,\n "include_past": false,\n "include_upstream": false,\n "new_state": "",\n "task_id": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/updateTaskInstancesState',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
dag_run_id: '',
dry_run: false,
execution_date: '',
include_downstream: false,
include_future: false,
include_past: false,
include_upstream: false,
new_state: '',
task_id: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState',
headers: {'content-type': 'application/json'},
body: {
dag_run_id: '',
dry_run: false,
execution_date: '',
include_downstream: false,
include_future: false,
include_past: false,
include_upstream: false,
new_state: '',
task_id: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dag_run_id: '',
dry_run: false,
execution_date: '',
include_downstream: false,
include_future: false,
include_past: false,
include_upstream: false,
new_state: '',
task_id: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState',
headers: {'content-type': 'application/json'},
data: {
dag_run_id: '',
dry_run: false,
execution_date: '',
include_downstream: false,
include_future: false,
include_past: false,
include_upstream: false,
new_state: '',
task_id: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_run_id":"","dry_run":false,"execution_date":"","include_downstream":false,"include_future":false,"include_past":false,"include_upstream":false,"new_state":"","task_id":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dag_run_id": @"",
@"dry_run": @NO,
@"execution_date": @"",
@"include_downstream": @NO,
@"include_future": @NO,
@"include_past": @NO,
@"include_upstream": @NO,
@"new_state": @"",
@"task_id": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'dag_run_id' => '',
'dry_run' => null,
'execution_date' => '',
'include_downstream' => null,
'include_future' => null,
'include_past' => null,
'include_upstream' => null,
'new_state' => '',
'task_id' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState', [
'body' => '{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/updateTaskInstancesState');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dag_run_id' => '',
'dry_run' => null,
'execution_date' => '',
'include_downstream' => null,
'include_future' => null,
'include_past' => null,
'include_upstream' => null,
'new_state' => '',
'task_id' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dag_run_id' => '',
'dry_run' => null,
'execution_date' => '',
'include_downstream' => null,
'include_future' => null,
'include_past' => null,
'include_upstream' => null,
'new_state' => '',
'task_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/updateTaskInstancesState');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/updateTaskInstancesState' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/dags/:dag_id/updateTaskInstancesState", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"
payload = {
"dag_run_id": "",
"dry_run": False,
"execution_date": "",
"include_downstream": False,
"include_future": False,
"include_past": False,
"include_upstream": False,
"new_state": "",
"task_id": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState"
payload <- "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/updateTaskInstancesState")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/dags/:dag_id/updateTaskInstancesState') do |req|
req.body = "{\n \"dag_run_id\": \"\",\n \"dry_run\": false,\n \"execution_date\": \"\",\n \"include_downstream\": false,\n \"include_future\": false,\n \"include_past\": false,\n \"include_upstream\": false,\n \"new_state\": \"\",\n \"task_id\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState";
let payload = json!({
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/dags/:dag_id/updateTaskInstancesState \
--header 'content-type: application/json' \
--data '{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}'echo '{
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
}' | \
http POST {{baseUrl}}/dags/:dag_id/updateTaskInstancesState \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "dag_run_id": "",\n "dry_run": false,\n "execution_date": "",\n "include_downstream": false,\n "include_future": false,\n "include_past": false,\n "include_upstream": false,\n "new_state": "",\n "task_id": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/updateTaskInstancesStateimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dag_run_id": "",
"dry_run": false,
"execution_date": "",
"include_downstream": false,
"include_future": false,
"include_past": false,
"include_upstream": false,
"new_state": "",
"task_id": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/updateTaskInstancesState")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update DAGs
{{baseUrl}}/dags
QUERY PARAMS
dag_id_pattern
BODY json
{
"dag_id": "",
"default_view": "",
"description": "",
"file_token": "",
"fileloc": "",
"has_import_errors": false,
"has_task_concurrency_limits": false,
"is_active": false,
"is_paused": false,
"is_subdag": false,
"last_expired": "",
"last_parsed_time": "",
"last_pickled": "",
"max_active_runs": 0,
"max_active_tasks": 0,
"next_dagrun": "",
"next_dagrun_create_after": "",
"next_dagrun_data_interval_end": "",
"next_dagrun_data_interval_start": "",
"owners": [],
"pickle_id": "",
"root_dag_id": "",
"schedule_interval": "",
"scheduler_lock": false,
"tags": [
{
"name": ""
}
],
"timetable_description": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags?dag_id_pattern=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"is_paused\": true\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags" {:query-params {:dag_id_pattern ""}
:content-type :json
:form-params {:is_paused true}})require "http/client"
url = "{{baseUrl}}/dags?dag_id_pattern="
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"is_paused\": true\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags?dag_id_pattern="),
Content = new StringContent("{\n \"is_paused\": true\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags?dag_id_pattern=");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"is_paused\": true\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags?dag_id_pattern="
payload := strings.NewReader("{\n \"is_paused\": true\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags?dag_id_pattern= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23
{
"is_paused": true
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags?dag_id_pattern=")
.setHeader("content-type", "application/json")
.setBody("{\n \"is_paused\": true\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags?dag_id_pattern="))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"is_paused\": true\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"is_paused\": true\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags?dag_id_pattern=")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags?dag_id_pattern=")
.header("content-type", "application/json")
.body("{\n \"is_paused\": true\n}")
.asString(); const data = JSON.stringify({
is_paused: true
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags?dag_id_pattern=');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags',
params: {dag_id_pattern: ''},
headers: {'content-type': 'application/json'},
data: {is_paused: true}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags?dag_id_pattern=';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"is_paused":true}'
};
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}}/dags?dag_id_pattern=',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "is_paused": true\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"is_paused\": true\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags?dag_id_pattern=")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags?dag_id_pattern=',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({is_paused: true}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags',
qs: {dag_id_pattern: ''},
headers: {'content-type': 'application/json'},
body: {is_paused: true},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags');
req.query({
dag_id_pattern: ''
});
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
is_paused: true
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags',
params: {dag_id_pattern: ''},
headers: {'content-type': 'application/json'},
data: {is_paused: true}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags?dag_id_pattern=';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"is_paused":true}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"is_paused": @YES };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags?dag_id_pattern="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags?dag_id_pattern=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"is_paused\": true\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags?dag_id_pattern=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'is_paused' => null
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags?dag_id_pattern=', [
'body' => '{
"is_paused": true
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setQueryData([
'dag_id_pattern' => ''
]);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'is_paused' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'is_paused' => null
]));
$request->setRequestUrl('{{baseUrl}}/dags');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setQuery(new http\QueryString([
'dag_id_pattern' => ''
]));
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags?dag_id_pattern=' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"is_paused": true
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags?dag_id_pattern=' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"is_paused": true
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"is_paused\": true\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags?dag_id_pattern=", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags"
querystring = {"dag_id_pattern":""}
payload = { "is_paused": True }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags"
queryString <- list(dag_id_pattern = "")
payload <- "{\n \"is_paused\": true\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, query = queryString, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags?dag_id_pattern=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"is_paused\": true\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags') do |req|
req.params['dag_id_pattern'] = ''
req.body = "{\n \"is_paused\": true\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags";
let querystring = [
("dag_id_pattern", ""),
];
let payload = json!({"is_paused": true});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.query(&querystring)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url '{{baseUrl}}/dags?dag_id_pattern=' \
--header 'content-type: application/json' \
--data '{
"is_paused": true
}'echo '{
"is_paused": true
}' | \
http PATCH '{{baseUrl}}/dags?dag_id_pattern=' \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "is_paused": true\n}' \
--output-document \
- '{{baseUrl}}/dags?dag_id_pattern='import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["is_paused": true] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags?dag_id_pattern=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a DAG
{{baseUrl}}/dags/:dag_id
BODY json
{
"dag_id": "",
"default_view": "",
"description": "",
"file_token": "",
"fileloc": "",
"has_import_errors": false,
"has_task_concurrency_limits": false,
"is_active": false,
"is_paused": false,
"is_subdag": false,
"last_expired": "",
"last_parsed_time": "",
"last_pickled": "",
"max_active_runs": 0,
"max_active_tasks": 0,
"next_dagrun": "",
"next_dagrun_create_after": "",
"next_dagrun_data_interval_end": "",
"next_dagrun_data_interval_start": "",
"owners": [],
"pickle_id": "",
"root_dag_id": "",
"schedule_interval": "",
"scheduler_lock": false,
"tags": [
{
"name": ""
}
],
"timetable_description": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"is_paused\": true\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id" {:content-type :json
:form-params {:is_paused true}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"is_paused\": true\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id"),
Content = new StringContent("{\n \"is_paused\": true\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"is_paused\": true\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id"
payload := strings.NewReader("{\n \"is_paused\": true\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23
{
"is_paused": true
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id")
.setHeader("content-type", "application/json")
.setBody("{\n \"is_paused\": true\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"is_paused\": true\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"is_paused\": true\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id")
.header("content-type", "application/json")
.body("{\n \"is_paused\": true\n}")
.asString(); const data = JSON.stringify({
is_paused: true
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id',
headers: {'content-type': 'application/json'},
data: {is_paused: true}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"is_paused":true}'
};
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}}/dags/:dag_id',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "is_paused": true\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"is_paused\": true\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({is_paused: true}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id',
headers: {'content-type': 'application/json'},
body: {is_paused: true},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
is_paused: true
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id',
headers: {'content-type': 'application/json'},
data: {is_paused: true}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"is_paused":true}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"is_paused": @YES };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"is_paused\": true\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'is_paused' => null
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id', [
'body' => '{
"is_paused": true
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'is_paused' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'is_paused' => null
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"is_paused": true
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"is_paused": true
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"is_paused\": true\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id"
payload = { "is_paused": True }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id"
payload <- "{\n \"is_paused\": true\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"is_paused\": true\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id') do |req|
req.body = "{\n \"is_paused\": true\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id";
let payload = json!({"is_paused": true});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id \
--header 'content-type: application/json' \
--data '{
"is_paused": true
}'echo '{
"is_paused": true
}' | \
http PATCH {{baseUrl}}/dags/:dag_id \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "is_paused": true\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_idimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["is_paused": true] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Clear a DAG run
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear
BODY json
{
"dry_run": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dry_run\": false\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear" {:content-type :json
:form-params {:dry_run false}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dry_run\": false\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"),
Content = new StringContent("{\n \"dry_run\": false\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dry_run\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"
payload := strings.NewReader("{\n \"dry_run\": false\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/dags/:dag_id/dagRuns/:dag_run_id/clear HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22
{
"dry_run": false
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear")
.setHeader("content-type", "application/json")
.setBody("{\n \"dry_run\": false\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"dry_run\": false\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dry_run\": false\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear")
.header("content-type", "application/json")
.body("{\n \"dry_run\": false\n}")
.asString(); const data = JSON.stringify({
dry_run: false
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear',
headers: {'content-type': 'application/json'},
data: {dry_run: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dry_run":false}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id/clear',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dry_run": false\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dry_run\": false\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/clear',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({dry_run: false}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear',
headers: {'content-type': 'application/json'},
body: {dry_run: false},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dry_run: false
});
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}}/dags/:dag_id/dagRuns/:dag_run_id/clear',
headers: {'content-type': 'application/json'},
data: {dry_run: false}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dry_run":false}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dry_run": @NO };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dry_run\": false\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'dry_run' => null
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear', [
'body' => '{
"dry_run": false
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dry_run' => null
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dry_run' => null
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dry_run": false
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dry_run": false
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dry_run\": false\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/clear", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"
payload = { "dry_run": False }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear"
payload <- "{\n \"dry_run\": false\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dry_run\": false\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/clear') do |req|
req.body = "{\n \"dry_run\": false\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear";
let payload = json!({"dry_run": false});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear \
--header 'content-type: application/json' \
--data '{
"dry_run": false
}'echo '{
"dry_run": false
}' | \
http POST {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "dry_run": false\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clearimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["dry_run": false] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/clear")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a DAG run
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
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/dags/:dag_id/dagRuns/:dag_run_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id';
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}}/dags/:dag_id/dagRuns/:dag_run_id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id',
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}}/dags/:dag_id/dagRuns/:dag_run_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id';
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}}/dags/:dag_id/dagRuns/:dag_run_id"]
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}}/dags/:dag_id/dagRuns/:dag_run_id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id",
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}}/dags/:dag_id/dagRuns/:dag_run_id');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id";
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}}/dags/:dag_id/dagRuns/:dag_run_idhttp DELETE {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")! 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
Get a DAG run
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
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/dags/:dag_id/dagRuns/:dag_run_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id';
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}}/dags/:dag_id/dagRuns/:dag_run_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id',
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}}/dags/:dag_id/dagRuns/:dag_run_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id';
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}}/dags/:dag_id/dagRuns/:dag_run_id"]
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}}/dags/:dag_id/dagRuns/:dag_run_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id",
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}}/dags/:dag_id/dagRuns/:dag_run_id');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id";
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}}/dags/:dag_id/dagRuns/:dag_run_idhttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")! 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 dataset events for a DAG run
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"
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/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents';
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents',
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents');
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents';
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents",
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents";
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}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEventshttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEventswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEventsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/upstreamDatasetEvents")! 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
List DAG runs (batch)
{{baseUrl}}/dags/~/dagRuns/list
BODY json
{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/~/dagRuns/list");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/dags/~/dagRuns/list" {:content-type :json
:form-params {:dag_ids []
:end_date_gte ""
:end_date_lte ""
:execution_date_gte ""
:execution_date_lte ""
:order_by ""
:page_limit 0
:page_offset 0
:start_date_gte ""
:start_date_lte ""
:states []}})require "http/client"
url = "{{baseUrl}}/dags/~/dagRuns/list"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/dags/~/dagRuns/list"),
Content = new StringContent("{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/~/dagRuns/list");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/~/dagRuns/list"
payload := strings.NewReader("{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/dags/~/dagRuns/list HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 240
{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dags/~/dagRuns/list")
.setHeader("content-type", "application/json")
.setBody("{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/~/dagRuns/list"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/~/dagRuns/list")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/dags/~/dagRuns/list")
.header("content-type", "application/json")
.body("{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}")
.asString(); const data = JSON.stringify({
dag_ids: [],
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
order_by: '',
page_limit: 0,
page_offset: 0,
start_date_gte: '',
start_date_lte: '',
states: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/dags/~/dagRuns/list');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/~/dagRuns/list',
headers: {'content-type': 'application/json'},
data: {
dag_ids: [],
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
order_by: '',
page_limit: 0,
page_offset: 0,
start_date_gte: '',
start_date_lte: '',
states: []
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/~/dagRuns/list';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_ids":[],"end_date_gte":"","end_date_lte":"","execution_date_gte":"","execution_date_lte":"","order_by":"","page_limit":0,"page_offset":0,"start_date_gte":"","start_date_lte":"","states":[]}'
};
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}}/dags/~/dagRuns/list',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dag_ids": [],\n "end_date_gte": "",\n "end_date_lte": "",\n "execution_date_gte": "",\n "execution_date_lte": "",\n "order_by": "",\n "page_limit": 0,\n "page_offset": 0,\n "start_date_gte": "",\n "start_date_lte": "",\n "states": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/~/dagRuns/list")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/~/dagRuns/list',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
dag_ids: [],
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
order_by: '',
page_limit: 0,
page_offset: 0,
start_date_gte: '',
start_date_lte: '',
states: []
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/~/dagRuns/list',
headers: {'content-type': 'application/json'},
body: {
dag_ids: [],
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
order_by: '',
page_limit: 0,
page_offset: 0,
start_date_gte: '',
start_date_lte: '',
states: []
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/dags/~/dagRuns/list');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dag_ids: [],
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
order_by: '',
page_limit: 0,
page_offset: 0,
start_date_gte: '',
start_date_lte: '',
states: []
});
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}}/dags/~/dagRuns/list',
headers: {'content-type': 'application/json'},
data: {
dag_ids: [],
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
order_by: '',
page_limit: 0,
page_offset: 0,
start_date_gte: '',
start_date_lte: '',
states: []
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/~/dagRuns/list';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_ids":[],"end_date_gte":"","end_date_lte":"","execution_date_gte":"","execution_date_lte":"","order_by":"","page_limit":0,"page_offset":0,"start_date_gte":"","start_date_lte":"","states":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dag_ids": @[ ],
@"end_date_gte": @"",
@"end_date_lte": @"",
@"execution_date_gte": @"",
@"execution_date_lte": @"",
@"order_by": @"",
@"page_limit": @0,
@"page_offset": @0,
@"start_date_gte": @"",
@"start_date_lte": @"",
@"states": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/~/dagRuns/list"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/~/dagRuns/list" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/~/dagRuns/list",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'dag_ids' => [
],
'end_date_gte' => '',
'end_date_lte' => '',
'execution_date_gte' => '',
'execution_date_lte' => '',
'order_by' => '',
'page_limit' => 0,
'page_offset' => 0,
'start_date_gte' => '',
'start_date_lte' => '',
'states' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/dags/~/dagRuns/list', [
'body' => '{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/~/dagRuns/list');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dag_ids' => [
],
'end_date_gte' => '',
'end_date_lte' => '',
'execution_date_gte' => '',
'execution_date_lte' => '',
'order_by' => '',
'page_limit' => 0,
'page_offset' => 0,
'start_date_gte' => '',
'start_date_lte' => '',
'states' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dag_ids' => [
],
'end_date_gte' => '',
'end_date_lte' => '',
'execution_date_gte' => '',
'execution_date_lte' => '',
'order_by' => '',
'page_limit' => 0,
'page_offset' => 0,
'start_date_gte' => '',
'start_date_lte' => '',
'states' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/dags/~/dagRuns/list');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/~/dagRuns/list' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/~/dagRuns/list' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/dags/~/dagRuns/list", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/~/dagRuns/list"
payload = {
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/~/dagRuns/list"
payload <- "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/~/dagRuns/list")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/dags/~/dagRuns/list') do |req|
req.body = "{\n \"dag_ids\": [],\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"order_by\": \"\",\n \"page_limit\": 0,\n \"page_offset\": 0,\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"states\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/~/dagRuns/list";
let payload = json!({
"dag_ids": (),
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": ()
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/dags/~/dagRuns/list' \
--header 'content-type: application/json' \
--data '{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}'echo '{
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
}' | \
http POST '{{baseUrl}}/dags/~/dagRuns/list' \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "dag_ids": [],\n "end_date_gte": "",\n "end_date_lte": "",\n "execution_date_gte": "",\n "execution_date_lte": "",\n "order_by": "",\n "page_limit": 0,\n "page_offset": 0,\n "start_date_gte": "",\n "start_date_lte": "",\n "states": []\n}' \
--output-document \
- '{{baseUrl}}/dags/~/dagRuns/list'import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dag_ids": [],
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"order_by": "",
"page_limit": 0,
"page_offset": 0,
"start_date_gte": "",
"start_date_lte": "",
"states": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/~/dagRuns/list")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List DAG runs
{{baseUrl}}/dags/:dag_id/dagRuns
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns"
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/dags/:dag_id/dagRuns HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns"))
.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}}/dags/:dag_id/dagRuns")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns")
.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}}/dags/:dag_id/dagRuns');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dags/:dag_id/dagRuns'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns';
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}}/dags/:dag_id/dagRuns',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns',
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}}/dags/:dag_id/dagRuns'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns');
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}}/dags/:dag_id/dagRuns'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns';
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}}/dags/:dag_id/dagRuns"]
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}}/dags/:dag_id/dagRuns" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns",
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}}/dags/:dag_id/dagRuns');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns";
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}}/dags/:dag_id/dagRunshttp GET {{baseUrl}}/dags/:dag_id/dagRunswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRunsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns")! 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()
PATCH
Modify a DAG run
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id
BODY json
{
"state": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"state\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id" {:content-type :json
:form-params {:state ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"state\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"),
Content = new StringContent("{\n \"state\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"state\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
payload := strings.NewReader("{\n \"state\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id/dagRuns/:dag_run_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17
{
"state": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.setHeader("content-type", "application/json")
.setBody("{\n \"state\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"state\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"state\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.header("content-type", "application/json")
.body("{\n \"state\": \"\"\n}")
.asString(); const data = JSON.stringify({
state: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id',
headers: {'content-type': 'application/json'},
data: {state: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"state":""}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "state": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"state\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({state: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id',
headers: {'content-type': 'application/json'},
body: {state: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
state: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id',
headers: {'content-type': 'application/json'},
data: {state: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"state":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"state": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"state\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'state' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id', [
'body' => '{
"state": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'state' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'state' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"state": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"state": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"state\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
payload = { "state": "" }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id"
payload <- "{\n \"state\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"state\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id') do |req|
req.body = "{\n \"state\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id";
let payload = json!({"state": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id \
--header 'content-type: application/json' \
--data '{
"state": ""
}'echo '{
"state": ""
}' | \
http PATCH {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "state": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_idimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["state": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Trigger a new DAG run
{{baseUrl}}/dags/:dag_id/dagRuns
BODY json
{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/dags/:dag_id/dagRuns" {:content-type :json
:form-params {:conf {}
:dag_id ""
:dag_run_id ""
:data_interval_end ""
:data_interval_start ""
:end_date ""
:execution_date ""
:external_trigger false
:last_scheduling_decision ""
:logical_date ""
:note ""
:run_type ""
:start_date ""
:state ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns"),
Content = new StringContent("{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns"
payload := strings.NewReader("{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/dags/:dag_id/dagRuns HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 302
{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dags/:dag_id/dagRuns")
.setHeader("content-type", "application/json")
.setBody("{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/dags/:dag_id/dagRuns")
.header("content-type", "application/json")
.body("{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}")
.asString(); const data = JSON.stringify({
conf: {},
dag_id: '',
dag_run_id: '',
data_interval_end: '',
data_interval_start: '',
end_date: '',
execution_date: '',
external_trigger: false,
last_scheduling_decision: '',
logical_date: '',
note: '',
run_type: '',
start_date: '',
state: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/dags/:dag_id/dagRuns');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/dagRuns',
headers: {'content-type': 'application/json'},
data: {
conf: {},
dag_id: '',
dag_run_id: '',
data_interval_end: '',
data_interval_start: '',
end_date: '',
execution_date: '',
external_trigger: false,
last_scheduling_decision: '',
logical_date: '',
note: '',
run_type: '',
start_date: '',
state: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"conf":{},"dag_id":"","dag_run_id":"","data_interval_end":"","data_interval_start":"","end_date":"","execution_date":"","external_trigger":false,"last_scheduling_decision":"","logical_date":"","note":"","run_type":"","start_date":"","state":""}'
};
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}}/dags/:dag_id/dagRuns',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "conf": {},\n "dag_id": "",\n "dag_run_id": "",\n "data_interval_end": "",\n "data_interval_start": "",\n "end_date": "",\n "execution_date": "",\n "external_trigger": false,\n "last_scheduling_decision": "",\n "logical_date": "",\n "note": "",\n "run_type": "",\n "start_date": "",\n "state": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
conf: {},
dag_id: '',
dag_run_id: '',
data_interval_end: '',
data_interval_start: '',
end_date: '',
execution_date: '',
external_trigger: false,
last_scheduling_decision: '',
logical_date: '',
note: '',
run_type: '',
start_date: '',
state: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/:dag_id/dagRuns',
headers: {'content-type': 'application/json'},
body: {
conf: {},
dag_id: '',
dag_run_id: '',
data_interval_end: '',
data_interval_start: '',
end_date: '',
execution_date: '',
external_trigger: false,
last_scheduling_decision: '',
logical_date: '',
note: '',
run_type: '',
start_date: '',
state: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/dags/:dag_id/dagRuns');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
conf: {},
dag_id: '',
dag_run_id: '',
data_interval_end: '',
data_interval_start: '',
end_date: '',
execution_date: '',
external_trigger: false,
last_scheduling_decision: '',
logical_date: '',
note: '',
run_type: '',
start_date: '',
state: ''
});
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}}/dags/:dag_id/dagRuns',
headers: {'content-type': 'application/json'},
data: {
conf: {},
dag_id: '',
dag_run_id: '',
data_interval_end: '',
data_interval_start: '',
end_date: '',
execution_date: '',
external_trigger: false,
last_scheduling_decision: '',
logical_date: '',
note: '',
run_type: '',
start_date: '',
state: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"conf":{},"dag_id":"","dag_run_id":"","data_interval_end":"","data_interval_start":"","end_date":"","execution_date":"","external_trigger":false,"last_scheduling_decision":"","logical_date":"","note":"","run_type":"","start_date":"","state":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"conf": @{ },
@"dag_id": @"",
@"dag_run_id": @"",
@"data_interval_end": @"",
@"data_interval_start": @"",
@"end_date": @"",
@"execution_date": @"",
@"external_trigger": @NO,
@"last_scheduling_decision": @"",
@"logical_date": @"",
@"note": @"",
@"run_type": @"",
@"start_date": @"",
@"state": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'conf' => [
],
'dag_id' => '',
'dag_run_id' => '',
'data_interval_end' => '',
'data_interval_start' => '',
'end_date' => '',
'execution_date' => '',
'external_trigger' => null,
'last_scheduling_decision' => '',
'logical_date' => '',
'note' => '',
'run_type' => '',
'start_date' => '',
'state' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/dags/:dag_id/dagRuns', [
'body' => '{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'conf' => [
],
'dag_id' => '',
'dag_run_id' => '',
'data_interval_end' => '',
'data_interval_start' => '',
'end_date' => '',
'execution_date' => '',
'external_trigger' => null,
'last_scheduling_decision' => '',
'logical_date' => '',
'note' => '',
'run_type' => '',
'start_date' => '',
'state' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'conf' => [
],
'dag_id' => '',
'dag_run_id' => '',
'data_interval_end' => '',
'data_interval_start' => '',
'end_date' => '',
'execution_date' => '',
'external_trigger' => null,
'last_scheduling_decision' => '',
'logical_date' => '',
'note' => '',
'run_type' => '',
'start_date' => '',
'state' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/dags/:dag_id/dagRuns", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns"
payload = {
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": False,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns"
payload <- "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/dags/:dag_id/dagRuns') do |req|
req.body = "{\n \"conf\": {},\n \"dag_id\": \"\",\n \"dag_run_id\": \"\",\n \"data_interval_end\": \"\",\n \"data_interval_start\": \"\",\n \"end_date\": \"\",\n \"execution_date\": \"\",\n \"external_trigger\": false,\n \"last_scheduling_decision\": \"\",\n \"logical_date\": \"\",\n \"note\": \"\",\n \"run_type\": \"\",\n \"start_date\": \"\",\n \"state\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns";
let payload = json!({
"conf": json!({}),
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/dags/:dag_id/dagRuns \
--header 'content-type: application/json' \
--data '{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}'echo '{
"conf": {},
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
}' | \
http POST {{baseUrl}}/dags/:dag_id/dagRuns \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "conf": {},\n "dag_id": "",\n "dag_run_id": "",\n "data_interval_end": "",\n "data_interval_start": "",\n "end_date": "",\n "execution_date": "",\n "external_trigger": false,\n "last_scheduling_decision": "",\n "logical_date": "",\n "note": "",\n "run_type": "",\n "start_date": "",\n "state": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRunsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"conf": [],
"dag_id": "",
"dag_run_id": "",
"data_interval_end": "",
"data_interval_start": "",
"end_date": "",
"execution_date": "",
"external_trigger": false,
"last_scheduling_decision": "",
"logical_date": "",
"note": "",
"run_type": "",
"start_date": "",
"state": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update the DagRun note.
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote
BODY json
{
"note": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"note\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote" {:content-type :json
:form-params {:note ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"note\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"),
Content = new StringContent("{\n \"note\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"note\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"
payload := strings.NewReader("{\n \"note\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id/dagRuns/:dag_run_id/setNote HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16
{
"note": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote")
.setHeader("content-type", "application/json")
.setBody("{\n \"note\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"note\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"note\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote")
.header("content-type", "application/json")
.body("{\n \"note\": \"\"\n}")
.asString(); const data = JSON.stringify({
note: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote',
headers: {'content-type': 'application/json'},
data: {note: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"note":""}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id/setNote',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "note": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"note\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/setNote',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({note: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote',
headers: {'content-type': 'application/json'},
body: {note: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
note: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote',
headers: {'content-type': 'application/json'},
data: {note: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"note":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"note": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"note\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'note' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote', [
'body' => '{
"note": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'note' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'note' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"note": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"note": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"note\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/setNote", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"
payload = { "note": "" }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote"
payload <- "{\n \"note\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"note\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/setNote') do |req|
req.body = "{\n \"note\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote";
let payload = json!({"note": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote \
--header 'content-type: application/json' \
--data '{
"note": ""
}'echo '{
"note": ""
}' | \
http PATCH {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "note": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNoteimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["note": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/setNote")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List dag warnings
{{baseUrl}}/dagWarnings
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dagWarnings");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dagWarnings")require "http/client"
url = "{{baseUrl}}/dagWarnings"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dagWarnings"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dagWarnings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dagWarnings"
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/dagWarnings HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dagWarnings")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dagWarnings"))
.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}}/dagWarnings")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dagWarnings")
.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}}/dagWarnings');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/dagWarnings'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dagWarnings';
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}}/dagWarnings',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dagWarnings")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dagWarnings',
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}}/dagWarnings'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dagWarnings');
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}}/dagWarnings'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dagWarnings';
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}}/dagWarnings"]
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}}/dagWarnings" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dagWarnings",
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}}/dagWarnings');
echo $response->getBody();setUrl('{{baseUrl}}/dagWarnings');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dagWarnings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dagWarnings' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dagWarnings' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dagWarnings")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dagWarnings"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dagWarnings"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dagWarnings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dagWarnings') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dagWarnings";
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}}/dagWarningshttp GET {{baseUrl}}/dagWarningswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dagWarningsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dagWarnings")! 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 a dataset
{{baseUrl}}/datasets/:uri
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/datasets/:uri");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/datasets/:uri")require "http/client"
url = "{{baseUrl}}/datasets/:uri"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/datasets/:uri"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/datasets/:uri");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/datasets/:uri"
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/datasets/:uri HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/datasets/:uri")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/datasets/:uri"))
.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}}/datasets/:uri")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/datasets/:uri")
.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}}/datasets/:uri');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/datasets/:uri'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/datasets/:uri';
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}}/datasets/:uri',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/datasets/:uri")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/datasets/:uri',
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}}/datasets/:uri'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/datasets/:uri');
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}}/datasets/:uri'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/datasets/:uri';
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}}/datasets/:uri"]
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}}/datasets/:uri" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/datasets/:uri",
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}}/datasets/:uri');
echo $response->getBody();setUrl('{{baseUrl}}/datasets/:uri');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/datasets/:uri');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/datasets/:uri' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/datasets/:uri' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/datasets/:uri")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/datasets/:uri"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/datasets/:uri"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/datasets/:uri")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/datasets/:uri') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/datasets/:uri";
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}}/datasets/:urihttp GET {{baseUrl}}/datasets/:uriwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/datasets/:uriimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/datasets/:uri")! 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 dataset events
{{baseUrl}}/datasets/events
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/datasets/events");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/datasets/events")require "http/client"
url = "{{baseUrl}}/datasets/events"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/datasets/events"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/datasets/events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/datasets/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/datasets/events HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/datasets/events")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/datasets/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}}/datasets/events")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/datasets/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}}/datasets/events');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/datasets/events'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/datasets/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}}/datasets/events',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/datasets/events")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/datasets/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}}/datasets/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}}/datasets/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}}/datasets/events'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/datasets/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}}/datasets/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}}/datasets/events" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/datasets/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}}/datasets/events');
echo $response->getBody();setUrl('{{baseUrl}}/datasets/events');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/datasets/events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/datasets/events' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/datasets/events' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/datasets/events")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/datasets/events"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/datasets/events"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/datasets/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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/datasets/events') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/datasets/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}}/datasets/eventshttp GET {{baseUrl}}/datasets/eventswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/datasets/eventsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/datasets/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
List datasets
{{baseUrl}}/datasets
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/datasets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/datasets")require "http/client"
url = "{{baseUrl}}/datasets"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/datasets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/datasets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/datasets"
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/datasets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/datasets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/datasets"))
.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}}/datasets")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/datasets")
.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}}/datasets');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/datasets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/datasets';
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}}/datasets',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/datasets")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/datasets',
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}}/datasets'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/datasets');
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}}/datasets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/datasets';
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}}/datasets"]
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}}/datasets" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/datasets",
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}}/datasets');
echo $response->getBody();setUrl('{{baseUrl}}/datasets');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/datasets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/datasets' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/datasets' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/datasets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/datasets"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/datasets"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/datasets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/datasets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/datasets";
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}}/datasetshttp GET {{baseUrl}}/datasetswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/datasetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/datasets")! 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 a log entry
{{baseUrl}}/eventLogs/:event_log_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/eventLogs/:event_log_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/eventLogs/:event_log_id")require "http/client"
url = "{{baseUrl}}/eventLogs/:event_log_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/eventLogs/:event_log_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/eventLogs/:event_log_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/eventLogs/:event_log_id"
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/eventLogs/:event_log_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/eventLogs/:event_log_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/eventLogs/:event_log_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/eventLogs/:event_log_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/eventLogs/:event_log_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/eventLogs/:event_log_id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/eventLogs/:event_log_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/eventLogs/:event_log_id';
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}}/eventLogs/:event_log_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/eventLogs/:event_log_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/eventLogs/:event_log_id',
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}}/eventLogs/:event_log_id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/eventLogs/:event_log_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/eventLogs/:event_log_id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/eventLogs/:event_log_id';
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}}/eventLogs/:event_log_id"]
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}}/eventLogs/:event_log_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/eventLogs/:event_log_id",
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}}/eventLogs/:event_log_id');
echo $response->getBody();setUrl('{{baseUrl}}/eventLogs/:event_log_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/eventLogs/:event_log_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/eventLogs/:event_log_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/eventLogs/:event_log_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/eventLogs/:event_log_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/eventLogs/:event_log_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/eventLogs/:event_log_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/eventLogs/:event_log_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/eventLogs/:event_log_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/eventLogs/:event_log_id";
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}}/eventLogs/:event_log_idhttp GET {{baseUrl}}/eventLogs/:event_log_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/eventLogs/:event_log_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/eventLogs/:event_log_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List log entries
{{baseUrl}}/eventLogs
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/eventLogs");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/eventLogs")require "http/client"
url = "{{baseUrl}}/eventLogs"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/eventLogs"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/eventLogs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/eventLogs"
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/eventLogs HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/eventLogs")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/eventLogs"))
.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}}/eventLogs")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/eventLogs")
.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}}/eventLogs');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/eventLogs'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/eventLogs';
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}}/eventLogs',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/eventLogs")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/eventLogs',
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}}/eventLogs'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/eventLogs');
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}}/eventLogs'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/eventLogs';
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}}/eventLogs"]
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}}/eventLogs" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/eventLogs",
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}}/eventLogs');
echo $response->getBody();setUrl('{{baseUrl}}/eventLogs');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/eventLogs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/eventLogs' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/eventLogs' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/eventLogs")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/eventLogs"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/eventLogs"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/eventLogs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/eventLogs') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/eventLogs";
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}}/eventLogshttp GET {{baseUrl}}/eventLogswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/eventLogsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/eventLogs")! 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 an import error
{{baseUrl}}/importErrors/:import_error_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/importErrors/:import_error_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/importErrors/:import_error_id")require "http/client"
url = "{{baseUrl}}/importErrors/:import_error_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/importErrors/:import_error_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/importErrors/:import_error_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/importErrors/:import_error_id"
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/importErrors/:import_error_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/importErrors/:import_error_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/importErrors/:import_error_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/importErrors/:import_error_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/importErrors/:import_error_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/importErrors/:import_error_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/importErrors/:import_error_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/importErrors/:import_error_id';
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}}/importErrors/:import_error_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/importErrors/:import_error_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/importErrors/:import_error_id',
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}}/importErrors/:import_error_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/importErrors/:import_error_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/importErrors/:import_error_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/importErrors/:import_error_id';
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}}/importErrors/:import_error_id"]
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}}/importErrors/:import_error_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/importErrors/:import_error_id",
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}}/importErrors/:import_error_id');
echo $response->getBody();setUrl('{{baseUrl}}/importErrors/:import_error_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/importErrors/:import_error_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/importErrors/:import_error_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/importErrors/:import_error_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/importErrors/:import_error_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/importErrors/:import_error_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/importErrors/:import_error_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/importErrors/:import_error_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/importErrors/:import_error_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/importErrors/:import_error_id";
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}}/importErrors/:import_error_idhttp GET {{baseUrl}}/importErrors/:import_error_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/importErrors/:import_error_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/importErrors/:import_error_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List import errors
{{baseUrl}}/importErrors
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/importErrors");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/importErrors")require "http/client"
url = "{{baseUrl}}/importErrors"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/importErrors"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/importErrors");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/importErrors"
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/importErrors HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/importErrors")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/importErrors"))
.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}}/importErrors")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/importErrors")
.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}}/importErrors');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/importErrors'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/importErrors';
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}}/importErrors',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/importErrors")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/importErrors',
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}}/importErrors'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/importErrors');
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}}/importErrors'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/importErrors';
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}}/importErrors"]
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}}/importErrors" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/importErrors",
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}}/importErrors');
echo $response->getBody();setUrl('{{baseUrl}}/importErrors');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/importErrors');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/importErrors' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/importErrors' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/importErrors")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/importErrors"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/importErrors"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/importErrors")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/importErrors') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/importErrors";
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}}/importErrorshttp GET {{baseUrl}}/importErrorswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/importErrorsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/importErrors")! 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 instance status
{{baseUrl}}/health
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/health");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/health")require "http/client"
url = "{{baseUrl}}/health"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/health"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/health");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/health"
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/health HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/health")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/health"))
.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}}/health")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/health")
.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}}/health');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/health'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/health';
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}}/health',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/health")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/health',
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}}/health'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/health');
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}}/health'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/health';
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}}/health"]
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}}/health" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/health",
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}}/health');
echo $response->getBody();setUrl('{{baseUrl}}/health');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/health');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/health' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/health' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/health")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/health"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/health"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/health")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/health') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/health";
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}}/healthhttp GET {{baseUrl}}/healthwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/healthimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/health")! 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 version information
{{baseUrl}}/version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/version");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/version")require "http/client"
url = "{{baseUrl}}/version"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/version"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/version");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/version"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/version HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/version")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/version"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/version")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/version")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/version');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/version'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/version';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/version',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/version")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/version',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/version'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/version');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/version'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/version';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/version"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/version" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/version",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/version');
echo $response->getBody();setUrl('{{baseUrl}}/version');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/version');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/version' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/version' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/version")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/version"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/version"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/version")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/version') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/version";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/versionhttp GET {{baseUrl}}/versionwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/versionimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/version")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List permissions
{{baseUrl}}/permissions
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/permissions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/permissions")require "http/client"
url = "{{baseUrl}}/permissions"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/permissions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/permissions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/permissions"
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/permissions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/permissions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/permissions"))
.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}}/permissions")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/permissions")
.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}}/permissions');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/permissions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/permissions';
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}}/permissions',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/permissions")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/permissions',
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}}/permissions'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/permissions');
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}}/permissions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/permissions';
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}}/permissions"]
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}}/permissions" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/permissions",
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}}/permissions');
echo $response->getBody();setUrl('{{baseUrl}}/permissions');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/permissions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/permissions' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/permissions' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/permissions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/permissions"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/permissions"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/permissions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/permissions') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/permissions";
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}}/permissionshttp GET {{baseUrl}}/permissionswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/permissionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/permissions")! 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 a list of loaded plugins
{{baseUrl}}/plugins
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/plugins");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/plugins")require "http/client"
url = "{{baseUrl}}/plugins"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/plugins"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/plugins");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/plugins"
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/plugins HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/plugins")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/plugins"))
.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}}/plugins")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/plugins")
.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}}/plugins');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/plugins'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/plugins';
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}}/plugins',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/plugins")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/plugins',
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}}/plugins'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/plugins');
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}}/plugins'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/plugins';
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}}/plugins"]
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}}/plugins" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/plugins",
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}}/plugins');
echo $response->getBody();setUrl('{{baseUrl}}/plugins');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/plugins');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/plugins' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/plugins' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/plugins")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/plugins"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/plugins"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/plugins")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/plugins') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/plugins";
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}}/pluginshttp GET {{baseUrl}}/pluginswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/pluginsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/plugins")! 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
Create a pool
{{baseUrl}}/pools
BODY json
{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/pools");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/pools" {:content-type :json
:form-params {:description ""
:name ""
:occupied_slots 0
:open_slots 0
:queued_slots 0
:slots 0
:used_slots 0}})require "http/client"
url = "{{baseUrl}}/pools"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/pools"),
Content = new StringContent("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/pools");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/pools"
payload := strings.NewReader("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/pools HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 133
{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/pools")
.setHeader("content-type", "application/json")
.setBody("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/pools"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/pools")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/pools")
.header("content-type", "application/json")
.body("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
.asString(); const data = JSON.stringify({
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/pools');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/pools',
headers: {'content-type': 'application/json'},
data: {
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/pools';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"description":"","name":"","occupied_slots":0,"open_slots":0,"queued_slots":0,"slots":0,"used_slots":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/pools',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "description": "",\n "name": "",\n "occupied_slots": 0,\n "open_slots": 0,\n "queued_slots": 0,\n "slots": 0,\n "used_slots": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/pools")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/pools',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/pools',
headers: {'content-type': 'application/json'},
body: {
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/pools');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/pools',
headers: {'content-type': 'application/json'},
data: {
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/pools';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"description":"","name":"","occupied_slots":0,"open_slots":0,"queued_slots":0,"slots":0,"used_slots":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
@"name": @"",
@"occupied_slots": @0,
@"open_slots": @0,
@"queued_slots": @0,
@"slots": @0,
@"used_slots": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/pools"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/pools" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/pools",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'description' => '',
'name' => '',
'occupied_slots' => 0,
'open_slots' => 0,
'queued_slots' => 0,
'slots' => 0,
'used_slots' => 0
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/pools', [
'body' => '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/pools');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'description' => '',
'name' => '',
'occupied_slots' => 0,
'open_slots' => 0,
'queued_slots' => 0,
'slots' => 0,
'used_slots' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'description' => '',
'name' => '',
'occupied_slots' => 0,
'open_slots' => 0,
'queued_slots' => 0,
'slots' => 0,
'used_slots' => 0
]));
$request->setRequestUrl('{{baseUrl}}/pools');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/pools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/pools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/pools", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/pools"
payload = {
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/pools"
payload <- "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/pools")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/pools') do |req|
req.body = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/pools";
let payload = json!({
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/pools \
--header 'content-type: application/json' \
--data '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}'echo '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}' | \
http POST {{baseUrl}}/pools \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "description": "",\n "name": "",\n "occupied_slots": 0,\n "open_slots": 0,\n "queued_slots": 0,\n "slots": 0,\n "used_slots": 0\n}' \
--output-document \
- {{baseUrl}}/poolsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/pools")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a pool
{{baseUrl}}/pools/:pool_name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/pools/:pool_name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/pools/:pool_name")require "http/client"
url = "{{baseUrl}}/pools/:pool_name"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/pools/:pool_name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/pools/:pool_name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/pools/:pool_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/pools/:pool_name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/pools/:pool_name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/pools/:pool_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}}/pools/:pool_name")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/pools/:pool_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}}/pools/:pool_name');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/pools/:pool_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/pools/:pool_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}}/pools/:pool_name',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/pools/:pool_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/pools/:pool_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}}/pools/:pool_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}}/pools/:pool_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}}/pools/:pool_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/pools/:pool_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}}/pools/:pool_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}}/pools/:pool_name" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/pools/:pool_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}}/pools/:pool_name');
echo $response->getBody();setUrl('{{baseUrl}}/pools/:pool_name');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/pools/:pool_name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/pools/:pool_name' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/pools/:pool_name' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/pools/:pool_name")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/pools/:pool_name"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/pools/:pool_name"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/pools/:pool_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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/pools/:pool_name') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/pools/:pool_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}}/pools/:pool_namehttp DELETE {{baseUrl}}/pools/:pool_namewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/pools/:pool_nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/pools/:pool_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()
GET
Get a pool
{{baseUrl}}/pools/:pool_name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/pools/:pool_name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/pools/:pool_name")require "http/client"
url = "{{baseUrl}}/pools/:pool_name"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/pools/:pool_name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/pools/:pool_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/pools/:pool_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/pools/:pool_name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/pools/:pool_name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/pools/:pool_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}}/pools/:pool_name")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/pools/:pool_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}}/pools/:pool_name');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/pools/:pool_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/pools/:pool_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}}/pools/:pool_name',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/pools/:pool_name")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/pools/:pool_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}}/pools/:pool_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}}/pools/:pool_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}}/pools/:pool_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/pools/:pool_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}}/pools/:pool_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}}/pools/:pool_name" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/pools/:pool_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}}/pools/:pool_name');
echo $response->getBody();setUrl('{{baseUrl}}/pools/:pool_name');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/pools/:pool_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/pools/:pool_name' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/pools/:pool_name' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/pools/:pool_name")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/pools/:pool_name"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/pools/:pool_name"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/pools/:pool_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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/pools/:pool_name') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/pools/:pool_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}}/pools/:pool_namehttp GET {{baseUrl}}/pools/:pool_namewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/pools/:pool_nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/pools/:pool_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
List pools
{{baseUrl}}/pools
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/pools");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/pools")require "http/client"
url = "{{baseUrl}}/pools"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/pools"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/pools");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/pools"
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/pools HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/pools")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/pools"))
.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}}/pools")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/pools")
.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}}/pools');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/pools'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/pools';
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}}/pools',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/pools")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/pools',
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}}/pools'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/pools');
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}}/pools'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/pools';
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}}/pools"]
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}}/pools" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/pools",
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}}/pools');
echo $response->getBody();setUrl('{{baseUrl}}/pools');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/pools');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/pools' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/pools' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/pools")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/pools"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/pools"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/pools")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/pools') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/pools";
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}}/poolshttp GET {{baseUrl}}/poolswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/poolsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/pools")! 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()
PATCH
Update a pool
{{baseUrl}}/pools/:pool_name
BODY json
{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/pools/:pool_name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/pools/:pool_name" {:content-type :json
:form-params {:description ""
:name ""
:occupied_slots 0
:open_slots 0
:queued_slots 0
:slots 0
:used_slots 0}})require "http/client"
url = "{{baseUrl}}/pools/:pool_name"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/pools/:pool_name"),
Content = new StringContent("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/pools/:pool_name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/pools/:pool_name"
payload := strings.NewReader("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/pools/:pool_name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 133
{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/pools/:pool_name")
.setHeader("content-type", "application/json")
.setBody("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/pools/:pool_name"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/pools/:pool_name")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/pools/:pool_name")
.header("content-type", "application/json")
.body("{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
.asString(); const data = JSON.stringify({
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/pools/:pool_name');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/pools/:pool_name',
headers: {'content-type': 'application/json'},
data: {
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/pools/:pool_name';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"description":"","name":"","occupied_slots":0,"open_slots":0,"queued_slots":0,"slots":0,"used_slots":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/pools/:pool_name',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "description": "",\n "name": "",\n "occupied_slots": 0,\n "open_slots": 0,\n "queued_slots": 0,\n "slots": 0,\n "used_slots": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/pools/:pool_name")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/pools/:pool_name',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/pools/:pool_name',
headers: {'content-type': 'application/json'},
body: {
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/pools/:pool_name');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/pools/:pool_name',
headers: {'content-type': 'application/json'},
data: {
description: '',
name: '',
occupied_slots: 0,
open_slots: 0,
queued_slots: 0,
slots: 0,
used_slots: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/pools/:pool_name';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"description":"","name":"","occupied_slots":0,"open_slots":0,"queued_slots":0,"slots":0,"used_slots":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
@"name": @"",
@"occupied_slots": @0,
@"open_slots": @0,
@"queued_slots": @0,
@"slots": @0,
@"used_slots": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/pools/:pool_name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/pools/:pool_name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/pools/:pool_name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'description' => '',
'name' => '',
'occupied_slots' => 0,
'open_slots' => 0,
'queued_slots' => 0,
'slots' => 0,
'used_slots' => 0
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/pools/:pool_name', [
'body' => '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/pools/:pool_name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'description' => '',
'name' => '',
'occupied_slots' => 0,
'open_slots' => 0,
'queued_slots' => 0,
'slots' => 0,
'used_slots' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'description' => '',
'name' => '',
'occupied_slots' => 0,
'open_slots' => 0,
'queued_slots' => 0,
'slots' => 0,
'used_slots' => 0
]));
$request->setRequestUrl('{{baseUrl}}/pools/:pool_name');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/pools/:pool_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/pools/:pool_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/pools/:pool_name", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/pools/:pool_name"
payload = {
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/pools/:pool_name"
payload <- "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/pools/:pool_name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/pools/:pool_name') do |req|
req.body = "{\n \"description\": \"\",\n \"name\": \"\",\n \"occupied_slots\": 0,\n \"open_slots\": 0,\n \"queued_slots\": 0,\n \"slots\": 0,\n \"used_slots\": 0\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/pools/:pool_name";
let payload = json!({
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/pools/:pool_name \
--header 'content-type: application/json' \
--data '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}'echo '{
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
}' | \
http PATCH {{baseUrl}}/pools/:pool_name \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "description": "",\n "name": "",\n "occupied_slots": 0,\n "open_slots": 0,\n "queued_slots": 0,\n "slots": 0,\n "used_slots": 0\n}' \
--output-document \
- {{baseUrl}}/pools/:pool_nameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"description": "",
"name": "",
"occupied_slots": 0,
"open_slots": 0,
"queued_slots": 0,
"slots": 0,
"used_slots": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/pools/:pool_name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List providers
{{baseUrl}}/providers
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/providers");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/providers")require "http/client"
url = "{{baseUrl}}/providers"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/providers"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/providers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/providers"
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/providers HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/providers")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/providers"))
.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}}/providers")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/providers")
.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}}/providers');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/providers'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/providers';
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}}/providers',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/providers")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/providers',
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}}/providers'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/providers');
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}}/providers'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/providers';
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}}/providers"]
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}}/providers" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/providers",
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}}/providers');
echo $response->getBody();setUrl('{{baseUrl}}/providers');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/providers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/providers' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/providers' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/providers")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/providers"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/providers"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/providers")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/providers') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/providers";
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}}/providershttp GET {{baseUrl}}/providerswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/providersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/providers")! 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
Create a role
{{baseUrl}}/roles
BODY json
{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roles");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/roles" {:content-type :json
:form-params {:actions [{:action {:name ""}
:resource {:name ""}}]
:name ""}})require "http/client"
url = "{{baseUrl}}/roles"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/roles"),
Content = new StringContent("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/roles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/roles"
payload := strings.NewReader("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/roles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141
{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/roles")
.setHeader("content-type", "application/json")
.setBody("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/roles"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/roles")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/roles")
.header("content-type", "application/json")
.body("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
.asString(); const data = JSON.stringify({
actions: [
{
action: {
name: ''
},
resource: {
name: ''
}
}
],
name: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/roles');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/roles',
headers: {'content-type': 'application/json'},
data: {actions: [{action: {name: ''}, resource: {name: ''}}], name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/roles';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"actions":[{"action":{"name":""},"resource":{"name":""}}],"name":""}'
};
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}}/roles',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "actions": [\n {\n "action": {\n "name": ""\n },\n "resource": {\n "name": ""\n }\n }\n ],\n "name": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/roles")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/roles',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({actions: [{action: {name: ''}, resource: {name: ''}}], name: ''}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/roles',
headers: {'content-type': 'application/json'},
body: {actions: [{action: {name: ''}, resource: {name: ''}}], name: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/roles');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
actions: [
{
action: {
name: ''
},
resource: {
name: ''
}
}
],
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: 'POST',
url: '{{baseUrl}}/roles',
headers: {'content-type': 'application/json'},
data: {actions: [{action: {name: ''}, resource: {name: ''}}], name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/roles';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"actions":[{"action":{"name":""},"resource":{"name":""}}],"name":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"actions": @[ @{ @"action": @{ @"name": @"" }, @"resource": @{ @"name": @"" } } ],
@"name": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roles"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/roles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/roles",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'actions' => [
[
'action' => [
'name' => ''
],
'resource' => [
'name' => ''
]
]
],
'name' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/roles', [
'body' => '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/roles');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'actions' => [
[
'action' => [
'name' => ''
],
'resource' => [
'name' => ''
]
]
],
'name' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'actions' => [
[
'action' => [
'name' => ''
],
'resource' => [
'name' => ''
]
]
],
'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/roles');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/roles", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/roles"
payload = {
"actions": [
{
"action": { "name": "" },
"resource": { "name": "" }
}
],
"name": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/roles"
payload <- "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/roles")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/roles') do |req|
req.body = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/roles";
let payload = json!({
"actions": (
json!({
"action": json!({"name": ""}),
"resource": json!({"name": ""})
})
),
"name": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/roles \
--header 'content-type: application/json' \
--data '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}'echo '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}' | \
http POST {{baseUrl}}/roles \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "actions": [\n {\n "action": {\n "name": ""\n },\n "resource": {\n "name": ""\n }\n }\n ],\n "name": ""\n}' \
--output-document \
- {{baseUrl}}/rolesimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"actions": [
[
"action": ["name": ""],
"resource": ["name": ""]
]
],
"name": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roles")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a role
{{baseUrl}}/roles/:role_name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roles/:role_name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/roles/:role_name")require "http/client"
url = "{{baseUrl}}/roles/:role_name"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/roles/:role_name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/roles/:role_name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/roles/:role_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/roles/:role_name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/roles/:role_name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/roles/:role_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}}/roles/:role_name")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/roles/:role_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}}/roles/:role_name');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/roles/:role_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/roles/:role_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}}/roles/:role_name',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/roles/:role_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/roles/:role_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}}/roles/:role_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}}/roles/:role_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}}/roles/:role_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/roles/:role_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}}/roles/:role_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}}/roles/:role_name" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/roles/:role_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}}/roles/:role_name');
echo $response->getBody();setUrl('{{baseUrl}}/roles/:role_name');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/roles/:role_name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/roles/:role_name' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/roles/:role_name' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/roles/:role_name")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/roles/:role_name"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/roles/:role_name"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/roles/:role_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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/roles/:role_name') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/roles/:role_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}}/roles/:role_namehttp DELETE {{baseUrl}}/roles/:role_namewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/roles/:role_nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roles/:role_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()
GET
Get a role
{{baseUrl}}/roles/:role_name
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roles/:role_name");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/roles/:role_name")require "http/client"
url = "{{baseUrl}}/roles/:role_name"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/roles/:role_name"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/roles/:role_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/roles/:role_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/roles/:role_name HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/roles/:role_name")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/roles/:role_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}}/roles/:role_name")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/roles/:role_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}}/roles/:role_name');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/roles/:role_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/roles/:role_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}}/roles/:role_name',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/roles/:role_name")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/roles/:role_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}}/roles/:role_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}}/roles/:role_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}}/roles/:role_name'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/roles/:role_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}}/roles/:role_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}}/roles/:role_name" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/roles/:role_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}}/roles/:role_name');
echo $response->getBody();setUrl('{{baseUrl}}/roles/:role_name');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/roles/:role_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/roles/:role_name' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/roles/:role_name' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/roles/:role_name")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/roles/:role_name"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/roles/:role_name"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/roles/:role_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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/roles/:role_name') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/roles/:role_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}}/roles/:role_namehttp GET {{baseUrl}}/roles/:role_namewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/roles/:role_nameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roles/:role_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
List roles
{{baseUrl}}/roles
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roles");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/roles")require "http/client"
url = "{{baseUrl}}/roles"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/roles"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/roles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/roles"
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/roles HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/roles")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/roles"))
.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}}/roles")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/roles")
.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}}/roles');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/roles'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/roles';
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}}/roles',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/roles")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/roles',
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}}/roles'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/roles');
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}}/roles'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/roles';
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}}/roles"]
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}}/roles" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/roles",
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}}/roles');
echo $response->getBody();setUrl('{{baseUrl}}/roles');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/roles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/roles' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/roles' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/roles")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/roles"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/roles"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/roles")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/roles') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/roles";
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}}/roleshttp GET {{baseUrl}}/roleswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/rolesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roles")! 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()
PATCH
Update a role
{{baseUrl}}/roles/:role_name
BODY json
{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/roles/:role_name");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/roles/:role_name" {:content-type :json
:form-params {:actions [{:action {:name ""}
:resource {:name ""}}]
:name ""}})require "http/client"
url = "{{baseUrl}}/roles/:role_name"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/roles/:role_name"),
Content = new StringContent("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/roles/:role_name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/roles/:role_name"
payload := strings.NewReader("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/roles/:role_name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141
{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/roles/:role_name")
.setHeader("content-type", "application/json")
.setBody("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/roles/:role_name"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/roles/:role_name")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/roles/:role_name")
.header("content-type", "application/json")
.body("{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
.asString(); const data = JSON.stringify({
actions: [
{
action: {
name: ''
},
resource: {
name: ''
}
}
],
name: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/roles/:role_name');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/roles/:role_name',
headers: {'content-type': 'application/json'},
data: {actions: [{action: {name: ''}, resource: {name: ''}}], name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/roles/:role_name';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"actions":[{"action":{"name":""},"resource":{"name":""}}],"name":""}'
};
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}}/roles/:role_name',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "actions": [\n {\n "action": {\n "name": ""\n },\n "resource": {\n "name": ""\n }\n }\n ],\n "name": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/roles/:role_name")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/roles/:role_name',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({actions: [{action: {name: ''}, resource: {name: ''}}], name: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/roles/:role_name',
headers: {'content-type': 'application/json'},
body: {actions: [{action: {name: ''}, resource: {name: ''}}], name: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/roles/:role_name');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
actions: [
{
action: {
name: ''
},
resource: {
name: ''
}
}
],
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: 'PATCH',
url: '{{baseUrl}}/roles/:role_name',
headers: {'content-type': 'application/json'},
data: {actions: [{action: {name: ''}, resource: {name: ''}}], name: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/roles/:role_name';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"actions":[{"action":{"name":""},"resource":{"name":""}}],"name":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"actions": @[ @{ @"action": @{ @"name": @"" }, @"resource": @{ @"name": @"" } } ],
@"name": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/roles/:role_name"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/roles/:role_name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/roles/:role_name",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'actions' => [
[
'action' => [
'name' => ''
],
'resource' => [
'name' => ''
]
]
],
'name' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/roles/:role_name', [
'body' => '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/roles/:role_name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'actions' => [
[
'action' => [
'name' => ''
],
'resource' => [
'name' => ''
]
]
],
'name' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'actions' => [
[
'action' => [
'name' => ''
],
'resource' => [
'name' => ''
]
]
],
'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/roles/:role_name');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/roles/:role_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/roles/:role_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/roles/:role_name", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/roles/:role_name"
payload = {
"actions": [
{
"action": { "name": "" },
"resource": { "name": "" }
}
],
"name": ""
}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/roles/:role_name"
payload <- "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/roles/:role_name")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/roles/:role_name') do |req|
req.body = "{\n \"actions\": [\n {\n \"action\": {\n \"name\": \"\"\n },\n \"resource\": {\n \"name\": \"\"\n }\n }\n ],\n \"name\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/roles/:role_name";
let payload = json!({
"actions": (
json!({
"action": json!({"name": ""}),
"resource": json!({"name": ""})
})
),
"name": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/roles/:role_name \
--header 'content-type: application/json' \
--data '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}'echo '{
"actions": [
{
"action": {
"name": ""
},
"resource": {
"name": ""
}
}
],
"name": ""
}' | \
http PATCH {{baseUrl}}/roles/:role_name \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "actions": [\n {\n "action": {\n "name": ""\n },\n "resource": {\n "name": ""\n }\n }\n ],\n "name": ""\n}' \
--output-document \
- {{baseUrl}}/roles/:role_nameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"actions": [
[
"action": ["name": ""],
"resource": ["name": ""]
]
],
"name": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/roles/:role_name")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a mapped task instance
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_indexhttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_indexwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_indeximport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")! 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 a task instance
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_idhttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")! 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 logs
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_numberhttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_numberwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_numberimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/logs/:task_try_number")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List extra links
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/linkshttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/linkswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/linksimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/links")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List mapped task instances
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMappedhttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMappedwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMappedimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/listMapped")! 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
List task instances (batch)
{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list
BODY json
{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list" {:content-type :json
:form-params {:dag_ids []
:duration_gte ""
:duration_lte ""
:end_date_gte ""
:end_date_lte ""
:execution_date_gte ""
:execution_date_lte ""
:pool []
:queue []
:start_date_gte ""
:start_date_lte ""
:state []}})require "http/client"
url = "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"),
Content = new StringContent("{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"
payload := strings.NewReader("{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/dags/~/dagRuns/~/taskInstances/list HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 255
{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list")
.setHeader("content-type", "application/json")
.setBody("{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list")
.header("content-type", "application/json")
.body("{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}")
.asString(); const data = JSON.stringify({
dag_ids: [],
duration_gte: '',
duration_lte: '',
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
pool: [],
queue: [],
start_date_gte: '',
start_date_lte: '',
state: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list',
headers: {'content-type': 'application/json'},
data: {
dag_ids: [],
duration_gte: '',
duration_lte: '',
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
pool: [],
queue: [],
start_date_gte: '',
start_date_lte: '',
state: []
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_ids":[],"duration_gte":"","duration_lte":"","end_date_gte":"","end_date_lte":"","execution_date_gte":"","execution_date_lte":"","pool":[],"queue":[],"start_date_gte":"","start_date_lte":"","state":[]}'
};
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}}/dags/~/dagRuns/~/taskInstances/list',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dag_ids": [],\n "duration_gte": "",\n "duration_lte": "",\n "end_date_gte": "",\n "end_date_lte": "",\n "execution_date_gte": "",\n "execution_date_lte": "",\n "pool": [],\n "queue": [],\n "start_date_gte": "",\n "start_date_lte": "",\n "state": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/~/dagRuns/~/taskInstances/list',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
dag_ids: [],
duration_gte: '',
duration_lte: '',
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
pool: [],
queue: [],
start_date_gte: '',
start_date_lte: '',
state: []
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list',
headers: {'content-type': 'application/json'},
body: {
dag_ids: [],
duration_gte: '',
duration_lte: '',
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
pool: [],
queue: [],
start_date_gte: '',
start_date_lte: '',
state: []
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dag_ids: [],
duration_gte: '',
duration_lte: '',
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
pool: [],
queue: [],
start_date_gte: '',
start_date_lte: '',
state: []
});
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}}/dags/~/dagRuns/~/taskInstances/list',
headers: {'content-type': 'application/json'},
data: {
dag_ids: [],
duration_gte: '',
duration_lte: '',
end_date_gte: '',
end_date_lte: '',
execution_date_gte: '',
execution_date_lte: '',
pool: [],
queue: [],
start_date_gte: '',
start_date_lte: '',
state: []
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"dag_ids":[],"duration_gte":"","duration_lte":"","end_date_gte":"","end_date_lte":"","execution_date_gte":"","execution_date_lte":"","pool":[],"queue":[],"start_date_gte":"","start_date_lte":"","state":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dag_ids": @[ ],
@"duration_gte": @"",
@"duration_lte": @"",
@"end_date_gte": @"",
@"end_date_lte": @"",
@"execution_date_gte": @"",
@"execution_date_lte": @"",
@"pool": @[ ],
@"queue": @[ ],
@"start_date_gte": @"",
@"start_date_lte": @"",
@"state": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'dag_ids' => [
],
'duration_gte' => '',
'duration_lte' => '',
'end_date_gte' => '',
'end_date_lte' => '',
'execution_date_gte' => '',
'execution_date_lte' => '',
'pool' => [
],
'queue' => [
],
'start_date_gte' => '',
'start_date_lte' => '',
'state' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list', [
'body' => '{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dag_ids' => [
],
'duration_gte' => '',
'duration_lte' => '',
'end_date_gte' => '',
'end_date_lte' => '',
'execution_date_gte' => '',
'execution_date_lte' => '',
'pool' => [
],
'queue' => [
],
'start_date_gte' => '',
'start_date_lte' => '',
'state' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dag_ids' => [
],
'duration_gte' => '',
'duration_lte' => '',
'end_date_gte' => '',
'end_date_lte' => '',
'execution_date_gte' => '',
'execution_date_lte' => '',
'pool' => [
],
'queue' => [
],
'start_date_gte' => '',
'start_date_lte' => '',
'state' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/dags/~/dagRuns/~/taskInstances/list", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"
payload = {
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list"
payload <- "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/dags/~/dagRuns/~/taskInstances/list') do |req|
req.body = "{\n \"dag_ids\": [],\n \"duration_gte\": \"\",\n \"duration_lte\": \"\",\n \"end_date_gte\": \"\",\n \"end_date_lte\": \"\",\n \"execution_date_gte\": \"\",\n \"execution_date_lte\": \"\",\n \"pool\": [],\n \"queue\": [],\n \"start_date_gte\": \"\",\n \"start_date_lte\": \"\",\n \"state\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list";
let payload = json!({
"dag_ids": (),
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": (),
"queue": (),
"start_date_gte": "",
"start_date_lte": "",
"state": ()
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list' \
--header 'content-type: application/json' \
--data '{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}'echo '{
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
}' | \
http POST '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list' \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "dag_ids": [],\n "duration_gte": "",\n "duration_lte": "",\n "end_date_gte": "",\n "end_date_lte": "",\n "execution_date_gte": "",\n "execution_date_lte": "",\n "pool": [],\n "queue": [],\n "start_date_gte": "",\n "start_date_lte": "",\n "state": []\n}' \
--output-document \
- '{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list'import Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dag_ids": [],
"duration_gte": "",
"duration_lte": "",
"end_date_gte": "",
"end_date_lte": "",
"execution_date_gte": "",
"execution_date_lte": "",
"pool": [],
"queue": [],
"start_date_gte": "",
"start_date_lte": "",
"state": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/~/dagRuns/~/taskInstances/list")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List task instances
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstanceshttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstanceswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstancesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances")! 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()
PATCH
Update the TaskInstance note. (PATCH)
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote
BODY json
{
"note": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"note\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote" {:content-type :json
:form-params {:note ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"note\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"),
Content = new StringContent("{\n \"note\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"note\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"
payload := strings.NewReader("{\n \"note\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16
{
"note": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote")
.setHeader("content-type", "application/json")
.setBody("{\n \"note\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"note\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"note\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote")
.header("content-type", "application/json")
.body("{\n \"note\": \"\"\n}")
.asString(); const data = JSON.stringify({
note: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote',
headers: {'content-type': 'application/json'},
data: {note: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"note":""}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "note": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"note\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({note: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote',
headers: {'content-type': 'application/json'},
body: {note: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
note: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote',
headers: {'content-type': 'application/json'},
data: {note: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"note":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"note": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"note\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'note' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote', [
'body' => '{
"note": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'note' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'note' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"note": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"note": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"note\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"
payload = { "note": "" }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote"
payload <- "{\n \"note\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"note\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote') do |req|
req.body = "{\n \"note\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote";
let payload = json!({"note": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote \
--header 'content-type: application/json' \
--data '{
"note": ""
}'echo '{
"note": ""
}' | \
http PATCH {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "note": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNoteimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["note": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index/setNote")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update the TaskInstance note.
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote
BODY json
{
"note": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"note\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote" {:content-type :json
:form-params {:note ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"note\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"),
Content = new StringContent("{\n \"note\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"note\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"
payload := strings.NewReader("{\n \"note\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16
{
"note": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote")
.setHeader("content-type", "application/json")
.setBody("{\n \"note\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"note\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"note\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote")
.header("content-type", "application/json")
.body("{\n \"note\": \"\"\n}")
.asString(); const data = JSON.stringify({
note: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote',
headers: {'content-type': 'application/json'},
data: {note: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"note":""}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "note": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"note\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({note: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote',
headers: {'content-type': 'application/json'},
body: {note: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
note: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote',
headers: {'content-type': 'application/json'},
data: {note: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"note":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"note": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"note\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'note' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote', [
'body' => '{
"note": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'note' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'note' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"note": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"note": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"note\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"
payload = { "note": "" }
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote"
payload <- "{\n \"note\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"note\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote') do |req|
req.body = "{\n \"note\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote";
let payload = json!({"note": ""});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote \
--header 'content-type: application/json' \
--data '{
"note": ""
}'echo '{
"note": ""
}' | \
http PATCH {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "note": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNoteimport Foundation
let headers = ["content-type": "application/json"]
let parameters = ["note": ""] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/setNote")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Updates the state of a mapped task instance
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index
BODY json
{
"dry_run": false,
"new_state": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index" {:content-type :json
:form-params {:dry_run false
:new_state ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"),
Content = new StringContent("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
payload := strings.NewReader("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41
{
"dry_run": false,
"new_state": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.setHeader("content-type", "application/json")
.setBody("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.header("content-type", "application/json")
.body("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
.asString(); const data = JSON.stringify({
dry_run: false,
new_state: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
headers: {'content-type': 'application/json'},
data: {dry_run: false, new_state: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"dry_run":false,"new_state":""}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dry_run": false,\n "new_state": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({dry_run: false, new_state: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
headers: {'content-type': 'application/json'},
body: {dry_run: false, new_state: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dry_run: false,
new_state: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index',
headers: {'content-type': 'application/json'},
data: {dry_run: false, new_state: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"dry_run":false,"new_state":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dry_run": @NO,
@"new_state": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'dry_run' => null,
'new_state' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index', [
'body' => '{
"dry_run": false,
"new_state": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dry_run' => null,
'new_state' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dry_run' => null,
'new_state' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"dry_run": false,
"new_state": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"dry_run": false,
"new_state": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
payload = {
"dry_run": False,
"new_state": ""
}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index"
payload <- "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index') do |req|
req.body = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index";
let payload = json!({
"dry_run": false,
"new_state": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index \
--header 'content-type: application/json' \
--data '{
"dry_run": false,
"new_state": ""
}'echo '{
"dry_run": false,
"new_state": ""
}' | \
http PATCH {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "dry_run": false,\n "new_state": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_indeximport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dry_run": false,
"new_state": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/:map_index")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Updates the state of a task instance
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id
BODY json
{
"dry_run": false,
"new_state": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id" {:content-type :json
:form-params {:dry_run false
:new_state ""}})require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"),
Content = new StringContent("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
payload := strings.NewReader("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41
{
"dry_run": false,
"new_state": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.setHeader("content-type", "application/json")
.setBody("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.header("content-type", "application/json")
.body("{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
.asString(); const data = JSON.stringify({
dry_run: false,
new_state: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
headers: {'content-type': 'application/json'},
data: {dry_run: false, new_state: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"dry_run":false,"new_state":""}'
};
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "dry_run": false,\n "new_state": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({dry_run: false, new_state: ''}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
headers: {'content-type': 'application/json'},
body: {dry_run: false, new_state: ''},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
dry_run: false,
new_state: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id',
headers: {'content-type': 'application/json'},
data: {dry_run: false, new_state: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id';
const options = {
method: 'PATCH',
headers: {'content-type': 'application/json'},
body: '{"dry_run":false,"new_state":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dry_run": @NO,
@"new_state": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
'dry_run' => null,
'new_state' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id', [
'body' => '{
"dry_run": false,
"new_state": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'dry_run' => null,
'new_state' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'dry_run' => null,
'new_state' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"dry_run": false,
"new_state": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
"dry_run": false,
"new_state": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
payload = {
"dry_run": False,
"new_state": ""
}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id"
payload <- "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id') do |req|
req.body = "{\n \"dry_run\": false,\n \"new_state\": \"\"\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id";
let payload = json!({
"dry_run": false,
"new_state": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id \
--header 'content-type: application/json' \
--data '{
"dry_run": false,
"new_state": ""
}'echo '{
"dry_run": false,
"new_state": ""
}' | \
http PATCH {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{\n "dry_run": false,\n "new_state": ""\n}' \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_idimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"dry_run": false,
"new_state": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a user
{{baseUrl}}/users
BODY json
{}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/users" {:content-type :json})require "http/client"
url = "{{baseUrl}}/users"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/users"),
Content = new StringContent("{}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users"
payload := strings.NewReader("{}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2
{}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/users")
.setHeader("content-type", "application/json")
.setBody("{}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
.url("{{baseUrl}}/users")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/users")
.header("content-type", "application/json")
.body("{}")
.asString(); const data = JSON.stringify({});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/users');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/users',
headers: {'content-type': 'application/json'},
data: {}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};
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}}/users',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
.url("{{baseUrl}}/users")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/users',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/users',
headers: {'content-type': 'application/json'},
body: {},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/users');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({});
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}}/users',
headers: {'content-type': 'application/json'},
data: {}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/users', [
'body' => '{}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
]));
$request->setRequestUrl('{{baseUrl}}/users');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/users", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users"
payload = {}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users"
payload <- "{}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/users') do |req|
req.body = "{}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users";
let payload = json!({});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/users \
--header 'content-type: application/json' \
--data '{}'echo '{}' | \
http POST {{baseUrl}}/users \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{}' \
--output-document \
- {{baseUrl}}/usersimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a user
{{baseUrl}}/users/:username
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:username");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/users/:username")require "http/client"
url = "{{baseUrl}}/users/:username"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/users/:username"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:username");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:username"
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/users/:username HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/users/:username")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:username"))
.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}}/users/:username")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/users/:username")
.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}}/users/:username');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/users/:username'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:username';
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}}/users/:username',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:username")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:username',
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}}/users/:username'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/users/:username');
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}}/users/:username'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:username';
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}}/users/:username"]
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}}/users/:username" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:username",
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}}/users/:username');
echo $response->getBody();setUrl('{{baseUrl}}/users/:username');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:username');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:username' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:username' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/users/:username")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:username"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:username"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:username")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/users/:username') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:username";
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}}/users/:usernamehttp DELETE {{baseUrl}}/users/:usernamewget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/users/:usernameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:username")! 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
Get a user
{{baseUrl}}/users/:username
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:username");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:username")require "http/client"
url = "{{baseUrl}}/users/:username"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:username"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:username");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:username"
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/users/:username HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:username")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:username"))
.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}}/users/:username")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:username")
.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}}/users/:username');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/users/:username'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:username';
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}}/users/:username',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:username")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:username',
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}}/users/:username'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:username');
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}}/users/:username'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:username';
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}}/users/:username"]
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}}/users/:username" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:username",
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}}/users/:username');
echo $response->getBody();setUrl('{{baseUrl}}/users/:username');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:username');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:username' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:username' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/users/:username")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:username"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:username"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:username")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:username') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:username";
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}}/users/:usernamehttp GET {{baseUrl}}/users/:usernamewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/users/:usernameimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:username")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List users
{{baseUrl}}/users
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users")require "http/client"
url = "{{baseUrl}}/users"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users"
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/users HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users"))
.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}}/users")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users")
.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}}/users');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/users'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users';
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}}/users',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users',
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}}/users'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users');
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}}/users'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users';
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}}/users"]
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}}/users" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users",
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}}/users');
echo $response->getBody();setUrl('{{baseUrl}}/users');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/users' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/users' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/users")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/users"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users";
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}}/usershttp GET {{baseUrl}}/userswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users")! 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()
PATCH
Update a user
{{baseUrl}}/users/:username
BODY json
{}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:username");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/users/:username" {:content-type :json})require "http/client"
url = "{{baseUrl}}/users/:username"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{}"
response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/users/:username"),
Content = new StringContent("{}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:username");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:username"
payload := strings.NewReader("{}")
req, _ := http.NewRequest("PATCH", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/users/:username HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2
{}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/users/:username")
.setHeader("content-type", "application/json")
.setBody("{}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:username"))
.header("content-type", "application/json")
.method("PATCH", HttpRequest.BodyPublishers.ofString("{}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:username")
.patch(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/users/:username")
.header("content-type", "application/json")
.body("{}")
.asString(); const data = JSON.stringify({});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/users/:username');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/users/:username',
headers: {'content-type': 'application/json'},
data: {}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:username';
const options = {method: 'PATCH', headers: {'content-type': 'application/json'}, body: '{}'};
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}}/users/:username',
method: 'PATCH',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
.url("{{baseUrl}}/users/:username")
.patch(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:username',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({}));
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/users/:username',
headers: {'content-type': 'application/json'},
body: {},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/users/:username');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/users/:username',
headers: {'content-type': 'application/json'},
data: {}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:username';
const options = {method: 'PATCH', headers: {'content-type': 'application/json'}, body: '{}'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:username"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:username" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in
Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:username",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
CURLOPT_POSTFIELDS => json_encode([
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/users/:username', [
'body' => '{}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:username');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
]));
$request->setRequestUrl('{{baseUrl}}/users/:username');
$request->setRequestMethod('PATCH');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:username' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:username' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{}"
headers = { 'content-type': "application/json" }
conn.request("PATCH", "/baseUrl/users/:username", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:username"
payload = {}
headers = {"content-type": "application/json"}
response = requests.patch(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:username"
payload <- "{}"
encode <- "json"
response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:username")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.patch('/baseUrl/users/:username') do |req|
req.body = "{}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:username";
let payload = json!({});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/users/:username \
--header 'content-type: application/json' \
--data '{}'echo '{}' | \
http PATCH {{baseUrl}}/users/:username \
content-type:application/jsonwget --quiet \
--method PATCH \
--header 'content-type: application/json' \
--body-data '{}' \
--output-document \
- {{baseUrl}}/users/:usernameimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:username")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a variable
{{baseUrl}}/variables
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/variables");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/variables")require "http/client"
url = "{{baseUrl}}/variables"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/variables"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/variables");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/variables"
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/variables HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/variables")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/variables"))
.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}}/variables")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/variables")
.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}}/variables');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/variables'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/variables';
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}}/variables',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/variables")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/variables',
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}}/variables'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/variables');
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}}/variables'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/variables';
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}}/variables"]
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}}/variables" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/variables",
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}}/variables');
echo $response->getBody();setUrl('{{baseUrl}}/variables');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/variables');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/variables' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/variables' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/variables")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/variables"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/variables"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/variables")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/variables') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/variables";
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}}/variableshttp POST {{baseUrl}}/variableswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/variablesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/variables")! 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()
DELETE
Delete a variable
{{baseUrl}}/variables/:variable_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/variables/:variable_key");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/variables/:variable_key")require "http/client"
url = "{{baseUrl}}/variables/:variable_key"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/variables/:variable_key"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/variables/:variable_key");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/variables/:variable_key"
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/variables/:variable_key HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/variables/:variable_key")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/variables/:variable_key"))
.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}}/variables/:variable_key")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/variables/:variable_key")
.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}}/variables/:variable_key');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/variables/:variable_key'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/variables/:variable_key';
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}}/variables/:variable_key',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/variables/:variable_key")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/variables/:variable_key',
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}}/variables/:variable_key'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/variables/:variable_key');
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}}/variables/:variable_key'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/variables/:variable_key';
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}}/variables/:variable_key"]
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}}/variables/:variable_key" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/variables/:variable_key",
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}}/variables/:variable_key');
echo $response->getBody();setUrl('{{baseUrl}}/variables/:variable_key');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/variables/:variable_key');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/variables/:variable_key' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/variables/:variable_key' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/variables/:variable_key")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/variables/:variable_key"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/variables/:variable_key"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/variables/:variable_key")
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_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/variables/:variable_key') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/variables/:variable_key";
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}}/variables/:variable_keyhttp DELETE {{baseUrl}}/variables/:variable_keywget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/variables/:variable_keyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/variables/:variable_key")! 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
Get a variable
{{baseUrl}}/variables/:variable_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/variables/:variable_key");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/variables/:variable_key")require "http/client"
url = "{{baseUrl}}/variables/:variable_key"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/variables/:variable_key"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/variables/:variable_key");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/variables/:variable_key"
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/variables/:variable_key HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/variables/:variable_key")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/variables/:variable_key"))
.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}}/variables/:variable_key")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/variables/:variable_key")
.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}}/variables/:variable_key');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/variables/:variable_key'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/variables/:variable_key';
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}}/variables/:variable_key',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/variables/:variable_key")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/variables/:variable_key',
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}}/variables/:variable_key'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/variables/:variable_key');
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}}/variables/:variable_key'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/variables/:variable_key';
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}}/variables/:variable_key"]
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}}/variables/:variable_key" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/variables/:variable_key",
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}}/variables/:variable_key');
echo $response->getBody();setUrl('{{baseUrl}}/variables/:variable_key');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/variables/:variable_key');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/variables/:variable_key' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/variables/:variable_key' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/variables/:variable_key")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/variables/:variable_key"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/variables/:variable_key"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/variables/:variable_key")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/variables/:variable_key') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/variables/:variable_key";
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}}/variables/:variable_keyhttp GET {{baseUrl}}/variables/:variable_keywget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/variables/:variable_keyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/variables/:variable_key")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List variables
{{baseUrl}}/variables
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/variables");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/variables")require "http/client"
url = "{{baseUrl}}/variables"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/variables"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/variables");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/variables"
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/variables HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/variables")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/variables"))
.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}}/variables")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/variables")
.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}}/variables');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/variables'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/variables';
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}}/variables',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/variables")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/variables',
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}}/variables'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/variables');
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}}/variables'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/variables';
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}}/variables"]
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}}/variables" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/variables",
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}}/variables');
echo $response->getBody();setUrl('{{baseUrl}}/variables');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/variables');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/variables' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/variables' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/variables")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/variables"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/variables"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/variables")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/variables') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/variables";
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}}/variableshttp GET {{baseUrl}}/variableswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/variablesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/variables")! 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()
PATCH
Update a variable
{{baseUrl}}/variables/:variable_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/variables/:variable_key");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/variables/:variable_key")require "http/client"
url = "{{baseUrl}}/variables/:variable_key"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/variables/:variable_key"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/variables/:variable_key");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/variables/:variable_key"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/variables/:variable_key HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/variables/:variable_key")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/variables/:variable_key"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/variables/:variable_key")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/variables/:variable_key")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/variables/:variable_key');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/variables/:variable_key'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/variables/:variable_key';
const options = {method: 'PATCH'};
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}}/variables/:variable_key',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/variables/:variable_key")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/variables/:variable_key',
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: 'PATCH', url: '{{baseUrl}}/variables/:variable_key'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/variables/:variable_key');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/variables/:variable_key'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/variables/:variable_key';
const options = {method: 'PATCH'};
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}}/variables/:variable_key"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
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}}/variables/:variable_key" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/variables/:variable_key",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/variables/:variable_key');
echo $response->getBody();setUrl('{{baseUrl}}/variables/:variable_key');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/variables/:variable_key');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/variables/:variable_key' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/variables/:variable_key' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/variables/:variable_key")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/variables/:variable_key"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/variables/:variable_key"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/variables/:variable_key")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/variables/:variable_key') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/variables/:variable_key";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/variables/:variable_keyhttp PATCH {{baseUrl}}/variables/:variable_keywget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/variables/:variable_keyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/variables/:variable_key")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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 an XCom entry
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_keyhttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_keywget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_keyimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries/:xcom_key")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List XCom entries
{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")require "http/client"
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"
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/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"))
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")
.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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries',
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries');
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries';
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"]
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries",
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries');
echo $response->getBody();setUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries";
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}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntrieshttp GET {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntrieswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntriesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dags/:dag_id/dagRuns/:dag_run_id/taskInstances/:task_id/xcomEntries")! 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()