def __init__(self, series=None):
"""Initialize the deployment environment."""
self.series = None
if series:
self.series = series
self.d = amulet.Deployment(series=self.series)
else:
self.d = amulet.Deployment()
def setUpClass(cls):
cls.deployment = amulet.Deployment()
# Editors Note: Instead of declaring the bundle in the amulet
# setup stanza, rely on bundletester to deploy the bundle on
# this tests behalf. When coupled with reset:false in
# tests.yaml this yields faster test runs per bundle.
# Allow some time for Juju to provision and deploy the bundle.
cls.deployment.setup(timeout=SECONDS_TO_WAIT)
# Wait for the system to settle down.
application_messages = {
'kubernetes-worker': 'Kubernetes worker running.'
}
cls.deployment.sentry.wait_for_messages(application_messages,
timeout=600)
# Make every unit available through self reference
# eg: for worker in self.workers:
# print(worker.info['public-address'])
cls.easyrsas = cls.deployment.sentry['easyrsa']
cls.etcds = cls.deployment.sentry['etcd']
cls.flannels = cls.deployment.sentry['flannel']
cls.masters = cls.deployment.sentry['kubernetes-master']
cls.workers = cls.deployment.sentry['kubernetes-worker']
def setUpClass(cls):
"""
Load the bundle and augment it with the latest kubernetes-e2e.
"""
cls.deployment = amulet.Deployment()
with open(cls.bundle_file) as f:
bun = f.read()
bundle = yaml.safe_load(bun)
cls.deployment.load(bundle)
cls.deployment.add('kubernetes-e2e',
charm='~containers/kubernetes-e2e',
series='xenial')
# Editors Note: Instead of declaring the bundle in the amulet
# setup stanza, rely on bundletester to deploy the bundle on
# this tests behalf. When coupled with reset:false in
# tests.yaml this yields faster test runs per bundle.
# Allow some time for Juju to provision and deploy the bundle.
cls.deployment.setup(timeout=SECONDS_TO_WAIT)
cls.deployment.relate('kubernetes-e2e:certificates',
'easyrsa:client')
cls.deployment.relate('kubernetes-e2e:kubernetes-master',
'kubernetes-master:kube-api-endpoint')
# Wait for the system to settle down.
application_messages = {'kubernetes-worker':
'Kubernetes worker running.',
'kubernetes-e2e':
'Ready to test.'}
cls.deployment.sentry.wait_for_messages(application_messages,
timeout=SECONDS_TO_WAIT)
cls.e2e = cls.deployment.sentry['kubernetes-e2e'][0]
def deploy():
deploy = amulet.Deployment(series='xenial')
deploy.add('haproxy')
deploy.expose('haproxy')
deploy.setup(timeout=900)
deploy.sentry.wait()
return deploy
def setUpClass(cls):
# classmethod inheritance doesn't work quite right with
# setUpClass / tearDownClass, so subclasses have to manually call this
cls.d = amulet.Deployment(series='trusty')
with open(cls.bundle_file) as f:
bun = f.read()
bundle = yaml.safe_load(bun)
cls.d.load(bundle)
cls.d.setup(timeout=1800)
cls.d.sentry.wait_for_messages(
{
'plugin':
'Ready (HDFS & YARN)',
'namenode': [
'Ready (3 DataNodes, HA active, with automatic fail-over)',
'Ready (3 DataNodes, HA standby, with automatic fail-over)',
]
},
timeout=1800)
for unit_name, unit_status in cls.d.sentry.get_status(
)['namenode'].items():
if 'active' in unit_status['workload-status']['message']:
cls.hdfs_active = cls.d.sentry.unit[unit_name]
else:
cls.hdfs_standby = cls.d.sentry.unit[unit_name]
cls.yarn = cls.d.sentry['resourcemanager'][0]
cls.slaves = cls.d.sentry['slave']
cls.client = cls.d.sentry['client'][0]
cls.plugins = cls.d.sentry['plugin']
def __init__(self, series=None):
self.log = self._get_logger()
self.max_connections = '30'
# the default of 80% eats too much resources in a CI environment
self.dataset_size = '25%'
self.d = amulet.Deployment(series=series)
self.d.add('mysql')
self.d.configure(
'mysql',
{
'max-connections': self.max_connections,
'dataset-size': self.dataset_size,
},
)
self.d.expose('mysql')
try:
self.d.setup(timeout=900)
self.d.sentry.wait()
except amulet.helpers.TimeoutError:
amulet.raise_status(amulet.SKIP,
msg="Environment wasn't stood up in time")
# Allow connections from outside
mysqlmaster = self.d.sentry['mysql'][0]
mysqlmaster.run(
"echo 'GRANT ALL ON *.* to root@\"%\"'\""
" IDENTIFIED BY '`cat /var/lib/mysql/mysql.passwd`'\"|"
"mysql -u root --password=`cat /var/lib/mysql/mysql.passwd`")
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('zk-autopurge', charm='zookeeper')
cls.d.setup(timeout=TIMEOUT)
cls.d.sentry.wait_for_messages({'zk-autopurge': re.compile('^ready')},
timeout=TIMEOUT)
cls.unit = cls.d.sentry['zk-autopurge'][0]
def setUpClass(self):
"""Read the bundle in and deploy the bundle."""
# Get the relative bundle path from the environment variable.
self.bundle = os.getenv('BUNDLE', 'bundle.yaml')
# Create a path to the bundle based on this file's location.
self.bundle_path = os.path.join(os.path.dirname(__file__),
'..',
self.bundle)
# Normalize the path to the bundle.
self.bundle_path = os.path.abspath(self.bundle_path)
print('Deploying bundle: {0}'.format(self.bundle_path))
self.deployment = amulet.Deployment()
with open(self.bundle_path, 'r') as bundle_file:
contents = yaml.safe_load(bundle_file)
self.deployment.load(contents)
# Allow some time for Juju to provision and deploy the bundle.
self.deployment.setup(timeout=SECONDS_TO_WAIT)
# Wait for the system to settle down.
self.deployment.sentry.wait()
self.k8s = self.deployment.sentry['kubernetes']
self.etcd = self.deployment.sentry['etcd']
def test_deploy(self):
self.d = amulet.Deployment(series='xenial')
#self.d.add('magpie', charm='magpie')
self.d.add('magpie', charm='~admcleod/magpie')
self.d.setup(timeout=900)
self.d.sentry.wait_for_messages({'magpie': 'Waiting for peers...'},
timeout=3600)
def setUpClass(cls, charmscaler_charm):
cls.d = amulet.Deployment(series="xenial")
cls.d.add("charmscaler", charm=charmscaler_charm)
credentials = get_juju_credentials()
cls.d.configure(
"charmscaler", {
"juju_api_endpoint": credentials["endpoint"],
"juju_model_uuid": credentials["model_uuid"],
"juju_username": credentials["username"],
"juju_password": credentials["password"],
})
cls.d.add("influxdb", charm="cs:~chris.macnaughton/influxdb-7")
cls.d.add("telegraf", charm="cs:telegraf-2")
cls.d.add(SCALABLE_APP, charm=SCALABLE_CHARM)
cls.d.relate("charmscaler:db-api", "influxdb:query")
cls.d.relate("telegraf:influxdb-api", "influxdb:query")
cls.d.relate("telegraf:juju-info", "{}:juju-info".format(SCALABLE_APP))
cls.d.relate("charmscaler:scalable-charm",
"{}:juju-info".format(SCALABLE_APP))
try:
cls.d.setup(timeout=900)
cls.d.sentry.wait()
except amulet.helpers.TimeoutError:
message = "Environment wasn't stood up in time"
amulet.raise_status(amulet.SKIP, msg=message)
for resource in ["autoscaler", "charmpool"]:
attach_resource("charmscaler", resource, charmscaler_charm)
def setUpClass(cls):
cls.deployment = amulet.Deployment(series='xenial')
with open(cls.bundle_file) as stream:
bundle_yaml = stream.read()
bundle = yaml.safe_load(bundle_yaml)
if 'options' not in bundle['services']['kubernetes-worker']:
labels = {'labels': "mylabel=thebest"}
bundle['services']['kubernetes-worker']['options'] = labels
else:
if 'labels' not in bundle['services']['kubernetes-worker'][
'options']:
bundle['services']['kubernetes-worker']['options'][
'labels'] = "mylabel=thebest"
else:
bundle['services']['kubernetes-worker']['options'][
'labels'] += " mylabel=thebest"
cls.deployment.load(bundle)
# Allow some time for Juju to provision and deploy the bundle.
cls.deployment.setup(timeout=SECONDS_TO_WAIT)
# Wait for the system to settle down.
application_messages = {
'kubernetes-worker': 'Kubernetes worker running.'
}
cls.deployment.sentry.wait_for_messages(application_messages,
timeout=900)
def setUpClass(cls):
# classmethod inheritance doesn't work quite right with
# setUpClass / tearDownClass, so subclasses have to manually call this
cls.d = amulet.Deployment(series='xenial')
with open(cls.bundle_file) as f:
bun = f.read()
bundle = yaml.safe_load(bun)
# NB: strip machine ('to') placement out. amulet loses our machine spec
# somewhere between yaml and json; without that spec, charms specifying
# machine placement will not deploy. This is ok for now because all
# charms in this bundle are using 'reset: false' so we'll already
# have our deployment just the way we want it by the time this test
# runs. However, it's bad. Remove once this is fixed:
# https://github.com/juju/amulet/issues/148
for service, service_config in bundle['services'].items():
if 'to' in service_config:
del service_config['to']
cls.d.load(bundle)
cls.d.setup(timeout=3600)
# we need units reporting ready before we attempt our smoke tests
cls.d.sentry.wait_for_messages({'client': re.compile('ready'),
'namenode': re.compile('ready'),
'resourcemanager': re.compile('ready'),
'slave': re.compile('ready'),
}, timeout=3600)
cls.hdfs = cls.d.sentry['namenode'][0]
cls.yarn = cls.d.sentry['resourcemanager'][0]
cls.slave = cls.d.sentry['slave'][0]
def setUpClass(cls):
cls.deployment = amulet.Deployment(series='xenial')
with open(cls.bundle_file) as stream:
bundle_yaml = stream.read()
bundle = yaml.safe_load(bundle_yaml)
cls.deployment.load(bundle)
# Allow some time for Juju to provision and deploy the bundle.
cls.deployment.setup(timeout=SECONDS_TO_WAIT)
# Wait for the system to settle down.
application_messages = {'kubernetes-worker':
'Kubernetes worker running.'}
cls.deployment.sentry.wait_for_messages(application_messages,
timeout=900)
# Make every unit available through self reference
# eg: for worker in self.workers:
# print(worker.info['public-address'])
cls.easyrsas = cls.deployment.sentry['easyrsa']
cls.etcds = cls.deployment.sentry['etcd']
cls.flannels = cls.deployment.sentry['flannel']
cls.loadbalancers = cls.deployment.sentry['kubeapi-load-balancer']
cls.masters = cls.deployment.sentry['kubernetes-master']
cls.workers = cls.deployment.sentry['kubernetes-worker']
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
#self.d.add('magpie', charm='magpie', units=2)
cls.d.add('magpie', charm='~admcleod/magpie', units=2)
cls.d.setup(timeout=900)
cls.magpie_0 = cls.d.sentry['magpie'][0]
cls.magpie_1 = cls.d.sentry['magpie'][1]
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
with open(cls.bundle_file) as f:
bun = f.read()
bundle = yaml.safe_load(bun)
# NB: strip machine ('to') placement. We don't seem to be guaranteed
# the same machine numbering after the initial bundletester deployment,
# so we might fail when redeploying --to a specific machine to run
# these bundle tests. This is ok because all charms in this bundle are
# using 'reset: false', so we'll already have our deployment just the
# way we want it by the time this test runs. This was originally
# raised as:
# https://github.com/juju/amulet/issues/148
for service, service_config in bundle['services'].items():
if 'to' in service_config:
del service_config['to']
cls.d.load(bundle)
cls.d.setup(timeout=3600)
# we need units reporting ready before we attempt our smoke tests
cls.d.sentry.wait_for_messages({'client': re.compile('ready'),
'namenode': re.compile('ready'),
'resourcemanager': re.compile('ready'),
'slave': re.compile('ready'),
'spark': re.compile('ready'),
'zookeeper': re.compile('ready'),
}, timeout=3600)
cls.hdfs = cls.d.sentry['namenode'][0]
cls.yarn = cls.d.sentry['resourcemanager'][0]
cls.slave = cls.d.sentry['slave'][0]
cls.spark = cls.d.sentry['spark'][0]
def ubuntu_basic_deployment(series):
""" Common test routines to run per-series. """
# Initialize
seconds = 900
u = AmuletUtils(logging.DEBUG)
d = amulet.Deployment(series=series)
d.add('ubuntu')
# Deploy services, wait for started state. Fail or skip on timeout.
try:
d.setup(timeout=seconds)
sentry_unit = d.sentry.unit['ubuntu/0']
except amulet.helpers.TimeoutError:
message = 'Deployment timed out ({}s)'.format(seconds)
amulet.raise_status(amulet.FAIL, msg=message)
except:
raise
# Confirm Ubuntu release name from the unit.
release, ret = u.get_ubuntu_release_from_sentry(sentry_unit)
if ret:
# Something went wrong trying to query the unit, or it is an
# unknown/alien release name based on distro-info validation.
amulet.raise_status(amulet.FAIL, msg=ret)
if release == series:
u.log.info('Release/series check: OK')
else:
msg = 'Release/series check: FAIL ({} != {})'.format(release, series)
u.log.error(msg)
amulet.raise_status(amulet.FAIL, msg=msg)
def setUpClass(cls):
cls.deployment = amulet.Deployment(series='precise')
cls.deployment.add('nagios')
cls.deployment.add('haproxy')
cls.deployment.add('rsyslog-forwarder')
cls.deployment.relate('nagios:website', 'haproxy:reverseproxy')
cls.deployment.relate('nagios:juju-info',
'rsyslog-forwarder:juju-info')
try:
cls.deployment.setup(timeout=900)
cls.deployment.sentry.wait()
except amulet.helpers.TimeoutError:
amulet.raise_status(amulet.SKIP,
msg="Environment wasn't stood up in time")
except:
raise
cls.nagios = cls.deployment.sentry['nagios/0']
cls.haproxy = cls.deployment.sentry['haproxy/0']
cls.rsyslogfwd = cls.deployment.sentry['rsyslog-forwarder/0']
cls.nagios.run('mkdir -p /tmp/amulet-test/test-dir;'
'echo contents > /tmp/amulet-test/test-file;')
cls.rsyslogfwd.run('echo more-contents > /tmp/amulet-sub-test;')
def setUpClass(cls):
"""Set up deployment.
This will be called only once during the Test class.
"""
# Get env variables
cls.charm_name = os.environ.get('CHARM_NAME')
cls.charm_store_group = os.environ.get('CHARM_STORE_GROUP')
cls.charm_build_dir = os.environ.get('CHARM_BUILD_DIR')
# Generate paths to locally built charms
cls.charm_path = os.path.join(cls.charm_build_dir, cls.charm_name)
# Setup Amulet deployment
cls.d = amulet.Deployment(series='xenial')
# Add services
cls.d.add(service_name=cls.charm_name, charm=cls.charm_path)
cls.d.add(service_name='slurm-node',
charm='cs:~{}/slurm-node'.format(cls.charm_store_group))
# # Add relations
cls.d.relate('{}:slurm-cluster'.format(cls.charm_name),
'slurm-node:slurm-cluster')
# Deploy services
cls.d.setup()
cls.d.sentry.wait()
# Get Slurm controller
cls.controller = cls.d.sentry[cls.charm_name][0]
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('zookeeper', units=3)
cls.d.setup(timeout=1800)
cls.d.sentry.wait_for_messages({'zookeeper': re.compile('ready')},
timeout=1800)
cls.unit = cls.d.sentry['zookeeper'][0]
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('spark')
cls.d.setup(timeout=1800)
cls.d.sentry.wait_for_messages({'spark': re.compile('ready')},
timeout=1800)
cls.spark = cls.d.sentry['spark'][0]
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
# Deploy the scenario from the bundle
with open(cls.bundle_file) as f:
bun = f.read()
bundle = yaml.safe_load(bun)
cls.d.load(bundle)
cls.d.setup(timeout=TEST_TIMEOUT)
cls.etcd = cls.d.sentry['etcd']
# This is a hacky work-around to amulet not supporting charm upgrades.
juju(['upgrade-charm', 'etcd', '--path', os.getcwd()])
# This is kind of a litmus test.
cls.d.sentry.wait_for_messages({'etcd': re.compile('snap-upgrade')})
# this is the legacy location of these TLS certs. As of rev-25 this is
# no longer the case, and this is safe to leave as is for the remainder
# of this tests lifecycle.
certs = "ETCDCTL_KEY_FILE=/etc/ssl/etcd/client.key " \
"ETCDCTL_CERT_FILE=/etc/ssl/etcd/client.crt " \
"ETCDCTL_CA_FILE=/etc/ssl/etcd/ca.crt"
# preseed the deployment with some data keys before releasing execution
cls.etcd[0].run('{} etcdctl set juju rocks'.format(certs))
cls.etcd[0].run('{} etcdctl set nested/data works'.format(certs))
def test_deploy(self):
self.d = amulet.Deployment(series='xenial')
self.d.add('tomee', 'apache-tomee')
self.d.setup(timeout=900)
self.tomee = self.d.sentry['tomee'][0]
self.d.sentry.wait_for_messages(
{'tomee': 'Failed to fetch TomEE binary'}, timeout=1800)
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('pig', 'cs:xenial/pig')
cls.d.setup(timeout=1800)
cls.d.sentry.wait_for_messages({'pig': re.compile('ready')},
timeout=1800)
cls.pig = cls.d.sentry['pig'][0]
def setUpClass(cls):
cls.d = amulet.Deployment(series='trusty')
cls.d.add('ubuntu-devenv', 'cs:~kwmonroe/trusty/ubuntu-devenv')
cls.d.add('openjdk', 'cs:~kwmonroe/trusty/openjdk')
cls.d.relate('ubuntu-devenv:java', 'openjdk:java')
cls.d.setup(timeout=900)
cls.d.sentry.wait(timeout=1800)
cls.unit = cls.d.sentry['ubuntu-devenv'][0]
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('hive')
cls.d.setup(timeout=1800)
cls.d.sentry.wait_for_messages({'hive': re.compile('ready|waiting')},
timeout=1800)
cls.unit = cls.d.sentry['hive'][0]
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('spark-test-ha', 'cs:xenial/spark', units=3)
cls.d.add('zk-test', 'cs:xenial/zookeeper')
cls.d.relate('zk-test:zookeeper', 'spark-test-ha:zookeeper')
cls.d.expose('spark-test-ha')
cls.d.setup(timeout=3600)
cls.d.sentry.wait(timeout=3600)
def setUp(self):
self.d = amulet.Deployment(series='trusty')
with open(self.bundle_file) as f:
bun = f.read()
bundle = yaml.safe_load(bun)
self.d.load(bundle)
self.d.setup(timeout=1800)
self.d.sentry.wait(timeout=1800)
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('spark-test-scale',
charm='spark',
units=3,
constraints={'mem': '7G'})
cls.d.setup(timeout=3600)
cls.d.sentry.wait(timeout=3600)
def setUpClass(cls):
cls.d = amulet.Deployment(series='trusty')
cls.d.add('pdi', 'pentahodataintegration')
cls.d.add('openjdk', 'cs:~kwmonroe/trusty/openjdk')
cls.d.relate('pdi:java', 'openjdk:java')
cls.d.setup(timeout=900)
cls.d.sentry.wait(timeout=1800)
cls.unit = cls.d.sentry['pdi'][0]
cls.d.expose('pdi')
def setUpClass(cls):
cls.d = amulet.Deployment(series='xenial')
cls.d.add('zeppelin-test-config',
charm='zeppelin',
constraints={'mem': '7G'})
cls.d.setup(timeout=1800)
cls.d.sentry.wait_for_messages(
{'zeppelin-test-config': re.compile('ready')}, timeout=1800)
cls.zeppelin = cls.d.sentry['zeppelin-test-config'][0]
