instance-runner.cfg 24.4 KB
Newer Older
1 2
[buildout]
parts =
3 4 5 6
  nginx_conf
  nginx-launcher
  certificate-authority
  ca-nginx
7 8
  gunicorn-launcher
  gunicorn-graceful
9
  sshkeys-dropbear-runner
10
  dropbear-server-add-authorized-key
11
  sshkeys-authority
12
  publish-connection-information
13 14
  slaprunner-promise
  slaprunner-frontend-promise
15
  slaprunner-supervisord-wrapper
16
  dropbear-promise
17
  runtestsuite
18
  symlinks
19
  shellinabox
20
  slapos-cfg
21
  slapos-repo
22
  cron-entry-prepare-software
23
  deploy-instance-parameters
24
  instance-software
25
  instance-software-type
26
  minishell-cwd
27
  bash-profile
28
  supervisord-wrapper
29
  supervisord-promise
30
{% if slapparameter_dict.get('custom-frontend-backend-url') and slapparameter_dict.get('check-custom-frontend-promise', 'false') == 'true' %}
31 32
  custom-frontend-promise
{% endif %}
33
## Monitoring part
34
###Parts to add for monitoring
35
  cron
36 37 38
  certificate-authority
  cron-entry-monitor
  cron-entry-rss
39 40 41
  deploy-index
  deploy-settings-cgi
  deploy-status-cgi
42
  deploy-status-history-cgi
43
  setup-static-files
44 45
  certificate-authority
  zero-parameters
46
  public-symlink
47 48 49 50 51 52
  cgi-httpd-wrapper
  cgi-httpd-graceful-wrapper
  monitor-promise
  monitor-instance-log-access
## Monitor for runner
  monitor-current-log-access
53
  monitor-deploy-cors-domain-cgi
54
  monitor-check-webrunner-internal-instance
55 56

extends = ${monitor-template:output}
57 58 59 60 61

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

62 63
{% if slapparameter_dict.get('custom-frontend-backend-url') -%}
[request-custom-frontend]
64
recipe = slapos.cookbook:requestoptional
65
software-url = {{ slapparameter_dict.get('custom-frontend-software-url', 'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg') }}
66 67 68 69
software-type = {{ slapparameter_dict.get('custom-frontend-software-type', 'RootSoftwareInstance') }}
slave = true
name = Custom Web Frontend

70 71 72 73 74
server-url = $${slap-connection:server-url}
key-file = $${slap-connection:key-file}
cert-file = $${slap-connection:cert-file}
computer-id = $${slap-connection:computer-id}
partition-id = $${slap-connection:partition-id}
75

76
{% if slapparameter_dict.get('custom-frontend-instance-guid') -%}
77
sla-instance_guid = $${slap-parameter:frontend-instance-guid}
78 79
{% endif -%}

80 81
{% set custom_frontend_backend_type = slapparameter_dict.get('custom-frontend-backend-type') -%}
{% if custom_frontend_backend_type -%}
82 83
config-type = {{ custom_frontend_backend_type }}
{% endif -%}
84
config-url = {{ slapparameter_dict.get('custom-frontend-backend-url') }}
85
return = site_url domain
86 87 88

[custom-frontend-promise]
recipe = slapos.cookbook:check_url_available
89 90 91 92 93
path = $${directory:promises}/custom_frontend_promise
url = https://$${request-custom-frontend:connection-domain}
{% if slapparameter_dict.get('custom-frontend-basic-auth') -%}
check-secure = 1
{% endif -%}
94 95 96
dash_path = {{ dash_executable_location }}
curl_path = {{ curl_executable_location }}

97
[publish-connection-information]
98
custom-frontend-url = https://$${request-custom-frontend:connection-domain}
99
{% endif %}
100

101
# Create all needed directories
102
[directory]
103
recipe = slapos.cookbook:mkdirectory
104 105 106 107 108 109
home = $${buildout:directory}
etc = $${:home}/etc/
var = $${:home}/var/
srv = $${:home}/srv/
bin = $${:home}/bin/
tmp = $${:home}/tmp/
110

111 112 113 114 115 116 117 118 119
sshkeys = $${:srv}/sshkeys
services = $${:etc}/service/
scripts = $${:etc}/run/
ssh = $${:etc}/ssh/
log = $${:var}/log/
run = $${:var}/run/
backup = $${:srv}/backup/
promises = $${:etc}/promise/
test = $${:etc}/test/
120
nginx-data = $${:srv}/nginx
121
ca-dir = $${:srv}/ssl
122
project = $${:srv}/runner/project
123 124 125

[runnerdirectory]
recipe = slapos.cookbook:mkdirectory
126 127
home = $${directory:srv}/runner/
test = $${directory:srv}/test/
128
project = $${:home}/project
129
public = $${:home}/public
130 131
software-root = $${:home}/software
instance-root = $${:home}/instance
132 133 134
project-test = $${:test}/project
software-test = $${:test}/software
instance-test = $${:test}/instance
135
sessions = $${buildout:directory}/.sessions
136 137
private-project = $${:home}/.git-private
public-project = $${:home}/.git-public
138

139 140
#Create password recovery code for slaprunner
[recovery-code]
141
recipe = slapos.cookbook:generate.password
142
storage-path = $${directory:etc}/.rcode
143
bytes = 8
144

145
[slaprunner]
146
slaprunner = ${buildout:directory}/bin/slaprunner
147
slapos = ${buildout:directory}/bin/slapos
148 149
slapproxy = ${buildout:directory}/bin/slapproxy
supervisor = ${buildout:directory}/bin/slapgrid-supervisorctl
150
git-binary = ${git:location}/bin/git
151
root_check = false
152
slapos.cfg = $${directory:etc}/slapos.cfg
153 154
working-directory = $${runnerdirectory:home}
project-directory = $${runnerdirectory:project}
155 156
instance_root = $${runnerdirectory:instance-root}
software_root = $${runnerdirectory:software-root}
157
instance-monitor-url = https://[$${:ipv6}]:$${monitor-parameters:port}
158 159 160
etc_dir = $${directory:etc}
log_dir =  $${directory:log}
run_dir = $${directory:run}
161 162 163
ssh_client = $${sshkeys-dropbear-runner:wrapper}
public_key = $${sshkeys-dropbear-runner:public-key}
private_key = $${sshkeys-dropbear-runner:private-key}
164 165
ipv4 = $${slap-network-information:local-ipv4}
ipv6 = $${slap-network-information:global-ipv6}
166
instance_root = $${runnerdirectory:instance-root}
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
167
proxy_port = 50000
168
runner_port = 50005
169
partition-amount = $${slap-parameter:instance-amount}
170
wrapper = $${directory:services}/slaprunner
171
debug = $${slap-parameter:debug}
172
access-url = https://[$${:ipv6}]:$${:runner_port}
173
supervisord_config = $${directory:etc}/supervisord.conf
174
supervisord_server = http://$${supervisord:server}
175
proxy_database = $${slaprunner:working-directory}/proxy.db
176 177 178
console = False
verbose = False
debug = False
179 180 181 182
auto_deploy = $${slap-parameter:auto-deploy}
auto_deploy_instance = $${slap-parameter:auto-deploy-instance}
autorun = $${slap-parameter:autorun}
knowledge0_file = $${buildout:directory}/$${public:filename}
183
minishell_cwd_file = $${directory:etc}/.minishell-cwd
184
minishell_history_file = $${directory:etc}/.minishell_history
185 186
software_info_json = $${runnerdirectory:home}/software_info.json
instance_info_json = $${runnerdirectory:home}/instance_info.json
187
path = $${shell:path}
188
instance_name = $${slap-parameter:instance-name}
189

190 191 192 193 194 195 196 197 198 199 200

#---------------------------
#--
#-- supervisord managing slaprunner instance processes
[slaprunner-supervisord-wrapper]
recipe = slapos.cookbook:wrapper
# XXX hardcoded locations
command-line = $${buildout:directory}/bin/slapos node supervisord --cfg $${directory:etc}/slapos.cfg -n
wrapper-path = $${directory:services}/slaprunner-supervisord


201 202
[test-runner]
<= slaprunner
203
slapos.cfg = $${directory:etc}/slapos-test.cfg
204 205
working-directory = $${runnerdirectory:test}
project-directory = $${runnerdirectory:project-test}
206 207
software_root = $${runnerdirectory:software-test}
instance_root = $${runnerdirectory:instance-test}
208
proxy_port = 8602
209
etc_dir = $${directory:test}
210 211
autorun = False
auto_deploy = True
212

213 214 215
[runtestsuite]
recipe = slapos.cookbook:wrapper
command-line = ${buildout:directory}/bin/slaprunnertest
216
wrapper-path = $${directory:bin}/runTestSuite
217
environment = RUNNER_CONFIG=$${slapos-cfg:rendered}
218 219 220 221 222 223

# Deploy dropbear (minimalist SSH server)
[sshkeys-directory]
recipe = slapos.cookbook:mkdirectory
requests = $${directory:sshkeys}/requests/
keys = $${directory:sshkeys}/keys/
224

225 226 227 228
[sshkeys-authority]
recipe = slapos.cookbook:sshkeys_authority
request-directory = $${sshkeys-directory:requests}
keys-directory = $${sshkeys-directory:keys}
229
wrapper = $${directory:services}/sshkeys_authority
230 231
keygen-binary = ${dropbear:location}/bin/dropbearkey

232
[dropbear-runner-server]
233 234
recipe = slapos.cookbook:dropbear
host = $${slap-network-information:global-ipv6}
235
port = 22222
236
home = $${buildout:directory}
237 238
wrapper = $${directory:bin}/runner_sshd
shell = ${bash:location}/bin/bash
239
rsa-keyfile = $${directory:ssh}/server_key.rsa
240
allow-port-forwarding = true
241 242
dropbear-binary = ${dropbear:location}/sbin/dropbear

243
[sshkeys-dropbear-runner]
244 245 246 247
<= sshkeys-authority
recipe = slapos.cookbook:sshkeys_authority.request
name = dropbear
type = rsa
248 249 250 251
executable = $${dropbear-runner-server:wrapper}
public-key = $${dropbear-runner-server:rsa-keyfile}.pub
private-key = $${dropbear-runner-server:rsa-keyfile}
wrapper = $${directory:services}/runner_sshd
252 253

[dropbear-server-add-authorized-key]
254
<= dropbear-runner-server
255
recipe = slapos.cookbook:dropbear.add_authorized_key
256
key = $${slap-parameter:user-authorized-key}
257

258
#---------------------------
259
#--
260 261
#-- Set nginx frontend

262 263 264 265 266 267 268 269 270 271
[tempdirectory]
recipe = slapos.cookbook:mkdirectory
client_body_temp_path = $${directory:tmp}/client_body_temp_path
proxy_temp_path = $${directory:tmp}/proxy_temp_path
fastcgi_temp_path = $${directory:tmp}/fastcgi_temp_path
uwsgi_temp_path = $${directory:tmp}/uwsgi_temp_path
scgi_temp_path = $${directory:tmp}/scgi_temp_path

[nginx-frontend]
# Options
272
nb_workers = 5
273
# Network
274 275 276
local-ip = $${slap-network-information:local-ipv4}
global-ip = $${slap-network-information:global-ipv6}
global-port = $${slaprunner:runner_port}
277
# Backend
278 279
runner-ip = $${slaprunner:ipv4}
runner-port = $${slaprunner:runner_port}
280 281 282 283 284 285 286 287
# SSL
ssl-certificate = $${ca-nginx:cert-file}
ssl-key = $${ca-nginx:key-file}
# Log
path_pid = $${directory:run}/nginx.pid
path_log = $${directory:log}/nginx.log
path_access_log = $${directory:log}/nginx.access.log
path_error_log = $${directory:log}/nginx.error.log
288
path_tmp = $${directory:tmp}/
289
nginx_prefix = $${buildout:directory}
290 291 292
# Config files
path_nginx_conf = $${directory:etc}/nginx.conf
# Executables
293
bin_nginx = ${nginx-webdav:location}/sbin/nginx
294
bin_launcher = $${directory:bin}/launcher
295 296
# Utils
path_shell = ${dash:location}/bin/dash
297 298
# Misc.
etc_dir = $${directory:etc}
299
work_dir = $${slaprunner:working-directory}
300 301 302 303 304 305

[nginx_conf]
recipe = slapos.recipe.template:jinja2
template = ${template_nginx_conf:location}/${template_nginx_conf:filename}
rendered = $${nginx-frontend:path_nginx_conf}
context =
306
    key shellinabox_socket shellinabox:socket
307
    key socket gunicorn:socket
308 309 310 311 312 313 314 315 316 317 318
    section param_nginx_frontend nginx-frontend
    section param_tempdir tempdirectory

[nginx-launcher]
recipe = slapos.recipe.template:jinja2
template = ${template_launcher:location}/${template_launcher:filename}
rendered = $${nginx-frontend:bin_launcher}
mode = 700
context =
    section param_nginx_frontend nginx-frontend

319 320 321 322 323 324 325 326 327 328 329 330 331
[httpd-parameters]
path_pid = $${directory:run}/httpd.pid
path_error_log = $${directory:log}/httpd-error.log
path_access_log = $${directory:log}/httpd-access.log
key_file = $${ca-httpd:key-file}
cert_file = $${ca-httpd:cert-file}
global_ip = $${slap-network-information:global-ipv6}
global_port = $${slaprunner:runner_port}
monitor_port = $${monitor-parameters:port}
monitor_index = $${deploy-index:rendered}
working_directory = $${slaprunner:working-directory}
dav_lock = $${directory:var}/DavLock
etc_dir = $${directory:etc}
332
var_dir = $${directory:var}
333
project_folder = $${directory:project}
334
project_private_folder = $${runnerdirectory:private-project}
335
project_public_folder = $${runnerdirectory:public-project}
336
runner_home = $${runnerdirectory:home}
337
git_http_backend = ${git:location}/libexec/git-core/git-http-backend
338
cgi_httpd_conf = $${monitor-httpd-configuration-file:rendered}
339
httpd_cors_file = $${monitor-httpd-cors:location}
340 341 342 343 344

[httpd-conf]
recipe = slapos.recipe.template:jinja2
template = ${template_httpd_conf:location}/${template_httpd_conf:filename}
rendered = $${directory:etc}/httpd.conf
345
context =
346 347 348
    section parameters httpd-parameters

[cgi-httpd-wrapper]
349 350 351
recipe = slapos.cookbook:wrapper
apache-executable = ${apache:location}/bin/httpd
wrapper-path = $${ca-httpd:executable}
352 353
command-line = $${:apache-executable} -f $${httpd-conf:rendered} -DFOREGROUND

354 355 356 357
#--------------------
#--
#-- WSGI

358
[gunicorn]
359 360 361 362 363 364 365 366
bin_gunicorn = $${directory:bin}/gunicorn
bin_launcher = $${directory:services}/gunicorn
path_shell = ${dash:location}/bin/dash
socket = $${directory:tmp}/flaskserver.sock
path_pid = $${directory:run}/gunicorn.pid

[gunicorn-launcher]
recipe = slapos.cookbook:wrapper
367
command-line = $${gunicorn:bin_gunicorn} slapos.runner.run:app -p $${gunicorn:path_pid} -b unix:$${gunicorn:socket} -e RUNNER_CONFIG=$${slaprunner:slapos.cfg} --error-logfile $${directory:log}/$${:error-log-file} --log-level error --preload
368
error-log-file = gunicorn-error.log
369
wrapper-path = $${gunicorn:bin_launcher}
370
environment = PATH=$${environ:PATH}:${git:location}/bin/
371
  RUNNER_CONFIG=$${slaprunner:slapos.cfg}
372
  LANG=en_GB.UTF-8
373 374 375

[gunicorn-graceful]
recipe = slapos.cookbook:wrapper
376
command-line = $${directory:bin}/killpidfromfile $${gunicorn:path_pid} SIGHUP
377 378
wrapper-path = $${directory:scripts}/gunicorn-graceful

379
#--------------------
380
#--
381
#-- ssl certificates
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406

[certificate-authority]
recipe = slapos.cookbook:certificate_authority
openssl-binary = ${openssl:location}/bin/openssl
ca-dir = $${directory:ca-dir}
requests-directory = $${cadirectory:requests}
wrapper = $${directory:services}/certificate_authority
ca-private = $${cadirectory:private}
ca-certs = $${cadirectory:certs}
ca-newcerts = $${cadirectory:newcerts}
ca-crl = $${cadirectory:crl}

[cadirectory]
recipe = slapos.cookbook:mkdirectory
requests = $${directory:ca-dir}/requests/
private = $${directory:ca-dir}/private/
certs = $${directory:ca-dir}/certs/
newcerts = $${directory:ca-dir}/newcerts/
crl = $${directory:ca-dir}/crl/

[ca-nginx]
<= certificate-authority
recipe = slapos.cookbook:certificate_authority.request
key-file = $${cadirectory:certs}/nginx_frontend.key
cert-file = $${cadirectory:certs}/nginx_frontend.crt
407 408
executable = $${nginx-launcher:rendered}
wrapper = $${directory:services}/nginx-frontend
409 410 411
# Put domain name
name = example.com

412
#--------------------
413 414
#--
#-- Request frontend
415

416 417
[request-frontend]
<= slap-connection
418
recipe = slapos.cookbook:requestoptional
419
name = SlapRunner Frontend
420
# XXX We have hardcoded SR URL here.
421
software-url = http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg
422
slave = true
423
config-url = $${slaprunner:access-url}
424
config-domain = $${slap-parameter:frontend-domain}
425
return = site_url domain
426

427 428 429 430 431
[monitor-frontend]
<= slap-connection
recipe = slapos.cookbook:requestoptional
name = Monitor Frontend
# XXX We have hardcoded SR URL here.
432
software-url = http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg
433
slave = true
434
config-url = https://[$${monitor-httpd-configuration:listening-ip}]:$${monitor-parameters:port}
435 436 437
config-domain = $${slap-parameter:frontend-domain}
return = site_url domain

438
#--------------------------------------
439
#--
440
#-- Send information to SlapOS Master
441

442
[publish-connection-information]
443
recipe = slapos.cookbook:publish
444
1_info = On your first run, Use "access_url" to setup you account. Then you can use both "url" or "access_url". Or "backend_url" if you want to use ipv6. Set up your account in the webrunner in order to use webdav, and being able to clone your git repositories from the runner.
445
2_info = In order to set up your account, get the recovery-code from the monitoring interface. Before read the notification on monitor_info.
446
backend_url = $${slaprunner:access-url}
447
access_url = $${:url}/login
448
url =  https://$${request-frontend:connection-domain}
449
ssh_command = ssh $${dropbear-runner-server:host} -p $${dropbear-runner-server:port}
450
monitor_url = https://$${monitor-frontend:connection-domain}
451
monitor_backend_url = https://[$${monitor-httpd-configuration:listening-ip}]:$${monitor-parameters:port}
452 453
webdav_url = $${:monitor_url}/share/
public_url =  $${:monitor_url}/public/
454 455
git_public_url = https://[$${httpd-parameters:global_ip}]:$${httpd-parameters:monitor_port}/git-public/
git_private_url = https://[$${httpd-parameters:global_ip}]:$${httpd-parameters:monitor_port}/git/
456

457 458 459
#---------------------------
#--
#-- Deploy promises scripts
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
460

461 462
[slaprunner-promise]
recipe = slapos.cookbook:check_port_listening
463
path = $${directory:promises}/slaprunner
464 465
hostname = $${slaprunner:ipv6}
port = $${slaprunner:runner_port}
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
466

467
[slaprunner-frontend-promise]
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
468
recipe = slapos.cookbook:check_url_available
469
path = $${directory:promises}/slaprunner_frontend
470
url = https://$${request-frontend:connection-domain}/login
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
471 472
dash_path = ${dash:location}/bin/dash
curl_path = ${curl:location}/bin/curl
473
check-secure = 1
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
474

475 476
[dropbear-promise]
recipe = slapos.cookbook:check_port_listening
477
path = $${directory:promises}/dropbear
478 479
hostname = $${dropbear-runner-server:host}
port = $${dropbear-runner-server:port}
480

481 482
[symlinks]
recipe = cns.recipe.symlink
483
symlink_target = $${directory:bin}
484
symlink_base = ${buildout:directory}/bin
485 486 487

[slap-parameter]
# Default value if no ssh key is specified
488
user-authorized-key =
489
# Default value of instances number in slaprunner
490
instance-amount = 10
491 492
debug = false
frontend-domain =
493
slapos-repository = https://lab.nexedi.com/nexedi/slapos.git
494
slapos-software =
495
slapos-software-type =
496
slapos-reference = master
497
auto-deploy = false
498
auto-deploy-instance = true
499
autorun = false
500
monitor-port = 9684
501
instance-name =
502 503 504

[monitor-parameters]
port = $${slap-parameter:monitor-port}
505

506 507
[slapos-cfg]
recipe = slapos.recipe.template:jinja2
508
template = ${template-slapos-cfg:location}/${template-slapos-cfg:filename}
509 510 511
rendered = $${slaprunner:slapos.cfg}
mode = 700
context =
512
  section slaprunner slaprunner
513

514 515
[slapos-test-cfg]
recipe = slapos.recipe.template:jinja2
516
template = ${template-slapos-cfg:location}/${template-slapos-cfg:filename}
517 518 519 520 521
rendered = $${test-runner:slapos.cfg}
mode = 700
context =
  section slaprunner test-runner

522
[shellinabox]
523 524 525 526 527 528 529 530 531 532 533
recipe = slapos.recipe.template:jinja2
# We cannot use slapos.cookbook:wrapper here because this recipe escapes too much
socket = $${directory:run}/siab.sock
mode = 0700
rendered = $${directory:services}/shellinaboxd
template = inline:
  #!/bin/sh
  exec ${shellinabox:location}/bin/shellinaboxd \
    --disable-ssl \
    --disable-ssl-menu \
    --unixdomain-only=$${:socket}:$(id -u):$(id -g):0600 \
Jérome Perrin's avatar
Jérome Perrin committed
534
    --service "/:$(id -u):$(id -g):HOME:$${shell:wrapper} -l"
535 536 537

[shell]
recipe = slapos.cookbook:shell
Jérome Perrin's avatar
Jérome Perrin committed
538
wrapper = $${directory:bin}/bash
539
shell = ${bash:location}/bin/bash
540
home = $${buildout:directory}
541
path = $${environ:PATH}:/usr/bin:/bin/:${nano:location}/bin:${vim:location}/bin:${screen:location}/bin:${git:location}/bin:${tig:location}/bin
542 543
ps1 = "\\w> "

544 545 546
[environ]
recipe = collective.recipe.environment

547 548 549 550 551 552
[slapos-repo]
recipe = slapos.recipe.build:gitclone
repository = $${slap-parameter:slapos-repository}
git-executable = ${git:location}/bin/git
develop = true
location = $${directory:project}/slapos
553
branch = $${slap-parameter:slapos-reference}
554 555 556

[prepare-software]
recipe = slapos.cookbook:wrapper
557
command-line = ${curl:location}/bin/curl -g https://[$${slaprunner:ipv6}]:$${slaprunner:runner_port}/isSRReady --max-time 1 --insecure
558 559
wrapper-path = $${directory:scripts}/prepareSoftware

560 561 562 563 564 565 566
[cron-entry-prepare-software]
<= cron
recipe = slapos.cookbook:cron.d
name = prepare-software
frequency = */2 * * * *
command = $${prepare-software:wrapper-path}

567 568 569
[instance-parameters]
recipe = slapos.recipe.template:jinja2
extensions = jinja2.ext.do
570
template = ${template-parameters:location}/${template-parameters:filename}
571 572
rendered = $${directory:etc}/.parameter.xml.default
mode = 0644
573
context =
574 575 576 577 578 579 580 581
  key slapparameter_dict slap-configuration:configuration

[deploy-instance-parameters]
recipe = plone.recipe.command
stop-on-error = true
parameter-xml = $${directory:etc}/.parameter.xml
command = if [ ! -f $${:parameter-xml} ]; then cp $${instance-parameters:rendered} $${:parameter-xml}; fi

582 583 584 585 586 587 588
[instance-software-type]
recipe = plone.recipe.command
stop-on-error = true
# XXX It should not be named with .xml as it is not xml
software-type-path = $${directory:etc}/.software_type.xml
command = if [ ! -f $${:software-type-path} -a "$${slap-parameter:slapos-software-type}" != "" ]; then echo "$${slap-parameter:slapos-software-type}" > $${:software-type-path}; fi

589 590 591 592 593
[instance-software]
recipe = plone.recipe.command
stop-on-error = true
command = SR=$${slap-parameter:slapos-software} && if [ -n "$SR" ] && [ ! -f "$${directory:etc}/.project" ]; then echo workspace/slapos/$${slap-parameter:slapos-software}/ > $${directory:etc}/.project; fi

594 595 596 597 598 599 600 601
[slap-configuration]
recipe = slapos.cookbook:slapconfiguration.serialised
computer = $${slap-connection:computer-id}
partition = $${slap-connection:partition-id}
url = $${slap-connection:server-url}
key = $${slap-connection:key-file}
cert = $${slap-connection:cert-file}

602
[public]
603 604
recovery-code = $${recovery-code:passwd}

605
[zero-parameters]
606 607


608 609 610 611 612 613
[minishell-cwd]
recipe = plone.recipe.command
command = if [ ! -f $${slaprunner:minishell_cwd_file} ]; then echo $${runnerdirectory:home} > $${slaprunner:minishell_cwd_file}; fi
location = $${slaprunner:minishell_cwd_file}
stop-on-error = true

614
[bash-profile]
615 616 617 618
recipe = slapos.recipe.template:jinja2
template = ${template-bash-profile:location}/${template-bash-profile:filename}
rendered = $${buildout:directory}/.bash_profile
context =
619
    raw path $PATH:${nano:location}/bin:${vim:location}/bin:${screen:location}/bin:${git:location}/bin:${curl:location}/bin:${python2.7:location}/bin:${tig:location}/bin:${zip:location}/bin
620
    key workdir runnerdirectory:home
621

622 623 624 625 626

#---------------------------
#--
#-- supervisord managing slaprunner automation features

627
[supervisord]
628
autorestart = false
629 630 631 632
autostart = false
directory = $${buildout:directory}
exitcodes = 0
logfile = $${directory:log}/supervisord.log
633
no_logfile = NONE
634
numprocs = 1
635
path = $${shell:path}
636
pidfile = $${directory:run}/supervisord.pid
637 638
server = $${slaprunner:ipv4}:$${:port}
port = 39986
639
slapgrid-cp = slapgrid-cp
640
slapgrid-cp-command = $${slaprunner:slapos} node instance --all --cfg $${:slapos-cfg} --pidfile $${:slapgrid-cp-pid} --verbose --logfile $${:slapgrid-cp-log}
641 642
slapgrid-cp-log = $${runnerdirectory:home}/instance.log
slapgrid-cp-pid = $${directory:run}/slapgrid-cp.pid
643
slapgrid-cp-startretries = 0
644
slapgrid-sr = slapgrid-sr
645
slapgrid-sr-command = $${slaprunner:slapos} node software --all --cfg $${:slapos-cfg} --pidfile $${:slapgrid-sr-pid} --verbose --logfile $${:slapgrid-sr-log}
646 647
slapgrid-sr-log = $${runnerdirectory:home}/software.log
slapgrid-sr-pid = $${directory:run}/slapgrid-sr.pid
648
slapgrid-sr-startretries = 0
649 650 651
slapproxy = slapproxy
slapproxy-autorestart = true
slapproxy-autostart = true
652
slapproxy-startsecs = 1
653
slapproxy-command = $${slaprunner:slapos} proxy start --logfile $${:slapproxy-log} --cfg $${:slapos-cfg}
654
slapproxy-log = $${directory:log}/slapproxy.log
655 656
socket_name = unix://$${:socket_path}
socket_path = $${directory:tmp}/supervisord.sock
657
startsecs = 0
658 659 660
# This file logs errors from listeners. Supervisord has its own logfile.
# Processes should handle their logs by themselves
stderr_logfile = $${directory:log}/supervisord-errors.log
661
slapos-cfg = $${slaprunner:slapos.cfg}
662 663 664 665 666 667

[supervisord-conf]
recipe = slapos.recipe.template:jinja2
template = ${template-supervisord:location}/${template-supervisord:filename}
rendered = $${directory:etc}/supervisord.conf
context =
668 669
    import multiprocessing multiprocessing
    import builtin __builtin__
670
    section supervisord supervisord
671
    key slapparameter_dict slap-configuration:configuration
672 673 674 675 676 677 678 679 680 681
    key listener_slapgrid listener-slapgrid-bin:rendered

[listener-slapgrid-bin]
recipe = slapos.recipe.template:jinja2
template = ${template-listener-slapgrid:location}/${template-listener-slapgrid:filename}
rendered = $${directory:bin}/listener_slapgrid.py
mode = 0744
context =
    section supervisord supervisord
    section slaprunner slaprunner
682
    raw python_executable ${buildout:directory}/bin/${extra-eggs:interpreter}
683 684 685 686 687 688

[supervisord-wrapper]
recipe = slapos.cookbook:wrapper
command-line = $${buildout:directory}/bin/supervisord -c $${supervisord-conf:rendered} --nodaemon
wrapper-path = $${directory:services}/supervisord

689 690 691 692 693 694
[supervisord-promise]
recipe = slapos.cookbook:check_port_listening
path = $${directory:promises}/supervisord
hostname = $${slaprunner:ipv4}
port = $${supervisord:port}

695

696 697 698
[monitor-current-log-access]
< = monitor-directory-access
source = $${directory:log}
699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714

[monitor-deploy-cors-domain-cgi]
recipe = slapos.recipe.template:jinja2
template = ${cors-domain-cgi:location}/${cors-domain-cgi:filename}
rendered = $${monitor-directory:knowledge0-cgi}/$${:filename}
filename = cors-domain.cgi
mode = 0744
context =
  raw config_cfg $${buildout:directory}/knowledge0.cfg
  raw timestamp $${buildout:directory}/.timestamp
  raw python_executable ${buildout:executable}
  key apache_file httpd-parameters:httpd_cors_file
  key pwd monitor-directory:knowledge0-cgi
  key this_file :filename
  key httpd_graceful cgi-httpd-graceful-wrapper:rendered

715 716 717 718 719 720 721
[monitor-check-webrunner-internal-instance]
recipe = slapos.recipe.template:jinja2
template = ${monitor-check-webrunner-internal-instance:location}/${monitor-check-webrunner-internal-instance:filename}
rendered = $${monitor-directory:monitor-custom-scripts}/$${:filename}
filename = monitor-check-webrunner-internal-instance.py
mode = 0744

722 723 724 725 726 727
[monitor-httpd-cors]
recipe = plone.recipe.command
command = if [ ! -f $${:location} ]; then touch $${:location}; fi
location = $${directory:etc}/$${:filename}
filename = httpd-cors.cfg
stop-on-error = true