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

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

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})
retry false boolean retry (default: true)
verbose false boolean verbose

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

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

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

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

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

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

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

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

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
dry false boolean dry run

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")
disable-submission false boolean disable submission of data (default: false)

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")
disable-watch false boolean do not watch file but send data once (default: false)
disable-submission false boolean disable submission of data (default: false)

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")
disable-submission false boolean disable submission of data (default: false)

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
disable-submission false boolean disable submission of data (default: false)

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

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

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

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)

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

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)

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 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")
Last update: April 28, 2024