def configure_puppet(self, rhel_repo=None): """Configures puppet on the virtual machine/Host. :param rhel_repo: Red Hat repository link from properties file. :return: None. """ sat6_hostname = conf.properties['main.server.hostname'] self.configure_rhel_repo(rhel_repo) puppet_conf = ( 'pluginsync = true\n' 'report = true\n' 'ignoreschedules = true\n' 'daemon = false\n' 'ca_server = {0}\n' 'server = {1}\n' .format(sat6_hostname, sat6_hostname) ) result = self.run(u'yum install puppet -y') if result.return_code != 0: raise VirtualMachineError( 'Failed to install the puppet rpm') self.run( 'echo "{0}" >> /etc/puppet/puppet.conf' .format(puppet_conf) ) # This particular puppet run on client would populate a cert on sat6 # under the capsule --> certifcates or via cli "puppet cert list", so # that we sign it. self.run(u'puppet agent -t') ssh.command(u'puppet cert sign --all') # This particular puppet run would create the host entity under # 'All Hosts' and let's redirect stderr to /dev/null as errors at this # stage can be ignored. self.run(u'puppet agent -t 2> /dev/null')
def default_url_on_new_port(oldport, newport): """Creates context where the default smart-proxy is forwarded on a new port :param int oldport: Port to be forwarded. :param int newport: New port to be used to forward `oldport`. :return: A string containing the new capsule URL with port. :rtype: str """ logger = logging.getLogger('robottelo') domain = conf.properties['main.server.hostname'] user = conf.properties['main.server.ssh.username'] key = conf.properties['main.server.ssh.key_private'] ssh.upload_file(key, '/tmp/dsa_{0}'.format(newport)) ssh.command('chmod 700 /tmp/dsa_{0}'.format(newport)) with ssh._get_connection() as connection: command = u'ssh -i {0} -L {1}:{2}:{3} {4}@{5}'.format( '/tmp/dsa_{0}'.format(newport), newport, domain, oldport, user, domain) logger.debug('Creating tunnel {0}'.format(command)) # Run command and timeout in 30 seconds. _, _, stderr = connection.exec_command(command, 30) stderr = stderr.read() if len(stderr) > 0: logger.debug('Tunnel failed: {0}'.format(stderr)) # Something failed, so raise an exception. raise SSHTunnelError(stderr) yield 'https://{0}:{1}'.format(domain, newport)
def _restore_from_savepoint(self, savepoint): """Restore from savepoint""" if savepoint == '': self.logger.warning('No savepoint while continuing test!') return self.logger.info('Reset db from /home/backup/{}'.format(savepoint)) ssh.command('./reset-db.sh /home/backup/{}'.format(savepoint))
def test_selinux_foreman_module(self): """@Test: SELinux foreman module have the right version @Feature: Server health @Assert: Foreman RPM and SELinux module versions match """ rpm_result = ssh.command('rpm -q foreman-selinux') self.assertEqual(rpm_result.return_code, 0) semodule_result = ssh.command('semodule -l | grep foreman') self.assertEqual(semodule_result.return_code, 0) # Sample rpm output: foreman-selinux-1.7.2.8-1.el7sat.noarch rpm_version = self.version_regex.search(''.join( rpm_result.stdout)).group(1) # Sample semodule output: foreman 1.7.2.8.1 semodule_version = self.version_regex.search(''.join( semodule_result.stdout)).group(1) if rpm_version.endswith('-0'): # Examples of matching RPM and semodule version numbers: # # 1.7.2.8-0 1.7.2.8 # 1.7.2.8-1 1.7.2.8.1 # 1.7.2.8-2 1.7.2.8.2 rpm_version = rpm_version[:-2] self.assertEqual(rpm_version.replace('-', '.'), semodule_version)
def destroy(self): """Destroys the virtual machine on the provisioning server""" if not self._created: return result = ssh.command( 'virsh destroy {0}'.format(self.target_image), hostname=self.provisioning_server ) if result.return_code > 0: logger.warning(result.stderr) result = ssh.command( 'virsh undefine {0}'.format(self.target_image), hostname=self.provisioning_server ) if result.return_code > 0: logger.warning(result.stderr) image_name = '{0}.img'.format(self.target_image) result = ssh.command( 'rm {0}'.format(os.path.join(self.image_dir, image_name)), hostname=self.provisioning_server ) if result.return_code > 0: logger.warning(result.stderr)
def test_selinux_foreman_module(self): """@Test: SELinux foreman module have the right version @Feature: Server health @Assert: Foreman RPM and SELinux module versions match """ rpm_result = ssh.command('rpm -q foreman-selinux') self.assertEqual(rpm_result.return_code, 0) semodule_result = ssh.command('semodule -l | grep foreman') self.assertEqual(semodule_result.return_code, 0) # Sample rpm output: foreman-selinux-1.7.2.8-1.el7sat.noarch rpm_version = self.version_regex.search( ''.join(rpm_result.stdout)).group(1) # Sample semodule output: foreman 1.7.2.8.1 semodule_version = self.version_regex.search( ''.join(semodule_result.stdout)).group(1) if rpm_version.endswith('-0'): # Examples of matching RPM and semodule version numbers: # # 1.7.2.8-0 1.7.2.8 # 1.7.2.8-1 1.7.2.8.1 # 1.7.2.8-2 1.7.2.8.2 rpm_version = rpm_version[:-2] self.assertEqual(rpm_version.replace('-', '.'), semodule_version)
def run_puppet_module(self): """ Import some parameterized puppet class. This is required to make sure that we have smart class variable available. """ ssh.command('puppet module install --force puppetlabs/ntp')
def _restore_from_savepoint(self, savepoint): """Restore from a given savepoint""" if savepoint == '': self.logger.warning('No savepoint while continuing test!') return self.logger.info('Reset db from /home/backup/{}'.format(savepoint)) ssh.command('./reset-db.sh /home/backup/{}'.format(savepoint))
def run_puppet_agent(self): """Retrieves the client configuration from the puppet master and applies it to the local host. This is required to make sure that we have reports available. """ ssh.command('puppet agent -t')
def single_register_attach(cls, sub_id, default_org, environment, vm): """Subscribe VM to Satellite by Register + Attach""" ssh.command('subscription-manager clean', hostname=vm) time_reg = cls.sub_mgr_register_authentication(default_org, environment, vm) time_att = cls.sub_mgr_attach(sub_id, vm) return (time_reg, time_att)
def single_register_attach(cls, sub_id, default_org, environment, vm): """Subscribe VM to Satellite by Register + Attach""" ssh.command('subscription-manager clean', hostname=vm) time_reg = cls.sub_mgr_register_authentication( default_org, environment, vm) time_att = cls.sub_mgr_attach(sub_id, vm) return (time_reg, time_att)
def test_installer_check_services(self): """@Test: Services services start correctly @Feature: Installer @Assert: All services {'elasticsearch', 'foreman-proxy', 'foreman-tasks', 'httpd', 'mongod', 'postgresql', 'pulp_celerybeat', 'pulp_resource_manager', 'pulp_workers', 'qdrouterd', 'qpidd', 'tomcat'} are started """ services = ( 'elasticsearch', 'foreman-proxy', 'foreman-tasks', 'httpd', 'mongod', 'postgresql', 'pulp_celerybeat', 'pulp_resource_manager', 'pulp_workers', 'qdrouterd', 'qpidd', 'tomcat', ) # check `services` status using service command if get_host_info()[1] >= 7: status_format = 'systemctl status {0}' else: status_format = 'service {0} status' for service in services: result = ssh.command(status_format.format(service)) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) # check status reported by hammer ping command result = ssh.command(u'hammer -u {0[0]} -p {0[1]} ping'.format( get_server_credentials() )) # iterate over the lines grouping every 3 lines # example [1, 2, 3, 4, 5, 6] will return [(1, 2, 3), (4, 5, 6)] for service, status, server_response in izip( *[iter(result.stdout)] * 3): service = service.replace(':', '').strip() status = status.split(':')[1].strip().lower() server_response = server_response.split(':', 1)[1].strip() self.assertEqual( status, 'ok', '{0} responded with {1}'.format(service, server_response) )
def create(self): """Creates a virtual machine on the provisioning server using snap-guest :raises robottelo.vm.VirtualMachineError: Whenever a virtual machine could not be executed. """ if self._created: return if self.provisioning_server is None: raise VirtualMachineError('Provisioning server is not configured') command_args = [ 'snap-guest', '-b {source_image}', '-t {target_image}', '-m {vm_ram}', '-c {vm_cpu}', '-n bridge=br0 -f', ] if self.image_dir is not None: command_args.append('-p {image_dir}') command = ' '.join(command_args).format( source_image='{0}-base'.format(self.distro), target_image=self.target_image, vm_ram=self.ram, vm_cpu=self.cpu, image_dir=self.image_dir, ) result = ssh.command(command, self.provisioning_server) if result.return_code != 0: raise VirtualMachineError( 'Failed to run snap-guest: {0}'.format(result.stderr)) # Give some time to machine boot time.sleep(60) result = ssh.command( 'ping -c 1 {}.local'.format(self.target_image), self.provisioning_server ) if result.return_code != 0: raise VirtualMachineError( 'Failed to fetch virtual machine IP address information') output = ''.join(result.stdout) self.ip_addr = output.split('(')[1].split(')')[0] self._created = True
def create(self): """Creates a virtual machine on the provisioning server using snap-guest :raises robottelo.vm.VirtualMachineError: Whenever a virtual machine could not be executed. """ if self._created: return if self.provisioning_server is None: raise VirtualMachineError('Provisioning server is not configured') command_args = [ 'snap-guest', '-b {source_image}', '-t {target_image}', '-m {vm_ram}', '-c {vm_cpu}', '-n bridge=br0 -f', ] if self.image_dir is not None: command_args.append('-p {image_dir}') command = ' '.join(command_args).format( source_image='{0}-base'.format(self.distro), target_image=self.target_image, vm_ram=self.ram, vm_cpu=self.cpu, image_dir=self.image_dir, ) result = ssh.command(command, self.provisioning_server) if result.return_code != 0: raise VirtualMachineError('Failed to run snap-guest: {0}'.format( result.stderr)) # Give some time to machine boot time.sleep(60) result = ssh.command('ping -c 1 {}.local'.format(self.target_image), self.provisioning_server) if result.return_code != 0: raise VirtualMachineError( 'Failed to fetch virtual machine IP address information') output = ''.join(result.stdout) self.ip_addr = output.split('(')[1].split(')')[0] self._created = True
def test_import_orgs_recovery(self, test_data): """@test: Try to Import organizations with the same name to invoke usage of a recovery strategy (rename, map, none) @feature: Import Organizations Recover @assert: 2nd Import will result in No Action Taken, 3rd one will rename the new organizations, and the 4th one will map them """ # prepare the data files = dict(self.default_dataset[1]) files['users'] = update_csv_values( files['users'], 'organization_id', test_data, self.default_dataset[0] ) # initial import self.assertEqual( Import.organization({'csv-file': files['users']}).return_code, 0) # clear the .transition_data to clear the transition mapping ssh.command('rm -rf "${HOME}"/.transition_data') # use the 'none' strategy orgs_before = Org.list().stdout Import.organization({'csv-file': files['users'], 'recover': 'none'}) self.assertEqual(orgs_before, Org.list().stdout) # use the default (rename) strategy ssh_imp_rename = Import.organization_with_tr_data( {'csv-file': files['users']} ) self.assertEqual(len(ssh_imp_rename[1]), len(test_data)) for record in ssh_imp_rename[1]: self.assertEqual(Org.info({'id': record['sat6']}).return_code, 0) Import.organization({'csv-file': files['users'], 'delete': True}) # use the 'map' strategy ssh_imp_map = Import.organization_with_tr_data({ 'csv-file': files['users'], 'recover': 'map', }) for record in ssh_imp_map[1]: self.assertEqual( Org.info({'id': record['sat6']}).return_code, 0 ) Import.organization({'csv-file': files['users'], 'delete': True})
def read_transition_csv(csv_files, key='sat5'): """Process remote CSV files and transition them to Dictionary The result depends on the order of the processed files. This script should mimic the behavior of Katello's hammer-cli-import `load_persistent_maps()`_ method. :param csv_files: A list of Strings containing absolute paths of the remote CSV files :param key: (Optional) key to be used to uniquely identify an entity ('sat5' by default) :returns: A Dictionary object holding the key-value pairs of the current state of entity mapping .. _load_persistent_maps(): https://github.com/Katello/hammer-cli-import/blob/master/lib /hammer_cli_import/persistentmap.rb#L113 """ result = [] for csv_file in csv_files: ssh_cat = ssh.command(u'cat {0}'.format(csv_file)) if ssh_cat.return_code != 0: raise AssertionError(ssh_cat.stderr) csv = ssh_cat.stdout[:-1] keys = csv[0].split(',') for val in csv[1:]: record = dict(zip(keys, val.split(','))) for entity in result: if entity[key] == record[key]: entity.update(record) break else: result.append(record) return result
def csv_to_dataset(csv_files): """Process and return remote CSV files. Read the remote CSV files, and return a list of dictionaries for them :param csv_files: A list of strings, where each string is a path to a CSV file on the remote server. :returns: A list of dict, where each dict holds the contents of one CSV file. """ result = [] for csv_file in csv_files: ssh_cat = ssh.command(u'cat {0}'.format(csv_file)) if ssh_cat.return_code != 0: raise AssertionError(ssh_cat.stderr) csv = ssh_cat.stdout[:-1] keys = csv[0].split(',') result.extend([ dict(zip(keys, val.split(','))) for val in csv[1:] ]) return result
def execute(cls, command, user=None, password=None, expect_csv=False, timeout=None): """ Executes the command """ if user is None: user = cls.katello_user if password is None: password = cls.katello_passwd output_csv = u"" if expect_csv: output_csv = u" --output csv" shell_cmd = u"LANG=%s hammer -v -u %s -p %s %s %s" cmd = shell_cmd % (cls.locale, user, password, output_csv, command) return ssh.command(cmd.encode('utf-8'), expect_csv=expect_csv, timeout=timeout)
def single_register_activation_key(cls, ak_name, default_org, vm_ip): """Subscribe VM to Satellite by Register + ActivationKey""" # note: must create ssh keys for vm if running on local result = ssh.command('subscription-manager clean', hostname=vm_ip) result = ssh.command( 'time -p subscription-manager register --activationkey={0} ' '--org={1}'.format(ak_name, default_org), hostname=vm_ip ) if result.return_code != 0: LOGGER.error('Fail to subscribe {} by ak!'.format(vm_ip)) else: LOGGER.info('Subscribe client {} successfully'.format(vm_ip)) return cls.get_real_time(result.stderr)
def _traverse_command_tree(self, command): """Recursively walk through the hammer commands tree and assert that the expected options are present. """ output = hammer.parse_help( ssh.command('{0} --help'.format(command)).stdout ) command_options = set([option['name'] for option in output['options']]) command_subcommands = set( [subcommand['name'] for subcommand in output['subcommands']] ) if 'discovery_rule' in command and bz_bug_is_open(1219610): # Adjust the discovery_rule subcommand name. The expected data is # already with the naming convetion name expected = self._fetch_command_info( command.replace('discovery_rule', 'discovery-rule')) else: expected = self._fetch_command_info(command) expected_options = set() expected_subcommands = set() if expected is not None: expected_options = set( [option['name'] for option in expected['options']] ) expected_subcommands = set( [subcommand['name'] for subcommand in expected['subcommands']] ) if command == 'hammer' and bz_bug_is_open(1219610): # Adjust the discovery_rule subcommand name command_subcommands.discard('discovery_rule') command_subcommands.add('discovery-rule') added_options = tuple(command_options - expected_options) removed_options = tuple(expected_options - command_options) added_subcommands = tuple(command_subcommands - expected_subcommands) removed_subcommands = tuple(expected_subcommands - command_subcommands) if (added_options or added_subcommands or removed_options or removed_subcommands): diff = { 'added_command': expected is None, } if added_options: diff['added_options'] = added_options if removed_options: diff['removed_options'] = removed_options if added_subcommands: diff['added_subcommands'] = added_subcommands if removed_subcommands: diff['removed_subcommands'] = removed_subcommands self.differences[command] = diff if len(output['subcommands']) > 0: for subcommand in output['subcommands']: self._traverse_command_tree( '{0} {1}'.format(command, subcommand['name']) )
def test_hammer_ping(self): """ @test: hammer ping return code @feature: hammer ping @steps: 1. Execute hammer ping 2. Check its return code, should be 0 if all services are ok else != 0 @assert: hammer ping returns a right return code @bz: 1094826 """ result = ssh.command('hammer ping') self.assertEqual(len(result.stderr), 0) status_count = 0 ok_count = 0 # iterate over the lines grouping every 3 lines # example [1, 2, 3, 4, 5, 6] will return [(1, 2, 3), (4, 5, 6)] # only the status line is relevant for this test for _, status, _ in izip(*[iter(result.stdout)]*3): status_count += 1 if status.split(':')[1].strip().lower() == 'ok': ok_count += 1 if status_count == ok_count: self.assertEqual( result.return_code, 0, 'Return code should be 0 if all services are ok') else: self.assertNotEqual( result.return_code, 0, 'Return code should not be 0 if any service is not ok')
def single_register_activation_key(cls, ak_name, default_org, vm): """Subscribe VM to Satellite by Register + ActivationKey""" # note: must create ssh keys for vm if running on local result = ssh.command('subscription-manager clean', hostname=vm) result = ssh.command( 'time -p subscription-manager register --activationkey={0} ' '--org={1}'.format(ak_name, default_org), hostname=vm) if result.return_code != 0: LOGGER.error('Fail to subscribe {} by ak!'.format(vm)) return LOGGER.info('Subscribe client {} successfully'.format(vm)) real_time = [ real for real in result.stderr.split('\n') if real.startswith('real') ] return float(real_time[0].split(' ')[1])
def default_url_on_new_port(oldport, newport): """ Creates context where the default smart-proxy is forwarded on a new port """ logger = logging.getLogger("robottelo") domain = conf.properties['main.server.hostname'] user = conf.properties['main.server.ssh.username'] key = conf.properties['main.server.ssh.key_private'] ssh.upload_file(key, "/tmp/dsa_%s" % newport) ssh.command("chmod 700 /tmp/dsa_%s" % newport) with ssh._get_connection() as connection: command = "ssh -i %s -L %s:%s:%s %s@%s" % ( "/tmp/dsa_%s" % newport, newport, domain, oldport, user, domain ) logger.debug("Creating tunell %s", command) _, _, stderr = connection.exec_command(command, 1000) if len(stderr) > 0: logger.debug("Tunell failed %s", stderr) yield "https://%s:%s" % (domain, newport)
def _get_registered_uuids(self): """Get all registered systems' uuids from Postgres""" self.logger.info('Get UUID from database:') result = ssh.command("""su postgres -c 'psql -A -t -d foreman -c """ """"SELECT uuid FROM katello_systems;"'""") if result.return_code != 0: self.logger.error('Fail to fetch uuids.') raise RuntimeError('Invalid uuids. Stop!') return result.stdout
def _download_manifest(self): self.logger.info( 'Start downloading manifest: {}'.format(MANIFEST_FILE_NAME)) result = ssh.command('rm -f {0}; curl {1} -o /root/{0}'.format( MANIFEST_FILE_NAME, self.manifest_file)) if result.return_code != 0: self.logger.error('Fail to download manifest!') raise RuntimeError('Unable to download manifest. Stop!') self.logger.info('Downloading manifest complete.')
def destroy(self): """Destroys the virtual machine on the provisioning server""" if not self._created: return result = ssh.command('virsh destroy {0}'.format(self.target_image), hostname=self.provisioning_server) if result.return_code > 0: logger.warning(result.stderr) result = ssh.command('virsh undefine {0}'.format(self.target_image), hostname=self.provisioning_server) if result.return_code > 0: logger.warning(result.stderr) image_name = '{0}.img'.format(self.target_image) result = ssh.command('rm {0}'.format( os.path.join(self.image_dir, image_name)), hostname=self.provisioning_server) if result.return_code > 0: logger.warning(result.stderr)
def test_installer_check_services(self): # devnote: # maybe `hammer ping` command might be useful here to check the health # status """ @test: Services services start correctly @feature: Installer @assert: All services {katello-jobs, tomcat6, foreman, pulp, passenger-analytics, httpd, foreman_proxy, elasticsearch, postgresql, mongod} are started """ services = ('katello-jobs', 'tomcat6', 'foreman', 'httpd', 'elasticsearch', 'postgresql', 'mongod') # check `services` status using service command for service in services: result = ssh.command('service %s status' % service) logger.debug(result.stdout) if service == 'foreman': self.assertEqual(result.return_code, 1) else: self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) # check status reported by hammer ping command result = ssh.command('hammer ping') # iterate over the lines grouping every 3 lines # example [1, 2, 3, 4, 5, 6] will return [(1, 2, 3), (4, 5, 6)] for service, status, server_response in izip( *[iter(result.stdout)] * 3): service = service.replace(':', '').strip() status = status.split(':')[1].strip().lower() server_response = server_response.split(':', 1)[1].strip() logger.debug('%s [%s] - %s', service, status, server_response) self.assertEqual(status, 'ok', '%s responded with %s' % (service, server_response))
def _download_manifest(self): self.logger.info( 'Start downloading manifest: {}'.format(MANIFEST_FILE_NAME)) result = ssh.command( 'rm -f {0}; curl {1} -o /root/{0}' .format(MANIFEST_FILE_NAME, self.manifest_file)) if result.return_code != 0: self.logger.error('Fail to download manifest!') raise RuntimeError('Unable to download manifest. Stop!') self.logger.info('Downloading manifest complete.')
def sub_mgr_attach(cls, pool_id, vm_ip): """subscription-manager attach --pool=pool_id""" result = ssh.command( 'time -p subscription-manager attach --pool={}'.format(pool_id), hostname=vm_ip ) if result.return_code != 0: LOGGER.error('Fail to attach client {}'.format(vm_ip)) else: LOGGER.info('Attach client {} successfully'.format(vm_ip)) return cls.get_real_time(result.stderr)
def single_register_activation_key(cls, ak_name, default_org, vm): """Subscribe VM to Satellite by Register + ActivationKey""" # note: must create ssh keys for vm if running on local result = ssh.command('subscription-manager clean', hostname=vm) result = ssh.command( 'time -p subscription-manager register --activationkey={0} ' '--org={1}'.format(ak_name, default_org), hostname=vm ) if result.return_code != 0: LOGGER.error('Fail to subscribe {} by ak!'.format(vm)) return LOGGER.info('Subscribe client {} successfully'.format(vm)) real_time = [ real for real in result.stderr.split('\n') if real.startswith('real') ] return float(real_time[0].split(' ')[1])
def _get_registered_uuids(self): """Get all registered systems' uuids from Postgres""" self.logger.info('Get UUID from database:') result = ssh.command( """su postgres -c 'psql -A -t -d foreman -c """ """"SELECT uuid FROM katello_systems;"'""") if result.return_code != 0: self.logger.error('Fail to fetch uuids.') raise RuntimeError('Invalid uuids. Stop!') return result.stdout
def test_import_users_merge(self, test_data): """@test: Try to Merge users with the same name using 'merge-users' option. @feature: Import Users Map-users @assert: Users imported in 2nd import are being mapped to the existing ones with the same name """ # prepare the data tmp_dir = self.default_dataset[0] files = dict(self.default_dataset[1]) pwdfiles = [ os.path.join(tmp_dir, gen_string('alpha', 6)) for _ in range(2) ] files['users'] = update_csv_values( files['users'], u'organization_id', test_data, self.default_dataset[0] ) # initial import for result in ( Import.organization({'csv-file': files['users']}), Import.user({ 'csv-file': files['users'], 'new-passwords': pwdfiles[0], }), ): self.assertEqual(result.return_code, 0) # clear the .transition_data to clear the transition mapping ssh.command('rm -rf "${HOME}"/.transition_data/users*') # import users using merge-users option import_merge = Import.user_with_tr_data({ 'csv-file': files['users'], 'new-passwords': pwdfiles[1], 'merge-users': True, }) for record in import_merge[1]: self.assertNotEqual(User.info({'id': record['sat6']}).stdout, '')
def generate_command_tree(command): """Recursively walk trhough the hammer commands and subcommands and fetch their help. Return a dictionary with the contents. """ output = ssh.command('{0} --help'.format(command)).stdout contents = hammer.parse_help(output) if len(contents['subcommands']) > 0: for subcommand in contents['subcommands']: subcommand.update(generate_command_tree( '{0} {1}'.format(command, subcommand['name']) )) return contents
def test_reimport_users_default_negative(self, test_data): """@test: Try to Import all users from the predefined source and try to import them again @feature: Repetitive User Import @assert: 2nd Import will result in No Action Taken """ tmp_dir = self.default_dataset[0] files = dict(self.default_dataset[1]) pwdfile = os.path.join(tmp_dir, gen_string('alpha', 6)) files['users'] = update_csv_values( files['users'], u'organization_id', test_data, self.default_dataset[0] ) # Import the organizations first self.assertEqual( Import.organization({ 'csv-file': files['users'], }).return_code, 0) self.assertEqual( Import.user({ 'csv-file': files['users'], 'new-passwords': pwdfile, }).return_code, 0) ssh.command(u'rm -rf {}'.format(pwdfile)) users_before = set(user['login'] for user in User.list().stdout) self.assertEqual( Import.user({ 'csv-file': files['users'], 'new-passwords': pwdfile, }).return_code, 0) users_after = set(user['login'] for user in User.list().stdout) self.assertTrue(users_after.issubset(users_before))
def execute(cls, command, user=None, password=None, output_format=None, timeout=None): """Executes the cli ``command`` on the server via ssh""" user, password = cls._get_username_password(user, password) cmd = u'LANG={0} hammer -v -u {1} -p {2} {3} {4}'.format( conf.properties['main.locale'], user, password, u'--output={0}'.format(output_format) if output_format else u'', command ) return ssh.command( cmd.encode('utf-8'), output_format=output_format, timeout=timeout)
def user_with_tr_data(cls, options=None): """Import Users (from spacewalk-report users). :returns: A tuple of SSHCommandResult and a Dictionary containing the transition data of the Import """ result = cls.user(options) transition_data = [] if result.return_code == 0: transition_data = cls.read_transition_csv( ssh.command( u'ls -v ${HOME}/.transition_data/users*' ).stdout[:-1] ) return (result, transition_data)
def host_collection_with_tr_data(cls, options=None): """Import Host Collections (from spacewalk-report system-groups). :returns: A tuple of SSHCommandResult and a Dictionary containing the transition data of the Import """ result = cls.host_collection(options) transition_data = [] if result.return_code == 0: transition_data = cls.read_transition_csv( ssh.command( u'ls -v ${HOME}/.transition_data/host_collections*' ).stdout[:-1] ) return (result, transition_data)
def sub_mgr_attach(cls, pool_id, vm): """subscription-manager attach --pool=pool_id""" result = ssh.command( 'time -p subscription-manager attach --pool={}'.format(pool_id), hostname=vm) if result.return_code != 0: LOGGER.error('Fail to attach client {}'.format(vm)) return LOGGER.info('Attach client {} successfully'.format(vm)) real_time = [ real for real in result.stderr.split('\n') if real.startswith('real') ] real_time = real_time[0].split(' ')[1] return float(real_time)
def test_foreman_version(self): """@Test: Check if /usr/share/foreman/VERSION does not contain the develop tag. @Feature: Smoke Test @Assert: The file content does not have the develop tag. """ result = ssh.command("cat /usr/share/foreman/VERSION") self.assertEqual(result.return_code, 0) if get_server_software() == "downstream": self.assertNotIn("develop", u"".join(result.stdout)) else: self.assertIn("develop", u"".join(result.stdout))
def execute(self, command, user=None, password=None, expect_csv=False): """ Executes the command """ if user is None: user = self.katello_user if password is None: password = self.katello_passwd output_csv = "" if expect_csv: output_csv = " --output csv" shell_cmd = "LANG=%s hammer -v -u %s -p %s" + output_csv + " %s" cmd = shell_cmd % (self.locale, user, password, command) return ssh.command(cmd, expect_csv=expect_csv)
def run(self, cmd): """Runs a ssh command on the virtual machine :param str cmd: Command to run on the virtual machine :return: A :class:`robottelo.common.ssh.SSHCommandResult` instance with the commands results :rtype: robottelo.common.ssh.SSHCommandResult :raises robottelo.vm.VirtualMachineError: If the virtual machine is not created. """ if not self._created: raise VirtualMachineError( 'The virtual machine should be created before running any ssh ' 'command') return ssh.command(cmd, hostname=self.ip_addr)
def execute(cls, command, user=None, password=None, output_format=None, timeout=None): """Executes the cli ``command`` on the server via ssh""" user, password = cls._get_username_password(user, password) cmd = u'LANG={0} hammer -v -u {1} -p {2} {3} {4}'.format( conf.properties['main.locale'], user, password, u'--output={0}'.format(output_format) if output_format else u'', command) return ssh.command(cmd.encode('utf-8'), output_format=output_format, timeout=timeout)
def sub_mgr_register_authentication(cls, default_org, environment, vm): """subscription-manager register -u -p --org --environment""" result = ssh.command( 'time -p subscription-manager register --username={0} ' '--password={1} ' '--org={2} ' '--environment={3}'.format(cls.username, cls.password, default_org, environment), hostname=vm) if result.return_code != 0: LOGGER.error('Fail to register client {} by sub-mgr!'.format(vm)) return LOGGER.info('Register client {} successfully'.format(vm)) real_time = [ real for real in result.stderr.split('\n') if real.startswith('real') ] real_time = real_time[0].split(' ')[1] return float(real_time)
def test_hammer_ping(self): """@test: hammer ping return code @feature: hammer ping @steps: 1. Execute hammer ping 2. Check its return code, should be 0 if all services are ok else != 0 @assert: hammer ping returns a right return code """ result = ssh.command('hammer -u {0} -p {1} ping'.format( conf.properties['foreman.admin.username'], conf.properties['foreman.admin.password'])) self.assertEqual(len(result.stderr), 0) status_count = 0 ok_count = 0 # iterate over the lines grouping every 3 lines # example [1, 2, 3, 4, 5, 6] will return [(1, 2, 3), (4, 5, 6)] # only the status line is relevant for this test for _, status, _ in izip(*[iter(result.stdout)] * 3): status_count += 1 if status.split(':')[1].strip().lower() == 'ok': ok_count += 1 if status_count == ok_count: self.assertEqual(result.return_code, 0, 'Return code should be 0 if all services are ok') else: self.assertNotEqual( result.return_code, 0, 'Return code should not be 0 if any service is not ok')
from writer import Writer import sys import time old_stdout = sys.stdout log = open('timing-subscription', 'w') # log = open('test.log','w') sys.stdout = Writer(sys.stdout, log) ''' for i in range(100): print "Attempt: {0}".format(i) ''' print "Timing register by ak:" for i in range(20): print "Attempt: {0}".format(i) result = ssh.command('subscription-manager clean', hostname='10.12.23.223') if result.return_code != 0: print "Failed to subscribe: {0} and return code: {1}".format( result.stderr, result.return_code) start = time.time() result = ssh.command( 'subscription-manager register --activationkey=ak-1 --org="Default_Organization"', hostname='10.12.23.223') end = time.time() print 'real', ' ', end - start, 's' sys.stdout = old_stdout log.close()
# Testing upload manifest to Red Hat Satellite 6 by Robottelo Framework import os import sys import time os.getcwd() #sys.stdout = open('timing-upload','w') #os.chdir('/home/chozhang/Documents/robottelo/robottelo/') from robottelo.common import ssh from robottelo.cli.subscription import Subscription # open log file print 'Timing uploading manfest to server:' r = ssh.command('hostname') print r.stdout[0] ssh.command('rm test_manifest.zip') ssh.upload_file('/home/chozhang/Documents/satellite6/20150526-10k-RHEL-Manifest.zip','test_manifest.zip') start = time.time() result = Subscription.upload({ 'file':'./test_manifest.zip', 'organization-id':'1' }) if result.return_code != 0: print "Failed to upload manifest: {0} and return code: {1}" \ .format(result.stderr, result.return_code) else: # print subscription list result = Subscription.list({'organization-id':'1'}, per_page=False)