K8s_01-Robot tests packages

Signed-off-by: calvinosanc1 <guillermo.calvino@canonical.com>

k8s_jujucontroller_vnf/charms/tid-jujuk8s/lib/charms/layer/__init__.py

+import sys
+from importlib import import_module
+from pathlib import Path
+
+
+def import_layer_libs():
+    """
+    Ensure that all layer libraries are imported.
+
+    This makes it possible to do the following:
+
+        from charms import layer
+
+        layer.foo.do_foo_thing()
+
+    Note: This function must be called after bootstrap.
+    """
+    for module_file in Path('lib/charms/layer').glob('*'):
+        module_name = module_file.stem
+        if module_name in ('__init__', 'basic', 'execd') or not (
+            module_file.suffix == '.py' or module_file.is_dir()
+        ):
+            continue
+        import_module('charms.layer.{}'.format(module_name))
+
+
+# Terrible hack to support the old terrible interface.
+# Try to get people to call layer.options.get() instead so
+# that we can remove this garbage.
+# Cribbed from https://stackoverfLow.com/a/48100440/4941864
+class OptionsBackwardsCompatibilityHack(sys.modules[__name__].__class__):
+    def __call__(self, section=None, layer_file=None):
+        if layer_file is None:
+            return self.get(section=section)
+        else:
+            return self.get(section=section,
+                            layer_file=Path(layer_file))
+
+
+def patch_options_interface():
+    from charms.layer import options
+    if sys.version_info.minor >= 5:
+        options.__class__ = OptionsBackwardsCompatibilityHack
+    else:
+        # Py 3.4 doesn't support changing the __class__, so we have to do it
+        # another way.  The last line is needed because we already have a
+        # reference that doesn't get updated with sys.modules.
+        name = options.__name__
+        hack = OptionsBackwardsCompatibilityHack(name)
+        hack.get = options.get
+        sys.modules[name] = hack
+        sys.modules[__name__].options = hack
+
+
+try:
+    patch_options_interface()
+except ImportError:
+    # This may fail if pyyaml hasn't been installed yet. But in that
+    # case, the bootstrap logic will try it again once it has.
+    pass

k8s_jujucontroller_vnf/charms/tid-jujuk8s/lib/charms/layer/basic.py

+import os
+import sys
+import shutil
+from glob import glob
+from subprocess import check_call, check_output, CalledProcessError
+from time import sleep
+
+from charms import layer
+from charms.layer.execd import execd_preinstall
+
+
+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 bootstrap_charm_deps():
+    """
+    Set up the base charm dependencies so that the reactive system can run.
+    """
+    # execd must happen first, before any attempt to install packages or
+    # access the network, because sites use this hook to do bespoke
+    # configuration and install secrets so the rest of this bootstrap
+    # and the charm itself can actually succeed. This call does nothing
+    # unless the operator has created and populated $JUJU_CHARM_DIR/exec.d.
+    execd_preinstall()
+    # ensure that $JUJU_CHARM_DIR/bin is on the path, for helper scripts
+    charm_dir = os.environ['JUJU_CHARM_DIR']
+    os.environ['PATH'] += ':%s' % os.path.join(charm_dir, 'bin')
+    venv = os.path.abspath('../.venv')
+    vbin = os.path.join(venv, 'bin')
+    vpip = os.path.join(vbin, 'pip')
+    vpy = os.path.join(vbin, 'python')
+    hook_name = os.path.basename(sys.argv[0])
+    is_bootstrapped = os.path.exists('wheelhouse/.bootstrapped')
+    is_charm_upgrade = hook_name == 'upgrade-charm'
+    is_series_upgrade = hook_name == 'post-series-upgrade'
+    post_upgrade = os.path.exists('wheelhouse/.upgrade')
+    is_upgrade = not post_upgrade and (is_charm_upgrade or is_series_upgrade)
+    if is_bootstrapped and not is_upgrade:
+        # older subordinates might have downgraded charm-env, so we should
+        # restore it if necessary
+        install_or_update_charm_env()
+        activate_venv()
+        # the .upgrade file prevents us from getting stuck in a loop
+        # when re-execing to activate the venv; at this point, we've
+        # activated the venv, so it's safe to clear it
+        if post_upgrade:
+            os.unlink('wheelhouse/.upgrade')
+        return
+    if is_series_upgrade and os.path.exists(venv):
+        # series upgrade should do a full clear of the venv, rather than just
+        # updating it, to bring in updates to Python itself
+        shutil.rmtree(venv)
+    if is_upgrade:
+        if os.path.exists('wheelhouse/.bootstrapped'):
+            os.unlink('wheelhouse/.bootstrapped')
+        open('wheelhouse/.upgrade', 'w').close()
+    # bootstrap wheelhouse
+    if os.path.exists('wheelhouse'):
+        with open('/root/.pydistutils.cfg', 'w') as fp:
+            # make sure that easy_install also only uses the wheelhouse
+            # (see https://github.com/pypa/pip/issues/410)
+            fp.writelines([
+                "[easy_install]\n",
+                "allow_hosts = ''\n",
+                "find_links = file://{}/wheelhouse/\n".format(charm_dir),
+            ])
+        apt_install([
+            'python3-pip',
+            'python3-setuptools',
+            'python3-yaml',
+            'python3-dev',
+            'python3-wheel',
+            'build-essential',
+        ])
+        from charms.layer import options
+        cfg = options.get('basic')
+        # include packages defined in layer.yaml
+        apt_install(cfg.get('packages', []))
+        # if we're using a venv, set it up
+        if cfg.get('use_venv'):
+            if not os.path.exists(venv):
+                series = lsb_release()['DISTRIB_CODENAME']
+                if series in ('precise', 'trusty'):
+                    apt_install(['python-virtualenv'])
+                else:
+                    apt_install(['virtualenv'])
+                cmd = ['virtualenv', '-ppython3', '--never-download', venv]
+                if cfg.get('include_system_packages'):
+                    cmd.append('--system-site-packages')
+                check_call(cmd)
+            os.environ['PATH'] = ':'.join([vbin, os.environ['PATH']])
+            pip = vpip
+        else:
+            pip = 'pip3'
+            # save a copy of system pip to prevent `pip3 install -U pip`
+            # from changing it
+            if os.path.exists('/usr/bin/pip'):
+                shutil.copy2('/usr/bin/pip', '/usr/bin/pip.save')
+        # need newer pip, to fix spurious Double Requirement error:
+        # https://github.com/pypa/pip/issues/56
+        check_call([pip, 'install', '-U', '--no-index', '-f', 'wheelhouse',
+                    'pip'])
+        # per https://github.com/juju-solutions/layer-basic/issues/110
+        # this replaces the setuptools that was copied over from the system on
+        # venv create with latest setuptools and adds setuptools_scm
+        check_call([pip, 'install', '-U', '--no-index', '-f', 'wheelhouse',
+                    'setuptools', 'setuptools-scm'])
+        # install the rest of the wheelhouse deps
+        check_call([pip, 'install', '-U', '--ignore-installed', '--no-index',
+                   '-f', 'wheelhouse'] + glob('wheelhouse/*'))
+        # re-enable installation from pypi
+        os.remove('/root/.pydistutils.cfg')
+        # install python packages from layer options
+        if cfg.get('python_packages'):
+            check_call([pip, 'install', '-U'] + cfg.get('python_packages'))
+        if not cfg.get('use_venv'):
+            # restore system pip to prevent `pip3 install -U pip`
+            # from changing it
+            if os.path.exists('/usr/bin/pip.save'):
+                shutil.copy2('/usr/bin/pip.save', '/usr/bin/pip')
+                os.remove('/usr/bin/pip.save')
+        # setup wrappers to ensure envs are used for scripts
+        install_or_update_charm_env()
+        for wrapper in ('charms.reactive', 'charms.reactive.sh',
+                        'chlp', 'layer_option'):
+            src = os.path.join('/usr/local/sbin', 'charm-env')
+            dst = os.path.join('/usr/local/sbin', wrapper)
+            if not os.path.exists(dst):
+                os.symlink(src, dst)
+        if cfg.get('use_venv'):
+            shutil.copy2('bin/layer_option', vbin)
+        else:
+            shutil.copy2('bin/layer_option', '/usr/local/bin/')
+        # re-link the charm copy to the wrapper in case charms
+        # call bin/layer_option directly (as was the old pattern)
+        os.remove('bin/layer_option')
+        os.symlink('/usr/local/sbin/layer_option', 'bin/layer_option')
+        # flag us as having already bootstrapped so we don't do it again
+        open('wheelhouse/.bootstrapped', 'w').close()
+        # Ensure that the newly bootstrapped libs are available.
+        # Note: this only seems to be an issue with namespace packages.
+        # Non-namespace-package libs (e.g., charmhelpers) are available
+        # without having to reload the interpreter. :/
+        reload_interpreter(vpy if cfg.get('use_venv') else sys.argv[0])
+
+
+def install_or_update_charm_env():
+    # On Trusty python3-pkg-resources is not installed
+    try:
+        from pkg_resources import parse_version
+    except ImportError:
+        apt_install(['python3-pkg-resources'])
+        from pkg_resources import parse_version
+
+    try:
+        installed_version = parse_version(
+            check_output(['/usr/local/sbin/charm-env',
+                          '--version']).decode('utf8'))
+    except (CalledProcessError, FileNotFoundError):
+        installed_version = parse_version('0.0.0')
+    try:
+        bundled_version = parse_version(
+            check_output(['bin/charm-env',
+                          '--version']).decode('utf8'))
+    except (CalledProcessError, FileNotFoundError):
+        bundled_version = parse_version('0.0.0')
+    if installed_version < bundled_version:
+        shutil.copy2('bin/charm-env', '/usr/local/sbin/')
+
+
+def activate_venv():
+    """
+    Activate the venv if enabled in ``layer.yaml``.
+
+    This is handled automatically for normal hooks, but actions might
+    need to invoke this manually, using something like:
+
+        # Load modules from $JUJU_CHARM_DIR/lib
+        import sys
+        sys.path.append('lib')
+
+        from charms.layer.basic import activate_venv
+        activate_venv()
+
+    This will ensure that modules installed in the charm's
+    virtual environment are available to the action.
+    """
+    from charms.layer import options
+    venv = os.path.abspath('../.venv')
+    vbin = os.path.join(venv, 'bin')
+    vpy = os.path.join(vbin, 'python')
+    use_venv = options.get('basic', 'use_venv')
+    if use_venv and '.venv' not in sys.executable:
+        # activate the venv
+        os.environ['PATH'] = ':'.join([vbin, os.environ['PATH']])
+        reload_interpreter(vpy)
+    layer.patch_options_interface()
+    layer.import_layer_libs()
+
+
+def reload_interpreter(python):
+    """
+    Reload the python interpreter to ensure that all deps are available.
+
+    Newly installed modules in namespace packages sometimes seemt to
+    not be picked up by Python 3.
+    """
+    os.execve(python, [python] + list(sys.argv), os.environ)
+
+
+def apt_install(packages):
+    """
+    Install apt packages.
+
+    This ensures a consistent set of options that are often missed but
+    should really be set.
+    """
+    if isinstance(packages, (str, bytes)):
+        packages = [packages]
+
+    env = os.environ.copy()
+
+    if 'DEBIAN_FRONTEND' not in env:
+        env['DEBIAN_FRONTEND'] = 'noninteractive'
+
+    cmd = ['apt-get',
+           '--option=Dpkg::Options::=--force-confold',
+           '--assume-yes',
+           'install']
+    for attempt in range(3):
+        try:
+            check_call(cmd + packages, env=env)
+        except CalledProcessError:
+            if attempt == 2:  # third attempt
+                raise
+            try:
+                # sometimes apt-get update needs to be run
+                check_call(['apt-get', 'update'])
+            except CalledProcessError:
+                # sometimes it's a dpkg lock issue
+                pass
+            sleep(5)
+        else:
+            break
+
+
+def init_config_states():
+    import yaml
+    from charmhelpers.core import hookenv
+    from charms.reactive import set_state
+    from charms.reactive import toggle_state
+    config = hookenv.config()
+    config_defaults = {}
+    config_defs = {}
+    config_yaml = os.path.join(hookenv.charm_dir(), 'config.yaml')
+    if os.path.exists(config_yaml):
+        with open(config_yaml) as fp:
+            config_defs = yaml.safe_load(fp).get('options', {})
+            config_defaults = {key: value.get('default')
+                               for key, value in config_defs.items()}
+    for opt in config_defs.keys():
+        if config.changed(opt):
+            set_state('config.changed')
+            set_state('config.changed.{}'.format(opt))
+        toggle_state('config.set.{}'.format(opt), config.get(opt))
+        toggle_state('config.default.{}'.format(opt),
+                     config.get(opt) == config_defaults[opt])
+
+
+def clear_config_states():
+    from charmhelpers.core import hookenv, unitdata
+    from charms.reactive import remove_state
+    config = hookenv.config()
+    remove_state('config.changed')
+    for opt in config.keys():
+        remove_state('config.changed.{}'.format(opt))
+        remove_state('config.set.{}'.format(opt))
+        remove_state('config.default.{}'.format(opt))
+    unitdata.kv().flush()

k8s_jujucontroller_vnf/charms/tid-jujuk8s/lib/charms/layer/execd.py

+# Copyright 2014-2016 Canonical Limited.
+#
+# This file is part of layer-basic, the reactive base layer for Juju.
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+# This module may only import from the Python standard library.
+import os
+import sys
+import subprocess
+import time
+
+'''
+execd/preinstall
+
+Read the layer-basic docs for more info on how to use this feature.
+https://charmsreactive.readthedocs.io/en/latest/layer-basic.html#exec-d-support
+'''
+
+
+def default_execd_dir():
+    return os.path.join(os.environ['JUJU_CHARM_DIR'], 'exec.d')
+
+
+def execd_module_paths(execd_dir=None):
+    """Generate a list of full paths to modules within execd_dir."""
+    if not execd_dir:
+        execd_dir = default_execd_dir()
+
+    if not os.path.exists(execd_dir):
+        return
+
+    for subpath in os.listdir(execd_dir):
+        module = os.path.join(execd_dir, subpath)
+        if os.path.isdir(module):
+            yield module
+
+
+def execd_submodule_paths(command, execd_dir=None):
+    """Generate a list of full paths to the specified command within exec_dir.
+    """
+    for module_path in execd_module_paths(execd_dir):
+        path = os.path.join(module_path, command)
+        if os.access(path, os.X_OK) and os.path.isfile(path):
+            yield path
+
+
+def execd_sentinel_path(submodule_path):
+    module_path = os.path.dirname(submodule_path)
+    execd_path = os.path.dirname(module_path)
+    module_name = os.path.basename(module_path)
+    submodule_name = os.path.basename(submodule_path)
+    return os.path.join(execd_path,
+                        '.{}_{}.done'.format(module_name, submodule_name))
+
+
+def execd_run(command, execd_dir=None, stop_on_error=True, stderr=None):
+    """Run command for each module within execd_dir which defines it."""
+    if stderr is None:
+        stderr = sys.stdout
+    for submodule_path in execd_submodule_paths(command, execd_dir):
+        # Only run each execd once. We cannot simply run them in the
+        # install hook, as potentially storage hooks are run before that.
+        # We cannot rely on them being idempotent.
+        sentinel = execd_sentinel_path(submodule_path)
+        if os.path.exists(sentinel):
+            continue
+
+        try:
+            subprocess.check_call([submodule_path], stderr=stderr,
+                                  universal_newlines=True)
+            with open(sentinel, 'w') as f:
+                f.write('{} ran successfully {}\n'.format(submodule_path,
+                                                          time.ctime()))
+                f.write('Removing this file will cause it to be run again\n')
+        except subprocess.CalledProcessError as e:
+            # Logs get the details. We can't use juju-log, as the
+            # output may be substantial and exceed command line
+            # length limits.
+            print("ERROR ({}) running {}".format(e.returncode, e.cmd),
+                  file=stderr)
+            print("STDOUT<<EOM", file=stderr)
+            print(e.output, file=stderr)
+            print("EOM", file=stderr)
+
+            # Unit workload status gets a shorter fail message.
+            short_path = os.path.relpath(submodule_path)
+            block_msg = "Error ({}) running {}".format(e.returncode,
+                                                       short_path)
+            try:
+                subprocess.check_call(['status-set', 'blocked', block_msg],
+                                      universal_newlines=True)
+                if stop_on_error:
+                    sys.exit(0)  # Leave unit in blocked state.
+            except Exception:
+                pass  # We care about the exec.d/* failure, not status-set.
+
+            if stop_on_error:
+                sys.exit(e.returncode or 1)  # Error state for pre-1.24 Juju
+
+
+def execd_preinstall(execd_dir=None):
+    """Run charm-pre-install for each module within execd_dir."""
+    execd_run('charm-pre-install', execd_dir=execd_dir)

k8s_jujucontroller_vnf/charms/tid-jujuk8s/lib/charms/layer/options.py

+import os
+from pathlib import Path
+
+import yaml
+
+
+_CHARM_PATH = Path(os.environ.get('JUJU_CHARM_DIR', '.'))
+_DEFAULT_FILE = _CHARM_PATH / 'layer.yaml'
+_CACHE = {}
+
+
+def get(section=None, option=None, layer_file=_DEFAULT_FILE):
+    if option and not section:
+        raise ValueError('Cannot specify option without section')
+
+    layer_file = (_CHARM_PATH / layer_file).resolve()
+    if layer_file not in _CACHE:
+        with layer_file.open() as fp:
+            _CACHE[layer_file] = yaml.safe_load(fp.read())
+
+    data = _CACHE[layer_file].get('options', {})
+    if section:
+        data = data.get(section, {})
+    if option:
+        data = data.get(option)
+    return data

k8s_jujucontroller_vnf/charms/tid-jujuk8s/lib/charms/sshproxy.py

+"""Module to help with executing commands over SSH."""
+##
+# Copyright 2016 Canonical Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+##
+
+from charmhelpers.core import unitdata
+from charmhelpers.core.hookenv import log
+
+import io
+import ipaddress
+import paramiko
+import os
+import socket
+import shlex
+import traceback
+
+from subprocess import (
+    Popen,
+    CalledProcessError,
+    PIPE,
+)
+
+
+def get_config():
+    """Get the current charm configuration.
+
+    Get the "live" kv store every time we need to access the charm config, in
+    case it has recently been changed by a config-changed event.
+    """
+    db = unitdata.kv()
+    return db.get('config')
+
+
+def get_host_ip():
+    """Get the IP address for the ssh host.
+
+    HACK: This function was added to work around an issue where the
+    ssh-hostname was passed in the format of a.b.c.d;a.b.c.d, where the first
+    is the floating ip, and the second the non-floating ip, for an Openstack
+    instance.
+    """
+    cfg = get_config()
+    return cfg['ssh-hostname'].split(';')[0]
+
+
+def is_valid_hostname(hostname):
+    """Validate the ssh-hostname."""
+    log("Hostname: {}".format(hostname))
+    if hostname == "0.0.0.0":
+        return False
+
+    try:
+        ipaddress.ip_address(hostname)
+    except ValueError:
+        return False
+
+    return True
+
+
+def verify_ssh_credentials():
+    """Verify the ssh credentials have been installed to the VNF.
+
+    Attempts to run a stock command - `hostname` on the remote host.
+    """
+    verified = False
+    status = ''
+    cfg = get_config()
+
+    try:
+        host = get_host_ip()
+        if is_valid_hostname(host):
+            if len(cfg['ssh-hostname']) and len(cfg['ssh-username']):
+                cmd = 'hostname'
+                status, err = _run(cmd)
+
+                if len(err) == 0:
+                    verified = True
+        else:
+            status = "Invalid IP address."
+    except CalledProcessError as e:
+        status = 'Command failed: {} ({})'.format(
+            ' '.join(e.cmd),
+            str(e.output)
+        )
+    except paramiko.ssh_exception.AuthenticationException as e:
+        status = '{}.'.format(e)
+    except paramiko.ssh_exception.BadAuthenticationType as e:
+        status = '{}'.format(e.explanation)
+    except paramiko.ssh_exception.BadHostKeyException as e:
+        status = 'Host key mismatch: expected {} but got {}.'.format(
+            e.expected_key,
+            e.got_key,
+        )
+    except (TimeoutError, socket.timeout):
+        status = "Timeout attempting to reach {}".format(cfg['ssh-hostname'])
+    except Exception as error:
+        tb = traceback.format_exc()
+        status = 'Unhandled exception: {}'.format(tb)
+
+    return (verified, status)
+
+
+def charm_dir():
+    """Return the root directory of the current charm."""
+    d = os.environ.get('JUJU_CHARM_DIR')
+    if d is not None:
+        return d
+    return os.environ.get('CHARM_DIR')
+
+
+def run_local(cmd, env=None):
+    """Run a command locally."""
+    if isinstance(cmd, str):
+        cmd = shlex.split(cmd) if ' ' in cmd else [cmd]
+
+    if type(cmd) is not list:
+        cmd = [cmd]
+
+    p = Popen(cmd,
+              env=env,
+              shell=True,
+              stdout=PIPE,
+              stderr=PIPE)
+    stdout, stderr = p.communicate()
+    retcode = p.poll()
+    if retcode > 0:
+        raise CalledProcessError(returncode=retcode,
+                                 cmd=cmd,
+                                 output=stderr.decode("utf-8").strip())
+    return (stdout.decode('utf-8').strip(), stderr.decode('utf-8').strip())
+
+
+def _run(cmd, env=None):
+    """Run a command remotely via SSH.
+
+    Note: The previous behavior was to run the command locally if SSH wasn't
+    configured, but that can lead to cases where execution succeeds when you'd
+    expect it not to.
+    """
+    if isinstance(cmd, str):
+        cmd = shlex.split(cmd)
+
+    if type(cmd) is not list:
+        cmd = [cmd]
+
+    cfg = get_config()
+
+    if cfg:
+        if all(k in cfg for k in ['ssh-hostname', 'ssh-username',
+                                  'ssh-password', 'ssh-private-key']):
+            host = get_host_ip()
+            user = cfg['ssh-username']
+            passwd = cfg['ssh-password']
+            key = cfg['ssh-private-key']  # DEPRECATED
+
+            if host and user:
+                return ssh(cmd, host, user, passwd, key)
+
+    raise Exception("Invalid SSH credentials.")
+
+
+def get_ssh_client(host, user, password=None, key=None):
+    """Return a connected Paramiko ssh object."""
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+    pkey = None
+
+    # Check for the DEPRECATED private-key
+    if key:
+        f = io.StringIO(key)
+        pkey = paramiko.RSAKey.from_private_key(f)
+    else:
+        # Otherwise, check for the auto-generated private key
+        if os.path.exists('/root/.ssh/id_juju_sshproxy'):
+            with open('/root/.ssh/id_juju_sshproxy', 'r') as f:
+                pkey = paramiko.RSAKey.from_private_key(f)
+
+    ###########################################################################
+    # There is a bug in some versions of OpenSSH 4.3 (CentOS/RHEL 5) where    #
+    # the server may not send the SSH_MSG_USERAUTH_BANNER message except when #
+    # responding to an auth_none request. For example, paramiko will attempt  #
+    # to use password authentication when a password is set, but the server   #
+    # could deny that, instead requesting keyboard-interactive. The hack to   #
+    # workaround this is to attempt a reconnect, which will receive the right #
+    # banner, and authentication can proceed. See the following for more info #
+    # https://github.com/paramiko/paramiko/issues/432                         #
+    # https://github.com/paramiko/paramiko/pull/438                           #
+    ###########################################################################
+
+    try:
+        client.connect(host, port=22, username=user,
+                       password=password, pkey=pkey)
+    except paramiko.ssh_exception.SSHException as e:
+        if 'Error reading SSH protocol banner' == str(e):
+            # Once more, with feeling
+            client.connect(host, port=22, username=user,
+                           password=password, pkey=pkey)
+        else:
+            # Reraise the original exception
+            raise e
+
+    return client
+
+
+def sftp(local_file, remote_file, host, user, password=None, key=None):
+    """Copy a local file to a remote host."""
+    client = get_ssh_client(host, user, password, key)
+
+    # Create an sftp connection from the underlying transport
+    sftp = paramiko.SFTPClient.from_transport(client.get_transport())
+    sftp.put(local_file, remote_file)
+    client.close()
+
+
+def ssh(cmd, host, user, password=None, key=None):
+    """Run an arbitrary command over SSH."""
+    client = get_ssh_client(host, user, password, key)
+
+    cmds = ' '.join(cmd)
+    stdin, stdout, stderr = client.exec_command(cmds, get_pty=True)
+    retcode = stdout.channel.recv_exit_status()
+    client.close()  # @TODO re-use connections
+    if retcode > 0:
+        output = stderr.read().strip()
+        raise CalledProcessError(returncode=retcode, cmd=cmd,
+                                 output=output)
+    return (
+        stdout.read().decode('utf-8').strip(),
+        stderr.read().decode('utf-8').strip()
+    )

k8s_jujucontroller_vnf/charms/tid-jujuk8s/metadata.yaml

+"name": "tid-jujuk8s"
+"summary": "A charm for k8s_jujucontroller_vnf to deploy a K8s cluster"
+"maintainers":
+- "garciadeblas <gerardo.garciadeblas@telefonica.com>"
+- "garomero <garomero@minsait.com>"
+"description": |
+  A charm to manage k8s_jujucontroller_vnf in order to deploy a k8s cluster.
+  It assumes that juju is already installed via cloud-init, with a manual cloud
+  and a bootstrapped controller.
+  It has an action "create-cluster" that receives the IP addresses of the 4 machines
+  belonging to the cluster and does the following:
+    - Copy ssh key of the juju controller to the machines
+    - Add the machines to juju
+    - Deploys the k8s bundle in the machines.
+"tags":
+  # Replace "misc" with one or more whitelisted tags from this list:
+  # https://jujucharms.com/docs/stable/authors-charm-metadata
+- "misc"
+- "osm"
+- "vnf"
+"series":
+- "bionic"
+- "xenial"
+- "trusty"
+"subordinate": !!bool "false"

k8s_jujucontroller_vnf/charms/tid-jujuk8s/reactive/sshproxy.py

+##
+# Copyright 2016 Canonical Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+##
+
+from charmhelpers.core import unitdata
+from charmhelpers.core.hookenv import (
+    action_fail,
+    action_get,
+    action_set,
+    config,
+    log,
+    status_set,
+    DEBUG,
+)
+
+from charms.reactive.flags import register_trigger
+
+from charms.reactive import (
+    clear_flag,
+    set_flag,
+    when,
+    when_not,
+    when_any,
+)
+import charms.sshproxy
+import os
+import subprocess
+
+# Register a trigger so that we can respond to config.changed, even if
+# it's being cleared by another handler
+register_trigger(when='config.changed',
+                 set_flag='sshproxy.reconfigure')
+
+
+# @when_any('config.changed', 'sshproxy.reconfigure')
+@when_any('config.set.ssh-hostname', 'config.set.ssh-username', 'config.set.ssh-password', 'sshproxy.reconfigure')
+def ssh_configured():
+    """Check if charm is properly configured.
+
+    Check to see if the charm is configured with SSH credentials. If so,
+    set a state flag that can be used to execute ssh-only actions.
+
+    For example:
+
+    @when('sshproxy.configured')
+    def run_remote_command(cmd):
+        ...
+
+    @when_not('sshproxy.configured')
+    def run_local_command(cmd):
+        ...
+    """
+    log("Checking sshproxy configuration", DEBUG)
+    cfg = config()
+    ssh_keys = ['ssh-hostname', 'ssh-username',
+                'ssh-password', 'ssh-private-key']
+
+    if all(k in cfg for k in ssh_keys):
+
+        # Store config in unitdata so it's accessible to sshproxy
+        db = unitdata.kv()
+        db.set('config', cfg)
+
+        # Explicitly flush the kv so it's immediately available
+        db.flush()
+
+        log("Verifying ssh credentials...", DEBUG)
+        (verified, output) = charms.sshproxy.verify_ssh_credentials()
+        if verified:
+            log("SSH credentials verified.", DEBUG)
+            set_flag('sshproxy.configured')
+            status_set('active', 'Ready!')
+        else:
+            clear_flag('sshproxy.configured')
+            status_set('blocked', "Remote machine not ready yet: {}".format(output))
+    else:
+        log("No ssh credentials configured", DEBUG)
+        clear_flag('sshproxy.configured')
+        status_set('blocked', 'Invalid SSH credentials.')
+
+
+def generate_ssh_key():
+    """Generate a new 4096-bit rsa keypair.
+
+    If there is an existing keypair for this unit, it will be overwritten.
+    """
+    cfg = config()
+    if all(k in cfg for k in ['ssh-key-type', 'ssh-key-bits']):
+        keytype = cfg['ssh-key-type']
+        bits = str(cfg['ssh-key-bits'])
+        privatekey = '/root/.ssh/id_juju_sshproxy'
+        publickey = "{}.pub".format(privatekey)
+
+        if os.path.exists(privatekey):
+            os.remove(privatekey)
+        if os.path.exists(publickey):
+            os.remove(publickey)
+
+        cmd = "ssh-keygen -t {} -b {} -N '' -f {}".format(
+            keytype,
+            bits,
+            privatekey
+        )
+
+        output, err = charms.sshproxy.run_local([cmd])
+        if len(err) == 0:
+            return True
+    return False
+
+
+@when('actions.generate-ssh-key')
+def action_generate_ssh_key():
+    """Generate a new 4096-bit rsa keypair.
+
+    If there is an existing keypair for this unit, it will be overwritten.
+    """
+    try:
+        if not generate_ssh_key():
+            action_fail('Unable to generate ssh key.')
+    except subprocess.CalledProcessError as e:
+        action_fail('Command failed: %s (%s)' %
+                    (' '.join(e.cmd), str(e.output)))
+    finally:
+        clear_flag('actions.generate-ssh-key')
+
+
+def get_ssh_public_key():
+    """Get the public SSH key of this unit."""
+    publickey_path = '/root/.ssh/id_juju_sshproxy.pub'
+    publickey = None
+    if os.path.exists(publickey_path):
+        with open(publickey_path, 'r') as f:
+            publickey = f.read()
+
+    return publickey
+
+
+@when('actions.get-ssh-public-key')
+def action_get_ssh_public_key():
+    """Get the public SSH key of this unit."""
+    try:
+        action_set({'pubkey': get_ssh_public_key()})
+    except subprocess.CalledProcessError as e:
+        action_fail('Command failed: %s (%s)' %
+                    (' '.join(e.cmd), str(e.output)))
+    finally:
+        clear_flag('actions.get-ssh-public-key')
+
+
+@when('actions.verify-ssh-credentials')
+def action_verify_ssh_credentials():
+    """Verify the ssh credentials have been installed to the VNF.
+
+    Attempts to run a stock command - `hostname` on the remote host.
+    """
+    try:
+        (verified, output) = charms.sshproxy.verify_ssh_credentials()
+        action_set({
+            'output': output,
+            'verified': verified,
+        })
+        if not verified:
+            action_fail("Verification failed: {}".format(
+                output,
+            ))
+    finally:
+        clear_flag('actions.verify-ssh-credentials')
+
+
+@when('actions.run')
+def run_command():
+    """Run an arbitrary command.
+
+    Run an arbitrary command, either locally or over SSH with the configured
+    credentials.
+    """
+    try:
+        cmd = action_get('command')
+        output, err = charms.sshproxy._run(cmd)
+        if len(err):
+            action_fail("Command '{}' returned error code {}".format(cmd, err))
+        else:
+            action_set({'output': output})
+    except subprocess.CalledProcessError as e:
+        action_fail('Command failed: %s (%s)' %
+                    (' '.join(e.cmd), str(e.output)))
+    finally:
+        clear_flag('actions.run')
+
+
+@when_not('sshproxy.installed')
+def install_vnf_ubuntu_proxy():
+    """Install and Configure SSH Proxy."""
+
+    log("Generating SSH key...", DEBUG)
+    generate_ssh_key()
+    set_flag('sshproxy.installed')

k8s_jujucontroller_vnf/charms/tid-jujuk8s/requirements.txt

+flake8
+pytest

k8s_jujucontroller_vnf/charms/tid-jujuk8s/scripts/add-machine.sh

+#!/bin/bash
+sshpass -posm4u ssh-copy-id -o "StrictHostKeyChecking no" -i /home/ubuntu/.local/share/juju/ssh/juju_id_rsa ubuntu@$1
+sudo su -l ubuntu -c "nohup /snap/bin/juju add-machine ssh:ubuntu@"$1" > /dev/null 2>&1 &"
+

k8s_jujucontroller_vnf/charms/tid-jujuk8s/scripts/add-repo.sh

+#!/bin/bash
+REPO_NAME=$1
+REPO_URL=$2
+helm repo add ${REPO_NAME} ${REPO_URL}
+helm repo update
+

k8s_jujucontroller_vnf/charms/tid-jujuk8s/scripts/delete-release.sh

+#!/bin/bash
+RELEASE=$1
+helm delete --purge ${RELEASE}
+

k8s_jujucontroller_vnf/charms/tid-jujuk8s/scripts/init-helm.sh

+#!/bin/bash
+curl https://get.helm.sh/helm-v2.15.2-linux-amd64.tar.gz --output helm-v2.15.2.tar.gz
+tar -zxvf helm-v2.15.2.tar.gz
+sudo mv linux-amd64/helm /usr/local/bin/helm
+rm -rf linux-amd64/
+rm -f helm-v2.15.2.tar.gz
+/usr/local/bin/helm init
+# Snap for helm currently uses version 3 of helm
+#sudo snap install helm --classic
+#/snap/bin/helm init
+