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]