Skip to content

Interface

This document holds the interface specification.

vintner assets clean

cleans all assets

vintner assets clean 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/assets/clean
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/clean")
import requests
requests.post(SERVER_ADDRESS + "/assets/clean")
import khttp.post
post(SERVER_ADDRESS + "/assets/clean")

vintner assets content

shows content of an asset

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

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

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

vintner assets list 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/assets/list
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/assets/list")
import requests
requests.post(SERVER_ADDRESS + "/assets/list")
import khttp.post
post(SERVER_ADDRESS + "/assets/list")

vintner info about

general information

vintner info about 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/about
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/about")
import requests
requests.post(SERVER_ADDRESS + "/info/about")
import khttp.post
post(SERVER_ADDRESS + "/info/about")

vintner info author

open author

vintner info author 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/author
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/author")
import requests
requests.post(SERVER_ADDRESS + "/info/author")
import khttp.post
post(SERVER_ADDRESS + "/info/author")

vintner info contact

contact us

vintner info contact 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/contact
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/contact")
import requests
requests.post(SERVER_ADDRESS + "/info/contact")
import khttp.post
post(SERVER_ADDRESS + "/info/contact")

vintner info dependencies

dependencies used to implement vintner

vintner info dependencies 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/dependencies
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/dependencies")
import requests
requests.post(SERVER_ADDRESS + "/info/dependencies")
import khttp.post
post(SERVER_ADDRESS + "/info/dependencies")

vintner info docs

open documentation

vintner info docs 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/docs
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/docs")
import requests
requests.post(SERVER_ADDRESS + "/info/docs")
import khttp.post
post(SERVER_ADDRESS + "/info/docs")

vintner info license

license of vintner

vintner info license 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/license
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/license")
import requests
requests.post(SERVER_ADDRESS + "/info/license")
import khttp.post
post(SERVER_ADDRESS + "/info/license")

vintner info repo

open repository

vintner info repo 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/info/repo
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/info/repo")
import requests
requests.post(SERVER_ADDRESS + "/info/repo")
import khttp.post
post(SERVER_ADDRESS + "/info/repo")

vintner install ansible

installs Ansible

vintner install ansible 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/ansible
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/ansible")
import requests
requests.post(SERVER_ADDRESS + "/install/ansible")
import khttp.post
post(SERVER_ADDRESS + "/install/ansible")

vintner install docker

installs Docker

vintner install docker 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/docker
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/docker")
import requests
requests.post(SERVER_ADDRESS + "/install/docker")
import khttp.post
post(SERVER_ADDRESS + "/install/docker")

vintner install gcloud

installs GCloud

vintner install gcloud 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/gcloud
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/gcloud")
import requests
requests.post(SERVER_ADDRESS + "/install/gcloud")
import khttp.post
post(SERVER_ADDRESS + "/install/gcloud")

vintner install platformio

installs PlatformIO Core CLI

vintner install platformio 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/platformio
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/platformio")
import requests
requests.post(SERVER_ADDRESS + "/install/platformio")
import khttp.post
post(SERVER_ADDRESS + "/install/platformio")

vintner install python

installs Python

vintner install python 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/python
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/python")
import requests
requests.post(SERVER_ADDRESS + "/install/python")
import khttp.post
post(SERVER_ADDRESS + "/install/python")

vintner install terraform

installs Terraform

vintner install terraform 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/terraform
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/terraform")
import requests
requests.post(SERVER_ADDRESS + "/install/terraform")
import khttp.post
post(SERVER_ADDRESS + "/install/terraform")

vintner install unfurl

installs Unfurl in a venv in "~/unfurl"

vintner install unfurl 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/unfurl
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/unfurl")
import requests
requests.post(SERVER_ADDRESS + "/install/unfurl")
import khttp.post
post(SERVER_ADDRESS + "/install/unfurl")

vintner install utils

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

vintner install utils 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/utils
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/utils")
import requests
requests.post(SERVER_ADDRESS + "/install/utils")
import khttp.post
post(SERVER_ADDRESS + "/install/utils")

vintner install xopera

installs xOpera in a venv in "~/opera"

vintner install xopera 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/install/xopera
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/install/xopera")
import requests
requests.post(SERVER_ADDRESS + "/install/xopera")
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

vintner instances clean 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/instances/clean
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/clean")
import requests
requests.post(SERVER_ADDRESS + "/instances/clean")
import khttp.post
post(SERVER_ADDRESS + "/instances/clean")

vintner instances code

opens the instance directory in visual studio code

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

vintner instances continue

continue instance (deployment)

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

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

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

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

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

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

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

vintner instances list 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/instances/list
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/instances/list")
import requests
requests.post(SERVER_ADDRESS + "/instances/list")
import khttp.post
post(SERVER_ADDRESS + "/instances/list")

vintner instances open

opens template directory in a file browser

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

vintner instances outputs

returns instance outputs

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

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

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

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

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

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

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

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

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

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

vintner orchestrators init unfurl 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/unfurl
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/unfurl")
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/unfurl")
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

vintner orchestrators init unfurl-wsl 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/unfurl-wsl
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/unfurl-wsl")
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/unfurl-wsl")
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

vintner orchestrators init xopera 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/xopera
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/xopera")
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/xopera")
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

vintner orchestrators init xopera-wsl 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/orchestrators/init/xopera-wsl
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/orchestrators/init/xopera-wsl")
import requests
requests.post(SERVER_ADDRESS + "/orchestrators/init/xopera-wsl")
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

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

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

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

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

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

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

vintner setup benchmark 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/benchmark
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/benchmark")
import requests
requests.post(SERVER_ADDRESS + "/setup/benchmark")
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

vintner setup clean 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/clean
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/clean")
import requests
requests.post(SERVER_ADDRESS + "/setup/clean")
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

vintner setup code 

vintner setup init

initialises the filesystem

vintner setup init 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/init
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/init")
import requests
requests.post(SERVER_ADDRESS + "/setup/init")
import khttp.post
post(SERVER_ADDRESS + "/setup/init")

vintner setup open

opens the home directory

vintner setup open 

vintner setup path

returns the path to the home directory

vintner setup path 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/path
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/path")
import requests
requests.post(SERVER_ADDRESS + "/setup/path")
import khttp.post
post(SERVER_ADDRESS + "/setup/path")

vintner setup reset

resets the filesystem

vintner setup reset 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/setup/reset
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/setup/reset")
import requests
requests.post(SERVER_ADDRESS + "/setup/reset")
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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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)

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

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

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

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

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

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

vintner templates clean 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/templates/clean
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/clean")
import requests
requests.post(SERVER_ADDRESS + "/templates/clean")
import khttp.post
post(SERVER_ADDRESS + "/templates/clean")

vintner templates code

opens the template directory in visual studio code

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

vintner templates delete

deletes a template

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

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

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

vintner templates list 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/templates/list
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/templates/list")
import requests
requests.post(SERVER_ADDRESS + "/templates/list")
import khttp.post
post(SERVER_ADDRESS + "/templates/list")

vintner templates open

opens template directory in a file browser

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

vintner templates path

returns the path to the template directory

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

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

vintner utils nonce 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/nonce
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/nonce")
import requests
requests.post(SERVER_ADDRESS + "/utils/nonce")
import khttp.post
post(SERVER_ADDRESS + "/utils/nonce")

vintner utils normative

returns normative types

vintner utils normative 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/normative
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/normative")
import requests
requests.post(SERVER_ADDRESS + "/utils/normative")
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

vintner utils rules 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/rules
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/rules")
import requests
requests.post(SERVER_ADDRESS + "/utils/rules")
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

vintner utils scenarios 
1
2
3
curl --header "Content-Type: application/json" \
        --request POST \
        ${SERVER_ADDRESS}/utils/scenarios
const axios = require("axios")
await axios.post(SERVER_ADDRESS + "/utils/scenarios")
import requests
requests.post(SERVER_ADDRESS + "/utils/scenarios")
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 4, 2024