From 4faa7f927149a5c4ef7a03523f7bc14523cb9baa Mon Sep 17 00:00:00 2001 From: Stuart Mackie Date: Fri, 7 Oct 2016 12:24:58 -0700 Subject: Charms for Contrail 3.1 with Mitaka Change-Id: Id37f3b9743d1974e31fcd7cd9c54be41bb0c47fb Signed-off-by: Stuart Mackie --- charms/trusty/contrail-webui/.bzrignore | 4 + charms/trusty/contrail-webui/.project | 17 + charms/trusty/contrail-webui/.pydevproject | 9 + charms/trusty/contrail-webui/Makefile | 10 + charms/trusty/contrail-webui/README.md | 72 ++ .../trusty/contrail-webui/charm-helpers-sync.yaml | 5 + charms/trusty/contrail-webui/config.yaml | 52 ++ charms/trusty/contrail-webui/copyright | 17 + charms/trusty/contrail-webui/files/40contrail | 4 + charms/trusty/contrail-webui/files/contrail-webui | 6 + .../files/contrail-webui-contrail.ini | 14 + .../contrail-webui/files/contrail-webui-middleware | 6 + .../files/contrail-webui-middleware-contrail.ini | 14 + .../contrail-webui-middleware-opencontrail.ini | 14 + .../files/contrail-webui-opencontrail.ini | 14 + .../contrail-webui/files/supervisor-webui.conf | 36 + .../contrail-webui/files/supervisord_webui.conf | 140 ++++ charms/trusty/contrail-webui/hooks/actions.py | 5 + .../hooks/cassandra-relation-changed | 3 + .../contrail-webui/hooks/cassandra-relation-joined | 3 + .../contrail-webui/hooks/charmhelpers/__init__.py | 38 + .../hooks/charmhelpers/core/__init__.py | 15 + .../hooks/charmhelpers/core/decorators.py | 57 ++ .../hooks/charmhelpers/core/files.py | 45 ++ .../hooks/charmhelpers/core/fstab.py | 134 +++ .../hooks/charmhelpers/core/hookenv.py | 898 +++++++++++++++++++++ .../contrail-webui/hooks/charmhelpers/core/host.py | 586 ++++++++++++++ .../hooks/charmhelpers/core/hugepage.py | 69 ++ .../hooks/charmhelpers/core/kernel.py | 68 ++ .../hooks/charmhelpers/core/services/__init__.py | 18 + .../hooks/charmhelpers/core/services/base.py | 353 ++++++++ .../hooks/charmhelpers/core/services/helpers.py | 283 +++++++ .../hooks/charmhelpers/core/strutils.py | 72 ++ .../hooks/charmhelpers/core/sysctl.py | 56 ++ .../hooks/charmhelpers/core/templating.py | 68 ++ .../hooks/charmhelpers/core/unitdata.py | 521 ++++++++++++ .../hooks/charmhelpers/fetch/__init__.py | 468 +++++++++++ .../hooks/charmhelpers/fetch/archiveurl.py | 167 ++++ .../hooks/charmhelpers/fetch/bzrurl.py | 78 ++ .../hooks/charmhelpers/fetch/giturl.py | 73 ++ charms/trusty/contrail-webui/hooks/config-changed | 3 + .../hooks/contrail_api-relation-changed | 3 + .../hooks/contrail_api-relation-joined | 3 + .../hooks/contrail_discovery-relation-changed | 3 + .../hooks/contrail_discovery-relation-joined | 3 + .../hooks/identity_admin-relation-changed | 3 + .../hooks/identity_admin-relation-joined | 3 + charms/trusty/contrail-webui/hooks/install | 30 + .../contrail-webui/hooks/leader-settings-changed | 3 + .../contrail-webui/hooks/redis-relation-changed | 3 + .../contrail-webui/hooks/redis-relation-joined | 3 + charms/trusty/contrail-webui/hooks/services.py | 210 +++++ charms/trusty/contrail-webui/hooks/setup.py | 133 +++ charms/trusty/contrail-webui/hooks/start | 3 + charms/trusty/contrail-webui/hooks/stop | 3 + charms/trusty/contrail-webui/hooks/upgrade-charm | 3 + .../contrail-webui/hooks/website-relation-changed | 3 + .../contrail-webui/hooks/website-relation-joined | 3 + charms/trusty/contrail-webui/icon.svg | 309 +++++++ charms/trusty/contrail-webui/metadata.yaml | 24 + .../contrail-webui/templates/config.global.js.j2 | 315 ++++++++ .../templates/contrail-webui-userauth.js | 7 + 62 files changed, 5585 insertions(+) create mode 100644 charms/trusty/contrail-webui/.bzrignore create mode 100644 charms/trusty/contrail-webui/.project create mode 100644 charms/trusty/contrail-webui/.pydevproject create mode 100644 charms/trusty/contrail-webui/Makefile create mode 100644 charms/trusty/contrail-webui/README.md create mode 100644 charms/trusty/contrail-webui/charm-helpers-sync.yaml create mode 100644 charms/trusty/contrail-webui/config.yaml create mode 100644 charms/trusty/contrail-webui/copyright create mode 100644 charms/trusty/contrail-webui/files/40contrail create mode 100644 charms/trusty/contrail-webui/files/contrail-webui create mode 100644 charms/trusty/contrail-webui/files/contrail-webui-contrail.ini create mode 100644 charms/trusty/contrail-webui/files/contrail-webui-middleware create mode 100644 charms/trusty/contrail-webui/files/contrail-webui-middleware-contrail.ini create mode 100644 charms/trusty/contrail-webui/files/contrail-webui-middleware-opencontrail.ini create mode 100644 charms/trusty/contrail-webui/files/contrail-webui-opencontrail.ini create mode 100644 charms/trusty/contrail-webui/files/supervisor-webui.conf create mode 100644 charms/trusty/contrail-webui/files/supervisord_webui.conf create mode 100644 charms/trusty/contrail-webui/hooks/actions.py create mode 100755 charms/trusty/contrail-webui/hooks/cassandra-relation-changed create mode 100755 charms/trusty/contrail-webui/hooks/cassandra-relation-joined create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/__init__.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/__init__.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/decorators.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/files.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/fstab.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/hookenv.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/host.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/hugepage.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/kernel.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/services/__init__.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/services/base.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/services/helpers.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/strutils.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/sysctl.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/templating.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/core/unitdata.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/fetch/__init__.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/fetch/archiveurl.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/fetch/bzrurl.py create mode 100644 charms/trusty/contrail-webui/hooks/charmhelpers/fetch/giturl.py create mode 100755 charms/trusty/contrail-webui/hooks/config-changed create mode 100755 charms/trusty/contrail-webui/hooks/contrail_api-relation-changed create mode 100755 charms/trusty/contrail-webui/hooks/contrail_api-relation-joined create mode 100755 charms/trusty/contrail-webui/hooks/contrail_discovery-relation-changed create mode 100755 charms/trusty/contrail-webui/hooks/contrail_discovery-relation-joined create mode 100755 charms/trusty/contrail-webui/hooks/identity_admin-relation-changed create mode 100755 charms/trusty/contrail-webui/hooks/identity_admin-relation-joined create mode 100755 charms/trusty/contrail-webui/hooks/install create mode 100755 charms/trusty/contrail-webui/hooks/leader-settings-changed create mode 100755 charms/trusty/contrail-webui/hooks/redis-relation-changed create mode 100755 charms/trusty/contrail-webui/hooks/redis-relation-joined create mode 100644 charms/trusty/contrail-webui/hooks/services.py create mode 100644 charms/trusty/contrail-webui/hooks/setup.py create mode 100755 charms/trusty/contrail-webui/hooks/start create mode 100755 charms/trusty/contrail-webui/hooks/stop create mode 100755 charms/trusty/contrail-webui/hooks/upgrade-charm create mode 100755 charms/trusty/contrail-webui/hooks/website-relation-changed create mode 100755 charms/trusty/contrail-webui/hooks/website-relation-joined create mode 100644 charms/trusty/contrail-webui/icon.svg create mode 100644 charms/trusty/contrail-webui/metadata.yaml create mode 100644 charms/trusty/contrail-webui/templates/config.global.js.j2 create mode 100644 charms/trusty/contrail-webui/templates/contrail-webui-userauth.js (limited to 'charms/trusty/contrail-webui') diff --git a/charms/trusty/contrail-webui/.bzrignore b/charms/trusty/contrail-webui/.bzrignore new file mode 100644 index 0000000..162e2ba --- /dev/null +++ b/charms/trusty/contrail-webui/.bzrignore @@ -0,0 +1,4 @@ +.venv +.project +.pydevproject +bin diff --git a/charms/trusty/contrail-webui/.project b/charms/trusty/contrail-webui/.project new file mode 100644 index 0000000..90aded7 --- /dev/null +++ b/charms/trusty/contrail-webui/.project @@ -0,0 +1,17 @@ + + + contrail-webui + + + + + + org.python.pydev.PyDevBuilder + + + + + + org.python.pydev.pythonNature + + diff --git a/charms/trusty/contrail-webui/.pydevproject b/charms/trusty/contrail-webui/.pydevproject new file mode 100644 index 0000000..407a838 --- /dev/null +++ b/charms/trusty/contrail-webui/.pydevproject @@ -0,0 +1,9 @@ + + + +python 2.7 +Default + +/${PROJECT_DIR_NAME}/hooks + + diff --git a/charms/trusty/contrail-webui/Makefile b/charms/trusty/contrail-webui/Makefile new file mode 100644 index 0000000..378713f --- /dev/null +++ b/charms/trusty/contrail-webui/Makefile @@ -0,0 +1,10 @@ +#!/usr/bin/make +PYTHON := /usr/bin/env python + +bin/charm_helpers_sync.py: + @mkdir -p bin + @bzr cat lp:charm-helpers/tools/charm_helpers_sync/charm_helpers_sync.py \ + > bin/charm_helpers_sync.py + +sync: bin/charm_helpers_sync.py + @$(PYTHON) bin/charm_helpers_sync.py -c charm-helpers-sync.yaml diff --git a/charms/trusty/contrail-webui/README.md b/charms/trusty/contrail-webui/README.md new file mode 100644 index 0000000..0f5eaa7 --- /dev/null +++ b/charms/trusty/contrail-webui/README.md @@ -0,0 +1,72 @@ +Overview +-------- + +OpenContrail (www.opencontrail.org) is a fully featured Software Defined +Networking (SDN) solution for private clouds. It supports high performance +isolated tenant networks without requiring external hardware support. It +provides a Neutron plugin to integrate with OpenStack. + +This charm is designed to be used in conjunction with the rest of the OpenStack +related charms in the charm store to virtualize the network that Nova Compute +instances plug into. + +This charm provides the Web UI component which contains the +contrail-web-controller service. +Only OpenStack Icehouse or newer is supported. + +Usage +----- + +Keystone, Contrail Configuration and Cassandra are prerequisite services to +deploy. + +Once ready, deploy and relate as follows: + + juju deploy contrail-webui + juju add-relation contrail-webui keystone + juju add-relation contrail-webui:contrail_api contrail-configuration:contrail-api + juju add-relation contrail-webui:contrail_discovery contrail-configuration:contrail-discovery + juju add-relation contrail-webui:cassandra cassandra:database + +Install Sources +--------------- + +The version of OpenContrail installed when deploying can be changed using the +'install-sources' option. This is a multilined value that may refer to PPAs or +Deb repositories. + +Secure HTTPS/SSL Connections +---------------------------- + +HTTPS is enabled by default (port 8143) and also set with: + + juju set contrail-webui use-https=true + +A self-signed X.509 certificate will be generated for SSL use by default, but +you may specify one with the 'ssl-cert' and 'ssl-key' options. This is easier to +do using a YAML file: + + # config.yaml + contrail-webui: + ssl-cert: | + -----BEGIN CERTIFICATE----- + ... + -----END CERTIFICATE----- + ssl-key: | + -----BEGIN PRIVATE KEY----- + ... + -----END PRIVATE KEY----- + + juju set --config config.yaml contrail-webui + +High Availability (HA) +---------------------- + +Multiple units of this charm can be deployed to support HA deployments: + + juju add-unit contrail-webui + +Relating to haproxy charm (website relation) allows multiple units to be load +balanced: + + juju add-relation contrail-webui haproxy diff --git a/charms/trusty/contrail-webui/charm-helpers-sync.yaml b/charms/trusty/contrail-webui/charm-helpers-sync.yaml new file mode 100644 index 0000000..0af5672 --- /dev/null +++ b/charms/trusty/contrail-webui/charm-helpers-sync.yaml @@ -0,0 +1,5 @@ +branch: lp:charm-helpers +destination: hooks/charmhelpers +include: + - core + - fetch diff --git a/charms/trusty/contrail-webui/config.yaml b/charms/trusty/contrail-webui/config.yaml new file mode 100644 index 0000000..99a3d7c --- /dev/null +++ b/charms/trusty/contrail-webui/config.yaml @@ -0,0 +1,52 @@ +options: + install-sources: + type: string + default: | + - "ppa:opencontrail/ppa" + - "ppa:opencontrail/r2.20" + description: Package sources for install + install-keys: + type: string + description: Apt keys for package install sources + http-port: + type: int + default: 8080 + description: Port to listen for HTTP requests on. + https-port: + type: int + default: 8143 + description: Port to listen for HTTPS requests on. + use-https: + type: boolean + default: true + description: Use HTTPS. HTTP requests will be redirected to HTTPS. + ssl-cert: + type: string + description: | + PEM encoded X.509 certificate for use in SSL. + A self-signed certificate will be generated for use if ssl-cert and + ssl-key are not set. + ssl-key: + type: string + description: | + PEM encoded private key for use in SSL. + A self-signed certificate will be generated for use if ssl-cert and + ssl-key are not set. + logo-url: + type: string + default: "" + description: | + Optional URL to an image file with the site logo + to be used. + NOTE: it will get downloaded and cached every time + the config is updated. If empty, the default will + be used. + favicon-url: + type: string + default: "" + description: | + Optional URL to an icon file with the site favicon + to be used. + NOTE: it will get downloaded and cached every time + the config is updated. If empty, the default will + be used. diff --git a/charms/trusty/contrail-webui/copyright b/charms/trusty/contrail-webui/copyright new file mode 100644 index 0000000..567db82 --- /dev/null +++ b/charms/trusty/contrail-webui/copyright @@ -0,0 +1,17 @@ +Format: http://dep.debian.net/deps/dep5/ + +Files: * +Copyright: Copyright 2015, Canonical Ltd., All Rights Reserved. +License: GPL-3 + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + . + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + . + You should have received a copy of the GNU General Public License + along with this program. If not, see . diff --git a/charms/trusty/contrail-webui/files/40contrail b/charms/trusty/contrail-webui/files/40contrail new file mode 100644 index 0000000..d5f2e14 --- /dev/null +++ b/charms/trusty/contrail-webui/files/40contrail @@ -0,0 +1,4 @@ +Explanation: Use contrail version of nodejs +Package: nodejs +Pin: version /contrail/ +Pin-Priority: 1001 diff --git a/charms/trusty/contrail-webui/files/contrail-webui b/charms/trusty/contrail-webui/files/contrail-webui new file mode 100644 index 0000000..cc44e97 --- /dev/null +++ b/charms/trusty/contrail-webui/files/contrail-webui @@ -0,0 +1,6 @@ +#!/usr/bin/env bash + +# chkconfig: 2345 99 01 +# description: Juniper Network Virtualization WebUI + +supervisorctl -s unix:///tmp/supervisord_webui.sock ${1} `basename ${0}` diff --git a/charms/trusty/contrail-webui/files/contrail-webui-contrail.ini b/charms/trusty/contrail-webui/files/contrail-webui-contrail.ini new file mode 100644 index 0000000..a308c9c --- /dev/null +++ b/charms/trusty/contrail-webui/files/contrail-webui-contrail.ini @@ -0,0 +1,14 @@ +[program:contrail-webui] +directory=/usr/src/contrail/contrail-web-core +command=bash -c "node webServerStart.js" +priority=420 +autostart=true +killasgroup=true +stopsignal=KILL +stdout_capture_maxbytes=1MB +redirect_stderr=true +stdout_logfile=/var/log/contrail/contrail-webui-stdout.log +stderr_logfile=/dev/null +startretries=10 +startsecs=5 +exitcodes=0 ; 'expected' exit codes for process (default 0,2) diff --git a/charms/trusty/contrail-webui/files/contrail-webui-middleware b/charms/trusty/contrail-webui/files/contrail-webui-middleware new file mode 100644 index 0000000..e0d22c2 --- /dev/null +++ b/charms/trusty/contrail-webui/files/contrail-webui-middleware @@ -0,0 +1,6 @@ +#!/usr/bin/env bash + +# chkconfig: 2345 99 01 +# description: Juniper Network Virtualization WebUI Middleware + +supervisorctl -s unix:///tmp/supervisord_webui.sock ${1} `basename ${0}` diff --git a/charms/trusty/contrail-webui/files/contrail-webui-middleware-contrail.ini b/charms/trusty/contrail-webui/files/contrail-webui-middleware-contrail.ini new file mode 100644 index 0000000..ff12d91 --- /dev/null +++ b/charms/trusty/contrail-webui/files/contrail-webui-middleware-contrail.ini @@ -0,0 +1,14 @@ +[program:contrail-webui-middleware] +directory=/usr/src/contrail/contrail-web-core +command=bash -c "node jobServerStart.js" +priority=420 +autostart=true +killasgroup=true +stopsignal=KILL +stdout_capture_maxbytes=1MB +redirect_stderr=true +stdout_logfile=/var/log/contrail/contrail-webui-middleware-stdout.log +stderr_logfile=/dev/null +startretries=10 +startsecs=5 +exitcodes=0 ; 'expected' exit codes for process (default 0,2) diff --git a/charms/trusty/contrail-webui/files/contrail-webui-middleware-opencontrail.ini b/charms/trusty/contrail-webui/files/contrail-webui-middleware-opencontrail.ini new file mode 100644 index 0000000..05942b4 --- /dev/null +++ b/charms/trusty/contrail-webui/files/contrail-webui-middleware-opencontrail.ini @@ -0,0 +1,14 @@ +[program:contrail-webui-middleware] +directory=/var/lib/contrail-webui/contrail-web-core +command=bash -c "node jobServerStart.js" +priority=420 +autostart=true +killasgroup=true +stopsignal=KILL +stdout_capture_maxbytes=1MB +redirect_stderr=true +stdout_logfile=/var/log/contrail/contrail-webui-middleware-stdout.log +stderr_logfile=/dev/null +startretries=10 +startsecs=5 +exitcodes=0 ; 'expected' exit codes for process (default 0,2) diff --git a/charms/trusty/contrail-webui/files/contrail-webui-opencontrail.ini b/charms/trusty/contrail-webui/files/contrail-webui-opencontrail.ini new file mode 100644 index 0000000..4fa2c57 --- /dev/null +++ b/charms/trusty/contrail-webui/files/contrail-webui-opencontrail.ini @@ -0,0 +1,14 @@ +[program:contrail-webui] +directory=/var/lib/contrail-webui/contrail-web-core +command=bash -c "node webServerStart.js" +priority=420 +autostart=true +killasgroup=true +stopsignal=KILL +stdout_capture_maxbytes=1MB +redirect_stderr=true +stdout_logfile=/var/log/contrail/contrail-webui-stdout.log +stderr_logfile=/dev/null +startretries=10 +startsecs=5 +exitcodes=0 ; 'expected' exit codes for process (default 0,2) diff --git a/charms/trusty/contrail-webui/files/supervisor-webui.conf b/charms/trusty/contrail-webui/files/supervisor-webui.conf new file mode 100644 index 0000000..37b8e25 --- /dev/null +++ b/charms/trusty/contrail-webui/files/supervisor-webui.conf @@ -0,0 +1,36 @@ +description "Supervisord for VNC web-ui" + +start on runlevel [2345] +stop on runlevel [016] +limit core unlimited unlimited + +# Restart the process if it dies with a signal +# or exit code not given by the 'normal exit' stanza. +respawn + +# Give up if restart occurs 10 times in 90 seconds. +respawn limit 10 90 + +pre-start script + ulimit -s unlimited + ulimit -c unlimited + ulimit -d unlimited + ulimit -v unlimited + ulimit -n 4096 +end script + +script + supervisord --nodaemon -c /etc/contrail/supervisord_webui.conf || true + echo "supervisor-webui start failed...." + (lsof | grep -i supervisord_webui.sock) || true + pid=`lsof | grep -i supervisord_webui.sock | cut -d' ' -f3` || true + if [ "x$pid" != "x" ]; then + ps uw -p $pid + fi +end script + +pre-stop script + supervisorctl -s unix:///tmp/supervisord_webui.sock stop all + supervisorctl -s unix:///tmp/supervisord_webui.sock shutdown + /usr/bin/supervisor_killall /etc/contrail/supervisord_webui_files +end script diff --git a/charms/trusty/contrail-webui/files/supervisord_webui.conf b/charms/trusty/contrail-webui/files/supervisord_webui.conf new file mode 100644 index 0000000..f0eb90a --- /dev/null +++ b/charms/trusty/contrail-webui/files/supervisord_webui.conf @@ -0,0 +1,140 @@ +; Sample supervisor config file. +; +; For more information on the config file, please see: +; http://supervisord.org/configuration.html +; +; Note: shell expansion ("~" or "$HOME") is not supported. Environment +; variables can be expanded using this syntax: "%(ENV_HOME)s". + +[unix_http_server] +file=/tmp/supervisord_webui.sock ; (the path to the socket file) +chmod=0700 ; socket file mode (default 0700) +;chown=nobody:nogroup ; socket file uid:gid owner +;username=user ; (default is no username (open server)) +;password=123 ; (default is no password (open server)) + +;[inet_http_server] ; inet (TCP) server disabled by default +;port=localhost:9008 ; Port for analytics (ip_address:port specifier, *:port for all iface) +;username=user ; (default is no username (open server)) +;password=123 ; (default is no password (open server)) + +[supervisord] +logfile=/var/log/contrail/supervisord-webui.log ; (main log file;default $CWD/supervisord.log) +logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB) +logfile_backups=3 ; (num of main logfile rotation backups;default 10) +loglevel=info ; (log level;default info; others: debug,warn,trace) +pidfile=/var/run/supervisord_webui.pid ; (supervisord pidfile;default supervisord.pid) +nodaemon=false ; (start in foreground if true;default false) +minfds=1024 ; (min. avail startup file descriptors;default 1024) +minprocs=200 ; (min. avail process descriptors;default 200) +;umask=022 ; (process file creation umask;default 022) +;user=chrism ; (default is current user, required if root) +;identifier=supervisor ; (supervisord identifier, default is 'supervisor') +;directory=/tmp ; (default is not to cd during start) +;nocleanup=true ; (don't clean up tempfiles at start;default false) +childlogdir=/var/log/contrail ; ('AUTO' child log dir, default $TEMP) +;environment=KEY=value ; (key value pairs to add to environment) +;strip_ansi=false ; (strip ansi escape codes in logs; def. false) + +; the below section must remain in the config file for RPC +; (supervisorctl/web interface) to work, additional interfaces may be +; added by defining them in separate rpcinterface: sections +[rpcinterface:supervisor] +supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface + +[supervisorctl] +serverurl=unix:///tmp/supervisord_webui.sock ; use a unix:// URL for a unix socket +;serverurl=http://127.0.0.1:9001 ; use an http:// url to specify an inet socket +;username=chris ; should be same as http_username if set +;password=123 ; should be same as http_password if set +;prompt=mysupervisor ; cmd line prompt (default "supervisor") +;history_file=~/.sc_history ; use readline history if available + +; The below sample program section shows all possible program subsection values, +; create one or more 'real' program: sections to be able to control them under +; supervisor. + +;[program:theprogramname] +;command=/bin/cat ; the program (relative uses PATH, can take args) +;process_name=%(program_name)s ; process_name expr (default %(program_name)s) +;numprocs=1 ; number of processes copies to start (def 1) +;directory=/tmp ; directory to cwd to before exec (def no cwd) +;umask=022 ; umask for process (default None) +;priority=999 ; the relative start priority (default 999) +;autostart=true ; start at supervisord start (default: true) +;autorestart=unexpected ; whether/when to restart (default: unexpected) +;startsecs=1 ; number of secs prog must stay running (def. 1) +;startretries=3 ; max # of serial start failures (default 3) +;exitcodes=0,2 ; 'expected' exit codes for process (default 0,2) +;stopsignal=QUIT ; signal used to kill process (default TERM) +;stopwaitsecs=10 ; max num secs to wait b4 SIGKILL (default 10) +;stopasgroup=false ; send stop signal to the UNIX process group (default false) +;killasgroup=false ; SIGKILL the UNIX process group (def false) +;user=chrism ; setuid to this UNIX account to run the program +;redirect_stderr=true ; redirect proc stderr to stdout (default false) +;stdout_logfile=/a/path ; stdout log path, NONE for none; default AUTO +;stdout_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB) +;stdout_logfile_backups=10 ; # of stdout logfile backups (default 10) +;stdout_capture_maxbytes=1MB ; number of bytes in 'capturemode' (default 0) +;stdout_events_enabled=false ; emit events on stdout writes (default false) +;stderr_logfile=/a/path ; stderr log path, NONE for none; default AUTO +;stderr_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB) +;stderr_logfile_backups=10 ; # of stderr logfile backups (default 10) +;stderr_capture_maxbytes=1MB ; number of bytes in 'capturemode' (default 0) +;stderr_events_enabled=false ; emit events on stderr writes (default false) +;environment=A=1,B=2 ; process environment additions (def no adds) +;serverurl=AUTO ; override serverurl computation (childutils) + +; The below sample eventlistener section shows all possible +; eventlistener subsection values, create one or more 'real' +; eventlistener: sections to be able to handle event notifications +; sent by supervisor. + +;[eventlistener:theeventlistenername] +;command=/bin/eventlistener ; the program (relative uses PATH, can take args) +;process_name=%(program_name)s ; process_name expr (default %(program_name)s) +;numprocs=1 ; number of processes copies to start (def 1) +;events=EVENT ; event notif. types to subscribe to (req'd) +buffer_size=10000 ; event buffer queue size (default 10) +;directory=/tmp ; directory to cwd to before exec (def no cwd) +;umask=022 ; umask for process (default None) +;priority=-1 ; the relative start priority (default -1) +;autostart=true ; start at supervisord start (default: true) +;autorestart=unexpected ; whether/when to restart (default: unexpected) +;startsecs=1 ; number of secs prog must stay running (def. 1) +;startretries=3 ; max # of serial start failures (default 3) +;exitcodes=0,2 ; 'expected' exit codes for process (default 0,2) +;stopsignal=QUIT ; signal used to kill process (default TERM) +;stopwaitsecs=10 ; max num secs to wait b4 SIGKILL (default 10) +;stopasgroup=false ; send stop signal to the UNIX process group (default false) +;killasgroup=false ; SIGKILL the UNIX process group (def false) +;user=chrism ; setuid to this UNIX account to run the program +;redirect_stderr=true ; redirect proc stderr to stdout (default false) +;stdout_logfile=/a/path ; stdout log path, NONE for none; default AUTO +;stdout_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB) +;stdout_logfile_backups=10 ; # of stdout logfile backups (default 10) +;stdout_events_enabled=false ; emit events on stdout writes (default false) +;stderr_logfile=/a/path ; stderr log path, NONE for none; default AUTO +;stderr_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB) +;stderr_logfile_backups ; # of stderr logfile backups (default 10) +;stderr_events_enabled=false ; emit events on stderr writes (default false) +;environment=A=1,B=2 ; process environment additions +;serverurl=AUTO ; override serverurl computation (childutils) + +; The below sample group section shows all possible group values, +; create one or more 'real' group: sections to create "heterogeneous" +; process groups. + +;[group:contrail-webui] +;programs=contrail-webui,contrail-webui-middleware; each refers to 'x' in [program:x] definitions +;priority=999 ; the relative start priority (default 999) + +; The [include] section can just contain the "files" setting. This +; setting can list multiple files (separated by whitespace or +; newlines). It can also contain wildcards. The filenames are +; interpreted as relative to this file. Included files *cannot* +; include files themselves. + +[include] +files = /etc/contrail/supervisord_webui_files/*.ini + diff --git a/charms/trusty/contrail-webui/hooks/actions.py b/charms/trusty/contrail-webui/hooks/actions.py new file mode 100644 index 0000000..a8e3adf --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/actions.py @@ -0,0 +1,5 @@ +from charmhelpers.core import hookenv + + +def log_start(service_name): + hookenv.log('{0} starting'.format(service_name)) diff --git a/charms/trusty/contrail-webui/hooks/cassandra-relation-changed b/charms/trusty/contrail-webui/hooks/cassandra-relation-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/cassandra-relation-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/cassandra-relation-joined b/charms/trusty/contrail-webui/hooks/cassandra-relation-joined new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/cassandra-relation-joined @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/__init__.py b/charms/trusty/contrail-webui/hooks/charmhelpers/__init__.py new file mode 100644 index 0000000..f72e7f8 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/__init__.py @@ -0,0 +1,38 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +# Bootstrap charm-helpers, installing its dependencies if necessary using +# only standard libraries. +import subprocess +import sys + +try: + import six # flake8: noqa +except ImportError: + if sys.version_info.major == 2: + subprocess.check_call(['apt-get', 'install', '-y', 'python-six']) + else: + subprocess.check_call(['apt-get', 'install', '-y', 'python3-six']) + import six # flake8: noqa + +try: + import yaml # flake8: noqa +except ImportError: + if sys.version_info.major == 2: + subprocess.check_call(['apt-get', 'install', '-y', 'python-yaml']) + else: + subprocess.check_call(['apt-get', 'install', '-y', 'python3-yaml']) + import yaml # flake8: noqa diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/__init__.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/__init__.py new file mode 100644 index 0000000..d1400a0 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/decorators.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/decorators.py new file mode 100644 index 0000000..bb05620 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/decorators.py @@ -0,0 +1,57 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +# +# Copyright 2014 Canonical Ltd. +# +# Authors: +# Edward Hope-Morley +# + +import time + +from charmhelpers.core.hookenv import ( + log, + INFO, +) + + +def retry_on_exception(num_retries, base_delay=0, exc_type=Exception): + """If the decorated function raises exception exc_type, allow num_retries + retry attempts before raise the exception. + """ + def _retry_on_exception_inner_1(f): + def _retry_on_exception_inner_2(*args, **kwargs): + retries = num_retries + multiplier = 1 + while True: + try: + return f(*args, **kwargs) + except exc_type: + if not retries: + raise + + delay = base_delay * multiplier + multiplier += 1 + log("Retrying '%s' %d more times (delay=%s)" % + (f.__name__, retries, delay), level=INFO) + retries -= 1 + if delay: + time.sleep(delay) + + return _retry_on_exception_inner_2 + + return _retry_on_exception_inner_1 diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/files.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/files.py new file mode 100644 index 0000000..0f12d32 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/files.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +__author__ = 'Jorge Niedbalski ' + +import os +import subprocess + + +def sed(filename, before, after, flags='g'): + """ + Search and replaces the given pattern on filename. + + :param filename: relative or absolute file path. + :param before: expression to be replaced (see 'man sed') + :param after: expression to replace with (see 'man sed') + :param flags: sed-compatible regex flags in example, to make + the search and replace case insensitive, specify ``flags="i"``. + The ``g`` flag is always specified regardless, so you do not + need to remember to include it when overriding this parameter. + :returns: If the sed command exit code was zero then return, + otherwise raise CalledProcessError. + """ + expression = r's/{0}/{1}/{2}'.format(before, + after, flags) + + return subprocess.check_call(["sed", "-i", "-r", "-e", + expression, + os.path.expanduser(filename)]) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/fstab.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/fstab.py new file mode 100644 index 0000000..3056fba --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/fstab.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import io +import os + +__author__ = 'Jorge Niedbalski R. ' + + +class Fstab(io.FileIO): + """This class extends file in order to implement a file reader/writer + for file `/etc/fstab` + """ + + class Entry(object): + """Entry class represents a non-comment line on the `/etc/fstab` file + """ + def __init__(self, device, mountpoint, filesystem, + options, d=0, p=0): + self.device = device + self.mountpoint = mountpoint + self.filesystem = filesystem + + if not options: + options = "defaults" + + self.options = options + self.d = int(d) + self.p = int(p) + + def __eq__(self, o): + return str(self) == str(o) + + def __str__(self): + return "{} {} {} {} {} {}".format(self.device, + self.mountpoint, + self.filesystem, + self.options, + self.d, + self.p) + + DEFAULT_PATH = os.path.join(os.path.sep, 'etc', 'fstab') + + def __init__(self, path=None): + if path: + self._path = path + else: + self._path = self.DEFAULT_PATH + super(Fstab, self).__init__(self._path, 'rb+') + + def _hydrate_entry(self, line): + # NOTE: use split with no arguments to split on any + # whitespace including tabs + return Fstab.Entry(*filter( + lambda x: x not in ('', None), + line.strip("\n").split())) + + @property + def entries(self): + self.seek(0) + for line in self.readlines(): + line = line.decode('us-ascii') + try: + if line.strip() and not line.strip().startswith("#"): + yield self._hydrate_entry(line) + except ValueError: + pass + + def get_entry_by_attr(self, attr, value): + for entry in self.entries: + e_attr = getattr(entry, attr) + if e_attr == value: + return entry + return None + + def add_entry(self, entry): + if self.get_entry_by_attr('device', entry.device): + return False + + self.write((str(entry) + '\n').encode('us-ascii')) + self.truncate() + return entry + + def remove_entry(self, entry): + self.seek(0) + + lines = [l.decode('us-ascii') for l in self.readlines()] + + found = False + for index, line in enumerate(lines): + if line.strip() and not line.strip().startswith("#"): + if self._hydrate_entry(line) == entry: + found = True + break + + if not found: + return False + + lines.remove(line) + + self.seek(0) + self.write(''.join(lines).encode('us-ascii')) + self.truncate() + return True + + @classmethod + def remove_by_mountpoint(cls, mountpoint, path=None): + fstab = cls(path=path) + entry = fstab.get_entry_by_attr('mountpoint', mountpoint) + if entry: + return fstab.remove_entry(entry) + return False + + @classmethod + def add(cls, device, mountpoint, filesystem, options=None, path=None): + return cls(path=path).add_entry(Fstab.Entry(device, + mountpoint, filesystem, + options=options)) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/hookenv.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/hookenv.py new file mode 100644 index 0000000..ab53a78 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/hookenv.py @@ -0,0 +1,898 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +"Interactions with the Juju environment" +# Copyright 2013 Canonical Ltd. +# +# Authors: +# Charm Helpers Developers + +from __future__ import print_function +import copy +from distutils.version import LooseVersion +from functools import wraps +import glob +import os +import json +import yaml +import subprocess +import sys +import errno +import tempfile +from subprocess import CalledProcessError + +import six +if not six.PY3: + from UserDict import UserDict +else: + from collections import UserDict + +CRITICAL = "CRITICAL" +ERROR = "ERROR" +WARNING = "WARNING" +INFO = "INFO" +DEBUG = "DEBUG" +MARKER = object() + +cache = {} + + +def cached(func): + """Cache return values for multiple executions of func + args + + For example:: + + @cached + def unit_get(attribute): + pass + + unit_get('test') + + will cache the result of unit_get + 'test' for future calls. + """ + @wraps(func) + def wrapper(*args, **kwargs): + global cache + key = str((func, args, kwargs)) + try: + return cache[key] + except KeyError: + pass # Drop out of the exception handler scope. + res = func(*args, **kwargs) + cache[key] = res + return res + wrapper._wrapped = func + return wrapper + + +def flush(key): + """Flushes any entries from function cache where the + key is found in the function+args """ + flush_list = [] + for item in cache: + if key in item: + flush_list.append(item) + for item in flush_list: + del cache[item] + + +def log(message, level=None): + """Write a message to the juju log""" + command = ['juju-log'] + if level: + command += ['-l', level] + if not isinstance(message, six.string_types): + message = repr(message) + command += [message] + # Missing juju-log should not cause failures in unit tests + # Send log output to stderr + try: + subprocess.call(command) + except OSError as e: + if e.errno == errno.ENOENT: + if level: + message = "{}: {}".format(level, message) + message = "juju-log: {}".format(message) + print(message, file=sys.stderr) + else: + raise + + +class Serializable(UserDict): + """Wrapper, an object that can be serialized to yaml or json""" + + def __init__(self, obj): + # wrap the object + UserDict.__init__(self) + self.data = obj + + def __getattr__(self, attr): + # See if this object has attribute. + if attr in ("json", "yaml", "data"): + return self.__dict__[attr] + # Check for attribute in wrapped object. + got = getattr(self.data, attr, MARKER) + if got is not MARKER: + return got + # Proxy to the wrapped object via dict interface. + try: + return self.data[attr] + except KeyError: + raise AttributeError(attr) + + def __getstate__(self): + # Pickle as a standard dictionary. + return self.data + + def __setstate__(self, state): + # Unpickle into our wrapper. + self.data = state + + def json(self): + """Serialize the object to json""" + return json.dumps(self.data) + + def yaml(self): + """Serialize the object to yaml""" + return yaml.dump(self.data) + + +def execution_environment(): + """A convenient bundling of the current execution context""" + context = {} + context['conf'] = config() + if relation_id(): + context['reltype'] = relation_type() + context['relid'] = relation_id() + context['rel'] = relation_get() + context['unit'] = local_unit() + context['rels'] = relations() + context['env'] = os.environ + return context + + +def in_relation_hook(): + """Determine whether we're running in a relation hook""" + return 'JUJU_RELATION' in os.environ + + +def relation_type(): + """The scope for the current relation hook""" + return os.environ.get('JUJU_RELATION', None) + + +@cached +def relation_id(relation_name=None, service_or_unit=None): + """The relation ID for the current or a specified relation""" + if not relation_name and not service_or_unit: + return os.environ.get('JUJU_RELATION_ID', None) + elif relation_name and service_or_unit: + service_name = service_or_unit.split('/')[0] + for relid in relation_ids(relation_name): + remote_service = remote_service_name(relid) + if remote_service == service_name: + return relid + else: + raise ValueError('Must specify neither or both of relation_name and service_or_unit') + + +def local_unit(): + """Local unit ID""" + return os.environ['JUJU_UNIT_NAME'] + + +def remote_unit(): + """The remote unit for the current relation hook""" + return os.environ.get('JUJU_REMOTE_UNIT', None) + + +def service_name(): + """The name service group this unit belongs to""" + return local_unit().split('/')[0] + + +@cached +def remote_service_name(relid=None): + """The remote service name for a given relation-id (or the current relation)""" + if relid is None: + unit = remote_unit() + else: + units = related_units(relid) + unit = units[0] if units else None + return unit.split('/')[0] if unit else None + + +def hook_name(): + """The name of the currently executing hook""" + return os.environ.get('JUJU_HOOK_NAME', os.path.basename(sys.argv[0])) + + +class Config(dict): + """A dictionary representation of the charm's config.yaml, with some + extra features: + + - See which values in the dictionary have changed since the previous hook. + - For values that have changed, see what the previous value was. + - Store arbitrary data for use in a later hook. + + NOTE: Do not instantiate this object directly - instead call + ``hookenv.config()``, which will return an instance of :class:`Config`. + + Example usage:: + + >>> # inside a hook + >>> from charmhelpers.core import hookenv + >>> config = hookenv.config() + >>> config['foo'] + 'bar' + >>> # store a new key/value for later use + >>> config['mykey'] = 'myval' + + + >>> # user runs `juju set mycharm foo=baz` + >>> # now we're inside subsequent config-changed hook + >>> config = hookenv.config() + >>> config['foo'] + 'baz' + >>> # test to see if this val has changed since last hook + >>> config.changed('foo') + True + >>> # what was the previous value? + >>> config.previous('foo') + 'bar' + >>> # keys/values that we add are preserved across hooks + >>> config['mykey'] + 'myval' + + """ + CONFIG_FILE_NAME = '.juju-persistent-config' + + def __init__(self, *args, **kw): + super(Config, self).__init__(*args, **kw) + self.implicit_save = True + self._prev_dict = None + self.path = os.path.join(charm_dir(), Config.CONFIG_FILE_NAME) + if os.path.exists(self.path): + self.load_previous() + atexit(self._implicit_save) + + def load_previous(self, path=None): + """Load previous copy of config from disk. + + In normal usage you don't need to call this method directly - it + is called automatically at object initialization. + + :param path: + + File path from which to load the previous config. If `None`, + config is loaded from the default location. If `path` is + specified, subsequent `save()` calls will write to the same + path. + + """ + self.path = path or self.path + with open(self.path) as f: + self._prev_dict = json.load(f) + for k, v in copy.deepcopy(self._prev_dict).items(): + if k not in self: + self[k] = v + + def changed(self, key): + """Return True if the current value for this key is different from + the previous value. + + """ + if self._prev_dict is None: + return True + return self.previous(key) != self.get(key) + + def previous(self, key): + """Return previous value for this key, or None if there + is no previous value. + + """ + if self._prev_dict: + return self._prev_dict.get(key) + return None + + def save(self): + """Save this config to disk. + + If the charm is using the :mod:`Services Framework ` + or :meth:'@hook ' decorator, this + is called automatically at the end of successful hook execution. + Otherwise, it should be called directly by user code. + + To disable automatic saves, set ``implicit_save=False`` on this + instance. + + """ + with open(self.path, 'w') as f: + json.dump(self, f) + + def _implicit_save(self): + if self.implicit_save: + self.save() + + +@cached +def config(scope=None): + """Juju charm configuration""" + config_cmd_line = ['config-get'] + if scope is not None: + config_cmd_line.append(scope) + config_cmd_line.append('--format=json') + try: + config_data = json.loads( + subprocess.check_output(config_cmd_line).decode('UTF-8')) + if scope is not None: + return config_data + return Config(config_data) + except ValueError: + return None + + +@cached +def relation_get(attribute=None, unit=None, rid=None): + """Get relation information""" + _args = ['relation-get', '--format=json'] + if rid: + _args.append('-r') + _args.append(rid) + _args.append(attribute or '-') + if unit: + _args.append(unit) + try: + return json.loads(subprocess.check_output(_args).decode('UTF-8')) + except ValueError: + return None + except CalledProcessError as e: + if e.returncode == 2: + return None + raise + + +def relation_set(relation_id=None, relation_settings=None, **kwargs): + """Set relation information for the current unit""" + relation_settings = relation_settings if relation_settings else {} + relation_cmd_line = ['relation-set'] + accepts_file = "--file" in subprocess.check_output( + relation_cmd_line + ["--help"], universal_newlines=True) + if relation_id is not None: + relation_cmd_line.extend(('-r', relation_id)) + settings = relation_settings.copy() + settings.update(kwargs) + for key, value in settings.items(): + # Force value to be a string: it always should, but some call + # sites pass in things like dicts or numbers. + if value is not None: + settings[key] = "{}".format(value) + if accepts_file: + # --file was introduced in Juju 1.23.2. Use it by default if + # available, since otherwise we'll break if the relation data is + # too big. Ideally we should tell relation-set to read the data from + # stdin, but that feature is broken in 1.23.2: Bug #1454678. + with tempfile.NamedTemporaryFile(delete=False) as settings_file: + settings_file.write(yaml.safe_dump(settings).encode("utf-8")) + subprocess.check_call( + relation_cmd_line + ["--file", settings_file.name]) + os.remove(settings_file.name) + else: + for key, value in settings.items(): + if value is None: + relation_cmd_line.append('{}='.format(key)) + else: + relation_cmd_line.append('{}={}'.format(key, value)) + subprocess.check_call(relation_cmd_line) + # Flush cache of any relation-gets for local unit + flush(local_unit()) + + +def relation_clear(r_id=None): + ''' Clears any relation data already set on relation r_id ''' + settings = relation_get(rid=r_id, + unit=local_unit()) + for setting in settings: + if setting not in ['public-address', 'private-address']: + settings[setting] = None + relation_set(relation_id=r_id, + **settings) + + +@cached +def relation_ids(reltype=None): + """A list of relation_ids""" + reltype = reltype or relation_type() + relid_cmd_line = ['relation-ids', '--format=json'] + if reltype is not None: + relid_cmd_line.append(reltype) + return json.loads( + subprocess.check_output(relid_cmd_line).decode('UTF-8')) or [] + return [] + + +@cached +def related_units(relid=None): + """A list of related units""" + relid = relid or relation_id() + units_cmd_line = ['relation-list', '--format=json'] + if relid is not None: + units_cmd_line.extend(('-r', relid)) + return json.loads( + subprocess.check_output(units_cmd_line).decode('UTF-8')) or [] + + +@cached +def relation_for_unit(unit=None, rid=None): + """Get the json represenation of a unit's relation""" + unit = unit or remote_unit() + relation = relation_get(unit=unit, rid=rid) + for key in relation: + if key.endswith('-list'): + relation[key] = relation[key].split() + relation['__unit__'] = unit + return relation + + +@cached +def relations_for_id(relid=None): + """Get relations of a specific relation ID""" + relation_data = [] + relid = relid or relation_ids() + for unit in related_units(relid): + unit_data = relation_for_unit(unit, relid) + unit_data['__relid__'] = relid + relation_data.append(unit_data) + return relation_data + + +@cached +def relations_of_type(reltype=None): + """Get relations of a specific type""" + relation_data = [] + reltype = reltype or relation_type() + for relid in relation_ids(reltype): + for relation in relations_for_id(relid): + relation['__relid__'] = relid + relation_data.append(relation) + return relation_data + + +@cached +def metadata(): + """Get the current charm metadata.yaml contents as a python object""" + with open(os.path.join(charm_dir(), 'metadata.yaml')) as md: + return yaml.safe_load(md) + + +@cached +def relation_types(): + """Get a list of relation types supported by this charm""" + rel_types = [] + md = metadata() + for key in ('provides', 'requires', 'peers'): + section = md.get(key) + if section: + rel_types.extend(section.keys()) + return rel_types + + +@cached +def relation_to_interface(relation_name): + """ + Given the name of a relation, return the interface that relation uses. + + :returns: The interface name, or ``None``. + """ + return relation_to_role_and_interface(relation_name)[1] + + +@cached +def relation_to_role_and_interface(relation_name): + """ + Given the name of a relation, return the role and the name of the interface + that relation uses (where role is one of ``provides``, ``requires``, or ``peer``). + + :returns: A tuple containing ``(role, interface)``, or ``(None, None)``. + """ + _metadata = metadata() + for role in ('provides', 'requires', 'peer'): + interface = _metadata.get(role, {}).get(relation_name, {}).get('interface') + if interface: + return role, interface + return None, None + + +@cached +def role_and_interface_to_relations(role, interface_name): + """ + Given a role and interface name, return a list of relation names for the + current charm that use that interface under that role (where role is one + of ``provides``, ``requires``, or ``peer``). + + :returns: A list of relation names. + """ + _metadata = metadata() + results = [] + for relation_name, relation in _metadata.get(role, {}).items(): + if relation['interface'] == interface_name: + results.append(relation_name) + return results + + +@cached +def interface_to_relations(interface_name): + """ + Given an interface, return a list of relation names for the current + charm that use that interface. + + :returns: A list of relation names. + """ + results = [] + for role in ('provides', 'requires', 'peer'): + results.extend(role_and_interface_to_relations(role, interface_name)) + return results + + +@cached +def charm_name(): + """Get the name of the current charm as is specified on metadata.yaml""" + return metadata().get('name') + + +@cached +def relations(): + """Get a nested dictionary of relation data for all related units""" + rels = {} + for reltype in relation_types(): + relids = {} + for relid in relation_ids(reltype): + units = {local_unit(): relation_get(unit=local_unit(), rid=relid)} + for unit in related_units(relid): + reldata = relation_get(unit=unit, rid=relid) + units[unit] = reldata + relids[relid] = units + rels[reltype] = relids + return rels + + +@cached +def is_relation_made(relation, keys='private-address'): + ''' + Determine whether a relation is established by checking for + presence of key(s). If a list of keys is provided, they + must all be present for the relation to be identified as made + ''' + if isinstance(keys, str): + keys = [keys] + for r_id in relation_ids(relation): + for unit in related_units(r_id): + context = {} + for k in keys: + context[k] = relation_get(k, rid=r_id, + unit=unit) + if None not in context.values(): + return True + return False + + +def open_port(port, protocol="TCP"): + """Open a service network port""" + _args = ['open-port'] + _args.append('{}/{}'.format(port, protocol)) + subprocess.check_call(_args) + + +def close_port(port, protocol="TCP"): + """Close a service network port""" + _args = ['close-port'] + _args.append('{}/{}'.format(port, protocol)) + subprocess.check_call(_args) + + +@cached +def unit_get(attribute): + """Get the unit ID for the remote unit""" + _args = ['unit-get', '--format=json', attribute] + try: + return json.loads(subprocess.check_output(_args).decode('UTF-8')) + except ValueError: + return None + + +def unit_public_ip(): + """Get this unit's public IP address""" + return unit_get('public-address') + + +def unit_private_ip(): + """Get this unit's private IP address""" + return unit_get('private-address') + + +class UnregisteredHookError(Exception): + """Raised when an undefined hook is called""" + pass + + +class Hooks(object): + """A convenient handler for hook functions. + + Example:: + + hooks = Hooks() + + # register a hook, taking its name from the function name + @hooks.hook() + def install(): + pass # your code here + + # register a hook, providing a custom hook name + @hooks.hook("config-changed") + def config_changed(): + pass # your code here + + if __name__ == "__main__": + # execute a hook based on the name the program is called by + hooks.execute(sys.argv) + """ + + def __init__(self, config_save=None): + super(Hooks, self).__init__() + self._hooks = {} + + # For unknown reasons, we allow the Hooks constructor to override + # config().implicit_save. + if config_save is not None: + config().implicit_save = config_save + + def register(self, name, function): + """Register a hook""" + self._hooks[name] = function + + def execute(self, args): + """Execute a registered hook based on args[0]""" + _run_atstart() + hook_name = os.path.basename(args[0]) + if hook_name in self._hooks: + try: + self._hooks[hook_name]() + except SystemExit as x: + if x.code is None or x.code == 0: + _run_atexit() + raise + _run_atexit() + else: + raise UnregisteredHookError(hook_name) + + def hook(self, *hook_names): + """Decorator, registering them as hooks""" + def wrapper(decorated): + for hook_name in hook_names: + self.register(hook_name, decorated) + else: + self.register(decorated.__name__, decorated) + if '_' in decorated.__name__: + self.register( + decorated.__name__.replace('_', '-'), decorated) + return decorated + return wrapper + + +def charm_dir(): + """Return the root directory of the current charm""" + return os.environ.get('CHARM_DIR') + + +@cached +def action_get(key=None): + """Gets the value of an action parameter, or all key/value param pairs""" + cmd = ['action-get'] + if key is not None: + cmd.append(key) + cmd.append('--format=json') + action_data = json.loads(subprocess.check_output(cmd).decode('UTF-8')) + return action_data + + +def action_set(values): + """Sets the values to be returned after the action finishes""" + cmd = ['action-set'] + for k, v in list(values.items()): + cmd.append('{}={}'.format(k, v)) + subprocess.check_call(cmd) + + +def action_fail(message): + """Sets the action status to failed and sets the error message. + + The results set by action_set are preserved.""" + subprocess.check_call(['action-fail', message]) + + +def action_name(): + """Get the name of the currently executing action.""" + return os.environ.get('JUJU_ACTION_NAME') + + +def action_uuid(): + """Get the UUID of the currently executing action.""" + return os.environ.get('JUJU_ACTION_UUID') + + +def action_tag(): + """Get the tag for the currently executing action.""" + return os.environ.get('JUJU_ACTION_TAG') + + +def status_set(workload_state, message): + """Set the workload state with a message + + Use status-set to set the workload state with a message which is visible + to the user via juju status. If the status-set command is not found then + assume this is juju < 1.23 and juju-log the message unstead. + + workload_state -- valid juju workload state. + message -- status update message + """ + valid_states = ['maintenance', 'blocked', 'waiting', 'active'] + if workload_state not in valid_states: + raise ValueError( + '{!r} is not a valid workload state'.format(workload_state) + ) + cmd = ['status-set', workload_state, message] + try: + ret = subprocess.call(cmd) + if ret == 0: + return + except OSError as e: + if e.errno != errno.ENOENT: + raise + log_message = 'status-set failed: {} {}'.format(workload_state, + message) + log(log_message, level='INFO') + + +def status_get(): + """Retrieve the previously set juju workload state and message + + If the status-get command is not found then assume this is juju < 1.23 and + return 'unknown', "" + + """ + cmd = ['status-get', "--format=json", "--include-data"] + try: + raw_status = subprocess.check_output(cmd) + except OSError as e: + if e.errno == errno.ENOENT: + return ('unknown', "") + else: + raise + else: + status = json.loads(raw_status.decode("UTF-8")) + return (status["status"], status["message"]) + + +def translate_exc(from_exc, to_exc): + def inner_translate_exc1(f): + def inner_translate_exc2(*args, **kwargs): + try: + return f(*args, **kwargs) + except from_exc: + raise to_exc + + return inner_translate_exc2 + + return inner_translate_exc1 + + +@translate_exc(from_exc=OSError, to_exc=NotImplementedError) +def is_leader(): + """Does the current unit hold the juju leadership + + Uses juju to determine whether the current unit is the leader of its peers + """ + cmd = ['is-leader', '--format=json'] + return json.loads(subprocess.check_output(cmd).decode('UTF-8')) + + +@translate_exc(from_exc=OSError, to_exc=NotImplementedError) +def leader_get(attribute=None): + """Juju leader get value(s)""" + cmd = ['leader-get', '--format=json'] + [attribute or '-'] + return json.loads(subprocess.check_output(cmd).decode('UTF-8')) + + +@translate_exc(from_exc=OSError, to_exc=NotImplementedError) +def leader_set(settings=None, **kwargs): + """Juju leader set value(s)""" + # Don't log secrets. + # log("Juju leader-set '%s'" % (settings), level=DEBUG) + cmd = ['leader-set'] + settings = settings or {} + settings.update(kwargs) + for k, v in settings.items(): + if v is None: + cmd.append('{}='.format(k)) + else: + cmd.append('{}={}'.format(k, v)) + subprocess.check_call(cmd) + + +@cached +def juju_version(): + """Full version string (eg. '1.23.3.1-trusty-amd64')""" + # Per https://bugs.launchpad.net/juju-core/+bug/1455368/comments/1 + jujud = glob.glob('/var/lib/juju/tools/machine-*/jujud')[0] + return subprocess.check_output([jujud, 'version'], + universal_newlines=True).strip() + + +@cached +def has_juju_version(minimum_version): + """Return True if the Juju version is at least the provided version""" + return LooseVersion(juju_version()) >= LooseVersion(minimum_version) + + +_atexit = [] +_atstart = [] + + +def atstart(callback, *args, **kwargs): + '''Schedule a callback to run before the main hook. + + Callbacks are run in the order they were added. + + This is useful for modules and classes to perform initialization + and inject behavior. In particular: + + - Run common code before all of your hooks, such as logging + the hook name or interesting relation data. + - Defer object or module initialization that requires a hook + context until we know there actually is a hook context, + making testing easier. + - Rather than requiring charm authors to include boilerplate to + invoke your helper's behavior, have it run automatically if + your object is instantiated or module imported. + + This is not at all useful after your hook framework as been launched. + ''' + global _atstart + _atstart.append((callback, args, kwargs)) + + +def atexit(callback, *args, **kwargs): + '''Schedule a callback to run on successful hook completion. + + Callbacks are run in the reverse order that they were added.''' + _atexit.append((callback, args, kwargs)) + + +def _run_atstart(): + '''Hook frameworks must invoke this before running the main hook body.''' + global _atstart + for callback, args, kwargs in _atstart: + callback(*args, **kwargs) + del _atstart[:] + + +def _run_atexit(): + '''Hook frameworks must invoke this after the main hook body has + successfully completed. Do not invoke it if the hook fails.''' + global _atexit + for callback, args, kwargs in reversed(_atexit): + callback(*args, **kwargs) + del _atexit[:] diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/host.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/host.py new file mode 100644 index 0000000..cb3c527 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/host.py @@ -0,0 +1,586 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +"""Tools for working with the host system""" +# Copyright 2012 Canonical Ltd. +# +# Authors: +# Nick Moffitt +# Matthew Wedgwood + +import os +import re +import pwd +import glob +import grp +import random +import string +import subprocess +import hashlib +from contextlib import contextmanager +from collections import OrderedDict + +import six + +from .hookenv import log +from .fstab import Fstab + + +def service_start(service_name): + """Start a system service""" + return service('start', service_name) + + +def service_stop(service_name): + """Stop a system service""" + return service('stop', service_name) + + +def service_restart(service_name): + """Restart a system service""" + return service('restart', service_name) + + +def service_reload(service_name, restart_on_failure=False): + """Reload a system service, optionally falling back to restart if + reload fails""" + service_result = service('reload', service_name) + if not service_result and restart_on_failure: + service_result = service('restart', service_name) + return service_result + + +def service_pause(service_name, init_dir="/etc/init", initd_dir="/etc/init.d"): + """Pause a system service. + + Stop it, and prevent it from starting again at boot.""" + stopped = service_stop(service_name) + upstart_file = os.path.join(init_dir, "{}.conf".format(service_name)) + sysv_file = os.path.join(initd_dir, service_name) + if os.path.exists(upstart_file): + override_path = os.path.join( + init_dir, '{}.override'.format(service_name)) + with open(override_path, 'w') as fh: + fh.write("manual\n") + elif os.path.exists(sysv_file): + subprocess.check_call(["update-rc.d", service_name, "disable"]) + else: + # XXX: Support SystemD too + raise ValueError( + "Unable to detect {0} as either Upstart {1} or SysV {2}".format( + service_name, upstart_file, sysv_file)) + return stopped + + +def service_resume(service_name, init_dir="/etc/init", + initd_dir="/etc/init.d"): + """Resume a system service. + + Reenable starting again at boot. Start the service""" + upstart_file = os.path.join(init_dir, "{}.conf".format(service_name)) + sysv_file = os.path.join(initd_dir, service_name) + if os.path.exists(upstart_file): + override_path = os.path.join( + init_dir, '{}.override'.format(service_name)) + if os.path.exists(override_path): + os.unlink(override_path) + elif os.path.exists(sysv_file): + subprocess.check_call(["update-rc.d", service_name, "enable"]) + else: + # XXX: Support SystemD too + raise ValueError( + "Unable to detect {0} as either Upstart {1} or SysV {2}".format( + service_name, upstart_file, sysv_file)) + + started = service_start(service_name) + return started + + +def service(action, service_name): + """Control a system service""" + cmd = ['service', service_name, action] + return subprocess.call(cmd) == 0 + + +def service_running(service): + """Determine whether a system service is running""" + try: + output = subprocess.check_output( + ['service', service, 'status'], + stderr=subprocess.STDOUT).decode('UTF-8') + except subprocess.CalledProcessError: + return False + else: + if ("start/running" in output or "is running" in output): + return True + else: + return False + + +def service_available(service_name): + """Determine whether a system service is available""" + try: + subprocess.check_output( + ['service', service_name, 'status'], + stderr=subprocess.STDOUT).decode('UTF-8') + except subprocess.CalledProcessError as e: + return b'unrecognized service' not in e.output + else: + return True + + +def adduser(username, password=None, shell='/bin/bash', system_user=False): + """Add a user to the system""" + try: + user_info = pwd.getpwnam(username) + log('user {0} already exists!'.format(username)) + except KeyError: + log('creating user {0}'.format(username)) + cmd = ['useradd'] + if system_user or password is None: + cmd.append('--system') + else: + cmd.extend([ + '--create-home', + '--shell', shell, + '--password', password, + ]) + cmd.append(username) + subprocess.check_call(cmd) + user_info = pwd.getpwnam(username) + return user_info + + +def user_exists(username): + """Check if a user exists""" + try: + pwd.getpwnam(username) + user_exists = True + except KeyError: + user_exists = False + return user_exists + + +def add_group(group_name, system_group=False): + """Add a group to the system""" + try: + group_info = grp.getgrnam(group_name) + log('group {0} already exists!'.format(group_name)) + except KeyError: + log('creating group {0}'.format(group_name)) + cmd = ['addgroup'] + if system_group: + cmd.append('--system') + else: + cmd.extend([ + '--group', + ]) + cmd.append(group_name) + subprocess.check_call(cmd) + group_info = grp.getgrnam(group_name) + return group_info + + +def add_user_to_group(username, group): + """Add a user to a group""" + cmd = ['gpasswd', '-a', username, group] + log("Adding user {} to group {}".format(username, group)) + subprocess.check_call(cmd) + + +def rsync(from_path, to_path, flags='-r', options=None): + """Replicate the contents of a path""" + options = options or ['--delete', '--executability'] + cmd = ['/usr/bin/rsync', flags] + cmd.extend(options) + cmd.append(from_path) + cmd.append(to_path) + log(" ".join(cmd)) + return subprocess.check_output(cmd).decode('UTF-8').strip() + + +def symlink(source, destination): + """Create a symbolic link""" + log("Symlinking {} as {}".format(source, destination)) + cmd = [ + 'ln', + '-sf', + source, + destination, + ] + subprocess.check_call(cmd) + + +def mkdir(path, owner='root', group='root', perms=0o555, force=False): + """Create a directory""" + log("Making dir {} {}:{} {:o}".format(path, owner, group, + perms)) + uid = pwd.getpwnam(owner).pw_uid + gid = grp.getgrnam(group).gr_gid + realpath = os.path.abspath(path) + path_exists = os.path.exists(realpath) + if path_exists and force: + if not os.path.isdir(realpath): + log("Removing non-directory file {} prior to mkdir()".format(path)) + os.unlink(realpath) + os.makedirs(realpath, perms) + elif not path_exists: + os.makedirs(realpath, perms) + os.chown(realpath, uid, gid) + os.chmod(realpath, perms) + + +def write_file(path, content, owner='root', group='root', perms=0o444): + """Create or overwrite a file with the contents of a byte string.""" + log("Writing file {} {}:{} {:o}".format(path, owner, group, perms)) + uid = pwd.getpwnam(owner).pw_uid + gid = grp.getgrnam(group).gr_gid + with open(path, 'wb') as target: + os.fchown(target.fileno(), uid, gid) + os.fchmod(target.fileno(), perms) + target.write(content) + + +def fstab_remove(mp): + """Remove the given mountpoint entry from /etc/fstab + """ + return Fstab.remove_by_mountpoint(mp) + + +def fstab_add(dev, mp, fs, options=None): + """Adds the given device entry to the /etc/fstab file + """ + return Fstab.add(dev, mp, fs, options=options) + + +def mount(device, mountpoint, options=None, persist=False, filesystem="ext3"): + """Mount a filesystem at a particular mountpoint""" + cmd_args = ['mount'] + if options is not None: + cmd_args.extend(['-o', options]) + cmd_args.extend([device, mountpoint]) + try: + subprocess.check_output(cmd_args) + except subprocess.CalledProcessError as e: + log('Error mounting {} at {}\n{}'.format(device, mountpoint, e.output)) + return False + + if persist: + return fstab_add(device, mountpoint, filesystem, options=options) + return True + + +def umount(mountpoint, persist=False): + """Unmount a filesystem""" + cmd_args = ['umount', mountpoint] + try: + subprocess.check_output(cmd_args) + except subprocess.CalledProcessError as e: + log('Error unmounting {}\n{}'.format(mountpoint, e.output)) + return False + + if persist: + return fstab_remove(mountpoint) + return True + + +def mounts(): + """Get a list of all mounted volumes as [[mountpoint,device],[...]]""" + with open('/proc/mounts') as f: + # [['/mount/point','/dev/path'],[...]] + system_mounts = [m[1::-1] for m in [l.strip().split() + for l in f.readlines()]] + return system_mounts + + +def fstab_mount(mountpoint): + """Mount filesystem using fstab""" + cmd_args = ['mount', mountpoint] + try: + subprocess.check_output(cmd_args) + except subprocess.CalledProcessError as e: + log('Error unmounting {}\n{}'.format(mountpoint, e.output)) + return False + return True + + +def file_hash(path, hash_type='md5'): + """ + Generate a hash checksum of the contents of 'path' or None if not found. + + :param str hash_type: Any hash alrgorithm supported by :mod:`hashlib`, + such as md5, sha1, sha256, sha512, etc. + """ + if os.path.exists(path): + h = getattr(hashlib, hash_type)() + with open(path, 'rb') as source: + h.update(source.read()) + return h.hexdigest() + else: + return None + + +def path_hash(path): + """ + Generate a hash checksum of all files matching 'path'. Standard wildcards + like '*' and '?' are supported, see documentation for the 'glob' module for + more information. + + :return: dict: A { filename: hash } dictionary for all matched files. + Empty if none found. + """ + return { + filename: file_hash(filename) + for filename in glob.iglob(path) + } + + +def check_hash(path, checksum, hash_type='md5'): + """ + Validate a file using a cryptographic checksum. + + :param str checksum: Value of the checksum used to validate the file. + :param str hash_type: Hash algorithm used to generate `checksum`. + Can be any hash alrgorithm supported by :mod:`hashlib`, + such as md5, sha1, sha256, sha512, etc. + :raises ChecksumError: If the file fails the checksum + + """ + actual_checksum = file_hash(path, hash_type) + if checksum != actual_checksum: + raise ChecksumError("'%s' != '%s'" % (checksum, actual_checksum)) + + +class ChecksumError(ValueError): + pass + + +def restart_on_change(restart_map, stopstart=False): + """Restart services based on configuration files changing + + This function is used a decorator, for example:: + + @restart_on_change({ + '/etc/ceph/ceph.conf': [ 'cinder-api', 'cinder-volume' ] + '/etc/apache/sites-enabled/*': [ 'apache2' ] + }) + def config_changed(): + pass # your code here + + In this example, the cinder-api and cinder-volume services + would be restarted if /etc/ceph/ceph.conf is changed by the + ceph_client_changed function. The apache2 service would be + restarted if any file matching the pattern got changed, created + or removed. Standard wildcards are supported, see documentation + for the 'glob' module for more information. + """ + def wrap(f): + def wrapped_f(*args, **kwargs): + checksums = {path: path_hash(path) for path in restart_map} + f(*args, **kwargs) + restarts = [] + for path in restart_map: + if path_hash(path) != checksums[path]: + restarts += restart_map[path] + services_list = list(OrderedDict.fromkeys(restarts)) + if not stopstart: + for service_name in services_list: + service('restart', service_name) + else: + for action in ['stop', 'start']: + for service_name in services_list: + service(action, service_name) + return wrapped_f + return wrap + + +def lsb_release(): + """Return /etc/lsb-release in a dict""" + d = {} + with open('/etc/lsb-release', 'r') as lsb: + for l in lsb: + k, v = l.split('=') + d[k.strip()] = v.strip() + return d + + +def pwgen(length=None): + """Generate a random pasword.""" + if length is None: + # A random length is ok to use a weak PRNG + length = random.choice(range(35, 45)) + alphanumeric_chars = [ + l for l in (string.ascii_letters + string.digits) + if l not in 'l0QD1vAEIOUaeiou'] + # Use a crypto-friendly PRNG (e.g. /dev/urandom) for making the + # actual password + random_generator = random.SystemRandom() + random_chars = [ + random_generator.choice(alphanumeric_chars) for _ in range(length)] + return(''.join(random_chars)) + + +def is_phy_iface(interface): + """Returns True if interface is not virtual, otherwise False.""" + if interface: + sys_net = '/sys/class/net' + if os.path.isdir(sys_net): + for iface in glob.glob(os.path.join(sys_net, '*')): + if '/virtual/' in os.path.realpath(iface): + continue + + if interface == os.path.basename(iface): + return True + + return False + + +def get_bond_master(interface): + """Returns bond master if interface is bond slave otherwise None. + + NOTE: the provided interface is expected to be physical + """ + if interface: + iface_path = '/sys/class/net/%s' % (interface) + if os.path.exists(iface_path): + if '/virtual/' in os.path.realpath(iface_path): + return None + + master = os.path.join(iface_path, 'master') + if os.path.exists(master): + master = os.path.realpath(master) + # make sure it is a bond master + if os.path.exists(os.path.join(master, 'bonding')): + return os.path.basename(master) + + return None + + +def list_nics(nic_type=None): + '''Return a list of nics of given type(s)''' + if isinstance(nic_type, six.string_types): + int_types = [nic_type] + else: + int_types = nic_type + + interfaces = [] + if nic_type: + for int_type in int_types: + cmd = ['ip', 'addr', 'show', 'label', int_type + '*'] + ip_output = subprocess.check_output(cmd).decode('UTF-8') + ip_output = ip_output.split('\n') + ip_output = (line for line in ip_output if line) + for line in ip_output: + if line.split()[1].startswith(int_type): + matched = re.search('.*: (' + int_type + + r'[0-9]+\.[0-9]+)@.*', line) + if matched: + iface = matched.groups()[0] + else: + iface = line.split()[1].replace(":", "") + + if iface not in interfaces: + interfaces.append(iface) + else: + cmd = ['ip', 'a'] + ip_output = subprocess.check_output(cmd).decode('UTF-8').split('\n') + ip_output = (line.strip() for line in ip_output if line) + + key = re.compile('^[0-9]+:\s+(.+):') + for line in ip_output: + matched = re.search(key, line) + if matched: + iface = matched.group(1) + iface = iface.partition("@")[0] + if iface not in interfaces: + interfaces.append(iface) + + return interfaces + + +def set_nic_mtu(nic, mtu): + '''Set MTU on a network interface''' + cmd = ['ip', 'link', 'set', nic, 'mtu', mtu] + subprocess.check_call(cmd) + + +def get_nic_mtu(nic): + cmd = ['ip', 'addr', 'show', nic] + ip_output = subprocess.check_output(cmd).decode('UTF-8').split('\n') + mtu = "" + for line in ip_output: + words = line.split() + if 'mtu' in words: + mtu = words[words.index("mtu") + 1] + return mtu + + +def get_nic_hwaddr(nic): + cmd = ['ip', '-o', '-0', 'addr', 'show', nic] + ip_output = subprocess.check_output(cmd).decode('UTF-8') + hwaddr = "" + words = ip_output.split() + if 'link/ether' in words: + hwaddr = words[words.index('link/ether') + 1] + return hwaddr + + +def cmp_pkgrevno(package, revno, pkgcache=None): + '''Compare supplied revno with the revno of the installed package + + * 1 => Installed revno is greater than supplied arg + * 0 => Installed revno is the same as supplied arg + * -1 => Installed revno is less than supplied arg + + This function imports apt_cache function from charmhelpers.fetch if + the pkgcache argument is None. Be sure to add charmhelpers.fetch if + you call this function, or pass an apt_pkg.Cache() instance. + ''' + import apt_pkg + if not pkgcache: + from charmhelpers.fetch import apt_cache + pkgcache = apt_cache() + pkg = pkgcache[package] + return apt_pkg.version_compare(pkg.current_ver.ver_str, revno) + + +@contextmanager +def chdir(d): + cur = os.getcwd() + try: + yield os.chdir(d) + finally: + os.chdir(cur) + + +def chownr(path, owner, group, follow_links=True): + uid = pwd.getpwnam(owner).pw_uid + gid = grp.getgrnam(group).gr_gid + if follow_links: + chown = os.chown + else: + chown = os.lchown + + for root, dirs, files in os.walk(path): + for name in dirs + files: + full = os.path.join(root, name) + broken_symlink = os.path.lexists(full) and not os.path.exists(full) + if not broken_symlink: + chown(full, uid, gid) + + +def lchownr(path, owner, group): + chownr(path, owner, group, follow_links=False) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/hugepage.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/hugepage.py new file mode 100644 index 0000000..4aaca3f --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/hugepage.py @@ -0,0 +1,69 @@ +# -*- coding: utf-8 -*- + +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import yaml +from charmhelpers.core import fstab +from charmhelpers.core import sysctl +from charmhelpers.core.host import ( + add_group, + add_user_to_group, + fstab_mount, + mkdir, +) +from charmhelpers.core.strutils import bytes_from_string +from subprocess import check_output + + +def hugepage_support(user, group='hugetlb', nr_hugepages=256, + max_map_count=65536, mnt_point='/run/hugepages/kvm', + pagesize='2MB', mount=True, set_shmmax=False): + """Enable hugepages on system. + + Args: + user (str) -- Username to allow access to hugepages to + group (str) -- Group name to own hugepages + nr_hugepages (int) -- Number of pages to reserve + max_map_count (int) -- Number of Virtual Memory Areas a process can own + mnt_point (str) -- Directory to mount hugepages on + pagesize (str) -- Size of hugepages + mount (bool) -- Whether to Mount hugepages + """ + group_info = add_group(group) + gid = group_info.gr_gid + add_user_to_group(user, group) + sysctl_settings = { + 'vm.nr_hugepages': nr_hugepages, + 'vm.max_map_count': max_map_count, + 'vm.hugetlb_shm_group': gid, + } + if set_shmmax: + shmmax_current = int(check_output(['sysctl', '-n', 'kernel.shmmax'])) + shmmax_minsize = bytes_from_string(pagesize) * nr_hugepages + if shmmax_minsize > shmmax_current: + sysctl_settings['kernel.shmmax'] = shmmax_minsize + sysctl.create(yaml.dump(sysctl_settings), '/etc/sysctl.d/10-hugepage.conf') + mkdir(mnt_point, owner='root', group='root', perms=0o755, force=False) + lfstab = fstab.Fstab() + fstab_entry = lfstab.get_entry_by_attr('mountpoint', mnt_point) + if fstab_entry: + lfstab.remove_entry(fstab_entry) + entry = lfstab.Entry('nodev', mnt_point, 'hugetlbfs', + 'mode=1770,gid={},pagesize={}'.format(gid, pagesize), 0, 0) + lfstab.add_entry(entry) + if mount: + fstab_mount(mnt_point) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/kernel.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/kernel.py new file mode 100644 index 0000000..5dc6495 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/kernel.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +__author__ = "Jorge Niedbalski " + +from charmhelpers.core.hookenv import ( + log, + INFO +) + +from subprocess import check_call, check_output +import re + + +def modprobe(module, persist=True): + """Load a kernel module and configure for auto-load on reboot.""" + cmd = ['modprobe', module] + + log('Loading kernel module %s' % module, level=INFO) + + check_call(cmd) + if persist: + with open('/etc/modules', 'r+') as modules: + if module not in modules.read(): + modules.write(module) + + +def rmmod(module, force=False): + """Remove a module from the linux kernel""" + cmd = ['rmmod'] + if force: + cmd.append('-f') + cmd.append(module) + log('Removing kernel module %s' % module, level=INFO) + return check_call(cmd) + + +def lsmod(): + """Shows what kernel modules are currently loaded""" + return check_output(['lsmod'], + universal_newlines=True) + + +def is_module_loaded(module): + """Checks if a kernel module is already loaded""" + matches = re.findall('^%s[ ]+' % module, lsmod(), re.M) + return len(matches) > 0 + + +def update_initramfs(version='all'): + """Updates an initramfs image""" + return check_call(["update-initramfs", "-k", version, "-u"]) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/__init__.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/__init__.py new file mode 100644 index 0000000..0928158 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +from .base import * # NOQA +from .helpers import * # NOQA diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/base.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/base.py new file mode 100644 index 0000000..a42660c --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/base.py @@ -0,0 +1,353 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import os +import json +from inspect import getargspec +from collections import Iterable, OrderedDict + +from charmhelpers.core import host +from charmhelpers.core import hookenv + + +__all__ = ['ServiceManager', 'ManagerCallback', + 'PortManagerCallback', 'open_ports', 'close_ports', 'manage_ports', + 'service_restart', 'service_stop'] + + +class ServiceManager(object): + def __init__(self, services=None): + """ + Register a list of services, given their definitions. + + Service definitions are dicts in the following formats (all keys except + 'service' are optional):: + + { + "service": , + "required_data": , + "provided_data": , + "data_ready": , + "data_lost": , + "start": , + "stop": , + "ports": , + } + + The 'required_data' list should contain dicts of required data (or + dependency managers that act like dicts and know how to collect the data). + Only when all items in the 'required_data' list are populated are the list + of 'data_ready' and 'start' callbacks executed. See `is_ready()` for more + information. + + The 'provided_data' list should contain relation data providers, most likely + a subclass of :class:`charmhelpers.core.services.helpers.RelationContext`, + that will indicate a set of data to set on a given relation. + + The 'data_ready' value should be either a single callback, or a list of + callbacks, to be called when all items in 'required_data' pass `is_ready()`. + Each callback will be called with the service name as the only parameter. + After all of the 'data_ready' callbacks are called, the 'start' callbacks + are fired. + + The 'data_lost' value should be either a single callback, or a list of + callbacks, to be called when a 'required_data' item no longer passes + `is_ready()`. Each callback will be called with the service name as the + only parameter. After all of the 'data_lost' callbacks are called, + the 'stop' callbacks are fired. + + The 'start' value should be either a single callback, or a list of + callbacks, to be called when starting the service, after the 'data_ready' + callbacks are complete. Each callback will be called with the service + name as the only parameter. This defaults to + `[host.service_start, services.open_ports]`. + + The 'stop' value should be either a single callback, or a list of + callbacks, to be called when stopping the service. If the service is + being stopped because it no longer has all of its 'required_data', this + will be called after all of the 'data_lost' callbacks are complete. + Each callback will be called with the service name as the only parameter. + This defaults to `[services.close_ports, host.service_stop]`. + + The 'ports' value should be a list of ports to manage. The default + 'start' handler will open the ports after the service is started, + and the default 'stop' handler will close the ports prior to stopping + the service. + + + Examples: + + The following registers an Upstart service called bingod that depends on + a mongodb relation and which runs a custom `db_migrate` function prior to + restarting the service, and a Runit service called spadesd:: + + manager = services.ServiceManager([ + { + 'service': 'bingod', + 'ports': [80, 443], + 'required_data': [MongoRelation(), config(), {'my': 'data'}], + 'data_ready': [ + services.template(source='bingod.conf'), + services.template(source='bingod.ini', + target='/etc/bingod.ini', + owner='bingo', perms=0400), + ], + }, + { + 'service': 'spadesd', + 'data_ready': services.template(source='spadesd_run.j2', + target='/etc/sv/spadesd/run', + perms=0555), + 'start': runit_start, + 'stop': runit_stop, + }, + ]) + manager.manage() + """ + self._ready_file = os.path.join(hookenv.charm_dir(), 'READY-SERVICES.json') + self._ready = None + self.services = OrderedDict() + for service in services or []: + service_name = service['service'] + self.services[service_name] = service + + def manage(self): + """ + Handle the current hook by doing The Right Thing with the registered services. + """ + hookenv._run_atstart() + try: + hook_name = hookenv.hook_name() + if hook_name == 'stop': + self.stop_services() + else: + self.reconfigure_services() + self.provide_data() + except SystemExit as x: + if x.code is None or x.code == 0: + hookenv._run_atexit() + hookenv._run_atexit() + + def provide_data(self): + """ + Set the relation data for each provider in the ``provided_data`` list. + + A provider must have a `name` attribute, which indicates which relation + to set data on, and a `provide_data()` method, which returns a dict of + data to set. + + The `provide_data()` method can optionally accept two parameters: + + * ``remote_service`` The name of the remote service that the data will + be provided to. The `provide_data()` method will be called once + for each connected service (not unit). This allows the method to + tailor its data to the given service. + * ``service_ready`` Whether or not the service definition had all of + its requirements met, and thus the ``data_ready`` callbacks run. + + Note that the ``provided_data`` methods are now called **after** the + ``data_ready`` callbacks are run. This gives the ``data_ready`` callbacks + a chance to generate any data necessary for the providing to the remote + services. + """ + for service_name, service in self.services.items(): + service_ready = self.is_ready(service_name) + for provider in service.get('provided_data', []): + for relid in hookenv.relation_ids(provider.name): + units = hookenv.related_units(relid) + if not units: + continue + remote_service = units[0].split('/')[0] + argspec = getargspec(provider.provide_data) + if len(argspec.args) > 1: + data = provider.provide_data(remote_service, service_ready) + else: + data = provider.provide_data() + if data: + hookenv.relation_set(relid, data) + + def reconfigure_services(self, *service_names): + """ + Update all files for one or more registered services, and, + if ready, optionally restart them. + + If no service names are given, reconfigures all registered services. + """ + for service_name in service_names or self.services.keys(): + if self.is_ready(service_name): + self.fire_event('data_ready', service_name) + self.fire_event('start', service_name, default=[ + service_restart, + manage_ports]) + self.save_ready(service_name) + else: + if self.was_ready(service_name): + self.fire_event('data_lost', service_name) + self.fire_event('stop', service_name, default=[ + manage_ports, + service_stop]) + self.save_lost(service_name) + + def stop_services(self, *service_names): + """ + Stop one or more registered services, by name. + + If no service names are given, stops all registered services. + """ + for service_name in service_names or self.services.keys(): + self.fire_event('stop', service_name, default=[ + manage_ports, + service_stop]) + + def get_service(self, service_name): + """ + Given the name of a registered service, return its service definition. + """ + service = self.services.get(service_name) + if not service: + raise KeyError('Service not registered: %s' % service_name) + return service + + def fire_event(self, event_name, service_name, default=None): + """ + Fire a data_ready, data_lost, start, or stop event on a given service. + """ + service = self.get_service(service_name) + callbacks = service.get(event_name, default) + if not callbacks: + return + if not isinstance(callbacks, Iterable): + callbacks = [callbacks] + for callback in callbacks: + if isinstance(callback, ManagerCallback): + callback(self, service_name, event_name) + else: + callback(service_name) + + def is_ready(self, service_name): + """ + Determine if a registered service is ready, by checking its 'required_data'. + + A 'required_data' item can be any mapping type, and is considered ready + if `bool(item)` evaluates as True. + """ + service = self.get_service(service_name) + reqs = service.get('required_data', []) + return all(bool(req) for req in reqs) + + def _load_ready_file(self): + if self._ready is not None: + return + if os.path.exists(self._ready_file): + with open(self._ready_file) as fp: + self._ready = set(json.load(fp)) + else: + self._ready = set() + + def _save_ready_file(self): + if self._ready is None: + return + with open(self._ready_file, 'w') as fp: + json.dump(list(self._ready), fp) + + def save_ready(self, service_name): + """ + Save an indicator that the given service is now data_ready. + """ + self._load_ready_file() + self._ready.add(service_name) + self._save_ready_file() + + def save_lost(self, service_name): + """ + Save an indicator that the given service is no longer data_ready. + """ + self._load_ready_file() + self._ready.discard(service_name) + self._save_ready_file() + + def was_ready(self, service_name): + """ + Determine if the given service was previously data_ready. + """ + self._load_ready_file() + return service_name in self._ready + + +class ManagerCallback(object): + """ + Special case of a callback that takes the `ServiceManager` instance + in addition to the service name. + + Subclasses should implement `__call__` which should accept three parameters: + + * `manager` The `ServiceManager` instance + * `service_name` The name of the service it's being triggered for + * `event_name` The name of the event that this callback is handling + """ + def __call__(self, manager, service_name, event_name): + raise NotImplementedError() + + +class PortManagerCallback(ManagerCallback): + """ + Callback class that will open or close ports, for use as either + a start or stop action. + """ + def __call__(self, manager, service_name, event_name): + service = manager.get_service(service_name) + new_ports = service.get('ports', []) + port_file = os.path.join(hookenv.charm_dir(), '.{}.ports'.format(service_name)) + if os.path.exists(port_file): + with open(port_file) as fp: + old_ports = fp.read().split(',') + for old_port in old_ports: + if bool(old_port): + old_port = int(old_port) + if old_port not in new_ports: + hookenv.close_port(old_port) + with open(port_file, 'w') as fp: + fp.write(','.join(str(port) for port in new_ports)) + for port in new_ports: + if event_name == 'start': + hookenv.open_port(port) + elif event_name == 'stop': + hookenv.close_port(port) + + +def service_stop(service_name): + """ + Wrapper around host.service_stop to prevent spurious "unknown service" + messages in the logs. + """ + if host.service_running(service_name): + host.service_stop(service_name) + + +def service_restart(service_name): + """ + Wrapper around host.service_restart to prevent spurious "unknown service" + messages in the logs. + """ + if host.service_available(service_name): + if host.service_running(service_name): + host.service_restart(service_name) + else: + host.service_start(service_name) + + +# Convenience aliases +open_ports = close_ports = manage_ports = PortManagerCallback() diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/helpers.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/helpers.py new file mode 100644 index 0000000..3f67783 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/services/helpers.py @@ -0,0 +1,283 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import os +import yaml + +from charmhelpers.core import hookenv +from charmhelpers.core import host +from charmhelpers.core import templating + +from charmhelpers.core.services.base import ManagerCallback + + +__all__ = ['RelationContext', 'TemplateCallback', + 'render_template', 'template'] + + +class RelationContext(dict): + """ + Base class for a context generator that gets relation data from juju. + + Subclasses must provide the attributes `name`, which is the name of the + interface of interest, `interface`, which is the type of the interface of + interest, and `required_keys`, which is the set of keys required for the + relation to be considered complete. The data for all interfaces matching + the `name` attribute that are complete will used to populate the dictionary + values (see `get_data`, below). + + The generated context will be namespaced under the relation :attr:`name`, + to prevent potential naming conflicts. + + :param str name: Override the relation :attr:`name`, since it can vary from charm to charm + :param list additional_required_keys: Extend the list of :attr:`required_keys` + """ + name = None + interface = None + + def __init__(self, name=None, additional_required_keys=None): + if not hasattr(self, 'required_keys'): + self.required_keys = [] + + if name is not None: + self.name = name + if additional_required_keys: + self.required_keys.extend(additional_required_keys) + self.get_data() + + def __bool__(self): + """ + Returns True if all of the required_keys are available. + """ + return self.is_ready() + + __nonzero__ = __bool__ + + def __repr__(self): + return super(RelationContext, self).__repr__() + + def is_ready(self): + """ + Returns True if all of the `required_keys` are available from any units. + """ + ready = len(self.get(self.name, [])) > 0 + if not ready: + hookenv.log('Incomplete relation: {}'.format(self.__class__.__name__), hookenv.DEBUG) + return ready + + def _is_ready(self, unit_data): + """ + Helper method that tests a set of relation data and returns True if + all of the `required_keys` are present. + """ + return set(unit_data.keys()).issuperset(set(self.required_keys)) + + def get_data(self): + """ + Retrieve the relation data for each unit involved in a relation and, + if complete, store it in a list under `self[self.name]`. This + is automatically called when the RelationContext is instantiated. + + The units are sorted lexographically first by the service ID, then by + the unit ID. Thus, if an interface has two other services, 'db:1' + and 'db:2', with 'db:1' having two units, 'wordpress/0' and 'wordpress/1', + and 'db:2' having one unit, 'mediawiki/0', all of which have a complete + set of data, the relation data for the units will be stored in the + order: 'wordpress/0', 'wordpress/1', 'mediawiki/0'. + + If you only care about a single unit on the relation, you can just + access it as `{{ interface[0]['key'] }}`. However, if you can at all + support multiple units on a relation, you should iterate over the list, + like:: + + {% for unit in interface -%} + {{ unit['key'] }}{% if not loop.last %},{% endif %} + {%- endfor %} + + Note that since all sets of relation data from all related services and + units are in a single list, if you need to know which service or unit a + set of data came from, you'll need to extend this class to preserve + that information. + """ + if not hookenv.relation_ids(self.name): + return + + ns = self.setdefault(self.name, []) + for rid in sorted(hookenv.relation_ids(self.name)): + for unit in sorted(hookenv.related_units(rid)): + reldata = hookenv.relation_get(rid=rid, unit=unit) + if self._is_ready(reldata): + ns.append(reldata) + + def provide_data(self): + """ + Return data to be relation_set for this interface. + """ + return {} + + +class MysqlRelation(RelationContext): + """ + Relation context for the `mysql` interface. + + :param str name: Override the relation :attr:`name`, since it can vary from charm to charm + :param list additional_required_keys: Extend the list of :attr:`required_keys` + """ + name = 'db' + interface = 'mysql' + + def __init__(self, *args, **kwargs): + self.required_keys = ['host', 'user', 'password', 'database'] + RelationContext.__init__(self, *args, **kwargs) + + +class HttpRelation(RelationContext): + """ + Relation context for the `http` interface. + + :param str name: Override the relation :attr:`name`, since it can vary from charm to charm + :param list additional_required_keys: Extend the list of :attr:`required_keys` + """ + name = 'website' + interface = 'http' + + def __init__(self, *args, **kwargs): + self.required_keys = ['host', 'port'] + RelationContext.__init__(self, *args, **kwargs) + + def provide_data(self): + return { + 'host': hookenv.unit_get('private-address'), + 'port': 80, + } + + +class RequiredConfig(dict): + """ + Data context that loads config options with one or more mandatory options. + + Once the required options have been changed from their default values, all + config options will be available, namespaced under `config` to prevent + potential naming conflicts (for example, between a config option and a + relation property). + + :param list *args: List of options that must be changed from their default values. + """ + + def __init__(self, *args): + self.required_options = args + self['config'] = hookenv.config() + with open(os.path.join(hookenv.charm_dir(), 'config.yaml')) as fp: + self.config = yaml.load(fp).get('options', {}) + + def __bool__(self): + for option in self.required_options: + if option not in self['config']: + return False + current_value = self['config'][option] + default_value = self.config[option].get('default') + if current_value == default_value: + return False + if current_value in (None, '') and default_value in (None, ''): + return False + return True + + def __nonzero__(self): + return self.__bool__() + + +class StoredContext(dict): + """ + A data context that always returns the data that it was first created with. + + This is useful to do a one-time generation of things like passwords, that + will thereafter use the same value that was originally generated, instead + of generating a new value each time it is run. + """ + def __init__(self, file_name, config_data): + """ + If the file exists, populate `self` with the data from the file. + Otherwise, populate with the given data and persist it to the file. + """ + if os.path.exists(file_name): + self.update(self.read_context(file_name)) + else: + self.store_context(file_name, config_data) + self.update(config_data) + + def store_context(self, file_name, config_data): + if not os.path.isabs(file_name): + file_name = os.path.join(hookenv.charm_dir(), file_name) + with open(file_name, 'w') as file_stream: + os.fchmod(file_stream.fileno(), 0o600) + yaml.dump(config_data, file_stream) + + def read_context(self, file_name): + if not os.path.isabs(file_name): + file_name = os.path.join(hookenv.charm_dir(), file_name) + with open(file_name, 'r') as file_stream: + data = yaml.load(file_stream) + if not data: + raise OSError("%s is empty" % file_name) + return data + + +class TemplateCallback(ManagerCallback): + """ + Callback class that will render a Jinja2 template, for use as a ready + action. + + :param str source: The template source file, relative to + `$CHARM_DIR/templates` + + :param str target: The target to write the rendered template to + :param str owner: The owner of the rendered file + :param str group: The group of the rendered file + :param int perms: The permissions of the rendered file + :param partial on_change_action: functools partial to be executed when + rendered file changes + """ + def __init__(self, source, target, + owner='root', group='root', perms=0o444, + on_change_action=None): + self.source = source + self.target = target + self.owner = owner + self.group = group + self.perms = perms + self.on_change_action = on_change_action + + def __call__(self, manager, service_name, event_name): + pre_checksum = '' + if self.on_change_action and os.path.isfile(self.target): + pre_checksum = host.file_hash(self.target) + service = manager.get_service(service_name) + context = {} + for ctx in service.get('required_data', []): + context.update(ctx) + templating.render(self.source, self.target, context, + self.owner, self.group, self.perms) + if self.on_change_action: + if pre_checksum == host.file_hash(self.target): + hookenv.log( + 'No change detected: {}'.format(self.target), + hookenv.DEBUG) + else: + self.on_change_action() + + +# Convenience aliases for templates +render_template = template = TemplateCallback diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/strutils.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/strutils.py new file mode 100644 index 0000000..7e3f969 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/strutils.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import six +import re + + +def bool_from_string(value): + """Interpret string value as boolean. + + Returns True if value translates to True otherwise False. + """ + if isinstance(value, six.string_types): + value = six.text_type(value) + else: + msg = "Unable to interpret non-string value '%s' as boolean" % (value) + raise ValueError(msg) + + value = value.strip().lower() + + if value in ['y', 'yes', 'true', 't', 'on']: + return True + elif value in ['n', 'no', 'false', 'f', 'off']: + return False + + msg = "Unable to interpret string value '%s' as boolean" % (value) + raise ValueError(msg) + + +def bytes_from_string(value): + """Interpret human readable string value as bytes. + + Returns int + """ + BYTE_POWER = { + 'K': 1, + 'KB': 1, + 'M': 2, + 'MB': 2, + 'G': 3, + 'GB': 3, + 'T': 4, + 'TB': 4, + 'P': 5, + 'PB': 5, + } + if isinstance(value, six.string_types): + value = six.text_type(value) + else: + msg = "Unable to interpret non-string value '%s' as boolean" % (value) + raise ValueError(msg) + matches = re.match("([0-9]+)([a-zA-Z]+)", value) + if not matches: + msg = "Unable to interpret string value '%s' as bytes" % (value) + raise ValueError(msg) + return int(matches.group(1)) * (1024 ** BYTE_POWER[matches.group(2)]) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/sysctl.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/sysctl.py new file mode 100644 index 0000000..21cc8ab --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/sysctl.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import yaml + +from subprocess import check_call + +from charmhelpers.core.hookenv import ( + log, + DEBUG, + ERROR, +) + +__author__ = 'Jorge Niedbalski R. ' + + +def create(sysctl_dict, sysctl_file): + """Creates a sysctl.conf file from a YAML associative array + + :param sysctl_dict: a YAML-formatted string of sysctl options eg "{ 'kernel.max_pid': 1337 }" + :type sysctl_dict: str + :param sysctl_file: path to the sysctl file to be saved + :type sysctl_file: str or unicode + :returns: None + """ + try: + sysctl_dict_parsed = yaml.safe_load(sysctl_dict) + except yaml.YAMLError: + log("Error parsing YAML sysctl_dict: {}".format(sysctl_dict), + level=ERROR) + return + + with open(sysctl_file, "w") as fd: + for key, value in sysctl_dict_parsed.items(): + fd.write("{}={}\n".format(key, value)) + + log("Updating sysctl_file: %s values: %s" % (sysctl_file, sysctl_dict_parsed), + level=DEBUG) + + check_call(["sysctl", "-p", sysctl_file]) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/templating.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/templating.py new file mode 100644 index 0000000..4531999 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/templating.py @@ -0,0 +1,68 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import os + +from charmhelpers.core import host +from charmhelpers.core import hookenv + + +def render(source, target, context, owner='root', group='root', + perms=0o444, templates_dir=None, encoding='UTF-8'): + """ + Render a template. + + The `source` path, if not absolute, is relative to the `templates_dir`. + + The `target` path should be absolute. + + The context should be a dict containing the values to be replaced in the + template. + + The `owner`, `group`, and `perms` options will be passed to `write_file`. + + If omitted, `templates_dir` defaults to the `templates` folder in the charm. + + Note: Using this requires python-jinja2; if it is not installed, calling + this will attempt to use charmhelpers.fetch.apt_install to install it. + """ + try: + from jinja2 import FileSystemLoader, Environment, exceptions + except ImportError: + try: + from charmhelpers.fetch import apt_install + except ImportError: + hookenv.log('Could not import jinja2, and could not import ' + 'charmhelpers.fetch to install it', + level=hookenv.ERROR) + raise + apt_install('python-jinja2', fatal=True) + from jinja2 import FileSystemLoader, Environment, exceptions + + if templates_dir is None: + templates_dir = os.path.join(hookenv.charm_dir(), 'templates') + loader = Environment(loader=FileSystemLoader(templates_dir)) + try: + source = source + template = loader.get_template(source) + except exceptions.TemplateNotFound as e: + hookenv.log('Could not load template %s from %s.' % + (source, templates_dir), + level=hookenv.ERROR) + raise e + content = template.render(context) + host.mkdir(os.path.dirname(target), owner, group, perms=0o755) + host.write_file(target, content.encode(encoding), owner, group, perms) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/core/unitdata.py b/charms/trusty/contrail-webui/hooks/charmhelpers/core/unitdata.py new file mode 100644 index 0000000..338104e --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/core/unitdata.py @@ -0,0 +1,521 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . +# +# +# Authors: +# Kapil Thangavelu +# +""" +Intro +----- + +A simple way to store state in units. This provides a key value +storage with support for versioned, transactional operation, +and can calculate deltas from previous values to simplify unit logic +when processing changes. + + +Hook Integration +---------------- + +There are several extant frameworks for hook execution, including + + - charmhelpers.core.hookenv.Hooks + - charmhelpers.core.services.ServiceManager + +The storage classes are framework agnostic, one simple integration is +via the HookData contextmanager. It will record the current hook +execution environment (including relation data, config data, etc.), +setup a transaction and allow easy access to the changes from +previously seen values. One consequence of the integration is the +reservation of particular keys ('rels', 'unit', 'env', 'config', +'charm_revisions') for their respective values. + +Here's a fully worked integration example using hookenv.Hooks:: + + from charmhelper.core import hookenv, unitdata + + hook_data = unitdata.HookData() + db = unitdata.kv() + hooks = hookenv.Hooks() + + @hooks.hook + def config_changed(): + # Print all changes to configuration from previously seen + # values. + for changed, (prev, cur) in hook_data.conf.items(): + print('config changed', changed, + 'previous value', prev, + 'current value', cur) + + # Get some unit specific bookeeping + if not db.get('pkg_key'): + key = urllib.urlopen('https://example.com/pkg_key').read() + db.set('pkg_key', key) + + # Directly access all charm config as a mapping. + conf = db.getrange('config', True) + + # Directly access all relation data as a mapping + rels = db.getrange('rels', True) + + if __name__ == '__main__': + with hook_data(): + hook.execute() + + +A more basic integration is via the hook_scope context manager which simply +manages transaction scope (and records hook name, and timestamp):: + + >>> from unitdata import kv + >>> db = kv() + >>> with db.hook_scope('install'): + ... # do work, in transactional scope. + ... db.set('x', 1) + >>> db.get('x') + 1 + + +Usage +----- + +Values are automatically json de/serialized to preserve basic typing +and complex data struct capabilities (dicts, lists, ints, booleans, etc). + +Individual values can be manipulated via get/set:: + + >>> kv.set('y', True) + >>> kv.get('y') + True + + # We can set complex values (dicts, lists) as a single key. + >>> kv.set('config', {'a': 1, 'b': True'}) + + # Also supports returning dictionaries as a record which + # provides attribute access. + >>> config = kv.get('config', record=True) + >>> config.b + True + + +Groups of keys can be manipulated with update/getrange:: + + >>> kv.update({'z': 1, 'y': 2}, prefix="gui.") + >>> kv.getrange('gui.', strip=True) + {'z': 1, 'y': 2} + +When updating values, its very helpful to understand which values +have actually changed and how have they changed. The storage +provides a delta method to provide for this:: + + >>> data = {'debug': True, 'option': 2} + >>> delta = kv.delta(data, 'config.') + >>> delta.debug.previous + None + >>> delta.debug.current + True + >>> delta + {'debug': (None, True), 'option': (None, 2)} + +Note the delta method does not persist the actual change, it needs to +be explicitly saved via 'update' method:: + + >>> kv.update(data, 'config.') + +Values modified in the context of a hook scope retain historical values +associated to the hookname. + + >>> with db.hook_scope('config-changed'): + ... db.set('x', 42) + >>> db.gethistory('x') + [(1, u'x', 1, u'install', u'2015-01-21T16:49:30.038372'), + (2, u'x', 42, u'config-changed', u'2015-01-21T16:49:30.038786')] + +""" + +import collections +import contextlib +import datetime +import itertools +import json +import os +import pprint +import sqlite3 +import sys + +__author__ = 'Kapil Thangavelu ' + + +class Storage(object): + """Simple key value database for local unit state within charms. + + Modifications are not persisted unless :meth:`flush` is called. + + To support dicts, lists, integer, floats, and booleans values + are automatically json encoded/decoded. + """ + def __init__(self, path=None): + self.db_path = path + if path is None: + if 'UNIT_STATE_DB' in os.environ: + self.db_path = os.environ['UNIT_STATE_DB'] + else: + self.db_path = os.path.join( + os.environ.get('CHARM_DIR', ''), '.unit-state.db') + self.conn = sqlite3.connect('%s' % self.db_path) + self.cursor = self.conn.cursor() + self.revision = None + self._closed = False + self._init() + + def close(self): + if self._closed: + return + self.flush(False) + self.cursor.close() + self.conn.close() + self._closed = True + + def get(self, key, default=None, record=False): + self.cursor.execute('select data from kv where key=?', [key]) + result = self.cursor.fetchone() + if not result: + return default + if record: + return Record(json.loads(result[0])) + return json.loads(result[0]) + + def getrange(self, key_prefix, strip=False): + """ + Get a range of keys starting with a common prefix as a mapping of + keys to values. + + :param str key_prefix: Common prefix among all keys + :param bool strip: Optionally strip the common prefix from the key + names in the returned dict + :return dict: A (possibly empty) dict of key-value mappings + """ + self.cursor.execute("select key, data from kv where key like ?", + ['%s%%' % key_prefix]) + result = self.cursor.fetchall() + + if not result: + return {} + if not strip: + key_prefix = '' + return dict([ + (k[len(key_prefix):], json.loads(v)) for k, v in result]) + + def update(self, mapping, prefix=""): + """ + Set the values of multiple keys at once. + + :param dict mapping: Mapping of keys to values + :param str prefix: Optional prefix to apply to all keys in `mapping` + before setting + """ + for k, v in mapping.items(): + self.set("%s%s" % (prefix, k), v) + + def unset(self, key): + """ + Remove a key from the database entirely. + """ + self.cursor.execute('delete from kv where key=?', [key]) + if self.revision and self.cursor.rowcount: + self.cursor.execute( + 'insert into kv_revisions values (?, ?, ?)', + [key, self.revision, json.dumps('DELETED')]) + + def unsetrange(self, keys=None, prefix=""): + """ + Remove a range of keys starting with a common prefix, from the database + entirely. + + :param list keys: List of keys to remove. + :param str prefix: Optional prefix to apply to all keys in ``keys`` + before removing. + """ + if keys is not None: + keys = ['%s%s' % (prefix, key) for key in keys] + self.cursor.execute('delete from kv where key in (%s)' % ','.join(['?'] * len(keys)), keys) + if self.revision and self.cursor.rowcount: + self.cursor.execute( + 'insert into kv_revisions values %s' % ','.join(['(?, ?, ?)'] * len(keys)), + list(itertools.chain.from_iterable((key, self.revision, json.dumps('DELETED')) for key in keys))) + else: + self.cursor.execute('delete from kv where key like ?', + ['%s%%' % prefix]) + if self.revision and self.cursor.rowcount: + self.cursor.execute( + 'insert into kv_revisions values (?, ?, ?)', + ['%s%%' % prefix, self.revision, json.dumps('DELETED')]) + + def set(self, key, value): + """ + Set a value in the database. + + :param str key: Key to set the value for + :param value: Any JSON-serializable value to be set + """ + serialized = json.dumps(value) + + self.cursor.execute('select data from kv where key=?', [key]) + exists = self.cursor.fetchone() + + # Skip mutations to the same value + if exists: + if exists[0] == serialized: + return value + + if not exists: + self.cursor.execute( + 'insert into kv (key, data) values (?, ?)', + (key, serialized)) + else: + self.cursor.execute(''' + update kv + set data = ? + where key = ?''', [serialized, key]) + + # Save + if not self.revision: + return value + + self.cursor.execute( + 'select 1 from kv_revisions where key=? and revision=?', + [key, self.revision]) + exists = self.cursor.fetchone() + + if not exists: + self.cursor.execute( + '''insert into kv_revisions ( + revision, key, data) values (?, ?, ?)''', + (self.revision, key, serialized)) + else: + self.cursor.execute( + ''' + update kv_revisions + set data = ? + where key = ? + and revision = ?''', + [serialized, key, self.revision]) + + return value + + def delta(self, mapping, prefix): + """ + return a delta containing values that have changed. + """ + previous = self.getrange(prefix, strip=True) + if not previous: + pk = set() + else: + pk = set(previous.keys()) + ck = set(mapping.keys()) + delta = DeltaSet() + + # added + for k in ck.difference(pk): + delta[k] = Delta(None, mapping[k]) + + # removed + for k in pk.difference(ck): + delta[k] = Delta(previous[k], None) + + # changed + for k in pk.intersection(ck): + c = mapping[k] + p = previous[k] + if c != p: + delta[k] = Delta(p, c) + + return delta + + @contextlib.contextmanager + def hook_scope(self, name=""): + """Scope all future interactions to the current hook execution + revision.""" + assert not self.revision + self.cursor.execute( + 'insert into hooks (hook, date) values (?, ?)', + (name or sys.argv[0], + datetime.datetime.utcnow().isoformat())) + self.revision = self.cursor.lastrowid + try: + yield self.revision + self.revision = None + except: + self.flush(False) + self.revision = None + raise + else: + self.flush() + + def flush(self, save=True): + if save: + self.conn.commit() + elif self._closed: + return + else: + self.conn.rollback() + + def _init(self): + self.cursor.execute(''' + create table if not exists kv ( + key text, + data text, + primary key (key) + )''') + self.cursor.execute(''' + create table if not exists kv_revisions ( + key text, + revision integer, + data text, + primary key (key, revision) + )''') + self.cursor.execute(''' + create table if not exists hooks ( + version integer primary key autoincrement, + hook text, + date text + )''') + self.conn.commit() + + def gethistory(self, key, deserialize=False): + self.cursor.execute( + ''' + select kv.revision, kv.key, kv.data, h.hook, h.date + from kv_revisions kv, + hooks h + where kv.key=? + and kv.revision = h.version + ''', [key]) + if deserialize is False: + return self.cursor.fetchall() + return map(_parse_history, self.cursor.fetchall()) + + def debug(self, fh=sys.stderr): + self.cursor.execute('select * from kv') + pprint.pprint(self.cursor.fetchall(), stream=fh) + self.cursor.execute('select * from kv_revisions') + pprint.pprint(self.cursor.fetchall(), stream=fh) + + +def _parse_history(d): + return (d[0], d[1], json.loads(d[2]), d[3], + datetime.datetime.strptime(d[-1], "%Y-%m-%dT%H:%M:%S.%f")) + + +class HookData(object): + """Simple integration for existing hook exec frameworks. + + Records all unit information, and stores deltas for processing + by the hook. + + Sample:: + + from charmhelper.core import hookenv, unitdata + + changes = unitdata.HookData() + db = unitdata.kv() + hooks = hookenv.Hooks() + + @hooks.hook + def config_changed(): + # View all changes to configuration + for changed, (prev, cur) in changes.conf.items(): + print('config changed', changed, + 'previous value', prev, + 'current value', cur) + + # Get some unit specific bookeeping + if not db.get('pkg_key'): + key = urllib.urlopen('https://example.com/pkg_key').read() + db.set('pkg_key', key) + + if __name__ == '__main__': + with changes(): + hook.execute() + + """ + def __init__(self): + self.kv = kv() + self.conf = None + self.rels = None + + @contextlib.contextmanager + def __call__(self): + from charmhelpers.core import hookenv + hook_name = hookenv.hook_name() + + with self.kv.hook_scope(hook_name): + self._record_charm_version(hookenv.charm_dir()) + delta_config, delta_relation = self._record_hook(hookenv) + yield self.kv, delta_config, delta_relation + + def _record_charm_version(self, charm_dir): + # Record revisions.. charm revisions are meaningless + # to charm authors as they don't control the revision. + # so logic dependnent on revision is not particularly + # useful, however it is useful for debugging analysis. + charm_rev = open( + os.path.join(charm_dir, 'revision')).read().strip() + charm_rev = charm_rev or '0' + revs = self.kv.get('charm_revisions', []) + if charm_rev not in revs: + revs.append(charm_rev.strip() or '0') + self.kv.set('charm_revisions', revs) + + def _record_hook(self, hookenv): + data = hookenv.execution_environment() + self.conf = conf_delta = self.kv.delta(data['conf'], 'config') + self.rels = rels_delta = self.kv.delta(data['rels'], 'rels') + self.kv.set('env', dict(data['env'])) + self.kv.set('unit', data['unit']) + self.kv.set('relid', data.get('relid')) + return conf_delta, rels_delta + + +class Record(dict): + + __slots__ = () + + def __getattr__(self, k): + if k in self: + return self[k] + raise AttributeError(k) + + +class DeltaSet(Record): + + __slots__ = () + + +Delta = collections.namedtuple('Delta', ['previous', 'current']) + + +_KV = None + + +def kv(): + global _KV + if _KV is None: + _KV = Storage() + return _KV diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/__init__.py b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/__init__.py new file mode 100644 index 0000000..1cfb99f --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/__init__.py @@ -0,0 +1,468 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import importlib +from tempfile import NamedTemporaryFile +import time +from yaml import safe_load +from charmhelpers.core.host import ( + lsb_release +) +import subprocess +from charmhelpers.core.hookenv import ( + config, + log, +) +import os + +import six +if six.PY3: + from urllib.parse import urlparse, urlunparse +else: + from urlparse import urlparse, urlunparse + + +CLOUD_ARCHIVE = """# Ubuntu Cloud Archive +deb http://ubuntu-cloud.archive.canonical.com/ubuntu {} main +""" +PROPOSED_POCKET = """# Proposed +deb http://archive.ubuntu.com/ubuntu {}-proposed main universe multiverse restricted +""" +CLOUD_ARCHIVE_POCKETS = { + # Folsom + 'folsom': 'precise-updates/folsom', + 'precise-folsom': 'precise-updates/folsom', + 'precise-folsom/updates': 'precise-updates/folsom', + 'precise-updates/folsom': 'precise-updates/folsom', + 'folsom/proposed': 'precise-proposed/folsom', + 'precise-folsom/proposed': 'precise-proposed/folsom', + 'precise-proposed/folsom': 'precise-proposed/folsom', + # Grizzly + 'grizzly': 'precise-updates/grizzly', + 'precise-grizzly': 'precise-updates/grizzly', + 'precise-grizzly/updates': 'precise-updates/grizzly', + 'precise-updates/grizzly': 'precise-updates/grizzly', + 'grizzly/proposed': 'precise-proposed/grizzly', + 'precise-grizzly/proposed': 'precise-proposed/grizzly', + 'precise-proposed/grizzly': 'precise-proposed/grizzly', + # Havana + 'havana': 'precise-updates/havana', + 'precise-havana': 'precise-updates/havana', + 'precise-havana/updates': 'precise-updates/havana', + 'precise-updates/havana': 'precise-updates/havana', + 'havana/proposed': 'precise-proposed/havana', + 'precise-havana/proposed': 'precise-proposed/havana', + 'precise-proposed/havana': 'precise-proposed/havana', + # Icehouse + 'icehouse': 'precise-updates/icehouse', + 'precise-icehouse': 'precise-updates/icehouse', + 'precise-icehouse/updates': 'precise-updates/icehouse', + 'precise-updates/icehouse': 'precise-updates/icehouse', + 'icehouse/proposed': 'precise-proposed/icehouse', + 'precise-icehouse/proposed': 'precise-proposed/icehouse', + 'precise-proposed/icehouse': 'precise-proposed/icehouse', + # Juno + 'juno': 'trusty-updates/juno', + 'trusty-juno': 'trusty-updates/juno', + 'trusty-juno/updates': 'trusty-updates/juno', + 'trusty-updates/juno': 'trusty-updates/juno', + 'juno/proposed': 'trusty-proposed/juno', + 'trusty-juno/proposed': 'trusty-proposed/juno', + 'trusty-proposed/juno': 'trusty-proposed/juno', + # Kilo + 'kilo': 'trusty-updates/kilo', + 'trusty-kilo': 'trusty-updates/kilo', + 'trusty-kilo/updates': 'trusty-updates/kilo', + 'trusty-updates/kilo': 'trusty-updates/kilo', + 'kilo/proposed': 'trusty-proposed/kilo', + 'trusty-kilo/proposed': 'trusty-proposed/kilo', + 'trusty-proposed/kilo': 'trusty-proposed/kilo', + # Liberty + 'liberty': 'trusty-updates/liberty', + 'trusty-liberty': 'trusty-updates/liberty', + 'trusty-liberty/updates': 'trusty-updates/liberty', + 'trusty-updates/liberty': 'trusty-updates/liberty', + 'liberty/proposed': 'trusty-proposed/liberty', + 'trusty-liberty/proposed': 'trusty-proposed/liberty', + 'trusty-proposed/liberty': 'trusty-proposed/liberty', + # Mitaka + 'mitaka': 'trusty-updates/mitaka', + 'trusty-mitaka': 'trusty-updates/mitaka', + 'trusty-mitaka/updates': 'trusty-updates/mitaka', + 'trusty-updates/mitaka': 'trusty-updates/mitaka', + 'mitaka/proposed': 'trusty-proposed/mitaka', + 'trusty-mitaka/proposed': 'trusty-proposed/mitaka', + 'trusty-proposed/mitaka': 'trusty-proposed/mitaka', +} + +# The order of this list is very important. Handlers should be listed in from +# least- to most-specific URL matching. +FETCH_HANDLERS = ( + 'charmhelpers.fetch.archiveurl.ArchiveUrlFetchHandler', + 'charmhelpers.fetch.bzrurl.BzrUrlFetchHandler', + 'charmhelpers.fetch.giturl.GitUrlFetchHandler', +) + +APT_NO_LOCK = 100 # The return code for "couldn't acquire lock" in APT. +APT_NO_LOCK_RETRY_DELAY = 10 # Wait 10 seconds between apt lock checks. +APT_NO_LOCK_RETRY_COUNT = 30 # Retry to acquire the lock X times. + + +class SourceConfigError(Exception): + pass + + +class UnhandledSource(Exception): + pass + + +class AptLockError(Exception): + pass + + +class BaseFetchHandler(object): + + """Base class for FetchHandler implementations in fetch plugins""" + + def can_handle(self, source): + """Returns True if the source can be handled. Otherwise returns + a string explaining why it cannot""" + return "Wrong source type" + + def install(self, source): + """Try to download and unpack the source. Return the path to the + unpacked files or raise UnhandledSource.""" + raise UnhandledSource("Wrong source type {}".format(source)) + + def parse_url(self, url): + return urlparse(url) + + def base_url(self, url): + """Return url without querystring or fragment""" + parts = list(self.parse_url(url)) + parts[4:] = ['' for i in parts[4:]] + return urlunparse(parts) + + +def filter_installed_packages(packages): + """Returns a list of packages that require installation""" + cache = apt_cache() + _pkgs = [] + for package in packages: + try: + p = cache[package] + p.current_ver or _pkgs.append(package) + except KeyError: + log('Package {} has no installation candidate.'.format(package), + level='WARNING') + _pkgs.append(package) + return _pkgs + + +def apt_cache(in_memory=True): + """Build and return an apt cache""" + from apt import apt_pkg + apt_pkg.init() + if in_memory: + apt_pkg.config.set("Dir::Cache::pkgcache", "") + apt_pkg.config.set("Dir::Cache::srcpkgcache", "") + return apt_pkg.Cache() + + +def apt_install(packages, options=None, fatal=False): + """Install one or more packages""" + if options is None: + options = ['--option=Dpkg::Options::=--force-confold'] + + cmd = ['apt-get', '--assume-yes'] + cmd.extend(options) + cmd.append('install') + if isinstance(packages, six.string_types): + cmd.append(packages) + else: + cmd.extend(packages) + log("Installing {} with options: {}".format(packages, + options)) + _run_apt_command(cmd, fatal) + + +def apt_upgrade(options=None, fatal=False, dist=False): + """Upgrade all packages""" + if options is None: + options = ['--option=Dpkg::Options::=--force-confold'] + + cmd = ['apt-get', '--assume-yes'] + cmd.extend(options) + if dist: + cmd.append('dist-upgrade') + else: + cmd.append('upgrade') + log("Upgrading with options: {}".format(options)) + _run_apt_command(cmd, fatal) + + +def apt_update(fatal=False): + """Update local apt cache""" + cmd = ['apt-get', 'update'] + _run_apt_command(cmd, fatal) + + +def apt_purge(packages, fatal=False): + """Purge one or more packages""" + cmd = ['apt-get', '--assume-yes', 'purge'] + if isinstance(packages, six.string_types): + cmd.append(packages) + else: + cmd.extend(packages) + log("Purging {}".format(packages)) + _run_apt_command(cmd, fatal) + + +def apt_mark(packages, mark, fatal=False): + """Flag one or more packages using apt-mark""" + cmd = ['apt-mark', mark] + if isinstance(packages, six.string_types): + cmd.append(packages) + else: + cmd.extend(packages) + log("Holding {}".format(packages)) + + if fatal: + subprocess.check_call(cmd, universal_newlines=True) + else: + subprocess.call(cmd, universal_newlines=True) + + +def apt_hold(packages, fatal=False): + return apt_mark(packages, 'hold', fatal=fatal) + + +def apt_unhold(packages, fatal=False): + return apt_mark(packages, 'unhold', fatal=fatal) + + +def add_source(source, key=None): + """Add a package source to this system. + + @param source: a URL or sources.list entry, as supported by + add-apt-repository(1). Examples:: + + ppa:charmers/example + deb https://stub:key@private.example.com/ubuntu trusty main + + In addition: + 'proposed:' may be used to enable the standard 'proposed' + pocket for the release. + 'cloud:' may be used to activate official cloud archive pockets, + such as 'cloud:icehouse' + 'distro' may be used as a noop + + @param key: A key to be added to the system's APT keyring and used + to verify the signatures on packages. Ideally, this should be an + ASCII format GPG public key including the block headers. A GPG key + id may also be used, but be aware that only insecure protocols are + available to retrieve the actual public key from a public keyserver + placing your Juju environment at risk. ppa and cloud archive keys + are securely added automtically, so sould not be provided. + """ + if source is None: + log('Source is not present. Skipping') + return + + if (source.startswith('ppa:') or + source.startswith('http') or + source.startswith('deb ') or + source.startswith('cloud-archive:')): + subprocess.check_call(['add-apt-repository', '--yes', source]) + elif source.startswith('cloud:'): + apt_install(filter_installed_packages(['ubuntu-cloud-keyring']), + fatal=True) + pocket = source.split(':')[-1] + if pocket not in CLOUD_ARCHIVE_POCKETS: + raise SourceConfigError( + 'Unsupported cloud: source option %s' % + pocket) + actual_pocket = CLOUD_ARCHIVE_POCKETS[pocket] + with open('/etc/apt/sources.list.d/cloud-archive.list', 'w') as apt: + apt.write(CLOUD_ARCHIVE.format(actual_pocket)) + elif source == 'proposed': + release = lsb_release()['DISTRIB_CODENAME'] + with open('/etc/apt/sources.list.d/proposed.list', 'w') as apt: + apt.write(PROPOSED_POCKET.format(release)) + elif source == 'distro': + pass + else: + log("Unknown source: {!r}".format(source)) + + if key: + if '-----BEGIN PGP PUBLIC KEY BLOCK-----' in key: + with NamedTemporaryFile('w+') as key_file: + key_file.write(key) + key_file.flush() + key_file.seek(0) + subprocess.check_call(['apt-key', 'add', '-'], stdin=key_file) + elif 'http://' in key: + with NamedTemporaryFile('w+') as key_file: + subprocess.check_call(['wget', key, '-O-'], stdout=key_file) + subprocess.check_call(['apt-key', 'add', key_file.name]) + else: + # Note that hkp: is in no way a secure protocol. Using a + # GPG key id is pointless from a security POV unless you + # absolutely trust your network and DNS. + subprocess.check_call(['apt-key', 'adv', '--keyserver', + 'hkp://keyserver.ubuntu.com:80', '--recv', + key]) + + +def configure_sources(update=False, + sources_var='install_sources', + keys_var='install_keys'): + """ + Configure multiple sources from charm configuration. + + The lists are encoded as yaml fragments in the configuration. + The frament needs to be included as a string. Sources and their + corresponding keys are of the types supported by add_source(). + + Example config: + install_sources: | + - "ppa:foo" + - "http://example.com/repo precise main" + install_keys: | + - null + - "a1b2c3d4" + + Note that 'null' (a.k.a. None) should not be quoted. + """ + sources = safe_load((config(sources_var) or '').strip()) or [] + keys = safe_load((config(keys_var) or '').strip()) or None + + if isinstance(sources, six.string_types): + sources = [sources] + + if keys is None: + for source in sources: + add_source(source, None) + else: + if isinstance(keys, six.string_types): + keys = [keys] + + if len(sources) != len(keys): + raise SourceConfigError( + 'Install sources and keys lists are different lengths') + for source, key in zip(sources, keys): + add_source(source, key) + if update: + apt_update(fatal=True) + + +def install_remote(source, *args, **kwargs): + """ + Install a file tree from a remote source + + The specified source should be a url of the form: + scheme://[host]/path[#[option=value][&...]] + + Schemes supported are based on this modules submodules. + Options supported are submodule-specific. + Additional arguments are passed through to the submodule. + + For example:: + + dest = install_remote('http://example.com/archive.tgz', + checksum='deadbeef', + hash_type='sha1') + + This will download `archive.tgz`, validate it using SHA1 and, if + the file is ok, extract it and return the directory in which it + was extracted. If the checksum fails, it will raise + :class:`charmhelpers.core.host.ChecksumError`. + """ + # We ONLY check for True here because can_handle may return a string + # explaining why it can't handle a given source. + handlers = [h for h in plugins() if h.can_handle(source) is True] + installed_to = None + for handler in handlers: + try: + installed_to = handler.install(source, *args, **kwargs) + except UnhandledSource as e: + log('Install source attempt unsuccessful: {}'.format(e), + level='WARNING') + if not installed_to: + raise UnhandledSource("No handler found for source {}".format(source)) + return installed_to + + +def install_from_config(config_var_name): + charm_config = config() + source = charm_config[config_var_name] + return install_remote(source) + + +def plugins(fetch_handlers=None): + if not fetch_handlers: + fetch_handlers = FETCH_HANDLERS + plugin_list = [] + for handler_name in fetch_handlers: + package, classname = handler_name.rsplit('.', 1) + try: + handler_class = getattr( + importlib.import_module(package), + classname) + plugin_list.append(handler_class()) + except (ImportError, AttributeError): + # Skip missing plugins so that they can be ommitted from + # installation if desired + log("FetchHandler {} not found, skipping plugin".format( + handler_name)) + return plugin_list + + +def _run_apt_command(cmd, fatal=False): + """ + Run an APT command, checking output and retrying if the fatal flag is set + to True. + + :param: cmd: str: The apt command to run. + :param: fatal: bool: Whether the command's output should be checked and + retried. + """ + env = os.environ.copy() + + if 'DEBIAN_FRONTEND' not in env: + env['DEBIAN_FRONTEND'] = 'noninteractive' + + if fatal: + retry_count = 0 + result = None + + # If the command is considered "fatal", we need to retry if the apt + # lock was not acquired. + + while result is None or result == APT_NO_LOCK: + try: + result = subprocess.check_call(cmd, env=env) + except subprocess.CalledProcessError as e: + retry_count = retry_count + 1 + if retry_count > APT_NO_LOCK_RETRY_COUNT: + raise + result = e.returncode + log("Couldn't acquire DPKG lock. Will retry in {} seconds." + "".format(APT_NO_LOCK_RETRY_DELAY)) + time.sleep(APT_NO_LOCK_RETRY_DELAY) + + else: + subprocess.call(cmd, env=env) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/archiveurl.py b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/archiveurl.py new file mode 100644 index 0000000..efd7f9f --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/archiveurl.py @@ -0,0 +1,167 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import os +import hashlib +import re + +from charmhelpers.fetch import ( + BaseFetchHandler, + UnhandledSource +) +from charmhelpers.payload.archive import ( + get_archive_handler, + extract, +) +from charmhelpers.core.host import mkdir, check_hash + +import six +if six.PY3: + from urllib.request import ( + build_opener, install_opener, urlopen, urlretrieve, + HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, + ) + from urllib.parse import urlparse, urlunparse, parse_qs + from urllib.error import URLError +else: + from urllib import urlretrieve + from urllib2 import ( + build_opener, install_opener, urlopen, + HTTPPasswordMgrWithDefaultRealm, HTTPBasicAuthHandler, + URLError + ) + from urlparse import urlparse, urlunparse, parse_qs + + +def splituser(host): + '''urllib.splituser(), but six's support of this seems broken''' + _userprog = re.compile('^(.*)@(.*)$') + match = _userprog.match(host) + if match: + return match.group(1, 2) + return None, host + + +def splitpasswd(user): + '''urllib.splitpasswd(), but six's support of this is missing''' + _passwdprog = re.compile('^([^:]*):(.*)$', re.S) + match = _passwdprog.match(user) + if match: + return match.group(1, 2) + return user, None + + +class ArchiveUrlFetchHandler(BaseFetchHandler): + """ + Handler to download archive files from arbitrary URLs. + + Can fetch from http, https, ftp, and file URLs. + + Can install either tarballs (.tar, .tgz, .tbz2, etc) or zip files. + + Installs the contents of the archive in $CHARM_DIR/fetched/. + """ + def can_handle(self, source): + url_parts = self.parse_url(source) + if url_parts.scheme not in ('http', 'https', 'ftp', 'file'): + # XXX: Why is this returning a boolean and a string? It's + # doomed to fail since "bool(can_handle('foo://'))" will be True. + return "Wrong source type" + if get_archive_handler(self.base_url(source)): + return True + return False + + def download(self, source, dest): + """ + Download an archive file. + + :param str source: URL pointing to an archive file. + :param str dest: Local path location to download archive file to. + """ + # propogate all exceptions + # URLError, OSError, etc + proto, netloc, path, params, query, fragment = urlparse(source) + if proto in ('http', 'https'): + auth, barehost = splituser(netloc) + if auth is not None: + source = urlunparse((proto, barehost, path, params, query, fragment)) + username, password = splitpasswd(auth) + passman = HTTPPasswordMgrWithDefaultRealm() + # Realm is set to None in add_password to force the username and password + # to be used whatever the realm + passman.add_password(None, source, username, password) + authhandler = HTTPBasicAuthHandler(passman) + opener = build_opener(authhandler) + install_opener(opener) + response = urlopen(source) + try: + with open(dest, 'w') as dest_file: + dest_file.write(response.read()) + except Exception as e: + if os.path.isfile(dest): + os.unlink(dest) + raise e + + # Mandatory file validation via Sha1 or MD5 hashing. + def download_and_validate(self, url, hashsum, validate="sha1"): + tempfile, headers = urlretrieve(url) + check_hash(tempfile, hashsum, validate) + return tempfile + + def install(self, source, dest=None, checksum=None, hash_type='sha1'): + """ + Download and install an archive file, with optional checksum validation. + + The checksum can also be given on the `source` URL's fragment. + For example:: + + handler.install('http://example.com/file.tgz#sha1=deadbeef') + + :param str source: URL pointing to an archive file. + :param str dest: Local destination path to install to. If not given, + installs to `$CHARM_DIR/archives/archive_file_name`. + :param str checksum: If given, validate the archive file after download. + :param str hash_type: Algorithm used to generate `checksum`. + Can be any hash alrgorithm supported by :mod:`hashlib`, + such as md5, sha1, sha256, sha512, etc. + + """ + url_parts = self.parse_url(source) + dest_dir = os.path.join(os.environ.get('CHARM_DIR'), 'fetched') + if not os.path.exists(dest_dir): + mkdir(dest_dir, perms=0o755) + dld_file = os.path.join(dest_dir, os.path.basename(url_parts.path)) + try: + self.download(source, dld_file) + except URLError as e: + raise UnhandledSource(e.reason) + except OSError as e: + raise UnhandledSource(e.strerror) + options = parse_qs(url_parts.fragment) + for key, value in options.items(): + if not six.PY3: + algorithms = hashlib.algorithms + else: + algorithms = hashlib.algorithms_available + if key in algorithms: + if len(value) != 1: + raise TypeError( + "Expected 1 hash value, not %d" % len(value)) + expected = value[0] + check_hash(dld_file, expected, key) + if checksum: + check_hash(dld_file, checksum, hash_type) + return extract(dld_file, dest) diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/bzrurl.py b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/bzrurl.py new file mode 100644 index 0000000..3531315 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/bzrurl.py @@ -0,0 +1,78 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import os +from charmhelpers.fetch import ( + BaseFetchHandler, + UnhandledSource +) +from charmhelpers.core.host import mkdir + +import six +if six.PY3: + raise ImportError('bzrlib does not support Python3') + +try: + from bzrlib.branch import Branch + from bzrlib import bzrdir, workingtree, errors +except ImportError: + from charmhelpers.fetch import apt_install + apt_install("python-bzrlib") + from bzrlib.branch import Branch + from bzrlib import bzrdir, workingtree, errors + + +class BzrUrlFetchHandler(BaseFetchHandler): + """Handler for bazaar branches via generic and lp URLs""" + def can_handle(self, source): + url_parts = self.parse_url(source) + if url_parts.scheme not in ('bzr+ssh', 'lp'): + return False + else: + return True + + def branch(self, source, dest): + url_parts = self.parse_url(source) + # If we use lp:branchname scheme we need to load plugins + if not self.can_handle(source): + raise UnhandledSource("Cannot handle {}".format(source)) + if url_parts.scheme == "lp": + from bzrlib.plugin import load_plugins + load_plugins() + try: + local_branch = bzrdir.BzrDir.create_branch_convenience(dest) + except errors.AlreadyControlDirError: + local_branch = Branch.open(dest) + try: + remote_branch = Branch.open(source) + remote_branch.push(local_branch) + tree = workingtree.WorkingTree.open(dest) + tree.update() + except Exception as e: + raise e + + def install(self, source): + url_parts = self.parse_url(source) + branch_name = url_parts.path.strip("/").split("/")[-1] + dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched", + branch_name) + if not os.path.exists(dest_dir): + mkdir(dest_dir, perms=0o755) + try: + self.branch(source, dest_dir) + except OSError as e: + raise UnhandledSource(e.strerror) + return dest_dir diff --git a/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/giturl.py b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/giturl.py new file mode 100644 index 0000000..f023b26 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/charmhelpers/fetch/giturl.py @@ -0,0 +1,73 @@ +# Copyright 2014-2015 Canonical Limited. +# +# This file is part of charm-helpers. +# +# charm-helpers is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 as +# published by the Free Software Foundation. +# +# charm-helpers is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with charm-helpers. If not, see . + +import os +from charmhelpers.fetch import ( + BaseFetchHandler, + UnhandledSource +) +from charmhelpers.core.host import mkdir + +import six +if six.PY3: + raise ImportError('GitPython does not support Python 3') + +try: + from git import Repo +except ImportError: + from charmhelpers.fetch import apt_install + apt_install("python-git") + from git import Repo + +from git.exc import GitCommandError # noqa E402 + + +class GitUrlFetchHandler(BaseFetchHandler): + """Handler for git branches via generic and github URLs""" + def can_handle(self, source): + url_parts = self.parse_url(source) + # TODO (mattyw) no support for ssh git@ yet + if url_parts.scheme not in ('http', 'https', 'git'): + return False + else: + return True + + def clone(self, source, dest, branch, depth=None): + if not self.can_handle(source): + raise UnhandledSource("Cannot handle {}".format(source)) + + if depth: + Repo.clone_from(source, dest, branch=branch, depth=depth) + else: + Repo.clone_from(source, dest, branch=branch) + + def install(self, source, branch="master", dest=None, depth=None): + url_parts = self.parse_url(source) + branch_name = url_parts.path.strip("/").split("/")[-1] + if dest: + dest_dir = os.path.join(dest, branch_name) + else: + dest_dir = os.path.join(os.environ.get('CHARM_DIR'), "fetched", + branch_name) + if not os.path.exists(dest_dir): + mkdir(dest_dir, perms=0o755) + try: + self.clone(source, dest_dir, branch, depth) + except GitCommandError as e: + raise UnhandledSource(e) + except OSError as e: + raise UnhandledSource(e.strerror) + return dest_dir diff --git a/charms/trusty/contrail-webui/hooks/config-changed b/charms/trusty/contrail-webui/hooks/config-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/config-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/contrail_api-relation-changed b/charms/trusty/contrail-webui/hooks/contrail_api-relation-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/contrail_api-relation-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/contrail_api-relation-joined b/charms/trusty/contrail-webui/hooks/contrail_api-relation-joined new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/contrail_api-relation-joined @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/contrail_discovery-relation-changed b/charms/trusty/contrail-webui/hooks/contrail_discovery-relation-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/contrail_discovery-relation-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/contrail_discovery-relation-joined b/charms/trusty/contrail-webui/hooks/contrail_discovery-relation-joined new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/contrail_discovery-relation-joined @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/identity_admin-relation-changed b/charms/trusty/contrail-webui/hooks/identity_admin-relation-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/identity_admin-relation-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/identity_admin-relation-joined b/charms/trusty/contrail-webui/hooks/identity_admin-relation-joined new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/identity_admin-relation-joined @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/install b/charms/trusty/contrail-webui/hooks/install new file mode 100755 index 0000000..d981389 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/install @@ -0,0 +1,30 @@ +#!/usr/bin/python + +import shutil + +import setup +setup.pre_install() + +from charmhelpers.core import hookenv +from charmhelpers.fetch import ( + configure_sources, + apt_upgrade, + apt_install, +) + +PACKAGES = [ "contrail-web-controller", "nodejs", + "supervisor", "contrail-utils" ] + +def install(): + hookenv.log('Installing contrail-webui') + + # set apt preferences + shutil.copy('files/40contrail', '/etc/apt/preferences.d') + + configure_sources(True, "install-sources", "install-keys") + apt_upgrade(fatal=True, dist=True) + apt_install(PACKAGES, fatal=True) + setup.fix_services() + +if __name__ == "__main__": + install() diff --git a/charms/trusty/contrail-webui/hooks/leader-settings-changed b/charms/trusty/contrail-webui/hooks/leader-settings-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/leader-settings-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/redis-relation-changed b/charms/trusty/contrail-webui/hooks/redis-relation-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/redis-relation-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/redis-relation-joined b/charms/trusty/contrail-webui/hooks/redis-relation-joined new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/redis-relation-joined @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/services.py b/charms/trusty/contrail-webui/hooks/services.py new file mode 100644 index 0000000..61c58cb --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/services.py @@ -0,0 +1,210 @@ +import os +import socket +import urllib + +import yaml + +import actions +from charmhelpers.core import hookenv +from charmhelpers.core import services +from charmhelpers.core import templating + +from setup import ( + create_ssl_certificate, + is_opencontrail, + write_ssl_certificate +) + + +CONFIG_FILE = os.path.join(os.sep, 'etc', 'contrail', 'config.global.js') + + +class CassandraRelation(services.RelationContext): + name = 'cassandra' + interface = 'cassandra' + required_keys = ['private-address'] + + +class ContrailAPIRelation(services.RelationContext): + name = 'contrail_api' + interface = 'contrail-api' + required_keys = ['private-address', 'port'] + + +class ContrailDiscoveryRelation(services.RelationContext): + name = 'contrail_discovery' + interface = 'contrail-discovery' + required_keys = ['private-address', 'port'] + + +class KeystoneRelation(services.RelationContext): + name = 'identity_admin' + interface = 'keystone-admin' + required_keys = ['service_hostname', 'service_port', 'service_username', + 'service_tenant_name', 'service_password'] + + +class RedisRelation(services.RelationContext): + name = 'redis' + interface = 'redis-master' + required_keys = ['hostname', 'port'] + + +class ContrailWebUIConfig(services.ManagerCallback): + + context_contrail = { + 'webcontroller_path': '/usr/src/contrail/contrail-web-controller', + 'logo_file': '/usr/src/contrail/contrail-web-core/webroot/img/juniper-networks-logo.png', + 'favicon_file': '/usr/src/contrail/contrail-web-core/webroot/img/juniper-networks-favicon.ico' + } + + context_opencontrail = { + 'webcontroller_path': '/var/lib/contrail-webui/contrail-web-controller', + 'logo_file': '/var/lib/contrail/contrail-web-core/webroot/img/opencontrail-logo.png', + 'favicon_file': '/var/lib/contrail/contrail-web-core/webroot/img/opencontrail-favicon.ico' + } + + def __call__(self, manager, service_name, event_name): + config = hookenv.config() + context = { + 'config': config + } + + context.update(self.context_opencontrail if is_opencontrail() + else self.context_contrail) + + context.update(ContrailAPIRelation()) + context.update(ContrailDiscoveryRelation()) + context.update(CassandraRelation()) + context.update(KeystoneRelation()) + + # Redis relation is optional + redis = RedisRelation() + if redis.is_ready(): + context.update(redis) + else: + context.update({ + 'redis': [{ + 'hostname': '127.0.0.1', + 'port': '6379' + }] + }) + + # Download logo and favicon or use the cached one + # if failed, falling back to the defaults + for target in ('logo', 'favicon'): + url = context['config']['{0}-url'.format(target)] + filename = os.path.join(os.sep, 'etc', 'contrail', + os.path.basename(url)) + context['config']['{0}-filename'.format(target)] = '' + if url: + try: + urllib.urlretrieve(url, filename) + except IOError: + pass + + try: + if os.stat(filename).st_size > 0: + context['config']['{0}-filename'.format(target)] = ( + filename + ) + except OSError: + pass + + templating.render( + context=context, + source='config.global.js.j2', + target=CONFIG_FILE, + perms=0o644 + ) + + templating.render( + context=context, + source='contrail-webui-userauth.js', + target='/etc/contrail/contrail-webui-userauth.js', + perms=0o640, + owner='root', + group='contrail' + ) + + +class SSLConfig(services.ManagerCallback): + def __call__(self, manager, service_name, event_name): + if hookenv.is_leader(): + config = hookenv.config() + cert = config.get('ssl-cert') + key = config.get('ssl-key') + if cert and key: + write_ssl_certificate(cert, key) + hookenv.leader_set({'ssl-cert': cert, 'ssl-key': key, + 'ssl-cert-created': ''}) + elif not hookenv.leader_get('ssl-cert-created'): + cert, key = create_ssl_certificate() + hookenv.leader_set({'ssl-cert': cert, 'ssl-key': key, + 'ssl-cert-created': True}) + + +class LeaderCallback(services.ManagerCallback): + def __call__(self, manager, service_name, event_name): + if not hookenv.is_leader(): + cert = hookenv.leader_get('ssl-cert') + key = hookenv.leader_get('ssl-key') + if cert and key: + write_ssl_certificate(cert, key) + + +class ContrailWebRelation(services.ManagerCallback): + def __call__(self, manager, service_name, event_name): + config = hookenv.config() + name = hookenv.local_unit().replace('/', '-') + addr = socket.gethostbyname(hookenv.unit_get('private-address')) + http_port = config['http-port'] + https_port = config['https-port'] + services = [ { 'service_name': 'contrail-webui-http', + 'service_host': '0.0.0.0', + 'service_port': http_port, + 'service_options': [ 'mode http', 'balance leastconn', 'option httpchk GET / HTTP/1.1\\r\\nHost:\\ www', 'stick on src table contrail-webui-https' ], + 'servers': [ [ name, addr, http_port, 'check' ] ] }, + { 'service_name': 'contrail-webui-https', + 'service_host': '0.0.0.0', + 'service_port': https_port, + 'service_options': [ 'mode tcp', 'balance leastconn', 'stick-table type ip size 10k expire 25h', 'stick on src' ], + 'servers': [ [ name, addr, https_port, 'check' ] ] } ] + + for relation in hookenv.relation_ids('website'): + hookenv.relation_set(relation, services=yaml.dump(services)) + + +def manage(): + config = hookenv.config() + cassandra = CassandraRelation() + contrail_api = ContrailAPIRelation() + contrail_discovery = ContrailDiscoveryRelation() + keystone = KeystoneRelation() + + config_callback = ContrailWebUIConfig() + ssl_callback = SSLConfig() + leader_callback = LeaderCallback() + website_callback = ContrailWebRelation() + + manager = services.ServiceManager([ + { + 'service': 'supervisor-webui', + 'ports': (config['http-port'], config['https-port']), + 'required_data': [ + config, + cassandra, + contrail_api, + contrail_discovery, + keystone, + ], + 'data_ready': [ + actions.log_start, + config_callback, + ssl_callback, + leader_callback, + website_callback, + ], + }, + ]) + manager.manage() diff --git a/charms/trusty/contrail-webui/hooks/setup.py b/charms/trusty/contrail-webui/hooks/setup.py new file mode 100644 index 0000000..ae1e7e3 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/setup.py @@ -0,0 +1,133 @@ +import os +import pwd +import shutil +import subprocess + +from charmhelpers.core.hookenv import log + +from charmhelpers.core.host import ( + adduser, + mkdir, + service_available, + service_restart, + service_stop, + user_exists +) + +def pre_install(): + """Do any setup required before the install hook.""" + install_charmhelpers() + + +def install_charmhelpers(): + """Install the charmhelpers library, if not present.""" + try: + import charmhelpers # noqa + except ImportError: + import subprocess + subprocess.check_call(['apt-get', 'install', '-y', 'python-pip']) + subprocess.check_call(['pip', 'install', 'charmhelpers']) + + +def create_ssl_certificate(): + base = web_install_dir() + cert = base + '/contrail-web-core/keys/cs-cert.pem' + key = base + '/contrail-web-core/keys/cs-key.pem' + log('Creating self-signed X.509 certificate...') + subprocess.check_call(['openssl', 'req', '-x509', + '-subj', '/CN=contrail-juju', + '-days', '3650', '-newkey', 'rsa:2048', '-nodes', + '-out', cert, '-keyout', key]) + log('...created self-signed X.509 certificate') + with open(cert, 'r') as f: + c = f.read() + with open(key, 'r') as f: + k = f.read() + return c, k + + +def is_opencontrail(): + return os.path.exists('/var/lib/contrail-webui') + + +def fix_permissions(): + """Fix package permissions.""" + os.chmod('/etc/contrail', 0o755) + os.chown('/etc/contrail', 0, 0) + + os.chmod(web_install_dir() + '/contrail-web-core/keys/cs-key.pem', 0o600) + + +def fix_services(): + fix_permissions() + fix_supervisord() + fix_webui() + fix_webui_middleware() + service_restart('supervisor-webui') + + +def fix_supervisord(): + # setup supervisord + if not user_exists('contrail'): + adduser('contrail', system_user=True) + + shutil.copy('files/supervisor-webui.conf', '/etc/init') + shutil.copy('files/supervisord_webui.conf', '/etc/contrail') + pw = pwd.getpwnam('contrail') + os.chown('/etc/contrail/supervisord_webui.conf', pw.pw_uid, pw.pw_gid) + mkdir('/etc/contrail/supervisord_webui_files', owner='contrail', + group='contrail', perms=0o755) + + mkdir('/var/log/contrail', owner='contrail', group='adm', perms=0o750) + + +def fix_webui(): + # disable webui upstart service + if service_available('contrail-webui-webserver'): + service_stop('contrail-webui-webserver') + with open('/etc/init/contrail-webui-webserver.override', 'w') as conf: + conf.write('manual\n') + + # use supervisord config + conf = 'files/contrail-webui-opencontrail.ini' \ + if is_opencontrail() \ + else 'files/contrail-webui-contrail.ini' + shutil.copy(conf, '/etc/contrail/supervisord_webui_files/contrail-webui.ini') + pw = pwd.getpwnam('contrail') + os.chown('/etc/contrail/supervisord_webui_files/contrail-webui.ini', + pw.pw_uid, pw.pw_gid) + shutil.copy('files/contrail-webui', '/etc/init.d') + os.chmod('/etc/init.d/contrail-webui', 0o755) + + +def fix_webui_middleware(): + # disable webui middleware upstart service + if service_available('contrail-webui-jobserver'): + service_stop('contrail-webui-jobserver') + with open('/etc/init/contrail-webui-jobserver.override', 'w') as conf: + conf.write('manual\n') + + # use supervisord config + conf = 'files/contrail-webui-middleware-opencontrail.ini' \ + if is_opencontrail() \ + else 'files/contrail-webui-middleware-contrail.ini' + shutil.copy(conf, '/etc/contrail/supervisord_webui_files/contrail-webui-middleware.ini') + pw = pwd.getpwnam('contrail') + os.chown('/etc/contrail/supervisord_webui_files/contrail-webui-middleware.ini', + pw.pw_uid, pw.pw_gid) + shutil.copy('files/contrail-webui-middleware', '/etc/init.d') + os.chmod('/etc/init.d/contrail-webui-middleware', 0o755) + + +def web_install_dir(): + return '/var/lib/contrail-webui' \ + if is_opencontrail() \ + else '/usr/src/contrail' + + +def write_ssl_certificate(cert, key): + base = web_install_dir() + with open(base + '/contrail-web-core/keys/cs-cert.pem', 'w') as f: + f.write(cert) + with open(base + '/contrail-web-core/keys/cs-key.pem', 'w') as f: + f.write(key) diff --git a/charms/trusty/contrail-webui/hooks/start b/charms/trusty/contrail-webui/hooks/start new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/start @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/stop b/charms/trusty/contrail-webui/hooks/stop new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/stop @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/upgrade-charm b/charms/trusty/contrail-webui/hooks/upgrade-charm new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/upgrade-charm @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/website-relation-changed b/charms/trusty/contrail-webui/hooks/website-relation-changed new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/website-relation-changed @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/hooks/website-relation-joined b/charms/trusty/contrail-webui/hooks/website-relation-joined new file mode 100755 index 0000000..5028988 --- /dev/null +++ b/charms/trusty/contrail-webui/hooks/website-relation-joined @@ -0,0 +1,3 @@ +#!/usr/bin/python +import services +services.manage() diff --git a/charms/trusty/contrail-webui/icon.svg b/charms/trusty/contrail-webui/icon.svg new file mode 100644 index 0000000..6f77c1a --- /dev/null +++ b/charms/trusty/contrail-webui/icon.svg @@ -0,0 +1,309 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + diff --git a/charms/trusty/contrail-webui/metadata.yaml b/charms/trusty/contrail-webui/metadata.yaml new file mode 100644 index 0000000..d1e1a33 --- /dev/null +++ b/charms/trusty/contrail-webui/metadata.yaml @@ -0,0 +1,24 @@ +name: contrail-webui +summary: OpenContrail WebUI Node +maintainer: Robert Ayres +description: | + OpenContrail is a network virtualization solution that provides an overlay + virtual-network to virtual-machines, containers or network namespaces. + . + This charm provides the Web UI node component. +tags: + - openstack +requires: + cassandra: + interface: cassandra + contrail_api: + interface: contrail-api + contrail_discovery: + interface: contrail-discovery + identity_admin: + interface: keystone-admin + redis: + interface: redis +provides: + website: + interface: http diff --git a/charms/trusty/contrail-webui/templates/config.global.js.j2 b/charms/trusty/contrail-webui/templates/config.global.js.j2 new file mode 100644 index 0000000..50a6d02 --- /dev/null +++ b/charms/trusty/contrail-webui/templates/config.global.js.j2 @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2014 Juniper Networks, Inc. All rights reserved. + */ + +var config = {}; + +config.orchestration = {}; +/**************************************************************************** + * Specify Orchestration Model + * Available models are: + * - openstack + * - cloudstack + * If you do not want to specify any model, set it to 'none' + * + *****************************************************************************/ +config.orchestration.Manager = 'openstack'; + +/**************************************************************************** + * This boolean flag indicates to communicate with Orchestration + * modules(networkManager, imageManager, computeManager, identityManager, + * storageManager), should the webServer communicate using the + * ip/port/authProtocol/apiVersion as specified in this file, or as returned + * from auth catalog list. + * Note: config.identityManager.apiVersion is not controlled by this boolean + * flag. + * + * true - These values should be taken from this config + * file. + * false - These values should be taken from auth catalog list + * + *****************************************************************************/ +config.serviceEndPointFromConfig = true; + +/**************************************************************************** + * This boolean flag specifies wheather region list should be taken from config + * file or from keystone endpoint + * true - If set as true, then keystone endpoint is taken from + * config.regions + * false - If set as false, then keystone endpoint is taken from + * config.identityManager + * + ****************************************************************************/ +config.regionsFromConfig = false; + +/**************************************************************************** + * Below are the configs for Api Server and analytics Service type & name as + * provisioned in keystone + * + * apiServiceType - Service Type for apiServer, default value is apiServer + * opServiceType - Service Type for analytics, default value is opServer + * + * Note: If there are multiple api server or analytices nodes in a specific + * region, then provision service type/name as ApiServer0, ApiServer1, + * ApiServer2 etc, similarly for analytics node: OpServer0, OpServer1, + * OpServer2 etc. + * + ****************************************************************************/ +config.endpoints = {}; +config.endpoints.apiServiceType = 'ApiServer'; +config.endpoints.opServiceType = 'OpServer'; + +/**************************************************************************** + * Mapping to region name with keystone endpoint + * + * For example: + * config.regions.RegionOne = 'http://nodeIp:5000/v2.0'; + * config.regions.RegionTwo = 'http://nodeIp:5000/v3'; + * + ****************************************************************************/ +config.regions = {}; +config.regions.RegionOne = 'http://{{ identity_admin[0]['service_hostname'] }}:{{ identity_admin[0]['service_port'] }}/v2.0'; + +/**************************************************************************** + * This boolean flag indicates if serviceEndPointFromConfig is set as false, + * then to take IP/Port/Protocol/Version information from auth catalog, + * should publicURL OR internalURL will be used. + * + * true - publicURL in endpoint will be used to retrieve IP/Port/Protocol/ + * Version information + * false - internalURL in endpoint will be used to retrieve + * IP/Port/Protocol/Version information + * + * NOTE: if config.serviceEndPointFromConfig is set as true, then this flag + * does not have any effect. + * + *****************************************************************************/ +config.serviceEndPointTakePublicURL = true; + +/**************************************************************************** + * Below are the config options for all Orchestration Modules below: + * - networkManager + * - imageManager + * - computeManager + * - identityManager + * - storageManager + * - cnfg + * - analytics + * + * Options: + * ip: + * IP to connect to for this Server. + * port: + * Port to connect to for this server + * authProtocol: + * Specify authProtocol either 'http' or 'https' + * apiVersion: + * REST API Version for this server to connect to. + * Specify a list of Versions in array notation. + * Below are the supported list of apiVersion for the modules as of now: + * imageManager - ['v1', 'v2'] + * computeManager - ['v1.1', 'v2'] + * identityManager - ['v2.0'] + * storageManager - ['v1'] + * + * Not applicable for cnfg/analytics as of now + * strictSSL: + * If true, requires certificates to be valid + * ca: + * An authority certificate to check the remote host against, + * if you do not want to specify then use '' + *****************************************************************************/ +config.networkManager = {}; +config.networkManager.ip = '127.0.0.1'; +config.networkManager.port = '9696' +config.networkManager.authProtocol = 'http'; +config.networkManager.apiVersion = []; +config.networkManager.strictSSL = false; +config.networkManager.ca = ''; + +config.imageManager = {}; +config.imageManager.ip = '127.0.0.1'; +config.imageManager.port = '9292'; +config.imageManager.authProtocol = 'http'; +config.imageManager.apiVersion = ['v1', 'v2']; +config.imageManager.strictSSL = false; +config.imageManager.ca = ''; + +config.computeManager = {}; +config.computeManager.ip = '127.0.0.1'; +config.computeManager.port = '8774'; +config.computeManager.authProtocol = 'http'; +config.computeManager.apiVersion = ['v1.1', 'v2']; +config.computeManager.strictSSL = false; +config.computeManager.ca = ''; + +config.identityManager = {}; +config.identityManager.ip = '{{ identity_admin[0]['service_hostname'] }}'; +config.identityManager.port = '{{ identity_admin[0]['service_port'] }}'; +config.identityManager.authProtocol = 'http'; +/****************************************************************************** + * Note: config.identityManager.apiVersion is not controlled by boolean flag + * config.serviceEndPointFromConfig. If specified apiVersion here, then these + * API versions will be used while using REST API to identityManager. + * If want to use with default apiVersion(v2.0), then can specify it as + * empty array. + ******************************************************************************/ +config.identityManager.apiVersion = ['v2.0']; +config.identityManager.strictSSL = false; +config.identityManager.ca = ''; + +config.storageManager = {}; +config.storageManager.ip = '127.0.0.1'; +config.storageManager.port = '8776'; +config.storageManager.authProtocol = 'http'; +config.storageManager.apiVersion = ['v1']; +config.storageManager.strictSSL = false; +config.storageManager.ca = ''; + +// VNConfig API server and port. +config.cnfg = {}; +config.cnfg.server_ip = '{{ contrail_api[0]['vip'] if contrail_api[0]['vip'] else contrail_api[0]['private-address'] }}'; +config.cnfg.server_port = '{{ contrail_api[0]['port'] }}'; +config.cnfg.authProtocol = 'http'; +config.cnfg.strictSSL = false; +config.cnfg.ca = ''; + +// Analytics API server and port. +config.analytics = {}; +config.analytics.server_ip = '127.0.0.1'; +config.analytics.server_port = '8081'; +config.analytics.authProtocol = 'http'; +config.analytics.strictSSL = false; +config.analytics.ca = ''; + +// vcenter related parameters +config.vcenter = {}; +config.vcenter.server_ip = '127.0.0.1'; //vCenter IP +config.vcenter.server_port = '443'; //Port +config.vcenter.authProtocol = 'https'; //http or https +config.vcenter.datacenter = 'vcenter'; //datacenter name +config.vcenter.dvsswitch = 'vswitch'; //dvsswitch name +config.vcenter.strictSSL = false; //Validate the certificate or ignore +config.vcenter.ca = ''; //specify the certificate key file +config.vcenter.wsdl = '/var/lib/contrail-webui/contrail-web-core/webroot/js/vim.wsdl'; + +/* Discovery Service */ +config.discoveryService = {}; +config.discoveryService.server_ip = '{{ contrail_discovery[0]['vip'] if contrail_discovery[0]['vip'] else contrail_discovery[0]['private-address'] }}'; +config.discoveryService.server_port = '{{ contrail_discovery[0]['port'] }}'; +/* Specifiy true if subscription to discovery server should be enabled, else + * specify false. Other than true/false value here is treated as true + */ +config.discoveryService.enable = true; + +/* Job Server */ +config.jobServer = {}; +config.jobServer.server_ip = '127.0.0.1'; +config.jobServer.server_port = '3000'; + +/* Upload/Download Directory */ +config.files = {}; +config.files.download_path = '/tmp'; + +/* Cassandra Server */ +config.cassandra = {}; +config.cassandra.server_ips = ['{{ cassandra|join('\', \'', attribute='private-address') }}']; +config.cassandra.server_port = '{{ cassandra[0]['rpc_port'] if cassandra[0]['rpc_port'] else cassandra[0]['port'] }}'; +config.cassandra.enable_edit = false; + +/* KUE Job Scheduler */ +config.kue = {}; +config.kue.ui_port = '3002' + +/* IP List to listen on */ +config.webui_addresses = ['0.0.0.0']; + +/* Is insecure access to WebUI? + * If set as false, then all http request will be redirected + * to https, if set true, then no https request will be processed, but only http + * request + */ +config.insecure_access = {{ ((not config['use-https']) ~ '')|lower }}; + +// HTTP port for NodeJS Server. +config.http_port = '{{ config['http-port']|default('8080', true) }}'; + +// HTTPS port for NodeJS Server. +config.https_port = '{{ config['https-port']|default('8143', true) }}'; + +// Activate/Deactivate Login. +config.require_auth = false; + +/* Number of node worker processes for cluster. */ +config.node_worker_count = 1; + +/* Number of Parallel Active Jobs with same type */ +config.maxActiveJobs = 10; + +/* Redis DB index for Web-UI */ +config.redisDBIndex = 3; + +/* WebUI Redis Server */ +config.redis_server_port = '{{ redis[0]['port'] }}'; +config.redis_server_ip = '{{ redis[0]['hostname'] }}'; +config.redis_dump_file = '/var/lib/redis/dump-webui.rdb'; +config.redis_password = ''; + +/* Logo File: Use complete path of logo file location */ +config.logo_file = '{{ config['logo-filename'] if config['logo-filename'] else logo_file }}'; + +/* Favicon File: Use complete path of favicon file location */ +config.favicon_file = '{{ config['favicon-filename'] if config['favicon-filename'] else favicon_file }}'; + +config.featurePkg = {}; +/* Add new feature Package Config details below */ +config.featurePkg.webController = {}; +config.featurePkg.webController.path = '{{ webcontroller_path }}'; +config.featurePkg.webController.enable = true; + +/* Enable/disable Stat Query Links in Sidebar*/ +config.qe = {}; +config.qe.enable_stat_queries = false; + +/* Configure level of logs, supported log levels are: + debug, info, notice, warning, error, crit, alert, emerg + */ +config.logs = {}; +config.logs.level = 'debug'; + +/****************************************************************************** + * Boolean flag getDomainProjectsFromApiServer indicates wheather the project + * list should come from API Server or Identity Manager. + * If Set + * - true, then project list will come from API Server + * - false, then project list will come from Identity Manager + * Default: false + * + ******************************************************************************/ +config.getDomainProjectsFromApiServer = false; +/***************************************************************************** + * Boolean flag L2_enable indicates the default forwarding-mode of a network. + * Allowed values : true / false + * Set this flag to true if all the networks are to be L2 networks, + * set to false otherwise. + *****************************************************************************/ +config.network = {}; +config.network.L2_enable = false; + +/****************************************************************************** + * Boolean flag getDomainsFromApiServer indicates wheather the domain + * list should come from API Server or Identity Manager. + * If Set + * - true, then domain list will come from API Server + * - false, then domain list will come from Identity Manager + * Default: true + * NOTE: if config.identityManager.apiVersion is set as v2.0, then this flag + * does not have any effect, in that case the domain list is retrieved + * from API Server. + * + *****************************************************************************/ +config.getDomainsFromApiServer = false; + +// Export this as a module. +module.exports = config; + diff --git a/charms/trusty/contrail-webui/templates/contrail-webui-userauth.js b/charms/trusty/contrail-webui/templates/contrail-webui-userauth.js new file mode 100644 index 0000000..f37a348 --- /dev/null +++ b/charms/trusty/contrail-webui/templates/contrail-webui-userauth.js @@ -0,0 +1,7 @@ +var auth = {}; +auth.admin_user = '{{ identity_admin[0]['service_username'] }}'; +auth.admin_password = '{{ identity_admin[0]['service_password'] }}'; +auth.admin_tenant_name = '{{ identity_admin[0]['service_tenant_name'] }}'; + +module.exports = auth; + -- cgit 1.2.3-korg