def test_binary(): with shell.tempdir(): with open('1.txt', 'w') as f: f.write('123') run('cat 1.txt | lz4 -1 |', preamble, 'cp - s3://bucket/binary/1.txt') assert '123' == run(preamble, 'cp s3://bucket/binary/1.txt - | lz4 -d -c')
def clone_source(): with shell.climb_git_root(): orig = os.getcwd() with shell.tempdir(cleanup=False): shell.run(f"rsync -avhc {orig}/ . --exclude '.git' --exclude '.tox' --exclude '.backups' --exclude '__pycache__'") shell.run('mkdir .git') return os.getcwd()
def apply(doc): output_dir = config.output_dir() if not os.path.exists(output_dir): os.makedirs(output_dir) log = planet.logger planet_filters = config.filters('Planet') # Go-go-gadget-template for template_file in config.template_files(): output_file = shell.run(template_file, doc) # run any template specific filters if config.filters(template_file) != planet_filters: output = open(output_file).read() for filter in config.filters(template_file): if filter in planet_filters: continue if filter.find('>') > 0: # tee'd output filter, dest = filter.split('>', 1) tee = shell.run(filter.strip(), output, mode="filter") if tee: output_dir = planet.config.output_dir() dest_file = os.path.join(output_dir, dest.strip()) dest_file = open(dest_file, 'w') dest_file.write(tee) dest_file.close() else: # pipe'd output output = shell.run(filter, output, mode="filter") if not output: os.unlink(output_file) break else: handle = open(output_file, 'w') handle.write(output) handle.close() # Process bill of materials for copy_file in config.bill_of_materials(): dest = os.path.join(output_dir, copy_file) for template_dir in config.template_directories(): source = os.path.join(template_dir, copy_file) if os.path.exists(source): break else: log.error('Unable to locate %s', copy_file) log.info("Template search path:") for template_dir in config.template_directories(): log.info(" %s", os.path.realpath(template_dir)) continue mtime = os.stat(source).st_mtime if not os.path.exists(dest) or os.stat(dest).st_mtime < mtime: dest_dir = os.path.split(dest)[0] if not os.path.exists(dest_dir): os.makedirs(dest_dir) log.info("Copying %s to %s", source, dest) if os.path.exists(dest): os.chmod(dest, 0644) shutil.copyfile(source, dest) shutil.copystat(source, dest)
def apply(doc): output_dir = config.output_dir() if not os.path.exists(output_dir): os.makedirs(output_dir) log = planet.getLogger(config.log_level(),config.log_format()) # Go-go-gadget-template for template_file in config.template_files(): shell.run(template_file, doc) # Process bill of materials for copy_file in config.bill_of_materials(): dest = os.path.join(output_dir, copy_file) for template_dir in config.template_directories(): source = os.path.join(template_dir, copy_file) if os.path.exists(source): break else: log.error('Unable to locate %s', copy_file) continue mtime = os.stat(source).st_mtime if not os.path.exists(dest) or os.stat(dest).st_mtime < mtime: dest_dir = os.path.split(dest)[0] if not os.path.exists(dest_dir): os.makedirs(dest_dir) log.info("Copying %s to %s", source, dest) shutil.copyfile(source, dest) shutil.copystat(source, dest)
def __rebaseFile( self , file , base ): """__rebaseFile(f,b) Execute the command to rebase file f to base address b. """ cmd = '%s -v -b 0x%x %s' % ( self.__rebaseTool , base , file ) shell.run( cmd )
def test_props(args): num_buckets, csv = args result = expected(num_buckets, csv) with shell.tempdir(): stdout = '\n'.join(sorted({l.split(':')[0] for l in result.splitlines()})) assert stdout == shell.run(f'bsv | bpartition {num_buckets} prefix', stdin=csv, echo=True) assert result == shell.run(f'bcat --prefix prefix*')
def test_appends(): with shell.tempdir(): stdin = """ 0,b,c,d 1,e,f,g 2,h,i,j """ stdout = """ prefix00 prefix01 prefix02 """ assert rm_whitespace(unindent(stdout)) == shell.run(f'bsv | bpartition 10 prefix', stdin=unindent(stdin)) assert rm_whitespace(unindent(stdout)) == shell.run(f'bsv | bpartition 10 prefix', stdin=unindent(stdin)) stdout = """ prefix00:b,c,d prefix00:b,c,d prefix01:e,f,g prefix01:e,f,g prefix02:h,i,j prefix02:h,i,j """ assert unindent(stdout).strip() == shell.run(f'bcat --prefix prefix*') stdout = """ prefix00 prefix01 prefix02 """ assert unindent(stdout).strip() == shell.run('ls prefix*')
def sketch_data(datas, alpha, bins, minval, quantiles): quantiles = ','.join(map(str, quantiles)) with shell.tempdir(): for data in datas: shell.run(f'bsv | bschema a:f64 | bquantile-sketch f64 -b {bins} -a {alpha} >> sketches', stdin='\n'.join(map(str, data)) + '\n') csv = shell.run(f'cat sketches | bquantile-merge {quantiles} | bschema f64:a,f64:a | csv') return [float(v) for line in csv.splitlines() for [q, v] in [line.split(',')]]
def test_fails_when_non_positive_buckets(): with shell.climb_git_root(): stdin = 'a' print(shell.run('pwd')) res = shell.run('bsv | bbucket 0', stdin=stdin, warn=True) assert 'NUM_BUCKETS must be positive, got: 0' == res['stderr'] assert res['exitcode'] == 1
def _set_env(self): os.environ['http_proxy'] = 'http://proxy-chain.intel.com:911' os.environ['https_proxy'] = 'http://proxy-chain.intel.com:911' os.environ[ 'no_proxy'] = 'intel.com,.intel.com,localhost,127.0.0.1,10.0.0.0/8' # ,192.168.0.0/16,172.16.0.0/12' command = f'{self.path_kubectl} config set-context --current --namespace={self._namespace}' run(command, capture_outputs=True)
def test_basic(): with shell.tempdir(): stdin = """ b,c,d e,f,g h,i,j """ stdout = """ prefix_02 prefix_04 prefix_05 """ assert rm_whitespace(unindent(stdout)) == shell.run( 'bsv | bpartition -l 10 prefix', stdin=unindent(stdin)) stdout = """ prefix_02:h,i,j prefix_04:e,f,g prefix_05:b,c,d """ assert unindent(stdout).strip() == shell.run('bcat -l -p prefix*') stdout = """ prefix_02 prefix_04 prefix_05 """ assert unindent(stdout).strip() == shell.run('ls prefix*')
def addDirectories(self, dirNames): for dirName in dirNames: parent = os.path.dirname(dirName) if parent and parent != "/" and not os.path.exists(parent + "/CVS"): self.addDirectories((parent,)) if not os.path.exists(dirName + "/CVS"): shell.run(self.log, "cvs", "add", dirName)
def test_map_from_n_without_numeric_prefixes(): # builds on map and map_to_n test with servers(1_000_000): step1 = 's4://bucket/step1' # input data step2 = 's4://bucket/step2' # bucketed step3 = 's4://bucket/step3' # partitioned step4 = 's4://bucket/step4' # merged buckets def fn(arg): i, chunk = arg run(f's4 cp - {step1}/{uuid.uuid4()}', stdin="\n".join(chunk) + "\n") list(pool.thread.map(fn, enumerate(util.iter.chunk(words, 180)))) run(f's4 map {step1}/ {step2}/ "python3 /tmp/bucket.py 3"') run(f's4 map-to-n {step2}/ {step3}/ "python3 /tmp/partition.py 3"') run(f"s4 map-from-n {step3}/ {step4}/ 'xargs cat'") assert run( f"s4 ls -r {step4}/ | awk '{{print $NF}}'").splitlines() == [ 'step4/00000', 'step4/00001', 'step4/00002', ] run(f's4 cp -r {step4}/ step4/') result = [] num_buckets = 3 for word in words: hash_bytes = hashlib.md5(word.encode()).digest() hash_int = int.from_bytes(hash_bytes, 'big') bucket = hash_int % num_buckets if bucket == 0: result.append(word) assert sorted(result) == sorted( run('cat step4/00000', stream=False).splitlines())
def test_run_command_with_root(self): spawn_mock = mock_pexpect_and_return(return_value=get_mock_process( password_prompt=False)) cmd = 'touch baz' shell.run(cmd, root=True) spawn_mock.assert_called_once_with(f'sudo {cmd}', encoding='utf-8')
def setup_module(m): m.tempdir = clone_source() m.orig = os.getcwd() m.path = os.environ['PATH'] os.chdir(m.tempdir) os.environ['PATH'] = f'{os.getcwd()}/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/bin' shell.run('make clean && make bsv csv btake', stream=True)
def test_data_modifications_not_allowed(): with servers(): run('echo | s4 cp - s4://bucket/data.txt') path = run('find . -type f -name data.txt') assert path.endswith('/data.txt') with pytest.raises(Exception): run('echo >>', path)
def delete_session(self, session_type=None, session_name=None, user=None): if user is not None: self._user = user print(f'Delete Session setting user to {self._user}') if not self._is_valid_session(session_name, session_type): raise DeleteSessionError(f'No such session {session_name}') for kind in ['service', 'deployment']: cmd = f"{self.path_kubectl} get {kind} {session_name} -o yaml" returncode, stdout, _ = run(cmd, None, capture_outputs=True) if returncode: raise DeleteSessionError( f'Failed to delete session {session_name}. Please contact [email protected]' ) tempyaml = tempfile.NamedTemporaryFile( mode="w", prefix=f'{session_name}.{kind}_', suffix=".yaml", delete=False) tempyaml.write(stdout) tempyaml.close() cmd = f'{self.path_kubectl} delete -f {tempyaml.name}' returncode, stdout, _ = run(cmd, None, capture_outputs=True) if returncode: raise DeleteSessionError( f'Failed to delete session {session_name}. Please contact [email protected]' ) tempyaml.delete logging.debug(f"Deleted {kind} for {session_name}")
def apply(doc): output_dir = config.output_dir() if not os.path.exists(output_dir): os.makedirs(output_dir) log = planet.logger planet_filters = config.filters('Planet') # Go-go-gadget-template for template_file in config.template_files(): output_file = shell.run(template_file, doc) # run any template specific filters if config.filters(template_file) != planet_filters: output = open(output_file).read() for filter in config.filters(template_file): if filter in planet_filters: continue if filter.find('>')>0: # tee'd output filter,dest = filter.split('>',1) tee = shell.run(filter.strip(), output, mode="filter") if tee: output_dir = planet.config.output_dir() dest_file = os.path.join(output_dir, dest.strip()) dest_file = open(dest_file,'w') dest_file.write(tee) dest_file.close() else: # pipe'd output output = shell.run(filter, output, mode="filter") if not output: os.unlink(output_file) break else: handle = open(output_file,'w') handle.write(output) handle.close() # Process bill of materials for copy_file in config.bill_of_materials(): dest = os.path.join(output_dir, copy_file) for template_dir in config.template_directories(): source = os.path.join(template_dir, copy_file) if os.path.exists(source): break else: log.error('Unable to locate %s', copy_file) log.info("Template search path:") for template_dir in config.template_directories(): log.info(" %s", os.path.realpath(template_dir)) continue mtime = os.stat(source).st_mtime if not os.path.exists(dest) or os.stat(dest).st_mtime < mtime: dest_dir = os.path.split(dest)[0] if not os.path.exists(dest_dir): os.makedirs(dest_dir) log.info("Copying %s to %s", source, dest) if os.path.exists(dest): os.chmod(dest, 0644) shutil.copyfile(source, dest) shutil.copystat(source, dest)
def on_press(key): global current if key in COMBINATION: current.add(key) if all(k in current for k in COMBINATION): current = set() shell.run()
def infoDiff(self, since=None, until='HEAD'): if since: shell.run(self.log, 'git', 'diff', '--stat=200', '--patch', '--minimal', '--irreversible-delete', '%s..%s' % (since, until)) else: shell.run(self.log, 'git', 'diff', '--stat=200', '--patch', '--minimal', '--irreversible-delete')
def add_script(cluster_id, schema_file, script_file): schema_path = 's3://shareablee-hive/tmp/scripts/%s' % uuid.uuid4() script_path = 's3://shareablee-hive/tmp/scripts/%s' % uuid.uuid4() shell.run('aws s3 cp', schema_file, schema_path) shell.run('aws s3 cp', script_file, script_path) add_step(cluster_id, 'copy schema', 'aws', 's3', 'cp', schema_path, '/tmp/schema.hql') add_step(cluster_id, 'copy script', 'aws', 's3', 'cp', script_path, '/tmp/script.hql') add_step(cluster_id, 'run script', 'hive', '-i', '/tmp/schema.hql', '-f', '/tmp/script.hql')
def addDirectories(self, dirNames): for dirName in dirNames: parent = os.path.dirname(dirName) if parent and parent != '/' and not os.path.exists(parent + '/CVS'): self.addDirectories((parent, )) if not os.path.exists(dirName + '/CVS'): shell.run(self.log, 'cvs', 'add', dirName)
def run(stdin, *args): with shell.climb_git_root(): stdinpath = 'stdin' stdoutpath = 'stdout' with open(stdinpath, 'w') as f: f.write(stdin) shell.run(*(('set -o pipefail; cat', stdinpath, '|') + args + ('>', stdoutpath)), stream=True) with open(stdoutpath) as f: return f.read()
def setenforce(mode): """ Sets enforcing mode of SElinux :param mode: Enforcing mode from [Permissive, Enforcing] :param type: ``str`` :raises: AssertionError """ assert mode in ["Permissive", "Enforcing"] shell.run("/usr/sbin/setenforce %s" % mode)
def exportDYSM(archivePath): workspace = os.path.dirname(archivePath) project_name = os.path.splitext(os.path.basename(archivePath))[0] dysmZipPath = workspace + "/" + project_name + ".app.dSYM.zip" dysmPath = workspace + "/" + project_name + ".app.dSYM" shell.run("cp -r %s/dSYMs/%s.app.dSYM %s" % (archivePath, project_name, workspace)) shell.run("zip -r -o %s %s" % (dysmZipPath, dysmPath))
def test_filtering(): assert '1,1\n2,2' == shell.run( 'echo -e "1,1\n2,2\n3\n" | bsv | bschema 1,1 --filter | csv') assert '22\n33' == shell.run( 'echo -e "1\n22\n33\n" | bsv | bschema 2 --filter | csv') assert '12850\n13107' == shell.run( 'echo -e "1\n22\n33\n" | bsv | bschema u16:a --filter | csv') assert 'as\n12' == shell.run( 'echo -e "asdf\nq\n123\n" | bsv | bschema "2*" --filter | csv')
def exportSymbol(archivePath): workspace = os.path.dirname(archivePath) project_name = os.path.splitext(os.path.basename(archivePath))[0] symbolZipPath = workspace + "/" + project_name + ".app.dSYM.zip" symbolPath = workspace + "/" + "BCSymbolMaps" shell.run("cp -r %s/BCSymbolMaps %s" % (archivePath, workspace)) shell.run("zip -r -o %s %s" % (symbolZipPath, symbolPath))
def update_zip(path, *includes): stderr('\nupdate zip:') _zip_file = zip_file(path) tempdir = os.path.dirname(_zip_file) [site_packages] = glob.glob(f'{tempdir}/env/lib/python3*/site-packages') with sh.cd(site_packages): sh.run(f'cp {path} .') sh.run(f'zip {_zip_file} {os.path.basename(path)}') stderr('', _zip_file)
def run(l): print("Hello Jammer! I am ISLA (Intelligent Spacedog Lighting Assistant") print("Please select a foreground color") s = raw_input(">") color1 = getattr(colors, s) print( "Ok thanks. You're doing great. Now please select a background color") s = raw_input(">") color2 = getattr(colors, s) print("Now just select an effects color and we are ready to go!") s = raw_input(">") color3 = getattr(colors, s) print("Ok thanks! Those are great choices") walk = fourstepmover(4, color1, color2) chill = fourstepmover(8, color2, colors.dim(color2, .1), 1.1) chill.loop = True walk.loop = True default = walk default.loop = True l.run(default) print("What would you like to do?") print("1. Cool fill 2. Freakout 3. Pulse 4. Walk") def handle_input(input): strippedInput = input.lstrip("i") immediate = False if strippedInput != input: immediate = True input = strippedInput def run(f): if immediate == True: l.runImmediately(f) else: l.run(f) if input == "1": print("Ok! Hold on dropping some dope beats in 4, 3, 2...") f = fourbarmover(color1, color2) run(f) l.run(chill) if input == "2": print("HOLD ON BUDDY") run(strobe(PartyBar().all(color3), 1 / 4.0, 4)) l.run(chill) if input == "3": print("Nice and smooth") run(chill) if input == "4": print("To the dog park we go!") run(walk) shell.run(l, handle_input)
def setup_module(m): m.tempdir = clone_source() m.orig = os.getcwd() m.path = os.environ['PATH'] os.chdir(m.tempdir) os.environ[ 'PATH'] = f'{os.getcwd()}/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/bin' shell.run('make clean', stream=True) compile_buffer_sizes('_csv', buffers) shell.run('make _csv')
def infoDiff(self, since=None, until='HEAD'): if since: shell.run(self.log, 'git', 'diff', '--stat=200', '--patch', '--minimal', '--irreversible-delete', '%s..%s' %(since, until)) else: shell.run(self.log, 'git', 'diff', '--stat=200', '--patch', '--minimal', '--irreversible-delete')
def test_map(): with servers(1_000_000): src = 's4://bucket/data_in' dst = 's4://bucket/data_out' def fn(arg): i, chunk = arg run(f's4 cp - {src}/{i:05}', stdin="\n".join(chunk) + "\n") list(pool.thread.map(fn, enumerate(util.iter.chunk(words, 180)))) assert run(f"s4 ls {src}/ | awk '{{print $NF}}' ").splitlines() == [ '00000', '00001', '00002', '00003', '00004', '00005' ] assert run(f's4 cp {src}/00000 - | head -n5').splitlines() == [ 'Abelson', 'Aberdeen', 'Allison', 'Amsterdam', 'Apollos' ] run(f's4 map {src}/ {dst}/ "tr A-Z a-z"') assert run(f"s4 ls {dst}/ | awk '{{print $NF}}'").splitlines() == [ '00000', '00001', '00002', '00003', '00004', '00005' ] assert run(f's4 cp {dst}/00000 - | head -n5').splitlines() == [ 'abelson', 'aberdeen', 'allison', 'amsterdam', 'apollos' ] run(f's4 cp -r {dst}/ result') assert run('cat result/*', stream=False) == '\n'.join(words).lower()
def test_props(csvs): result = expected(csvs) if result.strip(): with shell.tempdir(): paths = [] for i, csv in enumerate(csvs): path = f'file{i}.bsv' shell.run(f'bsv > {path}', stdin=csv) paths.append(path) assert result.strip() == shell.run(f'brmerge', *paths, ' | bcut 1 | csv', echo=True) assert shell.run('cat', *paths, '| brsort | bcut 1 | csv') == shell.run(f'brmerge', *paths, ' | bcut 1 | csv')
def start(port, conf, extra=''): with shell.cd(f'_{port}'): for i in range(5): try: shell.run( f'timeout 60 s4-server -port {port} -conf {conf} {extra}', stream=True) except: logging.exception('') continue assert False, f'failed to start server on ports from: {port}'
def is_elf(filename): """ Checks whether file is ELF executable :param filename: file name to check :type filename: ``str`` :returns: Whether file is ELF executable """ try: shell.run("readelf -h %s" % filename) return True except AssertionError: return False
def install(package_name): """ Does the 'yum install <package>' command. :param package_name: Name of the package to install (eg. katello-all) :type package_name: str :raises: AssertionError """ # Install it text = shell.run("yum -y install %s" % (package_name)) # Verify it shell.run("rpm -q %s" % (package_name)) return rpm.check_for_errors(text)
def commit(self, message): fd, name = tempfile.mkstemp(".bigitr") os.write(fd, message) # flat list: ['-s', 'A=a', '-s', 'B=b'] cvsvars = sum([["-s", x] for x in self.ctx.getCVSVariables(self.repo)], []) if self.mapped_branch is not None: commitargs = ["commit", "-r", self.branch, "-R", "-F", name] else: commitargs = ["commit", "-R", "-F", name] try: shell.run(self.log, "cvs", *(cvsvars + commitargs)) finally: os.remove(name) os.close(fd)
def package_installed(package): """ Returns whether is package installed or not :param package: Package name :type package: ``str`` :returns: ``True`` when package is installed, otherwise ``False`` :rtype: ``bool`` """ try: shell.run("rpm -q %s" % package) return True except AssertionError: return False
def remove(package_name): """ Does the 'yum remove <package>' command. :param package_name: Name of the package to be removed (eg. katello-all) :type package_name: str :raises: AssertionError """ # Remove it text = shell.run("yum -y remove %s" % (package_name)) # Verify it shell.run("rpm -q %s" % (package_name), errorcode=1) return text
def getenforce(): """ Returns enforcing mode of SElinux :returns: Enforcing mode of SELinux :rtype: ``str`` """ return shell.run("/usr/sbin/getenforce")
def ql(package): """ Performs a 'rpm -ql' command :param package: Package to be listed :type package: ``str`` """ return shell.run("rpm -ql %s" % package)
def e(package): """ Performs a 'rpm -e' command :param package: Package to be removed :type package: ``str`` """ return shell.run("rpm -e %s" % package)
def status(launch, bucket: 's3 bucket to upload logs to' = shell.conf.get_or_prompt_pref('launch_logs_bucket', __file__, message='bucket for launch_logs')): """ show all instances, and their state, ie running|done|failed|missing. """ launch = launch.replace('launch=', '') data = json.loads(params(launch)) results = shell.run("aws s3 ls %(bucket)s/launch_logs/launch=%(launch)s/ --recursive|awk '{print $NF}'| grep exited=" % locals()).splitlines() results = [(x.split('/')[-2], x.split('exited=')[-1]) for x in results] fail_labels = [label.split('label=', 1)[-1] for label, exit in results if exit != '0'] done_labels = [label.split('label=', 1)[-1] for label, exit in results if exit == '0'] running_labels = [aws.ec2._tags(i)['label'] for i in aws.ec2._ls(['launch=%s' % launch], state='running')] vals = [] for label in sorted(data['labels']): if label in fail_labels: vals.append('failed label=%s' % label) elif label in done_labels: vals.append('done label=%s' % label) elif label in running_labels: vals.append('running label=%s' % label) else: vals.append('missing label=%s' % label) for k, v in util.iter.groupby(vals, key=lambda x: x.split()[0]): logging.info('num %s: %s', k, len(v)) return sorted(vals, key=lambda x: x.split()[0], reverse=True)
def process_module(self, imodule): if imodule.type in ["cvs", "distribution"]: tmpdir="branch_tmp_"+str(distributions.my_get_thread_ident()) shell.rm(tmpdir) try: if imodule.type == "cvs": imodule.checkout( date = self.source_date, tag = self.source_tag, as = tmpdir) else: cvs.Checkout(self.source_tag or imodule.cvs_tag, "distribution", imodule.cvs_root, tmpdir, self.source_date or imodule.cvs_date) cmd='cvs tag %s %s "%s"' %( self.cvs_flags,self.dash_b, self.tag ) print "Running: %s (in %s + %s)" % (cmd, os.getcwd(), tmpdir) status, output = shell.run(cmd, dir = tmpdir) print output if status: print "Tagging module %s failed\n" % imodule.id except cvs.cvs_error: print "Tagging module %s failed\n" % imodule.id shell.rm(tmpdir)
def update(): """ Does the 'yum update' command. :raises: AssertionError """ # Update return rpm.check_for_errors(shell.run("yum -y update"))
def grouplist(): """ Does the 'yum grouplist' command. :raises: AssertionError """ # Check for update return shell.run("yum grouplist")
def run(self, cmd, nowarn=0): print "Running '%s' in %s" % (cmd, tmpdir()) status, output=shell.run(cmd, self.lcb, 1800, tmpdir()) if status and not nowarn: print "WARNING WARNING WARNING" print "Command failed: %s" % cmd return output
def __sign( self , file ): """__sign(f) Execute the command to sign dll f. """ cmd = '%s %s' % ( self.__signTool , file ) (ret, output) = shell.run( cmd ) if ret: log.error("Failed to sign %s: %s" % ( file , output ) )
def run_cmd(self, cmd): outmsg.verbose(cmd) t = time.time() try: ret=shell.run(cmd, self.lcb) except shell.error, se: e = err.Error() e.Set(str(se)) raise err.error, e
def package_build_host(package): """ Returns build host of the package. :param package: Package to check :type package: ``str`` :returns: Build host of the package :rtype: ``str`` """ return shell.run("rpm -q --qf \"%%{BUILDHOST}\" %s" % package).strip()
def package_problems(package): """ This functions returns reported problems with package :param package: Package to check :type package: ``str`` :returns: ``STDOUT`` of rpm -V :rtype: ``str`` """ return shell.run("rpm -Vvv %s" % package, None)
def run1(cmd, no_prefix=False): if not no_prefix: cmd = "%s%s" % (platform_prefix, cmd) debug("rlink, running: %s" % cmd) (e, out) = shell.run(cmd) if string.strip(out) != "": print out if e: print "Cmd '%s' failed with error code %d" % (cmd, e) sys.exit(1)
def run_noexit(cmd): cmd = "%s%s" % (platform_prefix, cmd) debug("rlink, running: %s" % cmd) (e, out) = shell.run(cmd) if string.strip(out) != "": print out if e: ## Only print verbose message if debug is enabled, since ## it typically isn't an error debug("Cmd '%s' failed with error code %d" % (cmd, e))
def Cmd(self, cmd, path, dir = None): log.trace( 'entry' , [ cmd ] ) cmd='cvs -d "%s" %s "%s"' % (self.root, cmd, path) log.info("running %s in %s + %s" % (repr(cmd), repr(os.getcwd()), repr(dir))) results = shell.run(cmd, dir = dir, timeout_seconds = 1800) resList = [] for item in results: resList.append(item) log.trace( 'exit' , [ resList ] ) return results
def search(package_name): """ Does the 'yum search <package>' command. :param package_name: Name of the package to install (eg. katello-all) :type package_name: str :raises: AssertionError """ # Install it return shell.run("yum search %s" % (package_name))
def readelf(filename): """ Returns content of the ``readelf --all`` call. :param filename: File to check :type filename: ``str`` :returns: Content of the ELF analysis :rtype: ``str`` """ return shell.run("readelf --all %s" % filename)
def groupinstall(group): """ Does the 'yum groupinstall <package>' command. :param package_name: Name of the group to install (eg. katello-all) :type package_name: str :raises: AssertionError """ # Install it text = shell.run("yum -y groupinstall %s" % (group)) return rpm.check_for_errors(text)