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 study technology

conduct technology case study

1
vintner study technology --application ${APPLICATION} --experimental ${EXPERIMENTAL}

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

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

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

1
2
3
4
5
import khttp.post
post(SERVER_ADDRESS + "/study/technology", json=mapOf(
    "application" to APPLICATION,
    "experimental" to EXPERIMENTAL
))
Option Mandatory Type Description
application true string application name, e.g., boutique or shop
experimental true enable experimental feature

vintner template enrich

enrich conditions

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

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 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
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 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

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 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: December 13, 2024