def info( cls, path ): if not path: raise cls.Error("No working copy path specified for calling svnversion with.") url = None repository = None branch = None remote = None revision = None try: command = "{svn} info {path}".format( svn=cls.binary(), path=path ) svn_info = as_str( subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ) ) url = re.search( r'URL: ([^\s]+)', svn_info ).expand(r'\1') repository = re.search( r'Repository Root: ([^\s]+)', svn_info ).expand(r'\1') branch = re.search( r'Relative URL: \^/([^\s]+)', svn_info ).expand(r'\1') revision = re.search( r'Revision: (\d+)', svn_info ).expand(r'\1') except subprocess.CalledProcessError: raise cls.Error("Not a Subversion working copy") except OSError: raise cls.Error("Subversion binary [{svn}] is not available".format( svn=as_warning( cls.binary() ) ) ) try: command = "svnversion -n {path}".format( path=path ) revision = as_str( subprocess.check_output( shlex.split( command ), stderr=subprocess.STDOUT ) ) except subprocess.CalledProcessError: pass except OSError: logger.warn( "The {svnversion} binary is not available. Consider installing it.".format( svnversion=as_warning("svnversion") ) ) return url, repository, branch, remote, revision
def info(cls, path): if not path: raise cls.Error( "No working copy path specified for calling bzr commands with." ) url = None repository = None branch = None remote = None revision = None if not os.path.exists(os.path.join(path, ".bzr")): raise cls.Error("Not a Bazaar working copy") try: command = "{bzr} nick".format(bzr=cls.binary()) branch = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()) command = "{bzr} revno".format(bzr=cls.binary()) revision = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()) command = "{bzr} info".format(bzr=cls.binary()) bzr_info = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()) repository_match = re.search( r'shared repository: (?P<repository>.*)\n', bzr_info) if repository_match: repository = repository_match.group('repository') url_match = re.search(r'checkout of branch: (?P<url>.*)\n', bzr_info) if url_match: url = url_match.group('url') except subprocess.CalledProcessError: raise cls.Error("Not a Bazaar working copy") except OSError: raise cls.Error("Bazaar binary [{bzr}] is not available".format( bzr=cls.binary())) return url, repository, branch, remote, revision
def info(cls, path): if not path: raise cls.Error( "No working copy path specified for calling hg commands with.") url = None repository = None branch = None remote = None revision = None if not os.path.exists(os.path.join(path, ".hg")): raise cls.Error("Not a Mercurial working copy") try: command = "{hg} summary".format(hg=cls.binary()) summary = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()).split('\n') revision = "" branch = "" for line in summary: if not revision and line.startswith('parent: '): revision = line.replace('parent: ', '') if branch: break elif not branch and line.startswith('branch: '): branch = line.replace('branch: ', '') if revision: break command = "{hg} path".format(hg=cls.binary()) repository = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()).split('=')[1] url = repository except subprocess.CalledProcessError: raise cls.Error("Not a Mercurial working copy") except OSError: raise cls.Error("Mercurial binary [{hg}] is not available".format( hg=cls.binary())) return url, repository, branch, remote, revision
def get_branch(cls, path): branch = None remote = None # In case we have a detached head we use this result = as_str( cls.execute_command( "{git} show -s --pretty=\%d HEAD".format(git=cls.binary()), path)) match = re.search(r'[(]HEAD[^,]*[,] (?P<branches>[^)]+)[)]', result) if match: branches = [b.strip() for b in match.group("branches").split(',')] logger.trace("Branches (using show) for [{}] are [{}]".format( as_notice(path), colour_items(branches))) if len(branches) == 1: # If this returns a tag: tag_name replace the ": " with "/" and then extract the tag_name # otherwise this will simply extract the branch_name as expected if not branches[0].startswith('tag:'): remote = branches[0] branch = branches[0].replace(': ', '/').split('/')[1] else: remote = branches[-2] branch = remote.split('/')[1] logger.trace("Branch (using show) for [{}] is [{}]".format( as_notice(path), as_info(branch))) else: logger.warn("No branch found from [{}]".format(result)) return branch, remote
def version_from_command(cls, cxx): command = "{} --version".format(cxx) if command_available(command): reported_version = None version_string = as_str( Popen(shlex.split(command), stdout=PIPE).communicate()[0]) matches = re.search(r'based on LLVM (?P<major>\d+)\.(?P<minor>\d)', version_string) if not matches: matches = re.search( r'Apple LLVM version (?P<major>\d+)\.(?P<minor>\d)', version_string) if not matches: matches = re.search( r'clang version (?P<major>\d+)\.(?P<minor>\d)', version_string) if matches: major = matches.group('major') minor = matches.group('minor') reported_version = {} reported_version['toolchain'] = 'clang' reported_version['name'] = 'clang' + major + minor reported_version['major'] = int(major) reported_version['minor'] = int(minor) reported_version['version'] = major + "." + minor reported_version['short_version'] = major + minor return reported_version return None
def version_from_command(cls, cxx, prefix): command = "{} --version".format(cxx) if command_available(command): reported_version = as_str( Popen(shlex.split(command), stdout=PIPE).communicate()[0]) reported_version = prefix + re.search( r'(\d)\.(\d)', reported_version).expand(r'\1\2') return reported_version return None
def __call__(self): for line in iter(self.call_readline, self._empty_str): line = as_str(line) if line: if self.processor: line = self.processor(line) if line: sys.stdout.write(line) else: sys.stdout.write(line)
def llvm_version_from(cls, llvm_tool): command = "{} --version".format(llvm_tool) if command_available(command): reported_version = as_str( Popen(shlex.split(command), stdout=PIPE).communicate()[0]) version = re.search(r'LLVM version (\d)\.(\d)\.(\d)', reported_version) reported_version = version.expand(r'\1') return reported_version return None
def _get_qt5_version(self): command = "pkg-config --modversion Qt5Core" try: return as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT).strip()) except: logger.debug( "In _get_qt5_version() failed to execute [{}]".format(command)) return None
def __call__(self): for line in iter(self.call_readline, ""): line = as_str(line.rstrip()) if line: if self.processor: line = self.processor(line) if line: print(line) else: print(line)
def info(cls, path): if not path: raise cls.Error( "No working copy path specified for calling git commands with." ) url = None repository = None branch = None remote = None revision = None if not os.path.exists(os.path.join(path, ".git")): raise cls.Error("Not a Git working copy") command = None try: command = "{git} describe --always".format(git=cls.binary()) revision = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()) branch, remote = cls.get_branch(path) command = "{git} config --get remote.origin.url".format( git=cls.binary()) repository = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path).strip()) url = repository except subprocess.CalledProcessError: raise cls.Error( "Git command [{command}] failed".format(command=str(command))) except OSError: raise cls.Error( "Git binary [{git}] is not available".format(git=cls.binary())) return url, repository, branch, remote, revision
def get_flags(cls, location): flags = {} flags['INCPATH'] = [os.path.join(location.local(), "include")] pg_config = "pg_config" if platform.system() == "Windows": pg_config = pg_config + ".exe" if not cuppa.output_processor.command_available(pg_config): # try to find the Postgresql install program_files = os.environ.get("ProgramW6432") postgresql_base = os.path.join(program_files, "PostgreSQL") if os.path.exists(postgresql_base): paths = glob.glob(postgresql_base + '\\*') if len(paths): paths.sort() latest = paths[-1] pg_config = '\"' + os.path.join( latest, "bin", pg_config) + '\"' if cuppa.output_processor.command_available(pg_config): command = "{pg_config} --includedir".format(pg_config=pg_config) libpq_include = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT).strip()) flags['INCPATH'].append(libpq_include) command = "{pg_config} --libdir".format(pg_config=pg_config) libpq_libpath = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT).strip()) flags['LIBPATH'] = [libpq_libpath] else: logger.error( "postgresql: pg_config not available so cannot determine LIBPATH for postgres libraries" ) raise QuinceException("pg_config not available") flags['DYNAMICLIBS'] = ['pq'] return flags
def get_info( cls, location, local_directory, full_url, expected_vc_type = None ): vcs_info = cls.detect_vcs_info( local_directory, expected_vc_type ) if vcs_info: return tuple( as_str(t) for t in vcs_info ) url = location repository = urlunparse( ( full_url.scheme, full_url.netloc, '', '', '', '' ) ) branch_path = unquote( full_url.path ) remote = None revision = None return ( url, repository, branch_path, remote, revision )
def __call__( self ): try: for line in iter( self.call_readline, "" ): line = as_str( line.rstrip() ) if line: if self.processor: line = self.processor( line ) if line: print( line ) else: print( line ) except UnicodeDecodeError as error: print( "WARNING: Ignoring unicode error {}".format( error ) )
def _libc_version( self, machine, system ): libc_file = "libc.so.6" libc_path = "/lib/" + libc_file if not path.exists( libc_path ): multiarch_lib_path = '-'.join( [ machine, system.lower(), 'gnu' ] ) libc_path = "/lib/" + multiarch_lib_path + "/" + libc_file try: libc_version = Popen([libc_path], stdout=PIPE).communicate()[0] return 'libc' + search( r'^GNU C Library [()a-zA-Z ]*([0-9][.0-9]+)', as_str( libc_version ), MULTILINE ).expand(r'\1').replace('.','') except: logger.warn( "Could not detect the version of libc installed. You might be missing some development libraries!" ) return None
def version_from_command(cls, cxx): command = "{} --version".format(cxx) if command_available(command): reported_version = as_str( Popen(shlex.split(command), stdout=PIPE).communicate()[0]) version = re.search(r'based on LLVM (\d)\.(\d)', reported_version) if not version: version = re.search(r'Apple LLVM version (\d)\.(\d)', reported_version) if not version: version = re.search(r'clang version (\d)\.(\d+)', reported_version) reported_version = 'clang' + version.expand(r'\1\2') return reported_version return None
def _set_qt5_dir(self, env): command = "pkg-config --cflags Qt5Core" try: cflags = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT).strip()) if cflags: flags = env.ParseFlags(cflags) if 'CPPPATH' in flags: shortest_path = flags['CPPPATH'][0] for include in flags['CPPPATH']: if len(include) < len(shortest_path): shortest_path = include env['QT5DIR'] = shortest_path except: logger.debug( "In _set_qt5_dir() failed to execute [{}]".format(command))
def execute_command(cls, command, path=None): try: logger.trace("Executing command [{command}]...".format( command=as_info(command))) result = as_str( subprocess.check_output(shlex.split(command), stderr=subprocess.STDOUT, cwd=path)).strip() logger.trace("Result of calling [{command}] was [{result}]".format( command=as_info(command), result=as_notice(result))) return result except subprocess.CalledProcessError as error: logger.trace( "Command [{command}] failed with exit code [{exit_code}]". format(command=as_warning(str(command)), exit_code=as_warning(str(error.returncode)))) raise cls.Error( "Command [{command}] failed".format(command=str(command))) except OSError: logger.trace("Binary [{git}] is not available".format( git=as_warning(cls.binary()))) raise cls.Error( "Binary [{git}] is not available".format(git=cls.binary()))
def __init__(self): secret_regex = re.compile(r'.*TOKEN.*') self.secrets = {} for key, val in six.iteritems(os.environ): if re.match(secret_regex, key): self.secrets[as_str(val)] = key