Skip to content

Interface

This document holds the interface specification.

vintner assets clean

cleans all assets

1
vintner assets clean 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/assets/clean

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/clean")

1
2
import requests
requests.post(SERVER_ADDRESS + "/assets/clean")

1
2
import khttp.post
post(SERVER_ADDRESS + "/assets/clean")

vintner assets content

shows content of an asset

1
vintner assets content --name ${NAME}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"name": "${NAME}"}' \
        ${SERVER_ADDRESS}/assets/content

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/content", {
    name: NAME
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/assets/content", json={
    "name": NAME
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/assets/content", json=mapOf(
    "name" to NAME
))
Option Mandatory Type Description
name true string name

vintner assets delete

deletes an asset

1
vintner assets delete --name ${NAME}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"name": "${NAME}"}' \
        ${SERVER_ADDRESS}/assets/delete

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/delete", {
    name: NAME
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/assets/delete", json={
    "name": NAME
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/assets/delete", json=mapOf(
    "name" to NAME
))
Option Mandatory Type Description
name true string name

vintner assets import

imports an asset

1
vintner assets import --name ${NAME} --file ${FILE} --content ${CONTENT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"name": "${NAME}", "file": "${FILE}", "content": "${CONTENT}"}' \
        ${SERVER_ADDRESS}/assets/import

1
2
3
4
5
6
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/import", {
    name: NAME,
    file: FILE,
    content: CONTENT
})

1
2
3
4
5
6
import requests
requests.post(SERVER_ADDRESS + "/assets/import", json={
    "name": NAME,
    "file": FILE,
    "content": CONTENT
})

1
2
3
4
5
6
import khttp.post
post(SERVER_ADDRESS + "/assets/import", json=mapOf(
    "name" to NAME,
    "file" to FILE,
    "content" to CONTENT
))
Option Mandatory Type Description
name true string name (must match /^[a-z-]+$/)
file true string path to a file
content true string content to import

vintner assets list

lists all assets

1
vintner assets list 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/assets/list

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/list")

1
2
import requests
requests.post(SERVER_ADDRESS + "/assets/list")

1
2
import khttp.post
post(SERVER_ADDRESS + "/assets/list")

vintner info about

general information

1
vintner info about 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/about

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/about")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/about")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/about")

vintner info author

open author

1
vintner info author 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/author

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/author")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/author")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/author")

vintner info contact

contact us

1
vintner info contact 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/contact

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/contact")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/contact")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/contact")

vintner info dependencies

dependencies used to implement vintner

1
vintner info dependencies 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/dependencies

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/dependencies")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/dependencies")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/dependencies")

vintner info docs

open documentation

1
vintner info docs 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/docs

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/docs")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/docs")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/docs")

vintner info license

license of vintner

1
vintner info license 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/license

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/license")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/license")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/license")

vintner info repo

open repository

1
vintner info repo 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/repo

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/repo")

1
2
import requests
requests.post(SERVER_ADDRESS + "/info/repo")

1
2
import khttp.post
post(SERVER_ADDRESS + "/info/repo")

vintner install ansible

installs Ansible

1
vintner install ansible 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/ansible

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/ansible")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/ansible")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/ansible")

vintner install docker

installs Docker

1
vintner install docker 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/docker

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/docker")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/docker")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/docker")

vintner install gcloud

installs GCloud

1
vintner install gcloud 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/gcloud

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/gcloud")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/gcloud")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/gcloud")

vintner install platformio

installs PlatformIO Core CLI

1
vintner install platformio 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/platformio

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/platformio")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/platformio")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/platformio")

vintner install python

installs Python

1
vintner install python 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/python

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/python")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/python")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/python")

vintner install terraform

installs Terraform

1
vintner install terraform 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/terraform

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/terraform")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/terraform")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/terraform")

vintner install unfurl

installs Unfurl in a venv in "~/unfurl"

1
vintner install unfurl 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/unfurl

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/unfurl")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/unfurl")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/unfurl")

vintner install utils

installs utils, such as sudo, unzip, git ...

1
vintner install utils 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/utils

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/utils")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/utils")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/utils")

vintner install xopera

installs xOpera in a venv in "~/opera"

1
vintner install xopera 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/xopera

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/xopera")

1
2
import requests
requests.post(SERVER_ADDRESS + "/install/xopera")

1
2
import khttp.post
post(SERVER_ADDRESS + "/install/xopera")

vintner instances adapt

submit sensor data used for adapting the instance

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}", "inputs": "${INPUTS}"}' \
        ${SERVER_ADDRESS}/instances/adapt

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/adapt", {
    instance: INSTANCE,
    inputs: INPUTS
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/instances/adapt", json={
    "instance": INSTANCE,
    "inputs": INPUTS
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/instances/adapt", json=mapOf(
    "instance" to INSTANCE,
    "inputs" to INPUTS
))
Option Mandatory Type Description
instance true string instance name
inputs true InputAssignmentMap sensor data

vintner instances clean

deletes all instances

1
vintner instances clean 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/instances/clean

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/clean")

1
2
import requests
requests.post(SERVER_ADDRESS + "/instances/clean")

1
2
import khttp.post
post(SERVER_ADDRESS + "/instances/clean")

vintner instances code

opens the instance directory in visual studio code

1
vintner instances code --instance ${INSTANCE}
Option Mandatory Type Description
instance true string instance name

vintner instances continue

continue instance (deployment)

1
vintner instances continue --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/continue

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/continue", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/continue", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/continue", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
verbose false boolean verbose
no-verbose false boolean
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances debug

debug utility that passes a command into the orchestrator in scope of the instance

1
vintner instances debug --instance ${INSTANCE} --command ${COMMAND}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}", "command": "${COMMAND}"}' \
        ${SERVER_ADDRESS}/instances/debug

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/debug", {
    instance: INSTANCE,
    command: COMMAND
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/instances/debug", json={
    "instance": INSTANCE,
    "command": COMMAND
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/instances/debug", json=mapOf(
    "instance" to INSTANCE,
    "command" to COMMAND
))
Option Mandatory Type Description
instance true string instance name
command true string command
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances delete

deletes instance

1
vintner instances delete --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/delete

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/delete", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/delete", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/delete", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances deploy

deploys instance

1
vintner instances deploy --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/deploy

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/deploy", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/deploy", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/deploy", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
inputs false string path to the deployment inputs (env: OPENTOSCA_VINTNER_DEPLOYMENT_INPUT_${KEY})
retries false boolean number of retries (default: "1")
verbose false boolean verbose
no-verbose false boolean
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances info

display instance info

1
vintner instances info --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/info

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/info", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/info", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/info", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances init

initializes a new instance

1
vintner instances init --instance ${INSTANCE} --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}", "template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/instances/init

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/init", {
    instance: INSTANCE,
    template: TEMPLATE
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/instances/init", json={
    "instance": INSTANCE,
    "template": TEMPLATE
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/instances/init", json=mapOf(
    "instance" to INSTANCE,
    "template" to TEMPLATE
))
Option Mandatory Type Description
instance true string instance name (must match /^[a-z-]+$/)
template true string template name
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances inspect

inspects variability-resolved service template

1
vintner instances inspect --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/inspect

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/inspect", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/inspect", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/inspect", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances list

lists all instances

1
vintner instances list 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/instances/list

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/list")

1
2
import requests
requests.post(SERVER_ADDRESS + "/instances/list")

1
2
import khttp.post
post(SERVER_ADDRESS + "/instances/list")

vintner instances open

opens template directory in a file browser

1
vintner instances open --instance ${INSTANCE}
Option Mandatory Type Description
instance true string instance name

vintner instances outputs

returns instance outputs

1
vintner instances outputs --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/outputs

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/outputs", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/outputs", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/outputs", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
verbose false boolean verbose
no-verbose false boolean
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances path

returns the path to the instance directory

1
vintner instances path --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/path

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/path", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/path", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/path", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name

vintner instances resolve

resolves variability

1
vintner instances resolve --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/resolve

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/resolve", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/resolve", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/resolve", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
presets false string... names of variability presets(env: OPENTOSCA_VINTNER_VARIABILITY_PRESETS) (default: [])
inputs false string path to the variability inputs (supported: [YAML, FeatureIDE ExtendedXML], env: OPENTOSCA_VINTNER_VARIABILITY_INPUT_${KEY})
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances state

set the state of the instance

1
vintner instances state --instance ${INSTANCE} --state ${STATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}", "state": "${STATE}"}' \
        ${SERVER_ADDRESS}/instances/state

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/state", {
    instance: INSTANCE,
    state: STATE
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/instances/state", json={
    "instance": INSTANCE,
    "state": STATE
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/instances/state", json=mapOf(
    "instance" to INSTANCE,
    "state" to STATE
))
Option Mandatory Type Description
instance true string instance name
state true string state
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean

vintner instances swap

swap instance template

1
vintner instances swap --instance ${INSTANCE} --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}", "template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/instances/swap

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/swap", {
    instance: INSTANCE,
    template: TEMPLATE
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/instances/swap", json={
    "instance": INSTANCE,
    "template": TEMPLATE
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/instances/swap", json=mapOf(
    "instance" to INSTANCE,
    "template" to TEMPLATE
))
Option Mandatory Type Description
instance true string instance name
template true string template name
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances unadapt

stop adaptation loop of instance

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/unadapt

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/unadapt", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/unadapt", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/unadapt", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name

vintner instances undeploy

undeploys instance

1
vintner instances undeploy --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/undeploy

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/undeploy", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/undeploy", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/undeploy", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
verbose false boolean verbose
no-verbose false boolean
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances update

update instance

1
vintner instances update --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/update

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/update", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/update", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/update", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
inputs false string path to the deployment inputs (env: OPENTOSCA_VINTNER_DEPLOYMENT_INPUT_${KEY})
verbose false boolean verbose
no-verbose false boolean
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner instances validate

validates variability-resolved service template

1
vintner instances validate --instance ${INSTANCE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"instance": "${INSTANCE}"}' \
        ${SERVER_ADDRESS}/instances/validate

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/validate", {
    instance: INSTANCE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/instances/validate", json={
    "instance": INSTANCE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/instances/validate", json=mapOf(
    "instance" to INSTANCE
))
Option Mandatory Type Description
instance true string instance name
inputs false string path to the deployment inputs
verbose false boolean verbose
no-verbose false boolean
dry false boolean dry run
no-dry false boolean
force false boolean force (default: false)
no-force false boolean
lock false boolean enable instance locking (default: true)
no-lock false boolean
machine false boolean enable state machine (default: true)
no-machine false boolean

vintner orchestrators attest

attests an orchestrator plugin

1
vintner orchestrators attest --orchestrator ${ORCHESTRATOR}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"orchestrator": "${ORCHESTRATOR}"}' \
        ${SERVER_ADDRESS}/orchestrators/attest

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/attest", {
    orchestrator: ORCHESTRATOR
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/attest", json={
    "orchestrator": ORCHESTRATOR
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/orchestrators/attest", json=mapOf(
    "orchestrator" to ORCHESTRATOR
))
Option Mandatory Type Description
orchestrator true string orchestrator

vintner orchestrators enable

enables an orchestrator plugin

1
vintner orchestrators enable --orchestrator ${ORCHESTRATOR}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"orchestrator": "${ORCHESTRATOR}"}' \
        ${SERVER_ADDRESS}/orchestrators/enable

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/enable", {
    orchestrator: ORCHESTRATOR
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/enable", json={
    "orchestrator": ORCHESTRATOR
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/orchestrators/enable", json=mapOf(
    "orchestrator" to ORCHESTRATOR
))
Option Mandatory Type Description
orchestrator true string orchestrator

vintner orchestrators init unfurl

initializes unfurl plugin

1
vintner orchestrators init unfurl 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/unfurl

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/unfurl")

1
2
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/unfurl")

1
2
import khttp.post
post(SERVER_ADDRESS + "/orchestrators/init/unfurl")
Option Mandatory Type Description
venv false boolean enable the use of a virtual environment (default: true)
no-venv false boolean disable the use of a virtual environment
dir false string directory of unfurl (default: "~/unfurl")

vintner orchestrators init unfurl-wsl

initializes unfurl-wsl plugin

1
vintner orchestrators init unfurl-wsl 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/unfurl-wsl

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/unfurl-wsl")

1
2
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/unfurl-wsl")

1
2
import khttp.post
post(SERVER_ADDRESS + "/orchestrators/init/unfurl-wsl")
Option Mandatory Type Description
venv false boolean enable the use of a virtual environment (default: true)
no-venv false boolean disable the use of a virtual environment
dir false string directory of unfurl (default: "~/unfurl")

vintner orchestrators init xopera

initializes xopera plugin

1
vintner orchestrators init xopera 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/xopera

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/xopera")

1
2
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/xopera")

1
2
import khttp.post
post(SERVER_ADDRESS + "/orchestrators/init/xopera")
Option Mandatory Type Description
venv false boolean enable the use of a virtual environment (default: true)
no-venv false boolean disable the use of a virtual environment
dir false string directory of xopera (default: "~/opera")

vintner orchestrators init xopera-wsl

initializes xopera-wsl plugin

1
vintner orchestrators init xopera-wsl 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/xopera-wsl

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/xopera-wsl")

1
2
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/xopera-wsl")

1
2
import khttp.post
post(SERVER_ADDRESS + "/orchestrators/init/xopera-wsl")
Option Mandatory Type Description
venv false boolean enable the use of a virtual environment (default: true)
no-venv false boolean enable the use of a virtual environment
dir false string directory of opera (default: "~/opera")

vintner query

runs a query and returns the result

1
vintner query --query ${QUERY}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"query": "${QUERY}"}' \
        ${SERVER_ADDRESS}/query

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/query", {
    query: QUERY
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/query", json={
    "query": QUERY
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/query", json=mapOf(
    "query" to QUERY
))
Option Mandatory Type Description
query true string path to query or query string
source false string specifies where to search for template to query (default: "vintner")
output false string path of the output
format false string output format (choices: ["yaml","json"], default: "yaml")

vintner sensors compute

starts a sensor for compute utilization, such as cpu and memory

1
vintner sensors compute --instance ${INSTANCE} --template ${TEMPLATE}
Option Mandatory Type Description
instance true string monitored instance
template true string node template name
vintner false string vintner address to submit sensors data (default: "http://127.0.0.1:3000")
time-interval false string interval to submit data (default: "every 10 seconds")
submission false boolean send data (default: true)
no-submission false boolean

vintner sensors file

starts a sensor for data stored in a file

1
vintner sensors file --instance ${INSTANCE} --file ${FILE}
Option Mandatory Type Description
instance true string monitored instance
file true string path to file
vintner false string vintner address to submit sensors data (default: "http://127.0.0.1:3000")
time-interval false string interval to submit data (default: "every 10 seconds")
watch false boolean watch file and send changes (default: true)
no-watch false boolean
submission false boolean send data (default: true)
no-submission false boolean

vintner sensors location

starts a sensor for the current location

1
vintner sensors location --instance ${INSTANCE} --template ${TEMPLATE}
Option Mandatory Type Description
instance true string monitored instance
template true string node template name
vintner false string vintner address to submit sensors data (default: "http://127.0.0.1:3000")
time-interval false string interval to submit data (default: "every minute")
submission false boolean send data (default: true)
no-submission false boolean

vintner sensors weekday

starts a sensor for the weekday

1
vintner sensors weekday --instance ${INSTANCE}
Option Mandatory Type Description
instance true string monitored instance
vintner false string vintner address to submit sensors data (default: "http://127.0.0.1:3000")
time-interval false string interval to submit data (default: "every day")
start false string set day to start from
submission false boolean send data (default: true)
no-submission false boolean

vintner server start

starts the server

1
vintner server start
Option Mandatory Type Description
host false string host on which to listen (default: "127.0.0.1")
port false number port on which to listen (default: "3000")

vintner setup benchmark

benchmarks the variability resolver

1
vintner setup benchmark 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/benchmark

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/benchmark")

1
2
import requests
requests.post(SERVER_ADDRESS + "/setup/benchmark")

1
2
import khttp.post
post(SERVER_ADDRESS + "/setup/benchmark")
Option Mandatory Type Description
io false boolean enable read and writes to the filesystem
no-io false boolean disable read and writes to the filesystem
seeds false numbers... seed for generating service templates (default: [10,250,500,1000,2500,5000,10000])
runs false number number of measurements for each test (default: 10)
latex false boolean plot results as latex (default: false)
markdown false boolean plot results as markdown (default: false)

vintner setup clean

cleans up the filesystem

1
vintner setup clean 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/clean

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/clean")

1
2
import requests
requests.post(SERVER_ADDRESS + "/setup/clean")

1
2
import khttp.post
post(SERVER_ADDRESS + "/setup/clean")
Option Mandatory Type Description
force false boolean force clean up
no-force false boolean

vintner setup code

opens the home directory in visual studio code

1
vintner setup code

vintner setup init

initialises the filesystem

1
vintner setup init 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/init

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/init")

1
2
import requests
requests.post(SERVER_ADDRESS + "/setup/init")

1
2
import khttp.post
post(SERVER_ADDRESS + "/setup/init")

vintner setup open

opens the home directory

1
vintner setup open

vintner setup path

returns the path to the home directory

1
vintner setup path 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/path

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/path")

1
2
import requests
requests.post(SERVER_ADDRESS + "/setup/path")

1
2
import khttp.post
post(SERVER_ADDRESS + "/setup/path")

vintner setup reset

resets the filesystem

1
vintner setup reset 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/reset

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/reset")

1
2
import requests
requests.post(SERVER_ADDRESS + "/setup/reset")

1
2
import khttp.post
post(SERVER_ADDRESS + "/setup/reset")
Option Mandatory Type Description
force false boolean force clean up
no-force false boolean

vintner stats ansible

returns ansible stats

1
vintner stats ansible --dir ${DIR} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/ansible

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/ansible", {
    dir: DIR,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/ansible", json={
    "dir": DIR,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/ansible", json=mapOf(
    "dir" to DIR,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
dir true string directory
experimental true enable experimental feature

vintner stats description

returns description stats

1
vintner stats description --template ${TEMPLATE} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/description

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/description", {
    template: TEMPLATE,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/description", json={
    "template": TEMPLATE,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/description", json=mapOf(
    "template" to TEMPLATE,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
template true string template
experimental true enable experimental feature

vintner stats EDMM

returns EDMM stats

1
vintner stats EDMM --template ${TEMPLATE} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/EDMM

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/EDMM", {
    template: TEMPLATE,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/EDMM", json={
    "template": TEMPLATE,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/EDMM", json=mapOf(
    "template" to TEMPLATE,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
template true string template
experimental true enable experimental feature

vintner stats EJS

returns EJS stats

1
vintner stats EJS --dir ${DIR} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/EJS

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/EJS", {
    dir: DIR,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/EJS", json={
    "dir": DIR,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/EJS", json=mapOf(
    "dir" to DIR,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
dir true string directory
experimental true enable experimental feature

vintner stats PATTERN

returns PATTERN stats

1
vintner stats PATTERN --template ${TEMPLATE} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/PATTERN

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/PATTERN", {
    template: TEMPLATE,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/PATTERN", json={
    "template": TEMPLATE,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/PATTERN", json=mapOf(
    "template" to TEMPLATE,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
template true string template
experimental true enable experimental feature

vintner stats pulumi

returns Pulumi stats

1
vintner stats pulumi --dir ${DIR} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/pulumi

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/pulumi", {
    dir: DIR,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/pulumi", json={
    "dir": DIR,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/pulumi", json=mapOf(
    "dir" to DIR,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
dir true string directory
experimental true enable experimental feature

vintner stats terraform

returns terraform stats

1
vintner stats terraform --dir ${DIR} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/terraform

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/terraform", {
    dir: DIR,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/terraform", json={
    "dir": DIR,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/terraform", json=mapOf(
    "dir" to DIR,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
dir true string directory
experimental true enable experimental feature

vintner stats TOSCA

returns TOSCA stats

1
vintner stats TOSCA --template ${TEMPLATE} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/TOSCA

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/TOSCA", {
    template: TEMPLATE,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/TOSCA", json={
    "template": TEMPLATE,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/TOSCA", json=mapOf(
    "template" to TEMPLATE,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
template true string template
experimental true enable experimental feature

vintner stats VDMM

returns VDMM stats

1
vintner stats VDMM --template ${TEMPLATE} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/stats/VDMM

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/stats/VDMM", {
    template: TEMPLATE,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/stats/VDMM", json={
    "template": TEMPLATE,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/stats/VDMM", json=mapOf(
    "template" to TEMPLATE,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
template true string template
experimental true enable experimental feature

vintner study effort

conduct effort case study

1
vintner study effort --dir ${DIR} --experimental ${EXPERIMENTAL} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}", "experimental": "${EXPERIMENTAL}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/study/effort

1
2
3
4
5
6
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/study/effort", {
    dir: DIR,
    experimental: EXPERIMENTAL,
    output: OUTPUT
})

1
2
3
4
5
6
import requests
requests.post(SERVER_ADDRESS + "/study/effort", json={
    "dir": DIR,
    "experimental": EXPERIMENTAL,
    "output": OUTPUT
})

1
2
3
4
5
6
import khttp.post
post(SERVER_ADDRESS + "/study/effort", json=mapOf(
    "dir" to DIR,
    "experimental" to EXPERIMENTAL,
    "output" to OUTPUT
))
Option Mandatory Type Description
dir true string
objects false strings... objects
experimental true enable experimental feature
write false store output
no-write false store output
simple false simple log
output true string path of the output

vintner study performance

conduct performance case study

1
vintner study performance --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/study/performance

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/study/performance", {
    experimental: EXPERIMENTAL
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/study/performance", json={
    "experimental": EXPERIMENTAL
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/study/performance", json=mapOf(
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
config false string
experimental true enable experimental feature

vintner study quality

conduct quality study

1
vintner study quality --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/study/quality

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/study/quality", {
    experimental: EXPERIMENTAL
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/study/quality", json={
    "experimental": EXPERIMENTAL
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/study/quality", json=mapOf(
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
config false string
experimental true enable experimental feature

vintner template assign

assign deployment technologies

1
vintner template assign --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/assign

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/assign", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/assign", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/assign", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to service template
output true string path of the output

vintner template enrich

enrich service template

1
vintner template enrich --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/enrich

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/enrich", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/enrich", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/enrich", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to variable service template
output true string path of the output
pretty false boolean prettify output

vintner template implement

implement node types

1
vintner template implement --dir ${DIR}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}"}' \
        ${SERVER_ADDRESS}/template/implement

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/implement", {
    dir: DIR
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/implement", json={
    "dir": DIR
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/implement", json=mapOf(
    "dir" to DIR
))
Option Mandatory Type Description
dir true string path to service template directory
orchestrator false string the orchestrator for which node type should be implemented (default: "unfurl")

vintner template init

initializes a CSAR

1
vintner template init --path ${PATH} --template ${TEMPLATE} --vintner ${VINTNER}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"path": "${PATH}", "template": "${TEMPLATE}", "vintner": "${VINTNER}"}' \
        ${SERVER_ADDRESS}/template/init

1
2
3
4
5
6
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/init", {
    path: PATH,
    template: TEMPLATE,
    vintner: VINTNER
})

1
2
3
4
5
6
import requests
requests.post(SERVER_ADDRESS + "/template/init", json={
    "path": PATH,
    "template": TEMPLATE,
    "vintner": VINTNER
})

1
2
3
4
5
6
import khttp.post
post(SERVER_ADDRESS + "/template/init", json=mapOf(
    "path" to PATH,
    "template" to TEMPLATE,
    "vintner" to VINTNER
))
Option Mandatory Type Description
path true string path of the directory
template true string template name (default: directory name of --path)
vintner true string vintner binary to execute (default: "task cli --")
force false boolean force initialization, e.g., on non-empty directories
no-force false boolean

vintner template inputs

read and transforms inputs

1
vintner template inputs --path ${PATH} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"path": "${PATH}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/inputs

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/inputs", {
    path: PATH,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/inputs", json={
    "path": PATH,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/inputs", json=mapOf(
    "path" to PATH,
    "output" to OUTPUT
))
Option Mandatory Type Description
path true string path to the variability inputs (supported: [YAML, FeatureIDE ExtendedXML])
output true string path of the output

vintner template normalize

normalize service template

1
vintner template normalize --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/normalize

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/normalize", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/normalize", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/normalize", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to variable service template
output true string path of the output

vintner template package

packages a directory to a CSAR

1
vintner template package --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/package

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/package", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/package", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/package", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to variable service template
output true string path of the output

vintner template pull

pull template dependencies

1
vintner template pull --dir ${DIR}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}"}' \
        ${SERVER_ADDRESS}/template/pull

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/pull", {
    dir: DIR
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/pull", json={
    "dir": DIR
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/pull", json=mapOf(
    "dir" to DIR
))
Option Mandatory Type Description
dir true string path to service template directory
link false boolean create symbolic links instead of copying files (default: false)
no-link false boolean

vintner template puml topology

plot topology as PlantUML

1
vintner template puml topology --path ${PATH}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"path": "${PATH}"}' \
        ${SERVER_ADDRESS}/template/puml/topology

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/puml/topology", {
    path: PATH
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/puml/topology", json={
    "path": PATH
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/puml/topology", json=mapOf(
    "path" to PATH
))
Option Mandatory Type Description
path true string path to service template
output false string path of the output
format false string output format (choices: ["puml","svg"], default: "puml")

vintner template puml types

plot types as PlantUML (each entity types is plotted separately)

1
vintner template puml types --path ${PATH}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"path": "${PATH}"}' \
        ${SERVER_ADDRESS}/template/puml/types

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/puml/types", {
    path: PATH
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/puml/types", json={
    "path": PATH
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/puml/types", json=mapOf(
    "path" to PATH
))
Option Mandatory Type Description
path true string path to service template
output false string path of the output directory (default: the directory of the service template)
types false string... entity types to consider, e.g., "node_types" (default: Every defined entity type)
format false string output format (choices: ["puml","svg"], default: "puml")

vintner template qualities

get quality ranges of template

1
vintner template qualities --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/template/qualities

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/qualities", {
    template: TEMPLATE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/qualities", json={
    "template": TEMPLATE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/qualities", json=mapOf(
    "template" to TEMPLATE
))
Option Mandatory Type Description
template true string path to service template
presets false string... names of variability presets(env: OPENTOSCA_VINTNER_VARIABILITY_PRESETS) (default: [])
inputs false string path to the variability inputs (supported: [YAML, FeatureIDE ExtendedXML], env: OPENTOSCA_VINTNER_VARIABILITY_INPUT_${KEY})

vintner template quality

get quality of template

1
vintner template quality --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/template/quality

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/quality", {
    template: TEMPLATE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/quality", json={
    "template": TEMPLATE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/quality", json=mapOf(
    "template" to TEMPLATE
))
Option Mandatory Type Description
template true string path to service template
punishment false number punishment for a missing or unsupported technology assignment
punish false boolean punish missing or unsupported technology assignment (default: true)
no-punish false boolean ignore missing or unsupported technology assignment

vintner template query

resolves all queries in a given service template

1
vintner template query --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/query

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/query", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/query", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/query", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to service template
output true string path of the output

vintner template resolve

resolves variability

1
vintner template resolve --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/resolve

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/resolve", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/resolve", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/resolve", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to variable service template
presets false strings... names of variability presets (env: OPENTOSCA_VINTNER_VARIABILITY_PRESETS) (default: [])
inputs false string path to the variability inputs (supported: [YAML, FeatureIDE ExtendedXML, env: OPENTOSCA_VINTNER_VARIABILITY_INPUT_)
output true string path of the output
pretty false boolean prettify output
edmm false boolean edmm compatibility, e.g., use node_template.technology
report false boolean also generate report

vintner template sign

signs a CSAR

1
vintner template sign --template ${TEMPLATE} --output ${OUTPUT} --key ${KEY}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}", "key": "${KEY}"}' \
        ${SERVER_ADDRESS}/template/sign

1
2
3
4
5
6
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/sign", {
    template: TEMPLATE,
    output: OUTPUT,
    key: KEY
})

1
2
3
4
5
6
import requests
requests.post(SERVER_ADDRESS + "/template/sign", json={
    "template": TEMPLATE,
    "output": OUTPUT,
    "key": KEY
})

1
2
3
4
5
6
import khttp.post
post(SERVER_ADDRESS + "/template/sign", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT,
    "key" to KEY
))
Option Mandatory Type Description
template true string path to service template
output true string path of the output (default: template path + ".asc" )
key true string path of the key

vintner template stats

collects stats of a given service template (experimental)

1
vintner template stats --template ${TEMPLATE} --experimental ${EXPERIMENTAL}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "experimental": "${EXPERIMENTAL}"}' \
        ${SERVER_ADDRESS}/template/stats

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/stats", {
    template: TEMPLATE,
    experimental: EXPERIMENTAL
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/stats", json={
    "template": TEMPLATE,
    "experimental": EXPERIMENTAL
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/stats", json=mapOf(
    "template" to TEMPLATE,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
template true strings... path to service template
experimental true enable experimental feature

vintner template test

runs tests defined in the CSAR

1
vintner template test --path ${PATH}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"path": "${PATH}"}' \
        ${SERVER_ADDRESS}/template/test

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/test", {
    path: PATH
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/test", json={
    "path": PATH
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/test", json=mapOf(
    "path" to PATH
))
Option Mandatory Type Description
path true string path or link to the extracted CSAR

vintner template unimplement

unimplement node types

1
vintner template unimplement --dir ${DIR}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}"}' \
        ${SERVER_ADDRESS}/template/unimplement

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/unimplement", {
    dir: DIR
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/unimplement", json={
    "dir": DIR
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/unimplement", json=mapOf(
    "dir" to DIR
))
Option Mandatory Type Description
dir true string path to service template directory

vintner template unpackage

unpackages a CSAR

1
vintner template unpackage --template ${TEMPLATE} --output ${OUTPUT}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "output": "${OUTPUT}"}' \
        ${SERVER_ADDRESS}/template/unpackage

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/unpackage", {
    template: TEMPLATE,
    output: OUTPUT
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/template/unpackage", json={
    "template": TEMPLATE,
    "output": OUTPUT
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/template/unpackage", json=mapOf(
    "template" to TEMPLATE,
    "output" to OUTPUT
))
Option Mandatory Type Description
template true string path to variable service template
output true string path of the output

vintner template unpull

unpull template dependencies

1
vintner template unpull --dir ${DIR}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"dir": "${DIR}"}' \
        ${SERVER_ADDRESS}/template/unpull

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/unpull", {
    dir: DIR
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/template/unpull", json={
    "dir": DIR
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/template/unpull", json=mapOf(
    "dir" to DIR
))
Option Mandatory Type Description
dir true string path to service template directory

vintner template verify

verify a CSAR

1
vintner template verify --template ${TEMPLATE} --signature ${SIGNATURE} --key ${KEY}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "signature": "${SIGNATURE}", "key": "${KEY}"}' \
        ${SERVER_ADDRESS}/template/verify

1
2
3
4
5
6
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/template/verify", {
    template: TEMPLATE,
    signature: SIGNATURE,
    key: KEY
})

1
2
3
4
5
6
import requests
requests.post(SERVER_ADDRESS + "/template/verify", json={
    "template": TEMPLATE,
    "signature": SIGNATURE,
    "key": KEY
})

1
2
3
4
5
6
import khttp.post
post(SERVER_ADDRESS + "/template/verify", json=mapOf(
    "template" to TEMPLATE,
    "signature" to SIGNATURE,
    "key" to KEY
))
Option Mandatory Type Description
template true string path to service template
signature true string path of the signature (default: template path + ".asc" )
key true string path of the key

vintner templates clean

removes all templates

1
vintner templates clean 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/templates/clean

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/clean")

1
2
import requests
requests.post(SERVER_ADDRESS + "/templates/clean")

1
2
import khttp.post
post(SERVER_ADDRESS + "/templates/clean")

vintner templates code

opens the template directory in visual studio code

1
vintner templates code --template ${TEMPLATE}
Option Mandatory Type Description
template true string template name

vintner templates delete

deletes a template

1
vintner templates delete --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/templates/delete

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/delete", {
    template: TEMPLATE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/templates/delete", json={
    "template": TEMPLATE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/templates/delete", json=mapOf(
    "template" to TEMPLATE
))
Option Mandatory Type Description
template true string template name

vintner templates import

imports a new template

1
vintner templates import --template ${TEMPLATE} --path ${PATH}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}", "path": "${PATH}"}' \
        ${SERVER_ADDRESS}/templates/import

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/import", {
    template: TEMPLATE,
    path: PATH
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/templates/import", json={
    "template": TEMPLATE,
    "path": PATH
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/templates/import", json=mapOf(
    "template" to TEMPLATE,
    "path" to PATH
))
Option Mandatory Type Description
template true string template name
path true string path or link to the CSAR
git-repository false string git repository
git-checkout false string git checkout
signature false path to the signature (default: template + ".asc")
key false assets name to verify the signature

vintner templates inspect

inspects the variable service template

1
vintner templates inspect --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/templates/inspect

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/inspect", {
    template: TEMPLATE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/templates/inspect", json={
    "template": TEMPLATE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/templates/inspect", json=mapOf(
    "template" to TEMPLATE
))
Option Mandatory Type Description
template true string template name

vintner templates list

lists all templates

1
vintner templates list 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/templates/list

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/list")

1
2
import requests
requests.post(SERVER_ADDRESS + "/templates/list")

1
2
import khttp.post
post(SERVER_ADDRESS + "/templates/list")

vintner templates open

opens template directory in a file browser

1
vintner templates open --template ${TEMPLATE}
Option Mandatory Type Description
template true string template name

vintner templates path

returns the path to the template directory

1
vintner templates path --template ${TEMPLATE}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"template": "${TEMPLATE}"}' \
        ${SERVER_ADDRESS}/templates/path

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/path", {
    template: TEMPLATE
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/templates/path", json={
    "template": TEMPLATE
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/templates/path", json=mapOf(
    "template" to TEMPLATE
))
Option Mandatory Type Description
template true string template name

vintner utils compare-yaml

returns if YAMLs diff

1
vintner utils compare-yaml --first ${FIRST} --second ${SECOND}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"first": "${FIRST}", "second": "${SECOND}"}' \
        ${SERVER_ADDRESS}/utils/compare-yaml

1
2
3
4
5
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/compare-yaml", {
    first: FIRST,
    second: SECOND
})

1
2
3
4
5
import requests
requests.post(SERVER_ADDRESS + "/utils/compare-yaml", json={
    "first": FIRST,
    "second": SECOND
})

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/utils/compare-yaml", json=mapOf(
    "first" to FIRST,
    "second" to SECOND
))
Option Mandatory Type Description
first true string path to feature model
second true string path to feature model

vintner utils feature-model

returns deployment scenarios

1
vintner utils feature-model --path ${PATH}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"path": "${PATH}"}' \
        ${SERVER_ADDRESS}/utils/feature-model

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/feature-model", {
    path: PATH
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/utils/feature-model", json={
    "path": PATH
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/utils/feature-model", json=mapOf(
    "path" to PATH
))
Option Mandatory Type Description
path true string path to feature model
format false string output format (choices: ["yaml","json"], default: "yaml")

vintner utils key

generates a key

1
vintner utils key --key ${KEY}

1
2
3
4
curl --header "Content-Type: application/json" \
        --request POST \
        --data '{"key": "${KEY}"}' \
        ${SERVER_ADDRESS}/utils/key

1
2
3
4
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/key", {
    key: KEY
})

1
2
3
4
import requests
requests.post(SERVER_ADDRESS + "/utils/key", json={
    "key": KEY
})

1
2
3
4
import khttp.post
post(SERVER_ADDRESS + "/utils/key", json=mapOf(
    "key" to KEY
))
Option Mandatory Type Description
key true string key name (must match /^[a-z-]+$/)

vintner utils nonce

generates a nonce

1
vintner utils nonce 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/nonce

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/nonce")

1
2
import requests
requests.post(SERVER_ADDRESS + "/utils/nonce")

1
2
import khttp.post
post(SERVER_ADDRESS + "/utils/nonce")

vintner utils normative

returns normative types

1
vintner utils normative 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/normative

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/normative")

1
2
import requests
requests.post(SERVER_ADDRESS + "/utils/normative")

1
2
import khttp.post
post(SERVER_ADDRESS + "/utils/normative")
Option Mandatory Type Description
orchestrator false string orchestrator dialect
profile false boolean include profile entry (default: true)
no-profile false boolean
base false boolean include base types (default: true)
no-base false boolean
extended false boolean include extended types (default: true)
no-extended false boolean
format false string output format (choices: ["yaml","json"], default: "yaml")

vintner utils rules

returns technology rules

1
vintner utils rules 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/rules

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/rules")

1
2
import requests
requests.post(SERVER_ADDRESS + "/utils/rules")

1
2
import khttp.post
post(SERVER_ADDRESS + "/utils/rules")
Option Mandatory Type Description
format false string output format (choices: ["yaml","json","latex","csv"], default: "yaml")

vintner utils scenarios

returns deployment scenarios

1
vintner utils scenarios 

1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/scenarios

1
2
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/scenarios")

1
2
import requests
requests.post(SERVER_ADDRESS + "/utils/scenarios")

1
2
import khttp.post
post(SERVER_ADDRESS + "/utils/scenarios")
Option Mandatory Type Description
component false string component
artifact false string artifact
no-artifact false boolean
technology false string technology
hosting false string... hosting
no-hosting false boolean
quality false number
format false string output format (choices: ["yaml","json"], default: "yaml")
Last update: October 18, 2025