instance-theia.cfg.jinja.in

{% set parameter_dict = dict(default_parameter_dict, **parameter_dict) %}
{% set additional_frontend = parameter_dict['additional-frontend-guid'] %}

[buildout]
extends =
  ${monitor-template:output}

theia-environment-parts =
  tasks.json
  slapos-repository
  runner-link
  settings.json
  request-script-template

theia-parts =
  frontend-reload
  promises

parts =
  monitor-base
  $${:theia-parts}
  $${:theia-environment-parts}
  publish-connection-parameter

eggs-directory = ${buildout:eggs-directory}
develop-eggs-directory = ${buildout:develop-eggs-directory}
offline = true


[publish-connection-parameter]
<= monitor-publish
recipe = slapos.cookbook:publish
url = $${remote-frontend:connection-secure_access}
{% if additional_frontend %}
additional-url = $${remote-additional-frontend:connection-secure_access}
{% endif %}
username = $${frontend-instance-password:username}
password = $${frontend-instance-password:passwd}
backend-url = $${frontend-instance:url}
ipv6 = {{ ipv6_random }}

[directory]
recipe = slapos.cookbook:mkdirectory
home = $${buildout:directory}
etc = $${:home}/etc
var = $${:home}/var
srv = $${:home}/srv
bin = $${:home}/bin
tmp = $${:home}/tmp
dot-theia = $${:home}/.theia/
pidfiles = $${:var}/run

services = $${:etc}/service
runner = $${:srv}/runner
backup = $${:srv}/backup/theia
project = $${:srv}/project

frontend-static = $${:srv}/frontend-static
frontend-static-public = $${:frontend-static}/public
frontend-static-css = $${:frontend-static}/css

bash-completions = $${:home}/.local/share/bash-completion/completions/
fish-completions = $${:home}/.config/fish/completions/


# Monitor
# -------

[monitor-instance-parameter]
monitor-httpd-port = {{ parameter_dict['monitor-httpd-port'] }}
{%- for k in ('monitor-cors-domains', 'monitor-username', 'monitor-password') %}
{%-   set v = parameter_dict.get(k) %}
{%-   if v %}
{{ k[8:] }} = {{ v }}
{%-   endif %}
{%- endfor %}
{%- for k in ('monitor-url-list', ) %}
{%-   set v = parameter_dict.get(k) %}
{%-   if v %}
{{ k }} = {{ v }}
{%-   endif %}
{%- endfor %}


# Promises
# --------

[promises]
recipe =
instance-promises =
  $${theia-listen-promise:name}
  $${frontend-listen-promise:name}
  $${frontend-authentication-promise:name}
  $${remote-frontend-url-available-promise:name}
  {% if additional_frontend %}
  $${remote-additional-frontend-url-available-promise:name}
  {% endif %}
  $${slapos-standalone-listen-promise:name}
  $${slapos-standalone-ready-promise:name}
  $${slapos-autorun-promise:name}

[theia-listen-promise]
<= monitor-promise-base
promise = check_socket_listening
name = $${:_buildout_section_name_}.py
config-host = $${theia-instance:ip}
config-port = $${theia-instance:port}

[frontend-listen-promise]
<= monitor-promise-base
promise = check_socket_listening
name = $${:_buildout_section_name_}.py
config-host = $${frontend-instance:ip}
config-port = $${frontend-instance:port}

[frontend-authentication-promise]
<= monitor-promise-base
promise = check_url_available
name = $${:_buildout_section_name_}.py
ip = $${frontend-instance:ip}
port = $${frontend-instance:port}
config-url = https://[$${:ip}]:$${:port}
config-username = $${frontend-instance-password:username}
config-password = $${frontend-instance-password:passwd}

[remote-frontend-url-available-promise]
<= monitor-promise-base
promise = check_url_available
name = $${:_buildout_section_name_}.py
config-url = $${remote-frontend:connection-secure_access}
config-http-code = 401

{% if additional_frontend %}
[remote-additional-frontend-url-available-promise]
<= monitor-promise-base
promise = check_url_available
name = $${:_buildout_section_name_}.py
config-url = $${remote-additional-frontend:connection-secure_access}
config-http-code = 401
{% endif %}

[slapos-standalone-listen-promise]
<= monitor-promise-base
promise = check_socket_listening
# XXX promise plugins can not contain "slapos" in their names
name = standalone-listen-promise.py
config-host = $${slapos-standalone-instance:hostname}
config-port = $${slapos-standalone-instance:port}

[slapos-standalone-ready-promise]
<= monitor-promise-base
promise = check_socket_listening
name = standalone-ready-promise.py
config-abstract = $${slapos-standalone-config:abstract-socket-path}

[slapos-autorun-promise]
<= monitor-promise-base
promise = check_service_state
name = autorun-state-promise.py
config-service = $${slapos-autorun:service-name}
config-expect = $${slapos-autorun:autorun}
config-run-directory = $${directory:runner}/var/run


# Remote Caddy Frontend
# ---------------------

[remote-frontend-base]
<= slap-connection
recipe = slapos.cookbook:requestoptional
slave = true
config-url = $${frontend-instance:url}
config-https-only = true
config-type = websocket
config-websocket-path-list = /services /socket.io
return = domain secure_access

[remote-frontend]
<= remote-frontend-base
name = {{ parameter_dict['frontend-name'] }}
software-url = {{ parameter_dict['frontend-sr'] }}
software-type = {{ parameter_dict['frontend-sr-type'] }}
{%- if parameter_dict.get('frontend-guid') %}
sla-instance_guid = {{ parameter_dict['frontend-guid'] }}
{%- endif %}

{% if additional_frontend %}
[remote-additional-frontend]
<= remote-frontend-base
name = {{ parameter_dict['additional-frontend-name'] }}
software-url = {{ parameter_dict['additional-frontend-sr'] }}
software-type = {{ parameter_dict['additional-frontend-sr-type'] }}
{%- if parameter_dict.get('additional-frontend-guid') %}
sla-instance_guid = {{ parameter_dict['additional-frontend-guid'] }}
{%- endif %}
{% endif %}


# Local Caddy Frontend
# --------------------

[frontend-instance-password]
recipe = slapos.cookbook:generate.password
username = admin
storage-path = $${buildout:parts-directory}/.$${:_buildout_section_name_}

[frontend-instance-port]
recipe = slapos.cookbook:free_port
minimum = 3000
maximum = 3100
ip = {{ ipv6_random }}

[frontend-instance-certificate]
recipe = plone.recipe.command
command =
  if [ ! -e $${:key-file} ]
  then
    ${openssl-output:openssl} req -x509 -nodes -days 3650 \
      -subj "/C=AA/ST=X/L=X/O=Dis/CN=$${:common-name}" \
      -newkey rsa:1024 -keyout $${:key-file} \
      -out $${:cert-file}
  fi
update-command = $${:command}
key-file = $${directory:etc}/$${:_buildout_section_name_}.key
cert-file = $${directory:etc}/$${:_buildout_section_name_}.crt
common-name = $${frontend-instance-config:ip}
location =
  $${:key-file}
  $${:cert-file}

[frontend-instance-config]
recipe = slapos.recipe.template
output = $${directory:etc}/$${:_buildout_section_name_}
inline =
  :$${:port} {
    bind $${:ip}
    tls $${frontend-instance-certificate:cert-file} $${frontend-instance-certificate:key-file}
    log stdout
    errors stderr
    gzip
    # because caddy does not support upgrade http2 to websocket
    # https://tools.ietf.org/html/rfc8441
    tls {
      alpn http/1.1
    }
    root $${directory:frontend-static}
    browse
    proxy / $${theia-instance:base-url} {
      except $${frontend-instance-fonts:folder-name} $${frontend-instance-slapos.css:folder-name} public $${favicon.ico:filename} $${frontend-instance-logo:filename}
    }
    proxy /services $${theia-instance:base-url} {
      websocket
    }
    proxy /socket.io $${theia-instance:base-url} {
      websocket
    }
    basicauth $${frontend-instance-password:username} $${frontend-instance-password:passwd} {
      realm "Theia"
      /
    }
  }
ip = $${frontend-instance-port:ip}
hostname = [$${:ip}]
port = $${frontend-instance-port:port}

[frontend-instance]
recipe = slapos.cookbook:wrapper
wrapper-path = $${directory:services}/$${:_buildout_section_name_}
command-line =
  ${caddy:output} -conf $${frontend-instance-config:output} -pidfile $${:pidfile}

ip = $${frontend-instance-config:ip}
hostname = $${frontend-instance-config:hostname}
port = $${frontend-instance-config:port}
pidfile = $${directory:pidfiles}/$${:_buildout_section_name_}.pid
url = https://$${:hostname}:$${:port}/

[frontend-instance-fonts]
; XXX caddy 1 does not seem to serve different folders at different locations
; so we link fonts in static folder
recipe = plone.recipe.command
location = $${directory:frontend-static}/$${:folder-name}
folder-name = fonts
command =
  mkdir -p $${:location}
  ln -sf ${source-code-pro-fonts:location} $${:location}/source-code-pro
  ln -sf ${jetbrains-mono-fonts:location} $${:location}/jetbrains-mono
stop-on-error = true

[frontend-instance-logo]
recipe = plone.recipe.command
filename = logo.png
full-path = $${directory:frontend-static}/$${:filename}
command =
  cp --remove-destination ${logo.png:output} $${:full-path}
stop-on-error = true

[frontend-instance-slapos.css]
recipe = slapos.recipe.template:jinja2
url = ${slapos.css.in:output}
output = $${directory:frontend-static}/$${:folder-name}/slapos.css
folder-name = css
context =
  key logo_image frontend-instance-logo:filename

[frontend-reload]
recipe = slapos.cookbook:wrapper
wrapper-path = $${directory:services}/$${:_buildout_section_name_}
command-line =
  ${bash:location}/bin/bash -c
  "kill -s USR1 $$(${coreutils:location}/bin/cat $${frontend-instance:pidfile}) \
    && ${coreutils:location}/bin/sleep infinity"
hash-files =
  $${frontend-instance-config:output}
  $${frontend-instance:wrapper-path}
wait-for-files = $${frontend-instance:pidfile}

[favicon.ico]
# generate a pseudo random favicon, different for each instance name.
recipe = slapos.recipe.build
seed = {{ root_title }}
install =
  import hashlib, shutil
  buildout_offline = self.buildout['buildout']['offline']
  self.buildout['buildout']['offline'] = 'false'
  try:
    gravatar_url = "https://www.gravatar.com/avatar/" + hashlib.md5(
      b'''$${:seed}'''
    ).hexdigest() + "?s=256&d=retro"
    shutil.copy(self.download(gravatar_url), '''$${:location}''')
  except Exception:
    # Because installation should work offline, if we can't download a favicon,
    # just ignore this step.
    self.logger.exception("Error while downloading favicon, using empty one")
    open('''$${:location}''', 'w').close()
  finally:
    self.buildout['buildout']['offline'] = buildout_offline

location = $${directory:frontend-static}/$${:filename}
filename = $${:_buildout_section_name_}


# Common Environment
# ------------------

[common-environment]
recipe = slapos.recipe.template
output = $${directory:bin}/$${:_buildout_section_name_}
inline =
  #!/bin/sh
  export HOME=$${directory:home}
  export PATH=${python-language-server:location}/bin:${java-jdk:location}/bin:${cli-utilities:PATH}:$HOME/.cargo/bin:$PATH
  export IPV6_SLAPRUNNER={{ ipv6_random }}

# Theia Backend
# -------------

[theia-service-port]
recipe = slapos.cookbook:free_port
minimum = 3500
maximum = 3600
ip = {{ ipv4_random }}

[theia-service]
recipe = slapos.recipe.template
output = $${directory:bin}/$${:_buildout_section_name_}
inline =
  #!/bin/sh
  {{ "{% raw %}" }}
  {% raw %}
  export THEIA_WEBVIEW_EXTERNAL_ENDPOINT='{{hostname}}'
  export THEIA_MINI_BROWSER_HOST_PATTERN='{{hostname}}'
  {% endraw %}
  {{ "{% endraw %}" }}
  export THEIA_OPEN_EDITOR_TOKEN=$(${openssl:location}/bin/openssl rand -hex 32)
  export THEIA_URL=$${:base-url}
  export THEIA_SHELL=$${theia-shell:output}
  export TMP=$${directory:tmp}
  export TEMP=$TMP
  export LC_ALL=C.UTF-8
  export TERMINFO=${ncurses:location}/lib/terminfo/
  export EDITOR="${theia-open:output} --wait"
  export THEIA_DEFAULT_PLUGINS="local-dir:${theia-plugins:location}"
  . $${common-environment:output}
  exec ${theia-wrapper:output} "$@"
ip =  $${theia-service-port:ip}
port = $${theia-service-port:port}
base-url = http://$${:ip}:$${:port}/

[theia-instance]
recipe = slapos.cookbook:wrapper
wrapper-path = $${directory:services}/$${:_buildout_section_name_}
command-line = $${theia-service:output}  --hostname=$${:hostname} --port=$${:port} $${directory:project}
hash-existing-files =
  ${yarn.lock:target}
  ${theia-wrapper:output}
ip =  {{ ipv4_random }}
hostname = $${:ip}
port = $${theia-service:port}
base-url = $${theia-service:base-url}

[theia-shell]
recipe = slapos.recipe.template:jinja2
output = $${directory:bin}/$${:_buildout_section_name_}
inline ={% raw %}#!{{ bash }}
  SHELL=$BASH
  # when running interactively, activate slapos configuration and reset GIT_EXEC_PATH to workaround https://github.com/eclipse-theia/theia/issues/7555
  if [ $# = 0 ]; then
    . {{ activate }}
    unset GIT_EXEC_PATH
    set -- --rcfile {{ bashrc }}
  fi
  exec "$SHELL" "$@"
  {% endraw %}
context =
  raw bash ${bash:location}/bin/bash
  key activate slapos-standalone-activate:output
  key bashrc theia-bashrc:output

[theia-bashrc]
recipe = slapos.recipe.template
output = $${directory:etc}/$${:_buildout_section_name_}
inline =
  # enable bash completion
  . ${bash-completion:location}/etc/profile.d/bash_completion.sh
  # source user's .bashrc
  [ -f ~/.bashrc ] && . ~/.bashrc
depends =
  $${shell-setup-completion:recipe}

[shell-setup-completion]
recipe = plone.recipe.command
stop-on-error = true
command =
  ${buildout:bin-directory}/slapos complete > $${directory:bash-completions}/slapos
  ${buildout:bin-directory}/slapos complete --shell fish > $${directory:fish-completions}/slapos.fish


# Embedded Instance
# -----------------

{%- set embedded_sr = parameter_dict['embedded-sr'] %}
{%- set embedded_sr_type = parameter_dict['embedded-sr-type'] %}
{%- set embedded_instance_parameters = parameter_dict['embedded-instance-parameters'] %}
{%- if embedded_sr %}
{%-   if embedded_sr.startswith('~/') %}
{%-     set embedded_sr = os_module.path.join(partition_root_path, embedded_sr[2:]) %}
{%-     set embedded_sr = os_module.path.normpath(embedded_sr) %}
{%-   endif %}
[request-embedded-instance-script]
recipe = slapos.recipe.template
output = $${directory:project}/request_embedded.sh
inline =
  #!/bin/sh

  slapos supply {{ embedded_sr }} slaprunner

  slapos request "embedded_instance" {{ embedded_sr }}
{%-   if embedded_sr_type %} --type {{ embedded_sr_type }} {%- endif %}
{%-   if embedded_instance_parameters %} --parameters-file $${embedded-instance-parameters:output}

[embedded-instance-parameters]
recipe = slapos.recipe.template
output = $${directory:project}/$${:_buildout_section_name_}.json
inline ={{ embedded_instance_parameters | indent(2) }}
{%-   endif %}
{%- endif %}

{%- set embedded_digest = str(embedded_sr) + str(embedded_sr_type) + str(embedded_instance_parameters) %}
{%- set embedded_digest_hash = hashlib_module.md5(embedded_digest.encode()).hexdigest() %}


# SlapOS Standalone
# -----------------

[slapos-standalone-port]
recipe = slapos.cookbook:free_port
minimum = 4000
maximum = 4100
ip = {{ ipv4_random }}

[slapos-standalone-config]
ipv4 = {{ ipv4_random }}
ipv6 = {{ ipv6_random }}
port = $${slapos-standalone-port:port}
local-software-release-root = $${directory:home}
slapos-configuration = $${directory:runner}/etc/slapos.cfg
computer-id = slaprunner
abstract-socket-path = $${directory:home}/standalone-{{ embedded_digest_hash[:16] }}

[slapos-standalone-activate]
recipe = slapos.recipe.template
output = $${directory:bin}/$${:_buildout_section_name_}
inline =
  export PATH=${buildout:bin-directory}:$PATH
  export SLAPOS_CONFIGURATION=$${slapos-standalone-config:slapos-configuration}
  export SLAPOS_CLIENT_CONFIGURATION=$SLAPOS_CONFIGURATION
  echo 'Standalone SlapOS for computer `$${slapos-standalone-config:computer-id}` activated'

[slapos-standalone-script]
recipe = slapos.recipe.template
output = $${directory:bin}/$${:_buildout_section_name_}
inline =
  #!${python-for-standalone:executable}
  import glob
  import json
  import os
  import signal
  import socket
  import subprocess
  import sys
  import time
  import traceback

  import slapos.slap.standalone

  # Include this hash, so that if it changes the standalone service will be restarted
  # {{ embedded_digest_hash }}

  shared_parts = """{{ '''${buildout:shared-part-list}''' | indent(2) }}"""
  shared_part_list = [x.strip() for x in shared_parts.splitlines() if x.strip()]
  partition_forward_configuration = (
    slapos.slap.standalone.PartitionForwardAsPartitionConfiguration(
      master_url="$${slap-connection:server-url}",
      computer="$${slap-connection:computer-id}",
      partition="$${slap-connection:partition-id}",
      cert="$${slap-connection:cert-file}",
      key="$${slap-connection:key-file}",
      software_release_list=(
        'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg',
      ),
    ),
  )
  standalone = slapos.slap.standalone.StandaloneSlapOS(
    "$${directory:runner}",
    "$${slapos-standalone-config:ipv4}",
    $${slapos-standalone-config:port},
    computer_id="$${slapos-standalone-config:computer-id}",
    shared_part_list=shared_part_list,
    software_root="$${directory:runner}/software",
    instance_root="$${directory:runner}/instance",
    partition_forward_configuration=partition_forward_configuration,
    slapos_bin="${buildout:bin-directory}/slapos",
    local_software_release_root="$${slapos-standalone-config:local-software-release-root}",
  )

  def signal_handler(signum, frame):
    print("Signal {signum} received".format(signum=signum))
    sys.exit()
  signal.signal(signal.SIGTERM, signal_handler)

  standalone.start()
  try:
    partition_count = 20
    print("Standalone SlapOS: Formatting %d partitions" % partition_count)
    standalone.format(partition_count, '$${slapos-standalone-config:ipv4}', '$${slapos-standalone-config:ipv6}')
    print("Standalone SlapOS for computer `$${slapos-standalone-config:computer-id}` started")
    # Run instance at least once, to start the supervisor managing instances.
    try:
      standalone.waitForInstance(max_retry=0)
    except slapos.slap.standalone.SlapOSNodeCommandError as e:
      print("Error instanciating: {}".format(e))
{%- if embedded_sr %}
    # Compatibility layer
    try:
      for cp in standalone.computer.getComputerPartitionList():
        if cp.getInstanceParameterDict().get("instance_title") == "Embedded Instance":
          print("Renaming 'Embedded Instance' into 'embedded_instance'")
          cp.rename(new_name="embedded_instance")
          break
    except Exception:
      print("Exception in compatibility layer, printing and moving on")
      traceback.print_exc()
    # Run request script
    print("Running SlapOS script $${request-embedded-instance-script:output}")
    slapos_env = {
      'PATH': os.path.dirname(standalone._slapos_bin),
      'SLAPOS_CONFIGURATION': standalone._slapos_config,
      'SLAPOS_CLIENT_CONFIGURATION': standalone._slapos_config
    }
    subprocess.call(("$${request-embedded-instance-script:output}",), env=slapos_env)
{%- endif %}
    s = socket.socket(socket.AF_UNIX)
    s.bind("\0$${slapos-standalone-config:abstract-socket-path}")
    s.listen(5)
    print("Standalone SlapOS ready")
    while True:
      s.accept()[0].close()
  finally:
    print("Stopping standalone subsystem")
    standalone.stop()
    print("Exiting")

[slapos-standalone]
recipe = slapos.recipe.template
output = $${directory:bin}/$${:_buildout_section_name_}
inline =
  #!/bin/sh
  . $${common-environment:output}
  #XXX find out where the extra nodejs in theia's PATH comes from
  export PATH=${nodejs:location}/bin/:$PATH
  . $${slapos-standalone-activate:output}
  exec $${slapos-standalone-script:output}

[slapos-standalone-instance]
recipe = slapos.cookbook:wrapper
wrapper-path = $${directory:services}/$${:_buildout_section_name_}
command-line = $${slapos-standalone:output}
hash-files =
  $${slapos-standalone:output}
  $${slapos-standalone-script:output}
hostname = $${slapos-standalone-config:ipv4}
port = $${slapos-standalone-config:port}


# Slapos Standalone Autoprocessing
# --------------------------------

[slapos-autorun]
recipe = plone.recipe.command
command =
  case $${:autorun} in
    ( running ) ${buildout:bin-directory}/supervisorctl -c $${:supervisor-conf} start $${:service-name};;
    ( stopped ) ${buildout:bin-directory}/supervisorctl -c $${:supervisor-conf} stop $${:service-name};;
  esac
update-command = $${:command}
service-name = slapos-node-auto
supervisor-conf = $${directory:runner}/etc/supervisord.conf
autorun = {{ parameter_dict['autorun'] }}


# Theia Local Environment Setup
# -----------------------------

[tasks.json]
recipe = slapos.recipe.template
output = $${directory:dot-theia}/tasks.json
inline =
  {
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
      {
        "label": "slapos node software",
        "detail": "Build all software supplied to the node",
        "type": "shell",
        "command": "${buildout:bin-directory}/slapos",
        "args": [
          "node",
          "software",
          // debug mode can be enabled by commenting out this line:
          // "--buildout-debug",
          "--all"
        ],
        "options": {
          "env": {
            "SLAPOS_CONFIGURATION": "$${slapos-standalone-config:slapos-configuration}",
            "GIT_EXEC_PATH": ""
          }
        },
        "group": {
          "kind": "build",
          "isDefault": true
        },
        "problemMatcher": []
      },
      {
        "label": "slapos node instance",
        "detail": "Create all instances requested on the node",
        "type": "shell",
        "command": "${buildout:bin-directory}/slapos",
        "args": [
          "node",
          "instance",
          // debug mode can be enabled by commenting out this line:
          // "--buildout-debug",
          "--all"
        ],
        "options": {
          "env": {
            "SLAPOS_CONFIGURATION": "$${slapos-standalone-config:slapos-configuration}",
            "GIT_EXEC_PATH": ""
          }
        },
        "problemMatcher": [],
        "group": {
          "kind": "build",
          "isDefault": true
        }
      }
    ]
  }

[slapos-repository]
recipe = slapos.recipe.build:gitclone
repository = https://lab.nexedi.com/nexedi/slapos.git
location = $${directory:project}/slapos
branch = 1.0
develop = true
git-executable = ${git:location}/bin/git

[settings.json]
recipe = slapos.recipe.template:jinja2
output = $${directory:dot-theia}$${:_buildout_section_name_}
once = $${:output}
inline =
  {
    "files.watcherExclude": {
      "**/.eggs/**": true,
      "**/.env/**": true,
      "**/.git/**": true,
      "**/node_modules/**": true,
      "$${directory:runner}/**":true,
      "$${directory:project}/runner/**":true
    },
    "git.terminalAuthentication": false,
    "security.workspace.trust.startupPrompt": "once"
  }

[runner-link]
recipe = slapos.cookbook:symbolic.link
target-directory = $${directory:project}
link-binary = $${directory:runner}

[request-script-template]
recipe = slapos.recipe.template
output = $${directory:project}/$${:_buildout_section_name_}.sh
inline =
  #!/bin/sh
  # This template is generated automatically, copy it in order to supply and request.
  # Any manual change to this file may be lost.
  software_name=html5as-base #replace the software name writen in ~/srv/project/slapos/software/
  software_release_uri=~/srv/project/slapos/software/$software_name/software.cfg
  # slapos supply is used to add the software to the software list to be supplied to a node.
  slapos supply $software_release_uri slaprunner
  # slapos request the allocation of an instance to the master.
  # slapos request also gets status and parameters of the instance if it has any
  # (slapos request is meant to be run multiple time until you get the status).
  slapos request $software_name'_1' $software_release_uri