Project-FiFo

The Project-FiFo Developer Hub

Welcome to the Project-FiFo developer hub. You'll find comprehensive guides and documentation to help you start working with Project-FiFo as quickly as possible, as well as support if you get stuck. Let's jump right in!

Get Started    
Suggest Edits

get

See 'get hypervisor' for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/hypervisors/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/hypervisors/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/hypervisors/");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/hypervisors/uuid
curl --request GET \
  --url http://example.com/api/3/hypervisors/uuid
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/hypervisors/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/hypervisors/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

delete

Every vm still residing on this hypervisor
will either be put in 'limbo' when at least one full backup exists,
or be deleted if not.

 
deleteexample.com/api/3/hypervisors/uuid
curl --request DELETE \
  --url http://example.com/api/3/hypervisors/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/hypervisors/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/hypervisors/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/characteristics/{path}

 
Suggest Edits

put

this can be later used on rules to match against.

 
putexample.com/api/3/hypervisors/uuid/characteristics/path
curl --request PUT \
  --url http://example.com/api/3/hypervisors/uuid/characteristics/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/hypervisors/uuid/characteristics/path' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/characteristics/path")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/hypervisors/uuid/characteristics/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/characteristics/path"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/hypervisors/uuid/characteristics/path
curl --request DELETE \
  --url http://example.com/api/3/hypervisors/uuid/characteristics/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/hypervisors/uuid/characteristics/path' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/characteristics/path")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/hypervisors/uuid/characteristics/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/characteristics/path"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/config

 
putexample.com/api/3/hypervisors/uuid/config
curl --request PUT \
  --url http://example.com/api/3/hypervisors/uuid/config
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/hypervisors/uuid/config' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/config")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/hypervisors/uuid/config");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/config"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/metrics

 
getexample.com/api/3/hypervisors/uuid/metrics
curl --request GET \
  --url http://example.com/api/3/hypervisors/uuid/metrics
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/hypervisors/uuid/metrics' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/metrics")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/hypervisors/uuid/metrics");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/metrics"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Client for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/clients/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/clients/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/clients/");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/clients/
curl --request POST \
  --url http://example.com/api/3/clients/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/clients/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/clients/");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/clients/uuid
curl --request GET \
  --url http://example.com/api/3/clients/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/clients/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/clients/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/clients/uuid
curl --request PUT \
  --url http://example.com/api/3/clients/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://example.com/api/3/clients/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/clients/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/clients/uuid
curl --request DELETE \
  --url http://example.com/api/3/clients/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/clients/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/clients/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/permissions/{permission}

 
Suggest Edits

get

Please note that 403 here does not mean the client is not allowed but that the
requesting token was not allowed to test for the client!

 
getexample.com/api/3/clients/uuid/permissions/permission
curl --request GET \
  --url http://example.com/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/clients/uuid/permissions/permission' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/permissions/permission")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/clients/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/permissions/permission"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/clients/uuid/permissions/permission
curl --request PUT \
  --url http://example.com/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/clients/uuid/permissions/permission' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/permissions/permission")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/clients/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/permissions/permission"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/clients/uuid/permissions/permission
curl --request DELETE \
  --url http://example.com/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/clients/uuid/permissions/permission' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/permissions/permission")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/clients/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/permissions/permission"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/uris

 
postexample.com/api/3/clients/uuid/uris
curl --request POST \
  --url http://example.com/api/3/clients/uuid/uris
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/clients/uuid/uris' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/uris")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/clients/uuid/uris");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/uris"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/uris/{id}

 
deleteexample.com/api/3/clients/uuid/uris/id
curl --request DELETE \
  --url http://example.com/api/3/clients/uuid/uris/id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/clients/uuid/uris/id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/uris/id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/clients/uuid/uris/id");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/uris/id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Dataset for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/datasets/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/datasets/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/datasets/");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/datasets/
curl --request POST \
  --url http://example.com/api/3/datasets/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/datasets/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/datasets/");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/datasets/uuid
curl --request GET \
  --url http://example.com/api/3/datasets/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/datasets/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/datasets/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/datasets/uuid
curl --request DELETE \
  --url http://example.com/api/3/datasets/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/datasets/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/datasets/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

put

This is the 1st step of a dataset import from a local file

 
putexample.com/api/3/datasets/uuid
curl --request PUT \
  --url http://example.com/api/3/datasets/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://example.com/api/3/datasets/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/datasets/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/dataset.gz

 
getexample.com/api/3/datasets/uuid/dataset.gz
curl --request GET \
  --url http://example.com/api/3/datasets/uuid/dataset.gz
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/datasets/uuid/dataset.gz' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/dataset.gz")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/datasets/uuid/dataset.gz");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/dataset.gz"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

put

This is the 2nd step of a dataset import from a local file

 
putexample.com/api/3/datasets/uuid/dataset.gz
curl --request PUT \
  --url http://example.com/api/3/datasets/uuid/dataset.gz
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/datasets/uuid/dataset.gz' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/dataset.gz")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/datasets/uuid/dataset.gz");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/dataset.gz"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/networks/{nic}

 
putexample.com/api/3/datasets/uuid/networks/nic
curl --request PUT \
  --url http://example.com/api/3/datasets/uuid/networks/nic
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/datasets/uuid/networks/nic' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/networks/nic")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/datasets/uuid/networks/nic");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/networks/nic"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/datasets/uuid/networks/nic
curl --request DELETE \
  --url http://example.com/api/3/datasets/uuid/networks/nic
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/datasets/uuid/networks/nic' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/networks/nic")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/datasets/uuid/networks/nic");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/networks/nic"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

Lists all Groupings visible to the user, either by uuid or objects.

 
get/
curl --request GET \
  --url http://example.com/api/3/groupings/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/groupings/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/groupings/");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/groupings/uuid
curl --request GET \
  --url http://example.com/api/3/groupings/uuid
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/groupings/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/groupings/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/elements/{other}

 
putexample.com/api/3/groupings/uuid/elements/other
curl --request PUT \
  --url http://example.com/api/3/groupings/uuid/elements/other
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/groupings/uuid/elements/other' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/elements/other")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/groupings/uuid/elements/other");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/elements/other"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/groupings/uuid/elements/other
curl --request DELETE \
  --url http://example.com/api/3/groupings/uuid/elements/other
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/groupings/uuid/elements/other' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/elements/other")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/groupings/uuid/elements/other");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/elements/other"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/config/{path}

 
putexample.com/api/3/groupings/uuid/config/path
curl --request PUT \
  --url http://example.com/api/3/groupings/uuid/config/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/groupings/uuid/config/path' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/config/path")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/groupings/uuid/config/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/config/path"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/groupings/uuid/config/path
curl --request DELETE \
  --url http://example.com/api/3/groupings/uuid/config/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/groupings/uuid/config/path' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/config/path")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/groupings/uuid/config/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/config/path"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/metadata/{path}

 
putexample.com/api/3/groupings/uuid/metadata/path
curl --request PUT \
  --url http://example.com/api/3/groupings/uuid/metadata/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/groupings/uuid/metadata/path' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/metadata/path")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/groupings/uuid/metadata/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/metadata/path"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/groupings/uuid/metadata/path
curl --request DELETE \
  --url http://example.com/api/3/groupings/uuid/metadata/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/groupings/uuid/metadata/path' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/metadata/path")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/groupings/uuid/metadata/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/metadata/path"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get IP Range for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/ipranges/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/ipranges/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/ipranges/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/ipranges/");

xhr.send(data);
import requests

url = "http://example.com/api/3/ipranges/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/ipranges/
curl --request POST \
  --url http://example.com/api/3/ipranges/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/ipranges/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/ipranges/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/ipranges/");

xhr.send(data);
import requests

url = "http://example.com/api/3/ipranges/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/ipranges/uuid
curl --request GET \
  --url http://example.com/api/3/ipranges/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/ipranges/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/ipranges/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/ipranges/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/ipranges/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/ipranges/uuid
curl --request PUT \
  --url http://example.com/api/3/ipranges/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://example.com/api/3/ipranges/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/ipranges/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/ipranges/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/ipranges/uuid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/{ip}

 
putexample.com/api/3/ipranges/uuid/ip
curl --request PUT \
  --url http://example.com/api/3/ipranges/uuid/ip
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/ipranges/uuid/ip' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/ipranges/uuid/ip")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/ipranges/uuid/ip");

xhr.send(data);
import requests

url = "http://example.com/api/3/ipranges/uuid/ip"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
get/
curl --request GET \
  --url http://example.com/api/3/scopes/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/scopes/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/scopes/")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/scopes/");

xhr.send(data);
import requests

url = "http://example.com/api/3/scopes/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
delete/
curl --request DELETE \
  --url http://example.com/api/3/sessions/
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/sessions/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/sessions/")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/sessions/");

xhr.send(data);
import requests

url = "http://example.com/api/3/sessions/"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
Suggest Edits

retrieves information about the current session

 
getexample.com/api/3/sessions/
curl --request GET \
  --url http://example.com/api/3/sessions/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/sessions/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/sessions/")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/sessions/");

xhr.send(data);
import requests

url = "http://example.com/api/3/sessions/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/one_time_token

 
Suggest Edits

get

FiFo uses one time tokens to secure web socket, that way
the token can be passed as a query parameter without securty
concerns since it will be only valid for a single use. One time
tokens have a very short lifetime and will be invalidated after
the first use.

 
getexample.com/api/3/sessions/one_time_token
curl --request GET \
  --url http://example.com/api/3/sessions/one_time_token
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/sessions/one_time_token' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/sessions/one_time_token")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/sessions/one_time_token");

xhr.send(data);
import requests

url = "http://example.com/api/3/sessions/one_time_token"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

This endpoint serves both 'Authorization Code Request' and the
'Implict Request' parts of the OAuth 2 workflow depending on the
response_type provided.

 
get/auth
curl --request GET \
  --url http://example.com/api/3/oauth2/auth
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/oauth2/auth' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/oauth2/auth")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/oauth2/auth");

xhr.send(data);
import requests

url = "http://example.com/api/3/oauth2/auth"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/oauth2/auth
curl --request POST \
  --url http://example.com/api/3/oauth2/auth
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/oauth2/auth' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/oauth2/auth")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/oauth2/auth");

xhr.send(data);
import requests

url = "http://example.com/api/3/oauth2/auth"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

This endpoint serves the following parts of the OAuth workflow, please
see the linked specifications for details as it does not fit the swagger
spec definition language.

 
postexample.com/api/3/oauth2/token
curl --request POST \
  --url http://example.com/api/3/oauth2/token
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/oauth2/token' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/oauth2/token")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/oauth2/token");

xhr.send(data);
import requests

url = "http://example.com/api/3/oauth2/token"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Roles for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/roles/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/roles/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/roles/");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/roles/
curl --request POST \
  --url http://example.com/api/3/roles/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/roles/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/roles/");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/roles/uuid
curl --request GET \
  --url http://example.com/api/3/roles/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/roles/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/roles/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/roles/uuid
curl --request DELETE \
  --url http://example.com/api/3/roles/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/roles/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/roles/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/permissions/{permission}

 
putexample.com/api/3/roles/uuid/permissions/permission
curl --request PUT \
  --url http://example.com/api/3/roles/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/roles/uuid/permissions/permission' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid/permissions/permission")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/roles/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid/permissions/permission"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/roles/uuid/permissions/permission
curl --request DELETE \
  --url http://example.com/api/3/roles/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/roles/uuid/permissions/permission' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid/permissions/permission")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/roles/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid/permissions/permission"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See 'Get Network' for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/networks/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/networks/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/networks/");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/networks/
curl --request POST \
  --url http://example.com/api/3/networks/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/networks/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/networks/");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/networks/uuid
curl --request GET \
  --url http://example.com/api/3/networks/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/networks/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/networks/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/networks/uuid
curl --request DELETE \
  --url http://example.com/api/3/networks/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/networks/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/networks/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/iprange/{iprange}

 
putexample.com/api/3/networks/uuid/iprange/iprange
curl --request PUT \
  --url http://example.com/api/3/networks/uuid/iprange/iprange
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/networks/uuid/iprange/iprange' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid/iprange/iprange")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/networks/uuid/iprange/iprange");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid/iprange/iprange"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/networks/uuid/iprange/iprange
curl --request DELETE \
  --url http://example.com/api/3/networks/uuid/iprange/iprange
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/networks/uuid/iprange/iprange' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid/iprange/iprange")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/networks/uuid/iprange/iprange");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid/iprange/iprange"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Org for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/orgs/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/orgs/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/orgs/");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/orgs/
curl --request POST \
  --url http://example.com/api/3/orgs/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/orgs/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/orgs/");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/orgs/uuid
curl --request GET \
  --url http://example.com/api/3/orgs/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/orgs/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/orgs/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/orgs/uuid
curl --request DELETE \
  --url http://example.com/api/3/orgs/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/orgs/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/orgs/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/accounting

 
Suggest Edits

get

This will grab accounting data for a period between start and end.
The data presented will include all data points for every resource
that existed in this timeframe not only those in the timeframe.
This allows reconstructing the entire situation during the time
frame, including resources that were created before and destroyed
after the period.

 
getexample.com/api/3/orgs/uuid/accounting
curl --request GET \
  --url http://example.com/api/3/orgs/uuid/accounting
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/orgs/uuid/accounting' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/accounting")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/orgs/uuid/accounting");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/accounting"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/user_create

 
Suggest Edits

put

This trigger is executed when a new user is created from someone
who belongs to an org

 
putexample.com/api/3/orgs/uuid/triggers/user_create
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/triggers/user_create
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/triggers/user_create' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/user_create")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/triggers/user_create");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/user_create"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/dataset_create

 
Suggest Edits

post

This trigger is executed when a new dataset is created from someone
who belongs to this org

 
postexample.com/api/3/orgs/uuid/triggers/dataset_create
curl --request POST \
  --url http://example.com/api/3/orgs/uuid/triggers/dataset_create
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/orgs/uuid/triggers/dataset_create' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/dataset_create")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/orgs/uuid/triggers/dataset_create");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/dataset_create"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/vm_create

 
Suggest Edits

put

This trigger is executed when a new VM is created by someone who
belongs to this org

 
putexample.com/api/3/orgs/uuid/triggers/vm_create
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/triggers/vm_create
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/triggers/vm_create' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/vm_create")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/triggers/vm_create");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/vm_create"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/{trigger-id}

 
deleteexample.com/api/3/orgs/uuid/triggers/trigger-id
curl --request DELETE \
  --url http://example.com/api/3/orgs/uuid/triggers/trigger-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/orgs/uuid/triggers/trigger-id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/trigger-id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/orgs/uuid/triggers/trigger-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/trigger-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/resources/{resource}

 
Suggest Edits

put

Increases or decreases resources for an org.

 
putexample.com/api/3/orgs/uuid/resources/resource
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/resources/resource
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/resources/resource' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/resources/resource")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/resources/resource");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/resources/resource"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/docker/networks/{scope}

 
putexample.com/api/3/orgs/uuid/docker/networks/scope
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/docker/networks/scope
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/docker/networks/scope' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/docker/networks/scope")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/docker/networks/scope");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/docker/networks/scope"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Package for the fields available for full-list-fields.

 
get/
curl --request GET \
  --url http://example.com/api/3/packages/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/packages/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/packages/");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

Requirements
'requirements' is an array of objects as with the following atributes:
'WEIGHT'
A number (positive or negative) or the string "most", "cant" for strong
enforcement or "scale" and "random" must, cant, and <number> rules
This rules simply compare an attribute of the hypervisor against a
value and either enforces a the rule (must/cant) or gives out points,
both positive and negative to rate the found hypervisors.
attribute
The attribute to check on the hypervisors, this can be a json like
path so for example "characteristics.colour" will look up colour in
the hypervisors characteristics
Value
The value to check against, this can be a number, a string, or an array.
condition
One of:

=, > - Checks if the value of attribute is larger (or equal) to the
value
=<, < - Checks if the value of attribute is smaller (or equal) to the
value
=:= - Checks if the value of attribute is equal to the value
=/= - Checks if the value of attribute is not equal to the value
"subset" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"superset" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"disjoint" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"element" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"allowed" - Checks if the value of attribute is a subset of value
(requires value to be an array)
scale rules
This rules linearly map an attributes value onto a given scale and
give the result as points for hypervisor selection.
attribute
The attribute to check on the hypervisors, this can be a json like
path so for example "characteristics.cores" will look up cores in the
hypervisors characteristics This must be an numeric value towork
low, and high
The lowest and highest number of the scale, to map against.
random ruleS
This rules simply generate a random number on a given scale, this
allows making non deterministic rules. The resulting number is used
as points for hypervisor selection.
low, and high
The lowest and highest number the random number is generated from.

 
postexample.com/api/3/packages/
curl --request POST \
  --url http://example.com/api/3/packages/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/packages/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/packages/");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/packages/uuid
curl --request GET \
  --url http://example.com/api/3/packages/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/packages/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/packages/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/packages/uuid
curl --request DELETE \
  --url http://example.com/api/3/packages/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/packages/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/packages/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

see get vm for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/vms/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/vms/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/vms/");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

Most of the keys in config
are self-explanatory the one noteworthy is networks however. it is
a map of nics (provided by the dataset) to UUIDs of networks (
not ip ranges!).

 
postexample.com/api/3/vms/
curl --request POST \
  --url http://example.com/api/3/vms/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/vms/' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/vms/uuid
curl --request GET \
  --url http://example.com/api/3/vms/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/vms/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/vms/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/vms/uuid
curl --request DELETE \
  --url http://example.com/api/3/vms/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/vms/uuid' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/vms/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
Suggest Edits

post

This is the same as the normal Create an VM request however it stops
before sending the request to the hypervisor. So no VM is ever created
however it does check if the VM could be created.
It needs to be noted that both false positives and false negatives
can occur so this is a good approximation but should not be taken as
a definite. False positive are more likely then false negatives.

 
postexample.com/api/3/vms/dry_run
curl --request POST \
  --url http://example.com/api/3/vms/dry_run
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/vms/dry_run' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/dry_run")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/dry_run");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/dry_run"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/state

 
putexample.com/api/3/vms/uuid/state
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/state
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/state' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/state")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/state");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/state"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/console

 
putexample.com/api/3/vms/uuid/console
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/console
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/console' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/console")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/console");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/console"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/package

 
putexample.com/api/3/vms/uuid/package
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/package
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/package' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/package")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/package");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/package"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/config

 
putexample.com/api/3/vms/uuid/config
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/config
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/config' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/config")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/config");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/config"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/owner

 
putexample.com/api/3/vms/uuid/owner
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/owner
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/owner' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/owner")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/owner");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/owner"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/nics

 
postexample.com/api/3/vms/uuid/nics
curl --request POST \
  --url http://example.com/api/3/vms/uuid/nics
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/vms/uuid/nics' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/nics")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/uuid/nics");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/nics"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/nics/{mac}

 
deleteexample.com/api/3/vms/uuid/nics/mac
curl --request DELETE \
  --url http://example.com/api/3/vms/uuid/nics/mac
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/vms/uuid/nics/mac' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/nics/mac")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/vms/uuid/nics/mac");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/nics/mac"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/hostname/{nic}

 
putexample.com/api/3/vms/uuid/hostname/nic
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/hostname/nic
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/hostname/nic' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/hostname/nic")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/hostname/nic");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/hostname/nic"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/fw_rules

 
Suggest Edits

post

Creates a firewall rule of the VM. One side is always the current VM
the other side can be defined in 'target'.
TARGET
the string "all" for all targets.
an object with the key 'ip' and the IP address in a string as value
for a single IP target.
an object with the key 'subnet' with the base address of the subnet
as string, and key 'mask' with a number indicating the relevant bits
as value for a subnet as target.
FILTERS
A list of one or more ports for UDP and TCP.
The string "all" for UDP and TCP.
a list of objects containing the key 'type' and optionally 'code',
both with numbers as values for ICMP.

 
postexample.com/api/3/vms/uuid/fw_rules
curl --request POST \
  --url http://example.com/api/3/vms/uuid/fw_rules
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/vms/uuid/fw_rules' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/fw_rules")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/uuid/fw_rules");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/fw_rules"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/fw_rules/{rule_id}

 
Suggest Edits

post

deletes a firewall rule for the VM uuid, the rule id can be found in
the 'rule_id' field of the rule

 
postexample.com/api/3/vms/uuid/fw_rules/rule_id
curl --request POST \
  --url http://example.com/api/3/vms/uuid/fw_rules/rule_id
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/vms/uuid/fw_rules/rule_id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/fw_rules/rule_id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/uuid/fw_rules/rule_id");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/fw_rules/rule_id"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/snapshots

 
postexample.com/api/3/vms/uuid/snapshots
curl --request POST \
  --url http://example.com/api/3/vms/uuid/snapshots
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/vms/uuid/snapshots' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/snapshots")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/uuid/snapshots");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/snapshots"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/snapshots/{snap-id}

 
Suggest Edits

put

This will roll back a zfs snapshot and delete all snapshots newer
then the snapshot.
Please note that ZFS snapshots do not allow keeping snapshots newer
that a rolled back snapshots so those will be deleted. Please use
backups of this is a feature you need

 
putexample.com/api/3/vms/uuid/snapshots/snap-id
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/snapshots/snap-id
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/snapshots/snap-id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/snapshots/snap-id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/snapshots/snap-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/snapshots/snap-id"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/nis/{snap-id}

 
Suggest Edits

delete

Newer snapshots will not be affected other then
their size night change.

 
deleteexample.com/api/3/vms/uuid/nis/snap-id
curl --request DELETE \
  --url http://example.com/api/3/vms/uuid/nis/snap-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/vms/uuid/nis/snap-id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/nis/snap-id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/vms/uuid/nis/snap-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/nis/snap-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/backups

 
Suggest Edits

post

Creates a ZFS snapshot and sends it to to LeoFS. Both
incremental and full backups can be created. If a incremental backup
is done the parent must be local.
In incremental backup here means that a incremental ZFS send is done
with the parent as parent.
The following files are created in LeoFS:

<vm-uuid>/<backup-uuid> - the gzip compressed ZFS snapshot

<vm-uuid>/<backup-uuid>.xml - the zone config XML file from /etc/zones/<vm-uuid>.xml

<vm-uuid>/<backup-uuid>.parent - UUID of the parent snapshot if this is a incremental backup.

 
postexample.com/api/3/vms/uuid/backups
curl --request POST \
  --url http://example.com/api/3/vms/uuid/backups
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/vms/uuid/backups' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/backups")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/uuid/backups");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/backups"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/backups/{backup-id}

 
Suggest Edits

parameters

 
Suggest Edits

get

This will check the sha1 hash of the storeed backup, to do this the
backup is internally streamed and a new sha1 is calcualated. Both
old and new values are then returned.

 
getexample.com/api/3/vms/uuid/backups/backup-id
curl --request GET \
  --url http://example.com/api/3/vms/uuid/backups/backup-id
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/vms/uuid/backups/backup-id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/backups/backup-id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/vms/uuid/backups/backup-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/backups/backup-id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

put

This restores a backup in the process the entire zfs volume might be
destroyed and re-created, all snapshots will be deleted!
If the VM is 'in limbo' so not deployed to a hypervisor right now, it
is possible to select the hypervisor it is re-deployed to.

 
putexample.com/api/3/vms/uuid/backups/backup-id
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/backups/backup-id
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/backups/backup-id' };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/backups/backup-id")

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

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

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/backups/backup-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/backups/backup-id"

response = requests.request("PUT", url)

print(response.text)