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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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

Last update: March 27, 2024