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

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to get

 
Suggest Edits

/{uuid}/elements/{other}

 
put /uuid/elements/other
curl --request PUT \
  --url http://undefined/api/3/groupings/uuid/elements/other
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid/elements/other",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid/elements/other"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to modify

other
string
required

uuid of the grouping to add

 
delete /uuid/elements/other
curl --request DELETE \
  --url http://undefined/api/3/groupings/uuid/elements/other
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid/elements/other",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid/elements/other"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to modify

other
string
required

uuid of the grouping to add

 
Suggest Edits

/{uuid}/config/{path}

 
put /uuid/config/path
curl --request PUT \
  --url http://undefined/api/3/groupings/uuid/config/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid/config/path",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid/config/path"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to modify

path
string
required

path of the configuration key

 
delete /uuid/config/path
curl --request DELETE \
  --url http://undefined/api/3/groupings/uuid/config/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid/config/path",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid/config/path"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to modify

path
string
required

path of the configuration key

 
Suggest Edits

/{uuid}/metadata/{path}

 
put /uuid/metadata/path
curl --request PUT \
  --url http://undefined/api/3/groupings/uuid/metadata/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid/metadata/path",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid/metadata/path"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to modify

path
string
required

path of the metadata key

 
delete /uuid/metadata/path
curl --request DELETE \
  --url http://undefined/api/3/groupings/uuid/metadata/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/groupings/uuid/metadata/path",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/groupings/uuid/metadata/path"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the grouping to modify

path
string
required

path of the metadata key

 
Suggest Edits

get

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
post /
curl --request POST \
  --url http://undefined/api/3/datasets/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

url
string

url of the manifest to import

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the datasets

 
delete /uuid
curl --request DELETE \
  --url http://undefined/api/3/datasets/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the datasets

 
Suggest Edits

put

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

 
put /uuid
curl --request PUT \
  --url http://undefined/api/3/datasets/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the dataset to import

 
Suggest Edits

/{uuid}/dataset.gz

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

var options = { method: 'GET',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid/dataset.gz",
  "method": "GET",
  "headers": {}
}

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

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

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the datasets

 
Suggest Edits

put

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

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

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid/dataset.gz",
  "method": "PUT",
  "headers": {}
}

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

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

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the dataset to import

 
Suggest Edits

/{uuid}/networks/{nic}

 
put /uuid/networks/nic
curl --request PUT \
  --url http://undefined/api/3/datasets/uuid/networks/nic
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid/networks/nic",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/uuid/networks/nic"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the dataset to import

nic
string
required

name of the nic to add (i.e. 'net1')

Body Params

description
string

description of the interface

 
delete /uuid/networks/nic
curl --request DELETE \
  --url http://undefined/api/3/datasets/uuid/networks/nic
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/datasets/uuid/networks/nic",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/datasets/uuid/networks/nic"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the dataset to import

nic
string
required

name of the nic to add (i.e. 'net1')

 
Suggest Edits

get

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
post /
curl --request POST \
  --url http://undefined/api/3/clients/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

client
string

the ClientID

secre
string

the secret for the client

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the client

 
put /uuid
curl --request PUT \
  --url http://undefined/api/3/clients/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

Body Params

secret
string

New secret for the client

 
delete /uuid
curl --request DELETE \
  --url http://undefined/api/3/clients/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

 
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!

 
get /uuid/permissions/permission
curl --request GET \
  --url http://undefined/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'GET',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid/permissions/permission",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid/permissions/permission"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

permission
string
required

the permission to test as path i.e. 'some/funky/permission'

 
put /uuid/permissions/permission
curl --request PUT \
  --url http://undefined/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid/permissions/permission",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid/permissions/permission"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

permission
string
required

the permission to test as path i.e. 'some/funky/permission'

 
delete /uuid/permissions/permission
curl --request DELETE \
  --url http://undefined/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid/permissions/permission",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid/permissions/permission"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

permission
string
required

the permission to test as path i.e. 'some/funky/permission'

 
Suggest Edits

/{uuid}/uris

 
post /uuid/uris
curl --request POST \
  --url http://undefined/api/3/clients/uuid/uris
var request = require("request");

var options = { method: 'POST',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid/uris",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid/uris"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

Body Params

uri
string

the URI to add

 
Suggest Edits

/{uuid}/uris/{id}

 
delete /uuid/uris/id
curl --request DELETE \
  --url http://undefined/api/3/clients/uuid/uris/id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/clients/uuid/uris/id",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/clients/uuid/uris/id"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the client

id
integer
required

id of the URI to delete

 
Suggest Edits

get

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

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

var options = { method: 'GET',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the hypervisor

 
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.

 
delete /uuid
curl --request DELETE \
  --url http://undefined/api/3/hypervisors/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the hypervisor

 
Suggest Edits

/{uuid}/characteristics/{path}

 
Suggest Edits

put

this can be later used on rules to match against.

 
put /uuid/characteristics/path
curl --request PUT \
  --url http://undefined/api/3/hypervisors/uuid/characteristics/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/uuid/characteristics/path",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/uuid/characteristics/path"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the hypervisor

path
string
required

url path prefix of the characteristic

 
delete /uuid/characteristics/path
curl --request DELETE \
  --url http://undefined/api/3/hypervisors/uuid/characteristics/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/uuid/characteristics/path",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/uuid/characteristics/path"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the hypervisor

path
string
required

url path to characteristic to delete

 
Suggest Edits

/{uuid}/config

 
put /uuid/config
curl --request PUT \
  --url http://undefined/api/3/hypervisors/uuid/config
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/uuid/config",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/uuid/config"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the hypervisor

Body Params

alias
string

new alias of the hypervisor

 
Suggest Edits

/{uuid}/metrics

 
get /uuid/metrics
curl --request GET \
  --url http://undefined/api/3/hypervisors/uuid/metrics
var request = require("request");

var options = { method: 'GET',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/hypervisors/uuid/metrics",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/hypervisors/uuid/metrics"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the hypervisor

 
Suggest Edits

get

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/ipranges/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/ipranges/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
post/
curl --request POST \
  --url http://undefined/api/3/ipranges/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/ipranges/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/ipranges/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

name
string

name of the ip range

tag
string

NIC Tag for the IP Range to use

subnet
string

The network address of the subnet

netmask
string

The netmask of the subnet

gateway
string

The gateway of the subnet

first
string

First address to hand out (must be part of subnet!)

last
string

Last address to hand out (must be part of subnet!)

vlan
integer

VLan to tag the nics with

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/ipranges/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/ipranges/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the ip range

 
put/uuid
curl --request PUT \
  --url http://undefined/api/3/ipranges/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/ipranges/uuid",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/ipranges/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the ip range

 
Suggest Edits

/{uuid}/{ip}

 
put/uuid/ip
curl --request PUT \
  --url http://undefined/api/3/ipranges/uuid/ip
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/ipranges/uuid/ip",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/ipranges/uuid/ip"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the ip range

ip
string
required

IP Address to release

 
Suggest Edits

get

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/networks/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/networks/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
post/
curl --request POST \
  --url http://undefined/api/3/networks/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/networks/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/networks/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

name
string

name of the network

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/networks/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/networks/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the network

 
delete/uuid
curl --request DELETE \
  --url http://undefined/api/3/networks/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/networks/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/networks/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the network

 
Suggest Edits

/{uuid}/iprange/{iprange}

 
put/uuid/iprange/iprange
curl --request PUT \
  --url http://undefined/api/3/networks/uuid/iprange/iprange
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/networks/uuid/iprange/iprange",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/networks/uuid/iprange/iprange"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the user to delete

iprange
string
required

uuid of the iprange to add

 
delete/uuid/iprange/iprange
curl --request DELETE \
  --url http://undefined/api/3/networks/uuid/iprange/iprange
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/networks/uuid/iprange/iprange",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/networks/uuid/iprange/iprange"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the user to delete

iprange
string
required

uuid of the iprange to add

 
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://undefined/api/3/oauth2/auth?response_type=response_type&client_id=client_id&redirect_uri=redirect_uri'
var request = require("request");

var options = { method: 'GET',
  url: 'http://undefined/api/3/oauth2/auth',
  qs: 
   { response_type: 'response_type',
     client_id: 'client_id',
     redirect_uri: 'redirect_uri' } };

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

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

url = URI("http://undefined/api/3/oauth2/auth?response_type=response_type&client_id=client_id&redirect_uri=redirect_uri")

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

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

response = http.request(request)
puts response.read_body
var settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/oauth2/auth?response_type=response_type&client_id=client_id&redirect_uri=redirect_uri",
  "method": "GET",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/oauth2/auth"

querystring = {"response_type":"response_type","client_id":"client_id","redirect_uri":"redirect_uri"}

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

response_type
string
required
client_id
string
required

ID of the client

redirect_uri
string
required

The URI redirected to at the end of the OAuth2 dance

state
string

client state that gets passed back to the redirect uri

scope
string

list of scopes to claim

 
post/auth
curl --request POST \
  --url http://undefined/api/3/oauth2/auth
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/oauth2/auth",
  "method": "POST",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/oauth2/auth"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

response_type
string
client_id
string

ID of the client

redirect_uri
string

The URI redirected to at the end of the OAuth2 dance

scope
array of strings

list of scopes to claim

state
string

client state that gets passed back to the redirect uri

username
string

the username

password
string

the password

 
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.

 
post/token
curl --request POST \
  --url http://undefined/api/3/oauth2/token
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/oauth2/token",
  "method": "POST",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/oauth2/token"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

grant_type
string
 
Suggest Edits

get

See Get Package for the fields available for full-list-fields.

 
get/
curl --request GET \
  --url http://undefined/api/3/packages/
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/packages/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/packages/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
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.

 
post/
curl --request POST \
  --url http://undefined/api/3/packages/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/packages/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/packages/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

name
string

Name of the package

quota
integer

'GB' of quota to give the package, for KVM this applies as
secondary disk

ram
integer

MB of memory for the

cpu_cap
integer

% of CPU cores to give the zone

cpu_shares
string

Shares of CPU time when two zones compete. (Defaults to
% of memory)

zfs_io_priority
integer

ZFS Priority if zones are competing. (Defaults to % of
memory)

blicksize
integer

Block size for KVM

compression
string

Compression used for the ZFS volume

requirements
array of s

A list of rules to create

org_resources
object

A mapping between resource name and claim

 
 
 
get/uuid
curl --request GET \
  --url http://undefined/api/3/packages/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/packages/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/packages/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the package

 
delete/uuid
curl --request DELETE \
  --url http://undefined/api/3/packages/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/packages/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/packages/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the package

 
Suggest Edits

get

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

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
post/
curl --request POST \
  --url http://undefined/api/3/orgs/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

name
string

the name of the organization

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the org

 
delete/uuid
curl --request DELETE \
  --url http://undefined/api/3/orgs/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the org

 
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.

 
get/uuid/accounting
curl --request GET \
  --url 'http://undefined/api/3/orgs/uuid/accounting?start=start&end=end'
var request = require("request");

var options = { method: 'GET',
  url: 'http://undefined/api/3/orgs/uuid/accounting',
  qs: { start: 'start', end: 'end' } };

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

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

url = URI("http://undefined/api/3/orgs/uuid/accounting?start=start&end=end")

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

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

response = http.request(request)
puts response.read_body
var settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/accounting?start=start&end=end",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/accounting"

querystring = {"start":"start","end":"end"}

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the organization

Query Params

start
integer
required

Timestamp of the start of the accounting period

end
integer
required

Timestamp of the end of the accounting period

 
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

 
put/uuid/triggers/user_create
curl --request PUT \
  --url http://undefined/api/3/orgs/uuid/triggers/user_create
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/triggers/user_create",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/triggers/user_create"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the organization

Body Params

action
string

Action to be performed, one of 'join_role', 'join_org',
'role_grant' and 'user_grant'

target
string

For 'join_' actions the role or org to be joined, for
'
_grant' the role or user the permission to be granted to

base
string

For '*_grant' triggers, the base of the permissions to
be granted

permission
array of strings

The rest of the permission to be granted

 
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

 
post/uuid/triggers/dataset_create
curl --request POST \
  --url http://undefined/api/3/orgs/uuid/triggers/dataset_create
var request = require("request");

var options = { method: 'POST',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/triggers/dataset_create",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/triggers/dataset_create"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the organization

Body Params

action
string

Action to be performed, one of 'join_role', 'join_org',
'role_grant' and 'user_grant'

target
string

For 'join_' actions the role or org to be joined, for
'
_grant' the role or user the permission to be granted to

base
string

For '*_grant' triggers, the base of the permissions to
be granted

permission
array of strings

The rest of the permission to be granted

 
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

 
put/uuid/triggers/vm_create
curl --request PUT \
  --url http://undefined/api/3/orgs/uuid/triggers/vm_create
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/triggers/vm_create",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/triggers/vm_create"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the organization

Body Params

action
string

Action to be performed, one of 'join_role', 'join_org',
'role_grant' and 'user_grant'

target
string

For 'join_' actions the role or org to be joined, for
'
_grant' the role or user the permission to be granted to

base
string

For '*_grant' triggers, the base of the permissions to
be granted

permission
array of strings

The rest of the permission to be granted

 
Suggest Edits

/{uuid}/triggers/{trigger-id}

 
delete/uuid/triggers/trigger-id
curl --request DELETE \
  --url http://undefined/api/3/orgs/uuid/triggers/trigger-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/triggers/trigger-id",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/triggers/trigger-id"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the org

trigger-id
integer
required

trigger to be deleted

 
Suggest Edits

/{uuid}/resources/{resource}

 
Suggest Edits

put

Increases or decreases resources for an org.

 
put/uuid/resources/resource
curl --request PUT \
  --url http://undefined/api/3/orgs/uuid/resources/resource
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/resources/resource",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/resources/resource"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the org

resource
string
required

Name of the resoruces

Body Params

dec
integer

Amount on how much to decrease the given resourcs

inc
integer

Amount on how much to increase the given resourcs

 
Suggest Edits

/{uuid}/docker/networks/{scope}

 
put/uuid/docker/networks/scope
curl --request PUT \
  --url http://undefined/api/3/orgs/uuid/docker/networks/scope
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/orgs/uuid/docker/networks/scope",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/orgs/uuid/docker/networks/scope"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the org

scope
string
required

Network type, either 'public' or 'private'

Body Params

network
string

The UUID of the network to add

 
get/
curl --request GET \
  --url http://undefined/api/3/scopes/
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/scopes/",
  "method": "GET",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/scopes/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
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://undefined/api/3/roles/
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/roles/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/roles/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
post/
curl --request POST \
  --url http://undefined/api/3/roles/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/roles/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/roles/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

name
string

Name of the role

secret
array of strings

the secret for the client

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

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/roles/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/roles/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the role

 
delete/uuid
curl --request DELETE \
  --url http://undefined/api/3/roles/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/roles/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/roles/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the role

 
Suggest Edits

/{uuid}/permissions/{permission}

 
put/uuid/permissions/permission
curl --request PUT \
  --url http://undefined/api/3/roles/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/roles/uuid/permissions/permission",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/roles/uuid/permissions/permission"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the role

permission
string
required

the permission to grant as path i.e. 'some/funky/permission'

 
delete/uuid/permissions/permission
curl --request DELETE \
  --url http://undefined/api/3/roles/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/roles/uuid/permissions/permission",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/roles/uuid/permissions/permission"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

UUID of the role

permission
string
required

the permission to revoke as path i.e. 'some/funky/permission'

 
delete/
curl --request DELETE \
  --url http://undefined/api/3/sessions/
var request = require("request");

var options = { method: 'DELETE', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/sessions/",
  "method": "DELETE",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/sessions/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results
 
 
Suggest Edits

retrieves information about the current session

 
get/
curl --request GET \
  --url http://undefined/api/3/sessions/
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/sessions/",
  "method": "GET",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/sessions/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
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.

 
get/one_time_token
curl --request GET \
  --url http://undefined/api/3/sessions/one_time_token
var request = require("request");

var options = { method: 'GET',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/sessions/one_time_token",
  "method": "GET",
  "headers": {},
  "processData": false
}

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

url = "http://undefined/api/3/sessions/one_time_token"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
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://undefined/api/3/vms/
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Query Params

full-list
boolean

Enables or disables the return ov objects rather then uuids

full-list-fields
array of strings

Fields to be returnd when full-list is enabled

 
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!).

 
post/
curl --request POST \
  --url http://undefined/api/3/vms/
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

package
string

uuid of the package to use for the vm

dataset
string

uuid of the dataset to use for the vm

config
object

object with additional

 
config.hostname
string
config.alias
string
config.requirements
array of s

Additional requirements

config.routes
object

List of routs, each rout is a object of the with 1 element
the network as a key the router as the value.

 
config.resolvers
array of strings

List of resolvers

config.delegate_dataset
boolean

Enable a delegated dataset

config.grouping
string

Cluster this VM is going to be placed in

config.hostnames
object

A object mapping nic (i.e. net0) to a hostname

 
config.metadata
object

Metadata to attatch, needs to be flat

 
config.networks
object

A object mapping nic (i.e. net0) to a netowrk uuids

 
 
 
get/uuid
curl --request GET \
  --url http://undefined/api/3/vms/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid",
  "method": "GET",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

 
delete/uuid
curl --request DELETE \
  --url http://undefined/api/3/vms/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

 
 
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.

 
post/dry_run
curl --request POST \
  --url http://undefined/api/3/vms/dry_run
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/dry_run",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/dry_run"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Body Params

package
string

uuid of the package to use for the vm

dataset
string

uuid of the dataset to use for the vm

config
object

object with aditional

 
 
Suggest Edits

/{uuid}/state

 
put/uuid/state
curl --request PUT \
  --url http://undefined/api/3/vms/uuid/state
var request = require("request");

var options = { method: 'PUT', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/state",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/state"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

Body Params

action
string

One of 'start', 'stop' or 'reboot'.

force
boolean

Used for 'stop' and 'reboot' determines if the shutdown
should be graceful or forced

 
Suggest Edits

/{uuid}/console

 
put/uuid/console
curl --request PUT \
  --url http://undefined/api/3/vms/uuid/console
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/console",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/console"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

Body Params

command
string

The command to execute

args
array of strings

An array of arguments to pass to the command

 
Suggest Edits

/{uuid}/package

 
put/uuid/package
curl --request PUT \
  --url http://undefined/api/3/vms/uuid/package
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/package",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/package"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

Body Params

action
string

One of 'start', 'stop' or 'reboot'

 
Suggest Edits

/{uuid}/config

 
put/uuid/config
curl --request PUT \
  --url http://undefined/api/3/vms/uuid/config
var request = require("request");

var options = { method: 'PUT', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/config",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/config"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

Body Params

hostname
string

the hostname of the vm

alias
string

the vm’s alias

resolvers
array of strings

list of VM’s resolvers

autoboot
boolean

whether the vm boots automatically or not

 
Suggest Edits

/{uuid}/owner

 
put/uuid/owner
curl --request PUT \
  --url http://undefined/api/3/vms/uuid/owner
var request = require("request");

var options = { method: 'PUT', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/owner",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/owner"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

Body Params

org
string

new owner

 
Suggest Edits

/{uuid}/nics

 
post/uuid/nics
curl --request POST \
  --url http://undefined/api/3/vms/uuid/nics
var request = require("request");

var options = { method: 'POST', url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/nics",
  "method": "POST",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/nics"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

Body Params

network
string
 
Suggest Edits

/{uuid}/nics/{mac}

 
delete/uuid/nics/mac
curl --request DELETE \
  --url http://undefined/api/3/vms/uuid/nics/mac
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/nics/mac",
  "method": "DELETE",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/nics/mac"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

mac
string
required

mac address of the nic to remove

 
Suggest Edits

/{uuid}/hostname/{nic}

 
put/uuid/hostname/nic
curl --request PUT \
  --url http://undefined/api/3/vms/uuid/hostname/nic
var request = require("request");

var options = { method: 'PUT',
  url: 'http://undefined/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://undefined/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 settings = {
  "async": true,
  "crossDomain": true,
  "url": "http://undefined/api/3/vms/uuid/hostname/nic",
  "method": "PUT",
  "headers": {}
}

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

url = "http://undefined/api/3/vms/uuid/hostname/nic"

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

print(response.text)
Status: {{ results.statusCode[0] }}
{{ results.method }}
{{ results.url }}
{{ results.requestHeaders }}
{{ results.data }}
{{ results.responseHeaders }}
Try the API to see results

Path Params

uuid
string
required

uuid of the vm

nic
string
required

name of the nic for wich the hostname shoulld be set

Body Params

hostname
string
 
Suggest Edits

/{uuid}/fw_rules