Lattice API Docs v1.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

This document describes the lattice API.

Base URLs:

• //localhost:8876/v1

Terms of service

License: Apache 2.0

Authentication

• API Key (ApiKeyAuth)
  • Parameter Name: apiKey, in: header.

builds

list-builds

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/builds \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/builds HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/builds',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/builds',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/builds',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/builds', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/builds");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/builds", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/builds

Lists builds

list builds

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "completionTimestamp": "string",
    "id": "string",
    "services": {},
    "startTimestamp": "string",
    "state": "string",
    "version": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.Build]	false	none	none
» completionTimestamp	string	false	none	Completion timestamp
» id	string	false	none	ID
» services	object	false	none	Services maps service paths (e.g. /foo/bar/buzz) to the status of the build for that service in the Build.
» startTimestamp	string	false	none	Start timestamp
» state	string	false	none	State
» version	string	false	none	Version

build-system

Code samples

# You can also use wget
curl -X POST //localhost:8876/v1/systems/{system}/builds \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST //localhost:8876/v1/systems/{system}/builds HTTP/1.1
Host: null
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/builds',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "version": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/builds',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '//localhost:8876/v1/systems/{system}/builds',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('//localhost:8876/v1/systems/{system}/builds', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/builds");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//localhost:8876/v1/systems/{system}/builds", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /systems/{system}/builds

Build system

build system

Body parameter

{
  "version": {}
}

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
body	body	rest.BuildRequest	true	Create build

Example responses

200 Response

{
  "completionTimestamp": "string",
  "id": "string",
  "services": {},
  "startTimestamp": "string",
  "state": "string",
  "version": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Build
400	Bad Request	Bad Request	v1.ErrorResponse

get-build

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/builds/{id} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/builds/{id} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/builds/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/builds/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/builds/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/builds/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/builds/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/builds/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/builds/{id}

Get build

get build

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Build ID

Example responses

200 Response

{
  "completionTimestamp": "string",
  "id": "string",
  "services": {},
  "startTimestamp": "string",
  "state": "string",
  "version": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Build
404	Not Found	Not Found	v1.ErrorResponse

get-build-logs

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/builds/{id}/logs?path=string \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/builds/{id}/logs?path=string HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/builds/{id}/logs',
  method: 'get',
  data: '?path=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/builds/{id}/logs?path=string',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/builds/{id}/logs',
  params: {
  'path' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/builds/{id}/logs', params={
  'path': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/builds/{id}/logs?path=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/builds/{id}/logs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/builds/{id}/logs

Get build logs

get logs

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Build ID
path	query	string	true	Node Path
sidecar	query	string	false	Sidecar
follow	query	string	false	Follow
previous	query	boolean	false	Previous
timestamps	query	boolean	false	Timestamps
tail	query	integer	false	tail
since	query	string	false	Since
sinceTime	query	string	false	Since Time

Example responses

200 Response

"string"

Responses

Status	Meaning	Description	Schema
200	OK	log stream	string
404	Not Found	Not Found	v1.ErrorResponse

deploys

list-deploys

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/deploys \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/deploys HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/deploys',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/deploys',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/deploys',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/deploys', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/deploys");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/deploys", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/deploys

Lists deploys

list deploys

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "buildId": "string",
    "id": "string",
    "state": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.Deploy]	false	none	none
» buildId	string	false	none	Build ID
» id	string	false	none	ID
» state	string	false	none	State

deploy-system

Code samples

# You can also use wget
curl -X POST //localhost:8876/v1/systems/{system}/deploys \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST //localhost:8876/v1/systems/{system}/deploys HTTP/1.1
Host: null
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/deploys',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "buildId": "string",
  "version": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/deploys',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '//localhost:8876/v1/systems/{system}/deploys',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('//localhost:8876/v1/systems/{system}/deploys', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/deploys");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//localhost:8876/v1/systems/{system}/deploys", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /systems/{system}/deploys

Deploy system

build system

Body parameter

{
  "buildId": "string",
  "version": {}
}

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
body	body	rest.DeployRequest	true	Create deploy

Example responses

200 Response

{
  "buildId": "string",
  "id": "string",
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Deploy
400	Bad Request	Bad Request	v1.ErrorResponse

get-deploy

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/deploys/{id} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/deploys/{id} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/deploys/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/deploys/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/deploys/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/deploys/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/deploys/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/deploys/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/deploys/{id}

Get deploy

get deploy

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Deploy ID

Example responses

200 Response

{
  "buildId": "string",
  "id": "string",
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Deploy
404	Not Found	Not Found	v1.ErrorResponse

jobs

list-jobs

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/jobs \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/jobs HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/jobs',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/jobs',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/jobs',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/jobs', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/jobs");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/jobs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/jobs

Lists jobs

list jobs

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "completionTimestamp": "string",
    "id": "string",
    "path": "string",
    "startTimestamp": "string",
    "state": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.Job]	false	none	none
» completionTimestamp	string	false	none	none
» id	string	false	none	none
» path	string	false	none	none
» startTimestamp	string	false	none	none
» state	string	false	none	none

get-job

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/jobs/{id} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/jobs/{id} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/jobs/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/jobs/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/jobs/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/jobs/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/jobs/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/jobs/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/jobs/{id}

Get job

get job

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Job ID

Example responses

200 Response

{
  "completionTimestamp": "string",
  "id": "string",
  "path": "string",
  "startTimestamp": "string",
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Job
404	Not Found	Not Found	v1.ErrorResponse

get-job-logs

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/jobs/{id}/logs \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/jobs/{id}/logs HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/jobs/{id}/logs',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/jobs/{id}/logs',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/jobs/{id}/logs',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/jobs/{id}/logs', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/jobs/{id}/logs");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/jobs/{id}/logs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/jobs/{id}/logs

Get job logs

get job logs

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Job ID
sidecar	query	string	false	Sidecar
follow	query	string	false	Follow
previous	query	boolean	false	Previous
timestamps	query	boolean	false	Timestamps
tail	query	integer	false	tail
since	query	string	false	Since
sinceTime	query	string	false	Since Time

Example responses

200 Response

"string"

Responses

Status	Meaning	Description	Schema
200	OK	log stream	string
404	Not Found	Not Found	v1.ErrorResponse

node-pools

list-node-pools

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/node-pools \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/node-pools HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/node-pools',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/node-pools',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/node-pools',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/node-pools', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/node-pools");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/node-pools", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/node-pools

Lists node pools

list node pools

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "failure_info": {
      "message": "string",
      "time": "string"
    },
    "id": "string",
    "instanceType": "string",
    "numInstances": 0,
    "path": "string",
    "state": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.NodePool]	false	none	none
» failure_info	v1.NodePoolFailureInfo	false	none	none
»» message	string	false	none	none
»» time	string	false	none	none
» id	string	false	none	none
» instanceType	string	false	none	FIXME: how to deal with epochs?
» numInstances	integer	false	none	none
» path	string	false	none	none
» state	string	false	none	none

get-node-pool

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/node-pools/{id} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/node-pools/{id} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/node-pools/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/node-pools/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/node-pools/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/node-pools/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/node-pools/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/node-pools/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/node-pools/{id}

Get node pool

get node pool

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	NodePool ID

Example responses

200 Response

{
  "failure_info": {
    "message": "string",
    "time": "string"
  },
  "id": "string",
  "instanceType": "string",
  "numInstances": 0,
  "path": "string",
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.NodePool
404	Not Found	Not Found	v1.ErrorResponse

secrets

list-secrets

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/secrets \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/secrets HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/secrets',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/secrets',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/secrets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/secrets', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/secrets");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/secrets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/secrets

Lists secrets

list secrets

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "name": "string",
    "path": "string",
    "value": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.Secret]	false	none	none
» name	string	false	none	none
» path	string	false	none	none
» value	string	false	none	none

set-secret

Code samples

# You can also use wget
curl -X POST //localhost:8876/v1/systems/{system}/secrets \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST //localhost:8876/v1/systems/{system}/secrets HTTP/1.1
Host: null
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/secrets',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "value": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/secrets',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '//localhost:8876/v1/systems/{system}/secrets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('//localhost:8876/v1/systems/{system}/secrets', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/secrets");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//localhost:8876/v1/systems/{system}/secrets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /systems/{system}/secrets

set secret

set secret

Body parameter

{
  "value": "string"
}

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
body	body	rest.SetSecretRequest	true	Create secret

Example responses

200 Response

{
  "name": "string",
  "path": "string",
  "value": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Secret
400	Bad Request	Bad Request	v1.ErrorResponse

delete-system

Code samples

# You can also use wget
curl -X DELETE //localhost:8876/v1/systems/{system}/secrets/{secret} \
  -H 'Accept: application/json'

DELETE //localhost:8876/v1/systems/{system}/secrets/{secret} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/secrets/{secret}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/secrets/{secret}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '//localhost:8876/v1/systems/{system}/secrets/{secret}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('//localhost:8876/v1/systems/{system}/secrets/{secret}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/secrets/{secret}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "//localhost:8876/v1/systems/{system}/secrets/{secret}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /systems/{system}/secrets/{secret}

Delete system

get system

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
secret	path	string	true	Secret Path

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Result
404	Not Found	Not Found	v1.ErrorResponse

get-secret

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/secrets/{secret} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/secrets/{secret} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/secrets/{secret}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/secrets/{secret}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/secrets/{secret}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/secrets/{secret}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/secrets/{secret}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/secrets/{secret}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/secrets/{secret}

Get secret

get secret

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
secret	path	string	true	Secret Path

Example responses

200 Response

{
  "name": "string",
  "path": "string",
  "value": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Secret
404	Not Found	Not Found	v1.ErrorResponse

services

list-services

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/services \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/services HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/services',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/services',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/services',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/services', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/services");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/services", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/services

Lists services

list services

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "availableInstances": 0,
    "failureInfo": {
      "message": "string",
      "time": "string"
    },
    "id": "string",
    "instances": [
      "string"
    ],
    "message": "string",
    "path": "string",
    "ports": {},
    "staleInstances": 0,
    "state": "string",
    "terminatingInstances": 0,
    "updatedInstances": 0
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.Service]	false	none	none
» availableInstances	integer	false	none	none
» failureInfo	v1.ServiceFailureInfo	false	none	none
»» message	string	false	none	none
»» time	string	false	none	none
» id	string	false	none	none
» instances	[string]	false	none	none
» message	string	false	none	none
» path	string	false	none	none
» ports	object	false	none	none
» staleInstances	integer	false	none	none
» state	string	false	none	none
» terminatingInstances	integer	false	none	none
» updatedInstances	integer	false	none	none

get-service

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/services/{id} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/services/{id} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/services/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/services/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/services/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/services/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/services/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/services/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/services/{id}

Get service

get service

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Service ID

Example responses

200 Response

{
  "availableInstances": 0,
  "failureInfo": {
    "message": "string",
    "time": "string"
  },
  "id": "string",
  "instances": [
    "string"
  ],
  "message": "string",
  "path": "string",
  "ports": {},
  "staleInstances": 0,
  "state": "string",
  "terminatingInstances": 0,
  "updatedInstances": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Service
404	Not Found	Not Found	v1.ErrorResponse

get-service-logs

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/services/{id}/logs?instance=string \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/services/{id}/logs?instance=string HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/services/{id}/logs',
  method: 'get',
  data: '?instance=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/services/{id}/logs?instance=string',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/services/{id}/logs',
  params: {
  'instance' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/services/{id}/logs', params={
  'instance': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/services/{id}/logs?instance=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/services/{id}/logs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/services/{id}/logs

Get service logs

get service logs

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Service ID
instance	query	string	true	Instance
sidecar	query	string	false	Sidecar
follow	query	string	false	Follow
previous	query	boolean	false	Previous
timestamps	query	boolean	false	Timestamps
tail	query	integer	false	tail
since	query	string	false	Since
sinceTime	query	string	false	Since Time

Example responses

200 Response

"string"

Responses

Status	Meaning	Description	Schema
200	OK	log stream	string
404	Not Found	Not Found	v1.ErrorResponse

systems

list-systems

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems

List systems

List systems

Example responses

200 Response

[
  {
    "definitionUrl": "git://github.com/foo/foo.git",
    "id": "string",
    "services": {},
    "state": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.System]	false	none	none
» definitionUrl	string	false	none	git url for for where the definition lives in
» id	string	false	none	System ID
» services	object	false	none	map for service path and services currently running in the system
» state	string	false	none	State. One of (pending, failed, deleting, stable, degraded, scaling, updating)

create-system

Code samples

# You can also use wget
curl -X POST //localhost:8876/v1/systems \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'

POST //localhost:8876/v1/systems HTTP/1.1
Host: null
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "definitionUrl": "string",
  "id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}

result = RestClient.post '//localhost:8876/v1/systems',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

r = requests.post('//localhost:8876/v1/systems', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//localhost:8876/v1/systems", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /systems

Create system

Create a new system

Body parameter

{
  "definitionUrl": "string",
  "id": "string"
}

Parameters

Parameter	In	Type	Required	Description
body	body	rest.CreateSystemRequest	true	Create system

Example responses

200 Response

{
  "definitionUrl": "git://github.com/foo/foo.git",
  "id": "string",
  "services": {},
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.System
400	Bad Request	Bad Request	v1.ErrorResponse

delete-system

Code samples

# You can also use wget
curl -X DELETE //localhost:8876/v1/systems/{system} \
  -H 'Accept: application/json'

DELETE //localhost:8876/v1/systems/{system} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.delete '//localhost:8876/v1/systems/{system}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.delete('//localhost:8876/v1/systems/{system}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "//localhost:8876/v1/systems/{system}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /systems/{system}

Delete system

Delete system

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

{}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Result
404	Not Found	Not Found	v1.ErrorResponse

get-system

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}

Get system

get system

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

{
  "definitionUrl": "git://github.com/foo/foo.git",
  "id": "string",
  "services": {},
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.System
404	Not Found	Not Found	v1.ErrorResponse

teardowns

list-teardowns

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/teardowns \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/teardowns HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/teardowns',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/teardowns',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/teardowns',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/teardowns', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/teardowns");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/teardowns", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/teardowns

Lists teardowns

list teardowns

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {
    "id": "string",
    "state": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.Teardown]	false	none	none
» id	string	false	none	ID
» state	string	false	none	State

teardown-system

Code samples

# You can also use wget
curl -X POST //localhost:8876/v1/systems/{system}/teardowns \
  -H 'Accept: application/json'

POST //localhost:8876/v1/systems/{system}/teardowns HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/teardowns',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/teardowns',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.post '//localhost:8876/v1/systems/{system}/teardowns',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.post('//localhost:8876/v1/systems/{system}/teardowns', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/teardowns");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//localhost:8876/v1/systems/{system}/teardowns", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /systems/{system}/teardowns

Teardown system

teardown system

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

{
  "id": "string",
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Teardown
400	Bad Request	Bad Request	v1.ErrorResponse
404	Not Found	Not Found	v1.ErrorResponse

get-teardown

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/teardowns/{id} \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/teardowns/{id} HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/teardowns/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/teardowns/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/teardowns/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/teardowns/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/teardowns/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/teardowns/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/teardowns/{id}

Get teardown

get teardown

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID
id	path	string	true	Teardown ID

Example responses

200 Response

{
  "id": "string",
  "state": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	v1.Teardown
404	Not Found	Not Found	v1.ErrorResponse

versions

list-system-versions

Code samples

# You can also use wget
curl -X GET //localhost:8876/v1/systems/{system}/versions \
  -H 'Accept: application/json'

GET //localhost:8876/v1/systems/{system}/versions HTTP/1.1
Host: null

Accept: application/json

var headers = {
  'Accept':'application/json'

};

$.ajax({
  url: '//localhost:8876/v1/systems/{system}/versions',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'application/json'

};

fetch('//localhost:8876/v1/systems/{system}/versions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get '//localhost:8876/v1/systems/{system}/versions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('//localhost:8876/v1/systems/{system}/versions', params={

}, headers = headers)

print r.json()

URL obj = new URL("//localhost:8876/v1/systems/{system}/versions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//localhost:8876/v1/systems/{system}/versions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /systems/{system}/versions

Lists system versions

list teardowns

Parameters

Parameter	In	Type	Required	Description
system	path	string	true	System ID

Example responses

200 Response

[
  {}
]

Responses

Status	Meaning	Description	Schema
200	OK	OK	Inline

Response Schema

Status Code 200

Name	Type	Required	Restrictions	Description
anonymous	[v1.SystemVersion]	false	none	none

Schemas

rest.BuildRequest

{
  "version": {}
}

Properties

Name	Type	Required	Restrictions	Description
version	v1.SystemVersion	false	none	none

rest.CreateSystemRequest

{
  "definitionUrl": "string",
  "id": "string"
}

Properties

Name	Type	Required	Restrictions	Description
definitionUrl	string	false	none	none
id	string	false	none	none

rest.DeployRequest

{
  "buildId": "string",
  "version": {}
}

Properties

Name	Type	Required	Restrictions	Description
buildId	string	false	none	none
version	v1.SystemVersion	false	none	none

rest.RunJobRequest

{
  "command": [
    "string"
  ],
  "environment": "string",
  "path": "string"
}

Properties

Name	Type	Required	Restrictions	Description
command	[string]	false	none	none
environment	string	false	none	none
path	string	false	none	none

rest.SetSecretRequest

{
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
value	string	false	none	none

v1.Build

{
  "completionTimestamp": "string",
  "id": "string",
  "services": {},
  "startTimestamp": "string",
  "state": "string",
  "version": "string"
}

Properties

Name	Type	Required	Restrictions	Description
completionTimestamp	string	false	none	Completion timestamp
id	string	false	none	ID
services	object	false	none	Services maps service paths (e.g. /foo/bar/buzz) to the status of the build for that service in the Build.
startTimestamp	string	false	none	Start timestamp
state	string	false	none	State
version	string	false	none	Version

v1.Deploy

{
  "buildId": "string",
  "id": "string",
  "state": "string"
}

Properties

Name	Type	Required	Restrictions	Description
buildId	string	false	none	Build ID
id	string	false	none	ID
state	string	false	none	State

v1.ErrorResponse

{
  "code": "string",
  "message": "status bad request"
}

Properties

Name	Type	Required	Restrictions	Description
code	string	false	none	none
message	string	false	none	none

v1.Job

{
  "completionTimestamp": "string",
  "id": "string",
  "path": "string",
  "startTimestamp": "string",
  "state": "string"
}

Properties

Name	Type	Required	Restrictions	Description
completionTimestamp	string	false	none	none
id	string	false	none	none
path	string	false	none	none
startTimestamp	string	false	none	none
state	string	false	none	none

v1.NodePool

{
  "failure_info": {
    "message": "string",
    "time": "string"
  },
  "id": "string",
  "instanceType": "string",
  "numInstances": 0,
  "path": "string",
  "state": "string"
}

Properties

Name	Type	Required	Restrictions	Description
failure_info	v1.NodePoolFailureInfo	false	none	none
id	string	false	none	none
instanceType	string	false	none	FIXME: how to deal with epochs?
numInstances	integer	false	none	none
path	string	false	none	none
state	string	false	none	none

v1.NodePoolFailureInfo

{
  "message": "string",
  "time": "string"
}

Properties

Name	Type	Required	Restrictions	Description
message	string	false	none	none
time	string	false	none	none

v1.Result

{}

Properties

None

v1.Secret

{
  "name": "string",
  "path": "string",
  "value": "string"
}

Properties

Name	Type	Required	Restrictions	Description
name	string	false	none	none
path	string	false	none	none
value	string	false	none	none

v1.Service

{
  "availableInstances": 0,
  "failureInfo": {
    "message": "string",
    "time": "string"
  },
  "id": "string",
  "instances": [
    "string"
  ],
  "message": "string",
  "path": "string",
  "ports": {},
  "staleInstances": 0,
  "state": "string",
  "terminatingInstances": 0,
  "updatedInstances": 0
}

Properties

Name	Type	Required	Restrictions	Description
availableInstances	integer	false	none	none
failureInfo	v1.ServiceFailureInfo	false	none	none
id	string	false	none	none
instances	[string]	false	none	none
message	string	false	none	none
path	string	false	none	none
ports	object	false	none	none
staleInstances	integer	false	none	none
state	string	false	none	none
terminatingInstances	integer	false	none	none
updatedInstances	integer	false	none	none

v1.ServiceFailureInfo

{
  "message": "string",
  "time": "string"
}

Properties

Name	Type	Required	Restrictions	Description
message	string	false	none	none
time	string	false	none	none

v1.System

{
  "definitionUrl": "git://github.com/foo/foo.git",
  "id": "string",
  "services": {},
  "state": "string"
}

Properties

Name	Type	Required	Restrictions	Description
definitionUrl	string	false	none	git url for for where the definition lives in
id	string	false	none	System ID
services	object	false	none	map for service path and services currently running in the system
state	string	false	none	State. One of (pending, failed, deleting, stable, degraded, scaling, updating)

v1.SystemVersion

{}

Properties

None

v1.Teardown

{
  "id": "string",
  "state": "string"
}

Properties

Name	Type	Required	Restrictions	Description
id	string	false	none	ID
state	string	false	none	State