def parse_dir(dirpath, extension=None):
if os.path.exists('.git'):
files = shell.check_output(['git', 'ls-files', dirpath]).split('\n')
files.remove('')
else:
files = shell.check_output(['find', dirpath, '-type', 'f']).split('\n')
files.remove('')
if extension is None:
return files
return [f for f in files if f.endswith(extension)]
def check_arch():
native_arch = shell.check_output(['dpkg', '--print-architecture'])
if native_arch == arch:
return
foreign_archs = shell.check_output(['dpkg', '--print-foreign-architectures'])
if arch in foreign_archs.split():
return
raise ConfigurationError(('Architecture %s is missing from your setup. ' + \
'You can add it with: "dpkg --add-architecture %s",' + \
' then run "apt-get update."') \
% (arch, arch))
def __init__(self, config, offline, assume_yes):
UnixBootstrapper.__init__(self, config, offline, assume_yes)
has_multilib = True
try:
shell.check_output (["pacman", "-Sp", "gcc-multilib"])
except CommandError:
has_multilib = False
if self.config.arch == Architecture.X86_64 and has_multilib:
self.packages.append('gcc-multilib')
else:
self.packages.append('gcc')
def _get_vswhere_vs_install(vswhere, vs_versions):
import json
vswhere_exe = str(vswhere)
# Get a list of installation paths for all installed Visual Studio
# instances, from VS 2013 to the latest one, sorted from newest to
# oldest, and including preview releases.
# Will not include BuildTools installations.
out = check_output([
vswhere_exe, '-legacy', '-prerelease', '-format', 'json', '-utf8',
'-sort'
])
installs = json.loads(out)
program_files = get_program_files_dir()
for install in installs:
version = install['installationVersion']
vs_version = 'vs' + version.split('.', maxsplit=1)[0]
if vs_version not in vs_versions:
continue
prefix = install['installationPath']
suffix = VCVARSALLS[vs_version][1]
path = program_files / prefix / suffix
# Find the location of the Visual Studio installation
if path.is_file():
return path.as_posix(), vs_version
raise FatalError(
'vswhere.exe could not find Visual Studio installation(s). '
'Looked for version(s): ' + ', '.join(vs_versions))
def list_file_deps(self, prefix, path):
files = shell.check_output(['otool', '-L', path]).splitlines()[1:]
# Shared libraries might be relocated, we look for files with the
# prefix or starting with @rpath
files = [
x.strip().split(' ')[0] for x in files
if prefix in x or "@rpath" in x
]
return [x.replace("@rpath/", prefix) for x in files]
def get_implib_dllname(config, path):
if config.msvc_toolchain_env and path.endswith('.lib'):
lib_exe = shutil.which('lib', path=config.msvc_toolchain_env['PATH'][0])
if not lib_exe:
raise FatalError('lib.exe not found, check cerbero configuration')
try:
ret = shell.check_output([lib_exe, '-list', path])
except FatalError:
return 0
# The last non-empty line should contain the dllname
return ret.split('\n')[-2]
dlltool = os.environ.get('DLLTOOL', None)
if not dlltool:
raise FatalError('dlltool not found, check cerbero configuration')
try:
return shell.check_output([dlltool, '-I', path])
except FatalError:
return 0
def list_shared_libraries(object_file):
res = shell.check_output([OTOOL_CMD, '-L', object_file]).splitlines()
# We don't use the first line
libs = res[1:]
# Remove the first character tabulation
libs = [x[1:] for x in libs]
# Remove the version info
libs = [x.split(' ', 1)[0] for x in libs]
return libs
def _get_la_deps_from_pc(self, laname, pcname, env):
ret = shell.check_output(
['pkg-config', '--libs-only-l', '--static', pcname],
env=env,
logfile=self.logfile)
# Don't add the library itself to the list of dependencies
return [
'lib' + lib[2:] for lib in self._get_unique_ordered(ret.split())
if lib[2:] != laname[3:]
]
def _perl_version(self):
try:
version = shell.check_output("perl -e 'print \"$]\";'")
except FatalError:
m.warning(_("Perl not found, you may need to run bootstrap."))
version = '0.000000'
# FIXME: when perl's mayor is >= 10
mayor = str(version[0])
minor = str(int(version[2:5]))
revision = str(int(version[5:8]))
return '.'.join([mayor, minor, revision])
def revision(repo):
'''
Get the current revision of a repository with svnversion
@param repo: the path to the repository
@type repo: str
'''
rev = shell.check_output(['svnversion'], cmd_dir=repo).splitlines()[0]
if rev[-1] == 'M':
rev = rev[:-1]
return rev
def list_tags(git_dir):
'''
List all tags
@param git_dir: path of the git repository
@type git_dir: str
@param fail: raise an error if the command failed
@type fail: false
@return: list of tag names (str)
@rtype: list
'''
return shell.check_output([GIT, 'tag', '-l'], cmd_dir=git_dir).strip().splitlines()
def find_orphan_files(self, allfiles, prefix, excludes=[]):
cmd = ['find', '.', '-type', 'f']
for x in excludes:
cmd += ['(', '!', '-name', x, ')']
distfiles = shell.check_output(cmd, cmd_dir=prefix).splitlines()
# remove './' from the list of files
distfiles = [f[2:] for f in distfiles]
orphan = sorted(list((set(distfiles) - set(allfiles))))
if len(orphan) > 0:
m.message("Found orphan files:")
m.message('\n'.join(orphan))
def gendef(self, dllpath, outputdir, libname):
defname = libname + '.def'
def_contents = shell.check_output('gendef - %s' % dllpath, outputdir,
logfile=self.logfile)
# If the output doesn't contain a 'LIBRARY' directive, gendef errored
# out. However, gendef always returns 0 so we need to inspect the
# output and guess.
if 'LIBRARY' not in def_contents:
raise FatalError('gendef failed on {!r}\n{}'.format(dllpath, def_contents))
with open(os.path.join(outputdir, defname), 'w') as f:
f.write(def_contents)
return defname
def _call(cmd, delimiter=None, env=None):
env = os.environ.copy() if env is None else env.copy()
output = shell.check_output(cmd, env=env)
output = output.strip()
if delimiter:
res = output.split('%s' % delimiter)
if res[0] == ' ':
res.remove(' ')
if res[0] == '':
res.remove('')
return [x.strip() for x in res]
return output
def list_file_deps(self, prefix, path):
env = os.environ.copy()
env['LC_ALL'] = 'C'
files = shell.check_output(['objdump', '-xw', path],
env=env).splitlines()
prog = re.compile(r"(?i)^.*DLL[^:]*: (\S+\.dll)$")
files = [
prog.sub(r"\1", x) for x in files if prog.match(x) is not None
]
files = [
os.path.join(prefix, 'bin', x) for x in files
if x.lower().endswith('dll')
]
return [os.path.realpath(x) for x in files if os.path.exists(x)]
def check_line_endings(platform):
'''
Checks if on windows we don't use the automatic line endings conversion
as it breaks everything
@param platform: the host platform
@type platform: L{cerbero.config.Platform}
@return: true if git config is core.autorlf=false
@rtype: bool
'''
if platform != Platform.WINDOWS:
return True
val = shell.check_output([GIT, 'config', '--get', 'core.autocrlf'], fail=False)
if ('false' in val.lower()):
return True
return False
def get_hash(git_dir, commit, logfile=None):
'''
Get a commit hash from a valid commit.
Can be used to check if a commit exists
@param git_dir: path of the git repository
@type git_dir: str
@param commit: the commit to log
@type commit: str
'''
if not os.path.isdir(os.path.join(git_dir, '.git')):
# If a recipe's source type is switched from tarball to git, then we
# can get called from built_version() when the directory isn't git.
# Return a fixed string + unix time to trigger a full fetch.
return 'not-git-' + str(time.time())
return shell.check_output([GIT, 'rev-parse', commit], cmd_dir=git_dir,
fail=False, quiet=True, logfile=logfile).rstrip()
async def submodules_update(git_dir, src_dir=None, fail=True, offline=False, logfile=None):
'''
Update submodules asynchronously from local directory
@param git_dir: path of the git repository
@type git_dir: str
@param src_dir: path or base URI of the source directory
@type src_dir: src
@param fail: raise an error if the command failed
@type fail: false
@param offline: don't use the network
@type offline: false
'''
if src_dir:
config = shell.check_output([GIT, 'config', '--file=.gitmodules', '--list'],
fail=False, cmd_dir=git_dir, logfile=logfile)
config_array = [s.split('=', 1) for s in config.splitlines()]
for c in config_array:
if c[0].startswith('submodule.') and c[0].endswith('.path'):
submodule = c[0][len('submodule.'):-len('.path')]
shell.new_call([GIT, 'config', '--file=.gitmodules', 'submodule.{}.url'.format(submodule),
os.path.join(src_dir, c[1])], cmd_dir=git_dir, logfile=logfile)
shell.new_call([GIT, 'submodule', 'init'], cmd_dir=git_dir, logfile=logfile)
if src_dir or not offline:
await shell.async_call([GIT, 'submodule', 'sync'], cmd_dir=git_dir, logfile=logfile,
cpu_bound=False)
await shell.async_call([GIT, 'submodule', 'update'], cmd_dir=git_dir, fail=fail,
logfile=logfile, cpu_bound=False)
else:
await shell.async_call([GIT, 'submodule', 'update', '--no-fetch'], cmd_dir=git_dir,
fail=fail, logfile=logfile, cpu_bound=False)
if src_dir:
for c in config_array:
if c[0].startswith('submodule.') and c[0].endswith('.url'):
shell.new_call([GIT, 'config', '--file=.gitmodules', c[0], c[1]],
cmd_dir=git_dir, logfile=logfile)
await shell.async_call([GIT, 'submodule', 'sync'], cmd_dir=git_dir, logfile=logfile,
cpu_bound=False)
def get_file_type(self, filepath):
return shell.check_output([self.FILE_CMD, '-bh',
filepath])[:-1] #remove trailing \n
def _is_mach_o_file(self, filename):
return os.path.splitext(filename)[1] in ['.dylib', '.so'] or \
shell.check_output(['file', '-bh', filename]).startswith('Mach-O')
def list_deps(self, prefix, path):
files = shell.check_output(['ldd', path]).splitlines()
return [x.split(' ')[2] for x in files if prefix in x]
