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

extends = ${monitor-template:output}
54 55 56 57 58

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

59 60 61 62 63 64 65
{% if slapparameter_dict.get('custom-frontend-backend-url') -%}
# Requests, if defined, a frontend to allow access to a server
# located inside of the virtual machine listening to port X
# to LAN IPv4.
# Internaly, the frontend will be asked to listen on the IPv6
# with port X + 10000, to match NAT rules of Qemu.
[request-custom-frontend]
66
recipe = slapos.cookbook:requestoptional
67 68 69 70 71
software-url = {{ slapparameter_dict.get('custom-frontend-software-url', 'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg') }}
software-type = {{ slapparameter_dict.get('custom-frontend-software-type', 'RootSoftwareInstance') }}
slave = true
name = Custom Web Frontend

72 73 74 75 76
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}
77

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

83 84 85 86 87
{% set custom_frontend_backend_type = slapparameter_dict.get('custom-frontend-backend-type')%}
{% if custom_frontend_backend_type %}
config = url type
config-type = {{ custom_frontend_backend_type }}
{% else %}
88
config = url
89
{% endif -%}
90
config-url = {{ slapparameter_dict.get('custom-frontend-backend-url') }}
91
return = site_url domain
92 93 94

[custom-frontend-promise]
recipe = slapos.cookbook:check_url_available
95 96 97 98 99
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 -%}
100 101 102 103
dash_path = {{ dash_executable_location }}
curl_path = {{ curl_executable_location }}

[publish-connection-informations]
104
custom-frontend-url = https://$${request-custom-frontend:connection-domain}
105
{% endif %}
106

107
# Create all needed directories
108
[directory]
109 110 111 112 113
recipe = slapos.cookbook:mkdirectory
etc = $${buildout:directory}/etc/
var = $${buildout:directory}/var/
srv = $${buildout:directory}/srv/
bin = $${buildout:directory}/bin/
114
tmp = $${buildout:directory}/tmp/
115

116 117 118 119 120 121 122 123 124
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/
125
nginx-data = $${directory:srv}/nginx
126
ca-dir = $${:srv}/ssl
127
project = $${:srv}/runner/project
128 129 130

[runnerdirectory]
recipe = slapos.cookbook:mkdirectory
131 132
home = $${directory:srv}/runner/
test = $${directory:srv}/test/
133
project = $${:home}/project
134
public = $${:home}/public
135 136
software-root = $${:home}/software
instance-root = $${:home}/instance
137 138 139
project-test = $${:test}/project
software-test = $${:test}/software
instance-test = $${:test}/instance
140
sessions = $${buildout:directory}/.sessions
141

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

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

188 189
[test-runner]
<= slaprunner
190
slapos.cfg = $${directory:etc}/slapos-test.cfg
191 192
working-directory = $${runnerdirectory:test}
project-directory = $${runnerdirectory:project-test}
193 194
software_root = $${runnerdirectory:software-test}
instance_root = $${runnerdirectory:instance-test}
195
proxy_port = 8602
196
etc_dir = $${directory:test}
197 198
autorun = False
auto_deploy = True
199

200 201 202 203 204
[runtestsuite]
recipe = slapos.cookbook:wrapper
command-line = ${buildout:directory}/bin/slaprunnertest
wrapper-path = $${directory:bin}/runTestSuite
environment = RUNNER_CONFIG=$${slapos-test-cfg:rendered}
205 206 207 208 209 210

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

212 213 214 215
[sshkeys-authority]
recipe = slapos.cookbook:sshkeys_authority
request-directory = $${sshkeys-directory:requests}
keys-directory = $${sshkeys-directory:keys}
216
wrapper = $${directory:services}/sshkeys_authority
217 218
keygen-binary = ${dropbear:location}/bin/dropbearkey

219
[dropbear-runner-server]
220 221
recipe = slapos.cookbook:dropbear
host = $${slap-network-information:global-ipv6}
222
port = 22222
223
home = $${buildout:directory}
224 225
wrapper = $${directory:bin}/runner_sshd
shell = ${bash:location}/bin/bash
226 227 228
rsa-keyfile = $${directory:ssh}/server_key.rsa
dropbear-binary = ${dropbear:location}/sbin/dropbear

229
[sshkeys-dropbear-runner]
230 231 232 233
<= sshkeys-authority
recipe = slapos.cookbook:sshkeys_authority.request
name = dropbear
type = rsa
234 235 236 237
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
238 239

[dropbear-server-add-authorized-key]
240
<= dropbear-runner-server
241
recipe = slapos.cookbook:dropbear.add_authorized_key
242
key = $${slap-parameter:user-authorized-key}
243

244
#---------------------------
245
#--
246 247
#-- Set nginx frontend

248 249 250 251 252 253 254 255 256 257 258 259
[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
nb_workers = 2
# Network
260
local-ip = $${slap-network-information:local-ipv4}
261
port = 30001
262 263
global-ip = $${slap-network-information:global-ipv6}
global-port = $${slaprunner:runner_port}
264
# Backend
265 266
runner-ip = $${slaprunner:ipv4}
runner-port = $${slaprunner:runner_port}
267 268 269 270 271 272 273 274
# 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
275
path_tmp = $${directory:tmp}/
276 277 278
# Config files
path_nginx_conf = $${directory:etc}/nginx.conf
# Executables
279
bin_nginx = ${nginx-webdav:location}/sbin/nginx
280
bin_launcher = $${directory:bin}/launcher
281 282
# Utils
path_shell = ${dash:location}/bin/dash
283 284
# Misc.
etc_dir = $${directory:etc}
285
work_dir = $${slaprunner:working-directory}
286 287 288 289 290 291

[nginx_conf]
recipe = slapos.recipe.template:jinja2
template = ${template_nginx_conf:location}/${template_nginx_conf:filename}
rendered = $${nginx-frontend:path_nginx_conf}
context =
292
    key shellinabox_port shellinabox:port
293
    key socket gunicorn:socket
294 295 296 297 298 299 300 301 302 303 304
    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

305 306 307 308 309 310 311 312 313 314 315 316 317
[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}
318
var_dir = $${directory:var}
319
project_folder = $${directory:project}
320
runner_home = $${runnerdirectory:home}
321
git_http_backend = ${git:location}/libexec/git-core/git-http-backend
322
cgi_httpd_conf = $${monitor-httpd-configuration-file:rendered}
323 324 325 326 327

[httpd-conf]
recipe = slapos.recipe.template:jinja2
template = ${template_httpd_conf:location}/${template_httpd_conf:filename}
rendered = $${directory:etc}/httpd.conf
328
context =
329 330 331
    section parameters httpd-parameters

[cgi-httpd-wrapper]
332 333 334
recipe = slapos.cookbook:wrapper
apache-executable = ${apache:location}/bin/httpd
wrapper-path = $${ca-httpd:executable}
335 336
command-line = $${:apache-executable} -f $${httpd-conf:rendered} -DFOREGROUND

337 338 339 340
#--------------------
#--
#-- WSGI

341
[gunicorn]
342 343 344 345 346 347 348 349
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
350 351
command-line = $${gunicorn:bin_gunicorn} slapos.runner: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 
error-log-file = gunicorn-error.log
352
wrapper-path = $${gunicorn:bin_launcher}
353
environment = PATH=$${environ:PATH}:${git:location}/bin/
354 355 356 357
  RUNNER_CONFIG=$${slaprunner:slapos.cfg}

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

361
#--------------------
362
#--
363
#-- ssl certificates
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

[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
389 390
executable = $${nginx-launcher:rendered}
wrapper = $${directory:services}/nginx-frontend
391 392 393
# Put domain name
name = example.com

394 395 396 397 398
[ca-shellinabox]
<= certificate-authority
recipe = slapos.cookbook:certificate_authority.request
executable = $${shellinabox:wrapper}
wrapper = $${directory:services}/shellinaboxd
399 400
key-file = $${cadirectory:certs}/shellinabox.key
cert-file = $${cadirectory:certs}/shellinabox.crt
401
#--------------------
402 403
#--
#-- Request frontend
404

405 406
[request-frontend]
<= slap-connection
407
recipe = slapos.cookbook:requestoptional
408
name = SlapRunner Frontend
409 410 411
# XXX We have hardcoded SR URL here.
software-url = http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg
slave = true
412
config = url domain
413
config-url = $${slaprunner:access-url}
414
config-domain = $${slap-parameter:frontend-domain}
415
return = site_url domain
416

417 418 419 420 421 422 423 424
[monitor-frontend]
<= slap-connection
recipe = slapos.cookbook:requestoptional
name = Monitor Frontend
# XXX We have hardcoded SR URL here.
software-url = http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg
slave = true
config = url domain
425
config-url = https://[$${monitor-httpd-configuration:listening-ip}]:$${monitor-parameters:port}
426 427 428
config-domain = $${slap-parameter:frontend-domain}
return = site_url domain

429
#--------------------------------------
430 431
#--
#-- Send informations to SlapOS Master
432

433 434
[publish-connection-informations]
recipe = slapos.cookbook:publish
435
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.
436
2_info = In order to set up your account, get the recovery-code from the monitoring interface. Before read the notification on monitor_info.
437
backend_url = $${slaprunner:access-url}
438
access_url = $${:url}/login
439
url =  https://$${request-frontend:connection-domain}
440
ssh_command = ssh $${dropbear-runner-server:host} -p $${dropbear-runner-server:port}
441
monitor_url = https://$${monitor-frontend:connection-domain}
442 443
webdav_url = $${:monitor_url}/share/
public_url =  $${:monitor_url}/public/
444 445
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/
446

447 448 449
#---------------------------
#--
#-- Deploy promises scripts
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
450

451 452
[slaprunner-promise]
recipe = slapos.cookbook:check_port_listening
453
path = $${directory:promises}/slaprunner
454 455
hostname = $${slaprunner:ipv6}
port = $${slaprunner:runner_port}
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
456

457
[slaprunner-frontend-promise]
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
458
recipe = slapos.cookbook:check_url_available
459
path = $${directory:promises}/slaprunner_frontend
460
url = https://$${request-frontend:connection-domain}/login
Jean-Baptiste Petre's avatar
Jean-Baptiste Petre committed
461 462 463
dash_path = ${dash:location}/bin/dash
curl_path = ${curl:location}/bin/curl

464 465
[dropbear-promise]
recipe = slapos.cookbook:check_port_listening
466
path = $${directory:promises}/dropbear
467 468
hostname = $${dropbear-runner-server:host}
port = $${dropbear-runner-server:port}
469

470 471 472 473 474 475
[shellinabox-promise]
recipe = slapos.cookbook:check_port_listening
path = $${directory:promises}/shellinabox
hostname = $${shellinabox:ipv6}
port = $${shellinabox:port}

476 477
[symlinks]
recipe = cns.recipe.symlink
478
symlink_target = $${directory:bin}
479
symlink_base = ${buildout:directory}/bin
480 481 482

[slap-parameter]
# Default value if no ssh key is specified
483
user-authorized-key =
484
# Default value of instances number in slaprunner
485
instance-amount = 10
486 487
debug = false
frontend-domain =
488 489
slapos-repository = http://git.erp5.org/repos/slapos.git
slapos-software =
490
slapos-software-type =
491
slapos-reference = master
492
auto-deploy = false
493
auto-deploy-instance = true
494
autorun = false
495
monitor-port = 9684
496 497 498

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

500 501
[slapos-cfg]
recipe = slapos.recipe.template:jinja2
502
template = ${template-slapos-cfg:location}/${template-slapos-cfg:filename}
503 504 505
rendered = $${slaprunner:slapos.cfg}
mode = 700
context =
506
  section slaprunner slaprunner
507

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

516 517
[shellinabox]
recipe = slapos.cookbook:shellinabox
518
ipv6 = $${slap-network-information:global-ipv6}
519
port = 8949
520
shell = $${shell:wrapper}
521
wrapper = $${directory:bin}/shellinaboxd
522
shellinabox-binary = ${shellinabox:location}/bin/shellinaboxd
523
password = $${zero-parameters:shell-password}
524
directory = $${runnerdirectory:home}
525
login-shell = $${directory:bin}/login
526 527 528
certificate-directory = $${cadirectory:certs}
cert-file = $${ca-shellinabox:cert-file}
key-file = $${ca-shellinabox:key-file}
529

530 531 532
[shellinabox-code]
recipe = slapos.cookbook:generate.password
storage-path = $${directory:etc}/.scode
533
bytes = 8
534 535 536 537 538 539

[shell]
recipe = slapos.cookbook:shell
wrapper = $${directory:bin}/sh
shell = ${bash:location}/bin/bash
home = $${runnerdirectory:home}
540
path = $${environ:PATH}:${nano:location}/bin:${vim:location}/bin:${screen:location}/bin:${git:location}/bin
541 542
ps1 = "\\w> "

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

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

[slapos-repo-config]
recipe = plone.recipe.command
stop-on-error = true
556 557
command = cd $${slapos-repo:location} && ${git:location}/bin/git checkout $${slap-parameter:slapos-reference} && SR=$${slap-parameter:slapos-software} && if [ -n "$SR" ] && [ ! -f "$${directory:etc}/.project" ]; then echo workspace/slapos/$${slap-parameter:slapos-software}/ > $${directory:etc}/.project; fi
update-command = true
558 559 560

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

564 565 566 567 568 569 570
[cron-entry-prepare-software]
<= cron
recipe = slapos.cookbook:cron.d
name = prepare-software
frequency = */2 * * * *
command = $${prepare-software:wrapper-path}

571 572 573
[instance-parameters]
recipe = slapos.recipe.template:jinja2
extensions = jinja2.ext.do
574
template = ${template-parameters:location}/${template-parameters:filename}
575 576
rendered = $${directory:etc}/.parameter.xml.default
mode = 0644
577
context =
578 579 580 581 582 583 584 585
  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

586 587 588 589 590 591 592
[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

593 594 595 596 597 598 599 600
[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}

601 602
[public]
shell-password = $${shellinabox-code:passwd}
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 619 620
recipe = slapos.recipe.template:jinja2
template = ${template-bash-profile:location}/${template-bash-profile:filename}
rendered = $${buildout:directory}/.bash_profile
context =
    raw path $PATH:${nano:location}/bin:${vim:location}/bin:${screen:location}/bin:${git:location}/bin:${curl:location}/bin:${python2.7:location}/bin
    key workdir runnerdirectory:home
621

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
[supervisord]
autorestart = unexpected
autostart = false
directory = $${buildout:directory}
exitcodes = 0
logfile = $${directory:log}/supervisord.log
numprocs = 1
path = $${environ:PATH}
pidfile = $${directory:run}/supervisord.pid
server = 127.0.0.1:39986
slapgrid-cp = slapgrid-cp
slapgrid-cp-command = $${slaprunner:slapos} node instance --all --cfg $${slaprunner:slapos.cfg} --pidfile $${:slapgrid-cp-pid} --verbose --logfile $${:slapgrid-cp-log}
slapgrid-cp-log = $${runnerdirectory:home}/instance.log
slapgrid-cp-pid = $${directory:run}/slapgrid-cp.pid
slapgrid-cp-startretries = 3
slapgrid-sr = slapgrid-sr
slapgrid-sr-command = $${slaprunner:slapos} node software --all --cfg $${slaprunner:slapos.cfg} --pidfile $${:slapgrid-sr-pid} --verbose --logfile $${:slapgrid-sr-log}
slapgrid-sr-log = $${runnerdirectory:home}/software.log
slapgrid-sr-pid = $${directory:run}/slapgrid-sr.pid
slapgrid-sr-startretries = 2
socket_name = unix://$${:socket_path}
socket_path = $${directory:tmp}/supervisord.sock
startsecs = 1
stdout_logfile = NONE

[supervisord-conf]
recipe = slapos.recipe.template:jinja2
template = ${template-supervisord:location}/${template-supervisord:filename}
rendered = $${directory:etc}/supervisord.conf
context =
    section supervisord supervisord

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

659 660 661
[monitor-current-log-access]
< = monitor-directory-access
source = $${directory:log}