def _setup_mon(ctx, manager, remote, mon, name, data_path, conf_path): # co-locate a new monitor on remote where an existing monitor is hosted cluster = manager.cluster remote.run(args=['sudo', 'mkdir', '-p', data_path]) keyring_path = '/etc/ceph/{cluster}.keyring'.format( cluster=manager.cluster) testdir = teuthology.get_testdir(ctx) monmap_path = '{tdir}/{cluster}.monmap'.format(tdir=testdir, cluster=cluster) manager.raw_cluster_cmd('mon', 'getmap', '-o', monmap_path) if manager.controller != remote: monmap = teuthology.get_file(manager.controller, monmap_path) teuthology.write_file(remote, monmap_path, StringIO(monmap)) remote.run(args=[ 'sudo', 'ceph-mon', '--cluster', cluster, '--mkfs', '-i', mon, '--monmap', monmap_path, '--keyring', keyring_path ]) if manager.controller != remote: teuthology.delete_file(remote, monmap_path) # raw_cluster_cmd() is performed using sudo, so sudo here also. teuthology.delete_file(manager.controller, monmap_path, sudo=True) # update ceph.conf so that the ceph CLI is able to connect to the cluster if conf_path: ip = remote.ip_address port = _get_next_port(ctx, ip, cluster) mon_addr = '{ip}:{port}'.format(ip=ip, port=port) ctx.ceph[cluster].conf[name] = {'mon addr': mon_addr} write_conf(ctx, conf_path, cluster)
def configure(ctx, config): assert isinstance(config, dict) log.info("Configuring testswift...") testdir = teuthology.get_testdir(ctx) for client, properties in config["clients"].iteritems(): log.info("client={c}".format(c=client)) log.info("config={c}".format(c=config)) testswift_conf = config["testswift_conf"][client] if properties is not None and "rgw_server" in properties: host = None for target, roles in zip(ctx.config["targets"].iterkeys(), ctx.config["roles"]): log.info("roles: " + str(roles)) log.info("target: " + str(target)) if properties["rgw_server"] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" testswift_conf["func_test"]["auth_host"] = host else: testswift_conf["func_test"]["auth_host"] = "localhost" log.info(client) (remote,) = ctx.cluster.only(client).remotes.keys() remote.run(args=["cd", "{tdir}/swift".format(tdir=testdir), run.Raw("&&"), "./bootstrap"]) conf_fp = StringIO() testswift_conf.write(conf_fp) teuthology.write_file( remote=remote, path="{tdir}/archive/testswift.{client}.conf".format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) yield
def write_core_site(ctx, config): coreSiteFile = "/tmp/cephtest/hadoop/conf/core-site.xml" hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): # check the config to see if we should use hdfs or ceph default_fs_string = "" if config.get('hdfs'): default_fs_string = 'hdfs://{master_ip}:54310'.format(master_ip=get_hadoop_master_ip(ctx)) else: default_fs_string = 'ceph:///' teuthology.write_file(remote, coreSiteFile, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>hadoop.tmp.dir</name> <value>/tmp/hadoop/tmp</value> </property> <property> <name>fs.default.name</name> <value>{default_fs}</value> </property> <property> <name>ceph.conf.file</name> <value>/tmp/cephtest/ceph.conf</value> </property> </configuration> '''.format(default_fs=default_fs_string)) log.info("wrote file: " + coreSiteFile + " to host: " + str(remote))
def write_mapred_site(ctx): mapredSiteFile = "{tdir}/apache_hadoop/conf/mapred-site.xml".format(tdir=teuthology.get_testdir(ctx)) master_ip = get_hadoop_master_ip(ctx) log.info("adding host {remote} as jobtracker".format(remote=master_ip)) hadoopNodes = ctx.cluster.only(teuthology.is_type("hadoop")) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file( remote, mapredSiteFile, """<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>mapred.job.tracker</name> <value>{remote}:54311</value> </property> </configuration> """.format( remote=master_ip ), ) log.info("wrote file: " + mapredSiteFile + " to host: " + str(remote))
def configure(ctx, config): assert isinstance(config, dict) log.info('Configuring s3-tests...') testdir = teuthology.get_testdir(ctx) for client, properties in config['clients'].iteritems(): s3tests_conf = config['s3tests_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].iterkeys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" s3tests_conf['DEFAULT']['host'] = host else: s3tests_conf['DEFAULT']['host'] = 'localhost' (remote, ) = ctx.cluster.only(client).remotes.keys() remote.run(args=[ 'cd', '{tdir}/s3-tests'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() s3tests_conf.write(conf_fp) teuthology.write_file( remote=remote, path='{tdir}/archive/s3-tests.{client}.conf'.format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) yield
def write_rotate_conf(ctx, daemons): testdir = teuthology.get_testdir(ctx) rotate_conf_path = os.path.join(os.path.dirname(__file__), "logrotate.conf") with file(rotate_conf_path, "rb") as f: conf = "" for daemon, size in daemons.iteritems(): log.info("writing logrotate stanza for {daemon}".format(daemon=daemon)) conf += f.read().format(daemon_type=daemon, max_size=size) f.seek(0, 0) for remote in ctx.cluster.remotes.iterkeys(): teuthology.write_file( remote=remote, path="{tdir}/logrotate.ceph-test.conf".format(tdir=testdir), data=StringIO(conf) ) remote.run( args=[ "sudo", "mv", "{tdir}/logrotate.ceph-test.conf".format(tdir=testdir), "/etc/logrotate.d/ceph-test.conf", run.Raw("&&"), "sudo", "chmod", "0644", "/etc/logrotate.d/ceph-test.conf", run.Raw("&&"), "sudo", "chown", "root.root", "/etc/logrotate.d/ceph-test.conf", ] ) remote.chcon("/etc/logrotate.d/ceph-test.conf", "system_u:object_r:etc_t:s0")
def write_mapred_site(ctx): """ Add required entries to conf/mapred-site.xml """ mapred_site_file = "{tdir}/apache_hadoop/conf/mapred-site.xml".format( tdir=teuthology.get_testdir(ctx)) master_ip = get_hadoop_master_ip(ctx) log.info('adding host {remote} as jobtracker'.format(remote=master_ip)) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file(remote, mapred_site_file, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>mapred.job.tracker</name> <value>{remote}:54311</value> </property> </configuration> '''.format(remote=master_ip)) log.info("wrote file: " + mapred_site_file + " to host: " + str(remote))
def _setup_mon(ctx, manager, remote, mon, name, data_path, conf_path): # co-locate a new monitor on remote where an existing monitor is hosted cluster = manager.cluster remote.run(args=['sudo', 'mkdir', '-p', data_path]) keyring_path = '/etc/ceph/{cluster}.keyring'.format( cluster=manager.cluster) testdir = teuthology.get_testdir(ctx) monmap_path = '{tdir}/{cluster}.monmap'.format(tdir=testdir, cluster=cluster) manager.raw_cluster_cmd('mon', 'getmap', '-o', monmap_path) if manager.controller != remote: monmap = teuthology.get_file(manager.controller, monmap_path) teuthology.write_file(remote, monmap_path, StringIO(monmap)) remote.run( args=[ 'sudo', 'ceph-mon', '--cluster', cluster, '--mkfs', '-i', mon, '--monmap', monmap_path, '--keyring', keyring_path]) if manager.controller != remote: teuthology.delete_file(remote, monmap_path) # raw_cluster_cmd() is performed using sudo, so sudo here also. teuthology.delete_file(manager.controller, monmap_path, sudo=True) # update ceph.conf so that the ceph CLI is able to connect to the cluster if conf_path: ip = remote.ip_address port = _get_next_port(ctx, ip, cluster) mon_addr = '{ip}:{port}'.format(ip=ip, port=port) ctx.ceph[cluster].conf[name] = {'mon addr': mon_addr} write_conf(ctx, conf_path, cluster)
def configure(ctx, config): """ Configure rgw and Swift """ assert isinstance(config, dict) log.info('Configuring testswift...') testdir = teuthology.get_testdir(ctx) for client, testswift_conf in config.iteritems(): (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'cd', '{tdir}/swift'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() testswift_conf.write(conf_fp) teuthology.write_file( remote=remote, path='{tdir}/archive/testswift.{client}.conf'.format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) yield
def write_rotate_conf(ctx, daemons): testdir = teuthology.get_testdir(ctx) rotate_conf_path = os.path.join(os.path.dirname(__file__), 'logrotate.conf') with file(rotate_conf_path, 'rb') as f: conf = "" for daemon, size in daemons.iteritems(): log.info('writing logrotate stanza for {daemon}'.format( daemon=daemon)) conf += f.read().format(daemon_type=daemon, max_size=size) f.seek(0, 0) for remote in ctx.cluster.remotes.iterkeys(): teuthology.write_file( remote=remote, path='{tdir}/logrotate.ceph-test.conf'.format( tdir=testdir), data=StringIO(conf)) remote.run(args=[ 'sudo', 'mv', '{tdir}/logrotate.ceph-test.conf'.format( tdir=testdir), '/etc/logrotate.d/ceph-test.conf', run.Raw('&&'), 'sudo', 'chmod', '0644', '/etc/logrotate.d/ceph-test.conf', run.Raw('&&'), 'sudo', 'chown', 'root.root', '/etc/logrotate.d/ceph-test.conf' ]) remote.chcon('/etc/logrotate.d/ceph-test.conf', 'system_u:object_r:etc_t:s0')
def configure(ctx, config): assert isinstance(config, dict) log.info('Configuring s3-tests...') for client, properties in config['clients'].iteritems(): s3tests_conf = config['s3tests_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].iterkeys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" s3tests_conf['DEFAULT']['host'] = host else: s3tests_conf['DEFAULT']['host'] = 'localhost' (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'cd', '/tmp/cephtest/s3-tests', run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() s3tests_conf.write(conf_fp) teuthology.write_file( remote=remote, path='/tmp/cephtest/archive/s3-tests.{client}.conf'.format(client=client), data=conf_fp.getvalue(), ) yield
def setup_dnsmasq(remote, testdir, cnames): """ configure dnsmasq on the given remote, adding each cname given """ log.info('Configuring dnsmasq on remote %s..', remote.name) # add address entries for each cname dnsmasq = "server=8.8.8.8\nserver=8.8.4.4\n" address_template = "address=/{cname}/{ip_address}\n" for cname, ip_address in cnames.items(): dnsmasq += address_template.format(cname=cname, ip_address=ip_address) # write to temporary dnsmasq file dnsmasq_tmp = '/'.join((testdir, 'ceph.tmp')) misc.write_file(remote, dnsmasq_tmp, dnsmasq) # move into /etc/dnsmasq.d/ dnsmasq_path = '/etc/dnsmasq.d/ceph' remote.run(args=['sudo', 'mv', dnsmasq_tmp, dnsmasq_path]) # restore selinux context if necessary remote.run(args=['sudo', 'restorecon', dnsmasq_path], check_status=False) # restart dnsmasq remote.run(args=['sudo', 'systemctl', 'restart', 'dnsmasq']) # verify dns name is set remote.run(args=['ping', '-c', '4', cnames.keys()[0]]) try: yield finally: log.info('Removing dnsmasq configuration from remote %s..', remote.name) # remove /etc/dnsmasq.d/ceph remote.run(args=['sudo', 'rm', dnsmasq_path]) # restart dnsmasq remote.run(args=['sudo', 'systemctl', 'restart', 'dnsmasq'])
def write_rotate_conf(ctx, daemons): testdir = teuthology.get_testdir(ctx) rotate_conf_path = os.path.join(os.path.dirname(__file__), 'logrotate.conf') with file(rotate_conf_path, 'rb') as f: conf = "" for daemon, size in daemons.iteritems(): log.info('writing logrotate stanza for {daemon}'.format(daemon=daemon)) conf += f.read().format(daemon_type=daemon, max_size=size) f.seek(0, 0) for remote in ctx.cluster.remotes.iterkeys(): teuthology.write_file(remote=remote, path='{tdir}/logrotate.ceph-test.conf'.format(tdir=testdir), data=StringIO(conf) ) remote.run( args=[ 'sudo', 'mv', '{tdir}/logrotate.ceph-test.conf'.format(tdir=testdir), '/etc/logrotate.d/ceph-test.conf', run.Raw('&&'), 'sudo', 'chmod', '0644', '/etc/logrotate.d/ceph-test.conf', run.Raw('&&'), 'sudo', 'chown', 'root.root', '/etc/logrotate.d/ceph-test.conf' ] ) remote.chcon('/etc/logrotate.d/ceph-test.conf', 'system_u:object_r:etc_t:s0')
def write_mapred_site(ctx): """ Add required entries to conf/mapred-site.xml """ mapred_site_file = "{tdir}/apache_hadoop/conf/mapred-site.xml".format( tdir=teuthology.get_testdir(ctx)) master_ip = get_hadoop_master_ip(ctx) log.info('adding host {remote} as jobtracker'.format(remote=master_ip)) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file( remote, mapred_site_file, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>mapred.job.tracker</name> <value>{remote}:54311</value> </property> </configuration> '''.format(remote=master_ip)) log.info("wrote file: " + mapred_site_file + " to host: " + str(remote))
def configure(ctx, config, run_stages): """ Configure the ragweed. This includes the running of the bootstrap code and the updating of local conf files. """ assert isinstance(config, dict) log.info('Configuring ragweed...') testdir = teuthology.get_testdir(ctx) for client, properties in config['clients'].items(): (remote, ) = ctx.cluster.only(client).remotes.keys() remote.run(args=[ 'cd', '{tdir}/ragweed'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) preparing = 'prepare' in run_stages[client] if not preparing: # should have been prepared in a previous run continue ragweed_conf = config['ragweed_conf'][client] if properties is not None and 'slow_backend' in properties: ragweed_conf['fixtures']['slow backend'] = properties[ 'slow_backend'] conf_fp = BytesIO() ragweed_conf.write(conf_fp) teuthology.write_file( remote=remote, path='{tdir}/archive/ragweed.{client}.conf'.format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) log.info('Configuring boto...') boto_src = os.path.join(os.path.dirname(__file__), 'boto.cfg.template') for client, properties in config['clients'].items(): with open(boto_src, 'rb') as f: (remote, ) = ctx.cluster.only(client).remotes.keys() conf = f.read().format(idle_timeout=config.get('idle_timeout', 30)) teuthology.write_file( remote=remote, path='{tdir}/boto.cfg'.format(tdir=testdir), data=conf, ) try: yield finally: log.info('Cleaning up boto...') for client, properties in config['clients'].items(): (remote, ) = ctx.cluster.only(client).remotes.keys() remote.run(args=[ 'rm', '{tdir}/boto.cfg'.format(tdir=testdir), ], )
def write_master(ctx): mastersFile = "/tmp/cephtest/hadoop/conf/masters" master = _get_master(ctx) remote, _ = master hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file(remote, mastersFile, '{remote}\n'.format(remote=remote.ssh.get_transport().getpeername()[0])) log.info("wrote file: " + mastersFile + " to host: " + str(remote))
def replace_resolv(remote, path): """ Update resolv.conf to point the nameserver at localhost. """ misc.write_file(remote, path, "nameserver 127.0.0.1\n") try: # install it remote.run(args=['sudo', 'cp', path, '/etc/resolv.conf']) yield finally: remote.run(args=['rm', path])
def setup(self): super(CBT, self).setup() self.first_mon = self.ctx.cluster.only(misc.get_first_mon(self.ctx, self.config)).remotes.keys()[0] self.cbt_config = self.generate_cbt_config() self.log.info('cbt configuration is %s', self.cbt_config) self.cbt_dir = os.path.join(misc.get_archive_dir(self.ctx), 'cbt') self.ctx.cluster.run(args=['mkdir', '-p', '-m0755', '--', self.cbt_dir]) misc.write_file(self.first_mon, os.path.join(self.cbt_dir, 'cbt_config.yaml'), yaml.safe_dump(self.cbt_config, default_flow_style=False)) self.checkout_cbt() self.install_dependencies()
def write_file(self, path, data, perms=None): """ Write the given data at the given path and set the given perms to the file on the path. """ if path.find(self.hostfs_mntpt) == -1: path = os.path.join(self.hostfs_mntpt, path) write_file(self.client_remote, path, data) if perms: self.run_shell(args=f'chmod {perms} {path}')
def write_master(ctx): mastersFile = "{tdir}/apache_hadoop/conf/masters".format(tdir=teuthology.get_testdir(ctx)) master = _get_master(ctx) master_remote, _ = master hadoopNodes = ctx.cluster.only(teuthology.is_type("hadoop")) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file( remote, mastersFile, "{master_host}\n".format(master_host=master_remote.ssh.get_transport().getpeername()[0]), ) log.info("wrote file: " + mastersFile + " to host: " + str(remote))
def write_master(ctx): mastersFile = "{tdir}/apache_hadoop/conf/masters".format( tdir=teuthology.get_testdir(ctx)) master = _get_master(ctx) master_remote, _ = master hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file( remote, mastersFile, '{master_host}\n'.format(master_host=master_remote.ssh. get_transport().getpeername()[0])) log.info("wrote file: " + mastersFile + " to host: " + str(remote))
def replace_resolv(remote, path): """ Update resolv.conf to point the nameserver at localhost. """ misc.write_file(remote, path, "nameserver 127.0.0.1\n") try: # install it if remote.os.package_type == "rpm": # for centos ovh resolv.conf has immutable attribute set remote.run(args=['sudo', 'chattr', '-i', '/etc/resolv.conf'], check_status=False) remote.run(args=['sudo', 'cp', path, '/etc/resolv.conf']) yield finally: remote.run(args=['rm', path])
def write_master(ctx): """ Add required entries to conf/masters These nodes host JobTrackers and Namenodes """ masters_file = "{tdir}/apache_hadoop/conf/masters".format( tdir=teuthology.get_testdir(ctx)) master = _get_master(ctx) master_remote, _ = master hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file(remote, masters_file, '{master_host}\n'.format( master_host=master_remote.ssh.get_transport().getpeername()[0])) log.info("wrote file: " + masters_file + " to host: " + str(remote))
def _setup_calamari_cluster(remote, restapi_remote): """ Add restapi db entry to the server. """ restapi_hostname = str(restapi_remote).split('@')[1] sqlcmd = 'insert into ceph_cluster (name, api_base_url) ' \ 'values ("{host}", "http://{host}:5000/api/v0.1/");'. \ format(host=restapi_hostname) teuthology.write_file(remote, '/tmp/create.cluster.sql', sqlcmd) return remote.run(args=[ 'cat', '/tmp/create.cluster.sql', run.Raw('|'), 'sudo', 'sqlite3', '/opt/calamari/webapp/calamari/db.sqlite3' ], stdout=StringIO())
def cod_setup_remote_data(log, ctx, remote, NUM_OBJECTS, DATADIR, REP_NAME, DATALINECOUNT): objects = range(1, NUM_OBJECTS + 1) for i in objects: NAME = REP_NAME + "{num}".format(num=i) DDNAME = os.path.join(DATADIR, NAME) remote.run(args=['rm', '-f', DDNAME ]) dataline = range(DATALINECOUNT) data = "This is the replicated data for " + NAME + "\n" DATA = "" for _ in dataline: DATA += data teuthology.write_file(remote, DDNAME, DATA)
def write_hadoop_env(ctx, config): hadoopEnvFile = "/tmp/cephtest/hadoop/conf/hadoop-env.sh" hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file(remote, hadoopEnvFile, '''export JAVA_HOME=/usr/lib/jvm/default-java export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/tmp/cephtest/binary/usr/local/lib:/usr/lib export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/tmp/cephtest/binary/usr/local/lib/libcephfs.jar:/tmp/cephtest/hadoop/build/hadoop-core*.jar export HADOOP_NAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_NAMENODE_OPTS" export HADOOP_SECONDARYNAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_SECONDARYNAMENODE_OPTS" export HADOOP_DATANODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_DATANODE_OPTS" export HADOOP_BALANCER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_BALANCER_OPTS" export HADOOP_JOBTRACKER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_JOBTRACKER_OPTS" ''' ) log.info("wrote file: " + hadoopEnvFile + " to host: " + str(remote))
def cod_setup_remote_data(log, ctx, remote, NUM_OBJECTS, DATADIR, BASE_NAME, DATALINECOUNT): objects = range(1, NUM_OBJECTS + 1) for i in objects: NAME = BASE_NAME + "{num}".format(num=i) DDNAME = os.path.join(DATADIR, NAME) remote.run(args=['rm', '-f', DDNAME]) dataline = range(DATALINECOUNT) data = "This is the data for " + NAME + "\n" DATA = "" for _ in dataline: DATA += data teuthology.write_file(remote, DDNAME, DATA)
def _setup_calamari_cluster(remote, restapi_remote): """ Add restapi db entry to the server. """ restapi_hostname = str(restapi_remote).split('@')[1] sqlcmd = 'insert into ceph_cluster (name, api_base_url) ' \ 'values ("{host}", "http://{host}:5000/api/v0.1/");'. \ format(host=restapi_hostname) teuthology.write_file(remote, '/tmp/create.cluster.sql', sqlcmd) return remote.run(args=['cat', '/tmp/create.cluster.sql', run.Raw('|'), 'sudo', 'sqlite3', '/opt/calamari/webapp/calamari/db.sqlite3'], stdout=StringIO())
def configure(ctx, config): """ Configure the s3-tests. This includes the running of the bootstrap code and the updating of local conf files. """ assert isinstance(config, dict) log.info('Configuring s3-roundtrip-tests...') testdir = teuthology.get_testdir(ctx) for client, properties in config['clients'].iteritems(): s3tests_conf = config['s3tests_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].keys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" s3tests_conf['s3']['host'] = host else: s3tests_conf['s3']['host'] = 'localhost' def_conf = s3tests_conf['DEFAULT'] s3tests_conf['s3'].setdefault('port', def_conf['port']) s3tests_conf['s3'].setdefault('is_secure', def_conf['is_secure']) (remote, ) = ctx.cluster.only(client).remotes.keys() remote.run(args=[ 'cd', '{tdir}/s3-tests'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() conf = dict( s3=s3tests_conf['s3'], roundtrip=s3tests_conf['roundtrip'], ) yaml.safe_dump(conf, conf_fp, default_flow_style=False) teuthology.write_file( remote=remote, path='{tdir}/archive/s3roundtrip.{client}.config.yaml'.format( tdir=testdir, client=client), data=conf_fp.getvalue(), ) yield
def configure(ctx, config): """ Configure the s3-tests. This includes the running of the bootstrap code and the updating of local conf files. """ assert isinstance(config, dict) log.info('Configuring s3-roundtrip-tests...') testdir = teuthology.get_testdir(ctx) for client, properties in config['clients'].iteritems(): s3tests_conf = config['s3tests_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].iterkeys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" s3tests_conf['s3']['host'] = host else: s3tests_conf['s3']['host'] = 'localhost' def_conf = s3tests_conf['DEFAULT'] s3tests_conf['s3'].setdefault('port', def_conf['port']) s3tests_conf['s3'].setdefault('is_secure', def_conf['is_secure']) (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'cd', '{tdir}/s3-tests'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() conf = dict( s3=s3tests_conf['s3'], roundtrip=s3tests_conf['roundtrip'], ) yaml.safe_dump(conf, conf_fp, default_flow_style=False) teuthology.write_file( remote=remote, path='{tdir}/archive/s3roundtrip.{client}.config.yaml'.format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) yield
def write_slaves(ctx): log.info("Setting up slave nodes...") slavesFile = "{tdir}/apache_hadoop/conf/slaves".format(tdir=teuthology.get_testdir(ctx)) tmpFile = StringIO() slaves = ctx.cluster.only(teuthology.is_type("hadoop.slave")) for remote, roles_for_host in slaves.remotes.iteritems(): tmpFile.write("{remote}\n".format(remote=remote.ssh.get_transport().getpeername()[0])) tmpFile.seek(0) hadoopNodes = ctx.cluster.only(teuthology.is_type("hadoop")) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file(remote=remote, path=slavesFile, data=tmpFile) tmpFile.seek(0) log.info("wrote file: " + slavesFile + " to host: " + str(remote))
def write_master(ctx): """ Add required entries to conf/masters These nodes host JobTrackers and Namenodes """ masters_file = "{tdir}/apache_hadoop/conf/masters".format( tdir=teuthology.get_testdir(ctx)) master = _get_master(ctx) master_remote, _ = master hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file( remote, masters_file, '{master_host}\n'.format(master_host=master_remote.ssh. get_transport().getpeername()[0])) log.info("wrote file: " + masters_file + " to host: " + str(remote))
def write_slaves(ctx): log.info('Setting up slave nodes...') slavesFile = "/tmp/cephtest/hadoop/conf/slaves" tmpFile = StringIO() slaves = ctx.cluster.only(teuthology.is_type('hadoop.slave')) for remote, roles_for_host in slaves.remotes.iteritems(): tmpFile.write('{remote}\n'.format(remote=remote.ssh.get_transport().getpeername()[0])) tmpFile.seek(0) hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file(remote=remote, path=slavesFile, data=tmpFile) tmpFile.seek(0) log.info("wrote file: " + slavesFile + " to host: " + str(remote))
def write_hadoop_env(ctx, config): hadoopEnvFile = "{tdir}/apache_hadoop/conf/hadoop-env.sh".format( tdir=teuthology.get_testdir(ctx)) hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file( remote, hadoopEnvFile, '''export JAVA_HOME=/usr/lib/jvm/default-java export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/usr/share/java/libcephfs.jar:{tdir}/apache_hadoop/build/hadoop-core*.jar:{tdir}/inktank_hadoop/build/hadoop-cephfs.jar export HADOOP_NAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_NAMENODE_OPTS" export HADOOP_SECONDARYNAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_SECONDARYNAMENODE_OPTS" export HADOOP_DATANODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_DATANODE_OPTS" export HADOOP_BALANCER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_BALANCER_OPTS" export HADOOP_JOBTRACKER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_JOBTRACKER_OPTS" '''.format(tdir=teuthology.get_testdir(ctx))) log.info("wrote file: " + hadoopEnvFile + " to host: " + str(remote))
def write_hdfs_site(ctx): hdfsSiteFile = "/tmp/cephtest/hadoop/conf/hdfs-site.xml" hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file(remote, hdfsSiteFile, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>dfs.replication</name> <value>1</value> </property> </configuration> ''' ) log.info("wrote file: " + hdfsSiteFile + " to host: " + str(remote))
def write_hdfs_site(ctx): hdfsSiteFile = "{tdir}/apache_hadoop/conf/hdfs-site.xml".format( tdir=teuthology.get_testdir(ctx)) hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file( remote, hdfsSiteFile, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>dfs.replication</name> <value>1</value> </property> </configuration> ''') log.info("wrote file: " + hdfsSiteFile + " to host: " + str(remote))
def write_core_site(ctx, config): """ Add required entries to conf/core-site.xml """ testdir = teuthology.get_testdir(ctx) core_site_file = "{tdir}/apache_hadoop/conf/core-site.xml".format( tdir=testdir) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: # check the config to see if we should use hdfs or ceph default_fs_string = "" if config.get('hdfs'): default_fs_string = 'hdfs://{master_ip}:54310'.format( master_ip=get_hadoop_master_ip(ctx)) else: default_fs_string = 'ceph:///' teuthology.write_file( remote, core_site_file, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>hadoop.tmp.dir</name> <value>/tmp/hadoop/tmp</value> </property> <property> <name>fs.default.name</name> <value>{default_fs}</value> </property> <property> <name>ceph.conf.file</name> <value>/etc/ceph/ceph.conf</value> </property> <property> <name>fs.ceph.impl</name> <value>org.apache.hadoop.fs.ceph.CephFileSystem</value> </property> </configuration> '''.format(tdir=teuthology.get_testdir(ctx), default_fs=default_fs_string)) log.info("wrote file: " + core_site_file + " to host: " + str(remote))
def write_core_site(ctx, config): """ Add required entries to conf/core-site.xml """ testdir = teuthology.get_testdir(ctx) core_site_file = "{tdir}/apache_hadoop/conf/core-site.xml".format( tdir=testdir) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: # check the config to see if we should use hdfs or ceph default_fs_string = "" if config.get('hdfs'): default_fs_string = 'hdfs://{master_ip}:54310'.format( master_ip=get_hadoop_master_ip(ctx)) else: default_fs_string = 'ceph:///' teuthology.write_file(remote, core_site_file, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>hadoop.tmp.dir</name> <value>/tmp/hadoop/tmp</value> </property> <property> <name>fs.default.name</name> <value>{default_fs}</value> </property> <property> <name>ceph.conf.file</name> <value>/etc/ceph/ceph.conf</value> </property> <property> <name>fs.ceph.impl</name> <value>org.apache.hadoop.fs.ceph.CephFileSystem</value> </property> </configuration> '''.format(tdir=teuthology.get_testdir(ctx), default_fs=default_fs_string)) log.info("wrote file: " + core_site_file + " to host: " + str(remote))
def ship_utilities(ctx, config): assert config is None FILES = ['daemon-helper', 'adjust-ulimits', 'chdir-coredump', 'valgrind.supp', 'kcon_most'] testdir = teuthology.get_testdir(ctx) for filename in FILES: log.info('Shipping %r...', filename) src = os.path.join(os.path.dirname(__file__), filename) dst = os.path.join(testdir, filename) with file(src, 'rb') as f: for rem in ctx.cluster.remotes.iterkeys(): teuthology.write_file( remote=rem, path=dst, data=f, ) f.seek(0) rem.run( args=[ 'chmod', 'a=rx', '--', dst, ], ) try: yield finally: log.info('Removing shipped files: %s...', ' '.join(FILES)) filenames = ( os.path.join(testdir, filename) for filename in FILES ) run.wait( ctx.cluster.run( args=[ 'rm', '-rf', '--', ] + list(filenames), wait=False, ), )
def ship_config(ctx, config): assert isinstance(config, list) log.info('Shipping apache config and rgw.fcgi...') src = os.path.join(os.path.dirname(__file__), 'apache.conf') for client in config: (remote,) = ctx.cluster.only(client).remotes.keys() with file(src, 'rb') as f: teuthology.write_file( remote=remote, path='/tmp/cephtest/apache/apache.conf', data=f, ) teuthology.write_file( remote=remote, path='/tmp/cephtest/apache/htdocs/rgw.fcgi', data="""#!/bin/sh ulimit -c unlimited export LD_LIBRARY_PATH=/tmp/cephtest/binary/usr/local/lib exec /tmp/cephtest/binary/usr/local/bin/radosgw -f -c /tmp/cephtest/ceph.conf """ ) remote.run( args=[ 'chmod', 'a=rx', '/tmp/cephtest/apache/htdocs/rgw.fcgi', ], ) try: yield finally: log.info('Removing apache config...') for client in config: ctx.cluster.only(client).run( args=[ 'rm', '-f', '/tmp/cephtest/apache/apache.conf', run.Raw('&&'), 'rm', '-f', '/tmp/cephtest/apache/htdocs/rgw.fcgi', ], )
def write_hadoop_env(ctx): """ Add required entries to conf/hadoop-env.sh """ hadoop_envfile = "{tdir}/apache_hadoop/conf/hadoop-env.sh".format( tdir=teuthology.get_testdir(ctx)) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file(remote, hadoop_envfile, '''export JAVA_HOME=/usr/lib/jvm/default-java export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/usr/share/java/libcephfs.jar:{tdir}/apache_hadoop/build/hadoop-core*.jar:{tdir}/inktank_hadoop/build/hadoop-cephfs.jar export HADOOP_NAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_NAMENODE_OPTS" export HADOOP_SECONDARYNAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_SECONDARYNAMENODE_OPTS" export HADOOP_DATANODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_DATANODE_OPTS" export HADOOP_BALANCER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_BALANCER_OPTS" export HADOOP_JOBTRACKER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_JOBTRACKER_OPTS" '''.format(tdir=teuthology.get_testdir(ctx))) log.info("wrote file: " + hadoop_envfile + " to host: " + str(remote))
def write_slaves(ctx): log.info('Setting up slave nodes...') slavesFile = "{tdir}/apache_hadoop/conf/slaves".format( tdir=teuthology.get_testdir(ctx)) tmpFile = StringIO() slaves = ctx.cluster.only(teuthology.is_type('hadoop.slave')) for remote, roles_for_host in slaves.remotes.iteritems(): tmpFile.write('{remote}\n'.format( remote=remote.ssh.get_transport().getpeername()[0])) tmpFile.seek(0) hadoopNodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file(remote=remote, path=slavesFile, data=tmpFile) tmpFile.seek(0) log.info("wrote file: " + slavesFile + " to host: " + str(remote))
def ship_utilities(ctx, config): assert config is None FILES = ['daemon-helper', 'enable-coredump'] for filename in FILES: log.info('Shipping %r...', filename) src = os.path.join(os.path.dirname(__file__), filename) dst = os.path.join('/tmp/cephtest', filename) with file(src, 'rb') as f: for rem in ctx.cluster.remotes.iterkeys(): teuthology.write_file( remote=rem, path=dst, data=f, ) f.seek(0) rem.run( args=[ 'chmod', 'a=rx', '--', dst, ], ) try: yield finally: log.info('Removing shipped files: %s...', ' '.join(FILES)) filenames = ( os.path.join('/tmp/cephtest', filename) for filename in FILES ) run.wait( ctx.cluster.run( args=[ 'rm', '-rf', '--', ] + list(filenames), wait=False, ), )
def write_hadoop_env(ctx, config): hadoopEnvFile = "{tdir}/apache_hadoop/conf/hadoop-env.sh".format(tdir=teuthology.get_testdir(ctx)) hadoopNodes = ctx.cluster.only(teuthology.is_type("hadoop")) for remote, roles_for_host in hadoopNodes.remotes.iteritems(): teuthology.write_file( remote, hadoopEnvFile, """export JAVA_HOME=/usr/lib/jvm/default-java export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/usr/share/java/libcephfs.jar:{tdir}/apache_hadoop/build/hadoop-core*.jar:{tdir}/inktank_hadoop/build/hadoop-cephfs.jar export HADOOP_NAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_NAMENODE_OPTS" export HADOOP_SECONDARYNAMENODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_SECONDARYNAMENODE_OPTS" export HADOOP_DATANODE_OPTS="-Dcom.sun.management.jmxremote $HADOOP_DATANODE_OPTS" export HADOOP_BALANCER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_BALANCER_OPTS" export HADOOP_JOBTRACKER_OPTS="-Dcom.sun.management.jmxremote $HADOOP_JOBTRACKER_OPTS" """.format( tdir=teuthology.get_testdir(ctx) ), ) log.info("wrote file: " + hadoopEnvFile + " to host: " + str(remote))
def configure(ctx, config): """ Configure rgw and Swift """ assert isinstance(config, dict) log.info('Configuring testswift...') testdir = teuthology.get_testdir(ctx) for client, properties in config['clients'].iteritems(): log.info('client={c}'.format(c=client)) log.info('config={c}'.format(c=config)) testswift_conf = config['testswift_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].iterkeys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" testswift_conf['func_test']['auth_host'] = host else: testswift_conf['func_test']['auth_host'] = 'localhost' log.info(client) (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'cd', '{tdir}/swift'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() testswift_conf.write(conf_fp) teuthology.write_file( remote=remote, path='{tdir}/archive/testswift.{client}.conf'.format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) yield
def write_hdfs_site(ctx): """ Add required entries to conf/hdfs-site.xml """ hdfs_site_file = "{tdir}/apache_hadoop/conf/hdfs-site.xml".format( tdir=teuthology.get_testdir(ctx)) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file(remote, hdfs_site_file, '''<?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href="configuration.xsl"?> <!-- Put site-specific property overrides in this file. --> <configuration> <property> <name>dfs.replication</name> <value>1</value> </property> </configuration> ''') log.info("wrote file: " + hdfs_site_file + " to host: " + str(remote))
def _write_cfg_file(self, cfg_dict, client): """ To write the final s3 tests config file on the remote a temporary one is created on the local machine """ testdir = teuthology.get_testdir(self.ctx) (remote, ) = self.ctx.cluster.only(client).remotes.keys() with open('s3_tests_tmp.yaml', 'w') as outfile: yaml.dump(cfg_dict, outfile, default_flow_style=False) conf_fp = StringIO() with open('s3_tests_tmp.yaml', 'r') as infile: for line in infile: conf_fp.write(line) teuthology.write_file( remote=remote, path='{tdir}/archive/s3-tests-java.{client}.conf'.format( tdir=testdir, client=client), data=conf_fp.getvalue(), ) os.remove('s3_tests_tmp.yaml')
def ship_config(ctx, config): assert isinstance(config, list) log.info('Shipping apache config and rgw.fcgi...') src = os.path.join(os.path.dirname(__file__), 'apache.conf') for client in config: (remote, ) = ctx.cluster.only(client).remotes.keys() with file(src, 'rb') as f: teuthology.write_file( remote=remote, path='/tmp/cephtest/apache/apache.conf', data=f, ) teuthology.write_file(remote=remote, path='/tmp/cephtest/apache/htdocs/rgw.fcgi', data="""#!/bin/sh ulimit -c unlimited export LD_LIBRARY_PATH=/tmp/cephtest/binary/usr/local/lib exec /tmp/cephtest/binary/usr/local/bin/radosgw -f -c /tmp/cephtest/ceph.conf """) remote.run(args=[ 'chmod', 'a=rx', '/tmp/cephtest/apache/htdocs/rgw.fcgi', ], ) try: yield finally: log.info('Removing apache config...') for client in config: ctx.cluster.only(client).run(args=[ 'rm', '-f', '/tmp/cephtest/apache/apache.conf', run.Raw('&&'), 'rm', '-f', '/tmp/cephtest/apache/htdocs/rgw.fcgi', ], )
def write_slaves(ctx): """ Add required entries to conf/slaves These nodes host TaskTrackers and DataNodes """ log.info('Setting up slave nodes...') slaves_file = "{tdir}/apache_hadoop/conf/slaves".format( tdir=teuthology.get_testdir(ctx)) tmp_file = StringIO() slaves = ctx.cluster.only(teuthology.is_type('hadoop.slave')) for remote in slaves.remotes: tmp_file.write('{remote}\n'.format( remote=remote.ssh.get_transport().getpeername()[0])) tmp_file.seek(0) hadoop_nodes = ctx.cluster.only(teuthology.is_type('hadoop')) for remote in hadoop_nodes.remotes: teuthology.write_file(remote=remote, path=slaves_file, data=tmp_file) tmp_file.seek(0) log.info("wrote file: " + slaves_file + " to host: " + str(remote))
def configure(ctx, config): assert isinstance(config, dict) log.info('Configuring testswift...') for client, properties in config['clients'].iteritems(): print 'client={c}'.format(c=client) print 'config={c}'.format(c=config) testswift_conf = config['testswift_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].iterkeys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" testswift_conf['func_test']['auth_host'] = host else: testswift_conf['func_test']['auth_host'] = 'localhost' print client (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'cd', '/tmp/cephtest/swift', run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() testswift_conf.write(conf_fp) teuthology.write_file( remote=remote, path='/tmp/cephtest/archive/testswift.{client}.conf'.format(client=client), data=conf_fp.getvalue(), ) yield
def configure(ctx, config): assert isinstance(config, dict) log.info("Configuring s3-readwrite-tests...") for client, properties in config["clients"].iteritems(): s3tests_conf = config["s3tests_conf"][client] if properties is not None and "rgw_server" in properties: host = None for target, roles in zip(ctx.config["targets"].iterkeys(), ctx.config["roles"]): log.info("roles: " + str(roles)) log.info("target: " + str(target)) if properties["rgw_server"] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" s3tests_conf["s3"]["host"] = host else: s3tests_conf["s3"]["host"] = "localhost" def_conf = s3tests_conf["DEFAULT"] s3tests_conf["s3"].setdefault("port", def_conf["port"]) s3tests_conf["s3"].setdefault("is_secure", def_conf["is_secure"]) (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=["cd", "{tdir}/s3-tests".format(tdir=teuthology.get_testdir(ctx)), run.Raw("&&"), "./bootstrap"] ) conf_fp = StringIO() conf = dict(s3=s3tests_conf["s3"], readwrite=s3tests_conf["readwrite"]) yaml.safe_dump(conf, conf_fp, default_flow_style=False) teuthology.write_file( remote=remote, path="{tdir}/archive/s3readwrite.{client}.config.yaml".format( tdir=teuthology.get_testdir(ctx), client=client ), data=conf_fp.getvalue(), ) yield
def ceph_bootstrap(ctx, config): cluster_name = config['cluster'] testdir = teuthology.get_testdir(ctx) fsid = ctx.ceph[cluster_name].fsid bootstrap_remote = ctx.ceph[cluster_name].bootstrap_remote first_mon = ctx.ceph[cluster_name].first_mon first_mon_role = ctx.ceph[cluster_name].first_mon_role mons = ctx.ceph[cluster_name].mons ctx.cluster.run(args=[ 'sudo', 'mkdir', '-p', '/etc/ceph', ]); ctx.cluster.run(args=[ 'sudo', 'chmod', '777', '/etc/ceph', ]); add_mirror_to_cluster(ctx, config.get('docker_registry_mirror', 'vossi04.front.sepia.ceph.com:5000')) try: # write seed config log.info('Writing seed config...') conf_fp = BytesIO() seed_config = build_initial_config(ctx, config) seed_config.write(conf_fp) teuthology.write_file( remote=bootstrap_remote, path='{}/seed.{}.conf'.format(testdir, cluster_name), data=conf_fp.getvalue()) log.debug('Final config:\n' + conf_fp.getvalue().decode()) ctx.ceph[cluster_name].conf = seed_config # register initial daemons ctx.daemons.register_daemon( bootstrap_remote, 'mon', first_mon, cluster=cluster_name, fsid=fsid, logger=log.getChild('mon.' + first_mon), wait=False, started=True, ) if not ctx.ceph[cluster_name].roleless: first_mgr = ctx.ceph[cluster_name].first_mgr ctx.daemons.register_daemon( bootstrap_remote, 'mgr', first_mgr, cluster=cluster_name, fsid=fsid, logger=log.getChild('mgr.' + first_mgr), wait=False, started=True, ) # bootstrap log.info('Bootstrapping...') cmd = [ 'sudo', ctx.cephadm, '--image', ctx.ceph[cluster_name].image, '-v', 'bootstrap', '--fsid', fsid, '--config', '{}/seed.{}.conf'.format(testdir, cluster_name), '--output-config', '/etc/ceph/{}.conf'.format(cluster_name), '--output-keyring', '/etc/ceph/{}.client.admin.keyring'.format(cluster_name), '--output-pub-ssh-key', '{}/{}.pub'.format(testdir, cluster_name), ] if not ctx.ceph[cluster_name].roleless: cmd += [ '--mon-id', first_mon, '--mgr-id', first_mgr, '--orphan-initial-daemons', # we will do it explicitly! '--skip-monitoring-stack', # we'll provision these explicitly ] if mons[first_mon_role].startswith('['): cmd += ['--mon-addrv', mons[first_mon_role]] else: cmd += ['--mon-ip', mons[first_mon_role]] if config.get('skip_dashboard'): cmd += ['--skip-dashboard'] # bootstrap makes the keyring root 0600, so +r it for our purposes cmd += [ run.Raw('&&'), 'sudo', 'chmod', '+r', '/etc/ceph/{}.client.admin.keyring'.format(cluster_name), ] bootstrap_remote.run(args=cmd) # fetch keys and configs log.info('Fetching config...') ctx.ceph[cluster_name].config_file = teuthology.get_file( remote=bootstrap_remote, path='/etc/ceph/{}.conf'.format(cluster_name)) log.info('Fetching client.admin keyring...') ctx.ceph[cluster_name].admin_keyring = teuthology.get_file( remote=bootstrap_remote, path='/etc/ceph/{}.client.admin.keyring'.format(cluster_name)) log.info('Fetching mon keyring...') ctx.ceph[cluster_name].mon_keyring = teuthology.get_file( remote=bootstrap_remote, path='/var/lib/ceph/%s/mon.%s/keyring' % (fsid, first_mon), sudo=True) # fetch ssh key, distribute to additional nodes log.info('Fetching pub ssh key...') ssh_pub_key = teuthology.get_file( remote=bootstrap_remote, path='{}/{}.pub'.format(testdir, cluster_name) ).decode('ascii').strip() log.info('Installing pub ssh key for root users...') ctx.cluster.run(args=[ 'sudo', 'install', '-d', '-m', '0700', '/root/.ssh', run.Raw('&&'), 'echo', ssh_pub_key, run.Raw('|'), 'sudo', 'tee', '-a', '/root/.ssh/authorized_keys', run.Raw('&&'), 'sudo', 'chmod', '0600', '/root/.ssh/authorized_keys', ]) # set options _shell(ctx, cluster_name, bootstrap_remote, ['ceph', 'config', 'set', 'mgr', 'mgr/cephadm/allow_ptrace', 'true']) # add other hosts for remote in ctx.cluster.remotes.keys(): if remote == bootstrap_remote: continue log.info('Writing (initial) conf and keyring to %s' % remote.shortname) teuthology.write_file( remote=remote, path='/etc/ceph/{}.conf'.format(cluster_name), data=ctx.ceph[cluster_name].config_file) teuthology.write_file( remote=remote, path='/etc/ceph/{}.client.admin.keyring'.format(cluster_name), data=ctx.ceph[cluster_name].admin_keyring) log.info('Adding host %s to orchestrator...' % remote.shortname) _shell(ctx, cluster_name, remote, [ 'ceph', 'orch', 'host', 'add', remote.shortname ]) r = _shell(ctx, cluster_name, remote, ['ceph', 'orch', 'host', 'ls', '--format=json'], stdout=StringIO()) hosts = [node['hostname'] for node in json.loads(r.stdout.getvalue())] assert remote.shortname in hosts yield finally: log.info('Cleaning up testdir ceph.* files...') ctx.cluster.run(args=[ 'rm', '-f', '{}/seed.{}.conf'.format(testdir, cluster_name), '{}/{}.pub'.format(testdir, cluster_name), ]) log.info('Stopping all daemons...') # this doesn't block until they are all stopped... #ctx.cluster.run(args=['sudo', 'systemctl', 'stop', 'ceph.target']) # so, stop them individually for role in ctx.daemons.resolve_role_list(None, CEPH_ROLE_TYPES): cluster, type_, id_ = teuthology.split_role(role) ctx.daemons.get_daemon(type_, id_, cluster).stop() # clean up /etc/ceph ctx.cluster.run(args=[ 'sudo', 'rm', '-f', '/etc/ceph/{}.conf'.format(cluster_name), '/etc/ceph/{}.client.admin.keyring'.format(cluster_name), ])
def configure(ctx, config, hadoops): tempdir = teuthology.get_testdir(ctx) log.info("Writing Hadoop slaves file...") for remote in hadoops.remotes: path, data = get_slaves_data(ctx) teuthology.write_file(remote, path, StringIO(data)) log.info("Writing Hadoop masters file...") for remote in hadoops.remotes: path, data = get_masters_data(ctx) teuthology.write_file(remote, path, StringIO(data)) log.info("Writing Hadoop core-site.xml file...") for remote in hadoops.remotes: path, data = get_core_site_data(ctx, config) teuthology.write_file(remote, path, StringIO(data)) log.info("Writing Hadoop yarn-site.xml file...") for remote in hadoops.remotes: path, data = get_yarn_site_data(ctx) teuthology.write_file(remote, path, StringIO(data)) log.info("Writing Hadoop hdfs-site.xml file...") for remote in hadoops.remotes: path, data = get_hdfs_site_data(ctx) teuthology.write_file(remote, path, StringIO(data)) log.info("Writing Hadoop mapred-site.xml file...") for remote in hadoops.remotes: path, data = get_mapred_site_data(ctx) teuthology.write_file(remote, path, StringIO(data)) log.info("Setting JAVA_HOME in hadoop-env.sh...") for remote in hadoops.remotes: path = "{tdir}/hadoop/etc/hadoop/hadoop-env.sh".format(tdir=tempdir) if remote.os.package_type == 'rpm': data = "JAVA_HOME=/usr/lib/jvm/java\n" elif remote.os.package_type == 'deb': data = "JAVA_HOME=/usr/lib/jvm/default-java\n" else: raise UnsupportedPackageTypeError(remote) teuthology.prepend_lines_to_file(remote, path, data) if config.get('hdfs', False): log.info("Formatting HDFS...") testdir = teuthology.get_testdir(ctx) hadoop_dir = "{tdir}/hadoop/".format(tdir=testdir) masters = ctx.cluster.only(teuthology.is_type('hadoop.master')) assert len(masters.remotes) == 1 master = masters.remotes.keys()[0] master.run( args=[hadoop_dir + "bin/hadoop", "namenode", "-format"], wait=True, )
def configure_s3a(client, dns_name, access_key, secret_key, bucket_name, testdir): """ Use the template to configure s3a test, Fill in access_key, secret_key and other details required for test. """ config_template = """<configuration> <property> <name>fs.s3a.endpoint</name> <value>{name}</value> </property> <property> <name>fs.s3a.connection.ssl.enabled</name> <value>false</value> </property> <property> <name>test.fs.s3n.name</name> <value>s3n://{bucket_name}/</value> </property> <property> <name>test.fs.s3a.name</name> <value>s3a://{bucket_name}/</value> </property> <property> <name>test.fs.s3.name</name> <value>s3://{bucket_name}/</value> </property> <property> <name>fs.s3.awsAccessKeyId</name> <value>{access_key}</value> </property> <property> <name>fs.s3.awsSecretAccessKey</name> <value>{secret_key}</value> </property> <property> <name>fs.s3n.awsAccessKeyId</name> <value>{access_key}</value> </property> <property> <name>fs.s3n.awsSecretAccessKey</name> <value>{secret_key}</value> </property> <property> <name>fs.s3a.access.key</name> <description>AWS access key ID. Omit for Role-based authentication.</description> <value>{access_key}</value> </property> <property> <name>fs.s3a.secret.key</name> <description>AWS secret key. Omit for Role-based authentication.</description> <value>{secret_key}</value> </property> </configuration> """.format(name=dns_name, bucket_name=bucket_name, access_key=access_key, secret_key=secret_key) config_path = testdir + '/hadoop/hadoop-tools/hadoop-aws/src/test/resources/auth-keys.xml' misc.write_file( remote=client, path=config_path, data=config_template, ) # output for debug client.run(args=['cat', config_path])
def task(ctx, config): """ Setup MPI and execute commands Example that starts an MPI process on specific clients:: tasks: - ceph: - ceph-fuse: [client.0, client.1] - ssh_keys: - mpi: nodes: [client.0, client.1] exec: ior ... Example that starts MPI processes on all clients:: tasks: - ceph: - ceph-fuse: - ssh_keys: - mpi: exec: ior ... Example that starts MPI processes on all roles:: tasks: - ceph: - ssh_keys: - mpi: nodes: all exec: ... Example that specifies a working directory for MPI processes: tasks: - ceph: - ceph-fuse: - pexec: clients: - ln -s {testdir}/mnt.* {testdir}/gmnt - ssh_keys: - mpi: exec: fsx-mpi workdir: {testdir}/gmnt - pexec: clients: - rm -f {testdir}/gmnt :param ctx: Context :param config: Configuration """ assert isinstance(config, dict), 'task mpi got invalid config' assert 'exec' in config, 'task mpi got invalid config, missing exec' testdir = teuthology.get_testdir(ctx) mpiexec = config['exec'].replace('$TESTDIR', testdir) hosts = [] remotes = [] master_remote = None if 'nodes' in config: if isinstance(config['nodes'], basestring) and config['nodes'] == 'all': for role in teuthology.all_roles(ctx.cluster): (remote,) = ctx.cluster.only(role).remotes.iterkeys() ip,port = remote.ssh.get_transport().getpeername() hosts.append(ip) remotes.append(remote) (master_remote,) = ctx.cluster.only(config['nodes'][0]).remotes.iterkeys() elif isinstance(config['nodes'], list): for role in config['nodes']: (remote,) = ctx.cluster.only(role).remotes.iterkeys() ip,port = remote.ssh.get_transport().getpeername() hosts.append(ip) remotes.append(remote) (master_remote,) = ctx.cluster.only(config['nodes'][0]).remotes.iterkeys() else: roles = ['client.{id}'.format(id=id_) for id_ in teuthology.all_roles_of_type(ctx.cluster, 'client')] (master_remote,) = ctx.cluster.only(roles[0]).remotes.iterkeys() for role in roles: (remote,) = ctx.cluster.only(role).remotes.iterkeys() ip,port = remote.ssh.get_transport().getpeername() hosts.append(ip) remotes.append(remote) workdir = [] if 'workdir' in config: workdir = ['-wdir', config['workdir'].replace('$TESTDIR', testdir) ] log.info('mpi rank 0 is: {name}'.format(name=master_remote.name)) # write out the mpi hosts file log.info('mpi nodes: [%s]' % (', '.join(hosts))) teuthology.write_file(remote=master_remote, path='{tdir}/mpi-hosts'.format(tdir=testdir), data='\n'.join(hosts)) log.info('mpiexec on {name}: {cmd}'.format(name=master_remote.name, cmd=mpiexec)) args=['mpiexec', '-f', '{tdir}/mpi-hosts'.format(tdir=testdir)] args.extend(workdir) args.extend(mpiexec.split(' ')) master_remote.run(args=args, ) log.info('mpi task completed') master_remote.run(args=['rm', '{tdir}/mpi-hosts'.format(tdir=testdir)])
def ceph_bootstrap(ctx, config): cluster_name = config['cluster'] testdir = teuthology.get_testdir(ctx) fsid = ctx.ceph[cluster_name].fsid mons = ctx.ceph[cluster_name].mons first_mon_role = sorted(mons.keys())[0] _, _, first_mon = teuthology.split_role(first_mon_role) (bootstrap_remote, ) = ctx.cluster.only(first_mon_role).remotes.keys() log.info('First mon is mon.%s on %s' % (first_mon, bootstrap_remote.shortname)) ctx.ceph[cluster_name].bootstrap_remote = bootstrap_remote ctx.ceph[cluster_name].first_mon = first_mon others = ctx.cluster.remotes[bootstrap_remote] log.info('others %s' % others) mgrs = sorted( [r for r in others if teuthology.is_type('mgr', cluster_name)(r)]) if not mgrs: raise RuntimeError('no mgrs on the same host as first mon %s' % first_mon) _, _, first_mgr = teuthology.split_role(mgrs[0]) log.info('First mgr is %s' % (first_mgr)) ctx.ceph[cluster_name].first_mgr = first_mgr try: # write seed config log.info('Writing seed config...') conf_fp = StringIO() seed_config = build_initial_config(ctx, config) seed_config.write(conf_fp) teuthology.write_file(remote=bootstrap_remote, path='{}/seed.{}.conf'.format( testdir, cluster_name), data=conf_fp.getvalue()) log.debug('Final config:\n' + conf_fp.getvalue()) ctx.ceph[cluster_name].conf = seed_config # register initial daemons ctx.daemons.register_daemon( bootstrap_remote, 'mon', first_mon, cluster=cluster_name, fsid=fsid, logger=log.getChild('mon.' + first_mon), wait=False, started=True, ) ctx.daemons.register_daemon( bootstrap_remote, 'mgr', first_mgr, cluster=cluster_name, fsid=fsid, logger=log.getChild('mgr.' + first_mgr), wait=False, started=True, ) # bootstrap log.info('Bootstrapping...') cmd = [ 'sudo', ctx.cephadm, '--image', ctx.ceph[cluster_name].image, 'bootstrap', '--fsid', fsid, '--mon-id', first_mon, '--mgr-id', first_mgr, '--config', '{}/seed.{}.conf'.format(testdir, cluster_name), '--output-config', '{}/{}.conf'.format(testdir, cluster_name), '--output-keyring', '{}/{}.keyring'.format(testdir, cluster_name), '--output-pub-ssh-key', '{}/{}.pub'.format(testdir, cluster_name), ] if mons[first_mon_role].startswith('['): cmd += ['--mon-addrv', mons[first_mon_role]] else: cmd += ['--mon-ip', mons[first_mon_role]] if config.get('skip_dashboard'): cmd += ['--skip-dashboard'] # bootstrap makes the keyring root 0600, so +r it for our purposes cmd += [ run.Raw('&&'), 'sudo', 'chmod', '+r', '{}/{}.keyring'.format(testdir, cluster_name), ] bootstrap_remote.run(args=cmd) # fetch keys and configs log.info('Fetching config...') ctx.ceph[cluster_name].config_file = teuthology.get_file( remote=bootstrap_remote, path='{}/{}.conf'.format(testdir, cluster_name)) log.info('Fetching client.admin keyring...') ctx.ceph[cluster_name].admin_keyring = teuthology.get_file( remote=bootstrap_remote, path='{}/{}.keyring'.format(testdir, cluster_name)) log.info('Fetching mon keyring...') ctx.ceph[cluster_name].mon_keyring = teuthology.get_file( remote=bootstrap_remote, path='/var/lib/ceph/%s/mon.%s/keyring' % (fsid, first_mon), sudo=True) # fetch ssh key, distribute to additional nodes log.info('Fetching pub ssh key...') ssh_pub_key = teuthology.get_file(remote=bootstrap_remote, path='{}/{}.pub'.format( testdir, cluster_name)).strip() log.info('Installing pub ssh key for root users...') ctx.cluster.run(args=[ 'sudo', 'install', '-d', '-m', '0700', '/root/.ssh', run.Raw('&&'), 'echo', ssh_pub_key, run.Raw('|'), 'sudo', 'tee', '-a', '/root/.ssh/authorized_keys', run.Raw('&&'), 'sudo', 'chmod', '0600', '/root/.ssh/authorized_keys', ]) # add other hosts for remote in ctx.cluster.remotes.keys(): if remote == bootstrap_remote: continue log.info('Writing conf and keyring to %s' % remote.shortname) teuthology.write_file(remote=remote, path='{}/{}.conf'.format( testdir, cluster_name), data=ctx.ceph[cluster_name].config_file) teuthology.write_file(remote=remote, path='{}/{}.keyring'.format( testdir, cluster_name), data=ctx.ceph[cluster_name].admin_keyring) log.info('Adding host %s to orchestrator...' % remote.shortname) _shell(ctx, cluster_name, remote, ['ceph', 'orch', 'host', 'add', remote.shortname]) r = _shell(ctx, cluster_name, remote, ['ceph', 'orch', 'host', 'ls', '--format=json'], stdout=StringIO()) hosts = [node['host'] for node in json.loads(r.stdout.getvalue())] assert remote.shortname in hosts yield finally: log.info('Cleaning up testdir ceph.* files...') ctx.cluster.run(args=[ 'rm', '-f', '{}/seed.{}.conf'.format(testdir, cluster_name), '{}/{}.pub'.format(testdir, cluster_name), '{}/{}.conf'.format(testdir, cluster_name), '{}/{}.keyring'.format(testdir, cluster_name), ]) log.info('Stopping all daemons...') # this doesn't block until they are all stopped... #ctx.cluster.run(args=['sudo', 'systemctl', 'stop', 'ceph.target']) # so, stop them individually for role in ctx.daemons.resolve_role_list(None, CEPH_ROLE_TYPES): cluster, type_, id_ = teuthology.split_role(role) ctx.daemons.get_daemon(type_, id_, cluster).stop()
def configure(ctx, config): """ Configure the s3-tests. This includes the running of the bootstrap code and the updating of local conf files. """ assert isinstance(config, dict) log.info('Configuring s3-tests...') testdir = teuthology.get_testdir(ctx) for client, properties in config['clients'].iteritems(): s3tests_conf = config['s3tests_conf'][client] if properties is not None and 'rgw_server' in properties: host = None for target, roles in zip(ctx.config['targets'].iterkeys(), ctx.config['roles']): log.info('roles: ' + str(roles)) log.info('target: ' + str(target)) if properties['rgw_server'] in roles: _, host = split_user(target) assert host is not None, "Invalid client specified as the rgw_server" s3tests_conf['DEFAULT']['host'] = host else: s3tests_conf['DEFAULT']['host'] = 'localhost' if properties is not None and 'slow_backend' in properties: s3tests_conf['fixtures']['slow backend'] = properties['slow_backend'] (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'cd', '{tdir}/s3-tests'.format(tdir=testdir), run.Raw('&&'), './bootstrap', ], ) conf_fp = StringIO() s3tests_conf.write(conf_fp) teuthology.write_file( remote=remote, path='{tdir}/archive/s3-tests.{client}.conf'.format(tdir=testdir, client=client), data=conf_fp.getvalue(), ) log.info('Configuring boto...') boto_src = os.path.join(os.path.dirname(__file__), 'boto.cfg.template') for client, properties in config['clients'].iteritems(): with file(boto_src, 'rb') as f: (remote,) = ctx.cluster.only(client).remotes.keys() conf = f.read().format( idle_timeout=config.get('idle_timeout', 30) ) teuthology.write_file( remote=remote, path='{tdir}/boto.cfg'.format(tdir=testdir), data=conf, ) try: yield finally: log.info('Cleaning up boto...') for client, properties in config['clients'].iteritems(): (remote,) = ctx.cluster.only(client).remotes.keys() remote.run( args=[ 'rm', '{tdir}/boto.cfg'.format(tdir=testdir), ], )
def ship_apache_configs(ctx, config, role_endpoints): """ Ship apache config and rgw.fgci to all clients. Clean up on termination """ assert isinstance(config, dict) assert isinstance(role_endpoints, dict) testdir = teuthology.get_testdir(ctx) log.info('Shipping apache config and rgw.fcgi...') src = os.path.join(os.path.dirname(__file__), 'apache.conf.template') for client, conf in config.iteritems(): (remote, ) = ctx.cluster.only(client).remotes.keys() system_type = teuthology.get_system_type(remote) if not conf: conf = {} idle_timeout = conf.get('idle_timeout', 30) if system_type == 'deb': mod_path = '/usr/lib/apache2/modules' print_continue = 'on' else: mod_path = '/usr/lib64/httpd/modules' print_continue = 'off' host, port = role_endpoints[client] with file(src, 'rb') as f: conf = f.read().format( testdir=testdir, mod_path=mod_path, print_continue=print_continue, host=host, port=port, client=client, idle_timeout=idle_timeout, ) teuthology.write_file( remote=remote, path='{tdir}/apache/apache.{client}.conf'.format( tdir=testdir, client=client), data=conf, ) teuthology.write_file( remote=remote, path='{tdir}/apache/htdocs.{client}/rgw.fcgi'.format( tdir=testdir, client=client), data="""#!/bin/sh ulimit -c unlimited exec radosgw -f -n {client} -k /etc/ceph/ceph.{client}.keyring --rgw-socket-path {tdir}/apache/tmp.{client}/fastcgi_sock/rgw_sock """.format(tdir=testdir, client=client)) remote.run(args=[ 'chmod', 'a=rx', '{tdir}/apache/htdocs.{client}/rgw.fcgi'.format(tdir=testdir, client=client), ], ) try: yield finally: log.info('Removing apache config...') for client in config.iterkeys(): ctx.cluster.only(client).run(args=[ 'rm', '-f', '{tdir}/apache/apache.{client}.conf'.format(tdir=testdir, client=client), run.Raw('&&'), 'rm', '-f', '{tdir}/apache/htdocs.{client}/rgw.fcgi'.format(tdir=testdir, client=client), ], )