import platform
import glob
-from portage.output import bold, red, blue, yellow, green, nocolor
+from portage.output import bold, blue, yellow, green
from .stuff import scan
-from .collect import prepare_search_dirs, parse_revdep_config, collect_libraries_from_dir, collect_binaries_from_dir
+from .collect import (prepare_search_dirs, parse_revdep_config,
+ collect_libraries_from_dir, collect_binaries_from_dir)
from .assign import assign_packages
from .cache import save_cache
def prepare_checks(files_to_check, libraries, bits, cmd_max_args):
- ''' Calls scanelf for all files_to_check, then returns found libraries and dependencies
+ ''' Calls scanelf for all files_to_check,
+ then returns found libraries and dependencies
'''
- libs = [] # libs found by scanelf
- dependencies = [] # list of lists of files (from file_to_check) that uses
- # library (for dependencies[id] and libs[id] => id==id)
+ # libs found by scanelf
+ libs = []
+ # list of lists of files (from file_to_check) that uses
+ # library (for dependencies[id] and libs[id] => id==id)
+ dependencies = []
+ for line in scan(
+ ['-M', str(bits), '-nBF', '%F %n'],
+ files_to_check, cmd_max_args
+ ):
- for line in scan(['-M', str(bits), '-nBF', '%F %n'], files_to_check, cmd_max_args):
- #call_program(['scanelf', '-M', str(bits), '-nBF', '%F %n',]+files_to_check).strip().split('\n'):
- r = line.strip().split(' ')
- if len(r) < 2: # no dependencies?
+ parts = line.strip().split(' ')
+ if len(parts) < 2: # no dependencies?
continue
- deps = r[1].split(',')
- for d in deps:
- if d in libs:
- i = libs.index(d)
- dependencies[i].append(r[0])
+ deps = parts[1].split(',')
+ for dep in deps:
+ if dep in libs:
+ index = libs.index(dep)
+ dependencies[index].append(parts[0])
else:
- libs.append(d)
- dependencies.append([r[0],])
+ libs.append(dep)
+ dependencies.append([parts[0],])
return (libs, dependencies)
broken = []
libnames = []
- for l in libraries:
- m = re.match('.+\/(.+)\.(so|la|a)(\..+)?', l)
- if m is not None:
- ln = m.group(1)
- if ln not in libnames:
- libnames += [ln, ]
-
- for f in la:
- if not os.path.exists(f):
+ for lib in libraries:
+ match = re.match('.+\/(.+)\.(so|la|a)(\..+)?', lib)
+ if match is not None:
+ libname = match.group(1)
+ if libname not in libnames:
+ libnames += [libname, ]
+
+ for _file in la:
+ if not os.path.exists(_file):
continue
- for line in open(f, 'r').readlines():
+ for line in open(_file, 'r').readlines():
line = line.strip()
if line.startswith('dependency_libs='):
- m = re.match("dependency_libs='([^']+)'", line)
- if m is not None:
- for el in m.group(1).split(' '):
+ match = re.match("dependency_libs='([^']+)'", line)
+ if match is not None:
+ for el in match.group(1).split(' '):
el = el.strip()
- if len(el) < 1 or el.startswith('-L') or el.startswith('-R'):
+ if (len(el) < 1 or el.startswith('-L')
+ or el.startswith('-R')
+ ):
continue
if el.startswith('-l') and 'lib'+el[2:] in libnames:
if not _break:
continue
- logger.info(yellow(' * ') + f + ' is broken (requires: ' + bold(el)+')')
- broken.append(f)
+ logger.info(yellow(' * ') + _file +
+ ' is broken (requires: ' + bold(el)+')')
+ broken.append(_file)
return broken
is list of library names.
'''
- # join libraries and looking at it as string is way too faster than for-jumping
+ # join libraries and looking at it as string
+ # is way faster than for-jumping
broken = []
- sl = '|'.join(system_libraries)
+ syslibs = '|'.join(system_libraries)
if not to_check:
- for f in found_libs:
- if f+'|' not in sl:
- broken.append(found_libs.index(f))
+ for found in found_libs:
+ if found + '|' not in syslibs:
+ broken.append(found_libs.index(found))
else:
for tc in to_check:
- for f in found_libs:
- if tc in f:# and f+'|' not in sl:
- broken.append(found_libs.index(f))
+ for found in found_libs:
+ if tc in found:# and found+'|' not in syslibs:
+ broken.append(found_libs.index(found))
return broken
-def main_checks(found_libs, broken, dependencies, logger):
+def main_checks(found_libs, broken_list, dependencies, logger):
''' Checks for broken dependencies.
found_libs have to be the same as returned by prepare_checks
- broken is list of libraries found by scanelf
+ broken_list is list of libraries found by scanelf
dependencies is the value returned by prepare_checks
'''
broken_pathes = []
- for b in broken:
- f = found_libs[b]
- logger.info('Broken files that requires: ' + bold(f))
- for d in dependencies[b]:
- logger.info(yellow(' * ') + d)
- broken_pathes.append(d)
+ for broken in broken_list:
+ found = found_libs[broken]
+ logger.info('Broken files that requires: ' + bold(found))
+ for dep_path in dependencies[broken]:
+ logger.info(yellow(' * ') + dep_path)
+ broken_pathes.append(dep_path)
return broken_pathes
"""
if libraries and la_libraries and libraries_links and binaries:
- logger.info(blue(' * ') + bold('Found a valid cache, skipping collecting phase'))
+ logger.info(blue(' * ') +
+ bold('Found a valid cache, skipping collecting phase'))
else:
- #TODO: add partial cache (for ex. only libraries) when found for some reason
+ #TODO: add partial cache (for ex. only libraries)
+ # when found for some reason
- logger.warn(green(' * ') + bold('Collecting system binaries and libraries'))
+ logger.warn(green(' * ') +
+ bold('Collecting system binaries and libraries'))
bin_dirs, lib_dirs = prepare_search_dirs(logger, settings)
- masked_dirs, masked_files, ld = parse_revdep_config(settings['REVDEP_CONFDIR'])
+ masked_dirs, masked_files, ld = \
+ parse_revdep_config(settings['REVDEP_CONFDIR'])
lib_dirs.update(ld)
bin_dirs.update(ld)
- masked_dirs = masked_dirs.union(set(['/lib/modules', '/lib32/modules', '/lib64/modules',]))
+ masked_dirs.update([
+ '/lib/modules',
+ '/lib32/modules',
+ '/lib64/modules'
+ ]
+ )
- logger.info(green(' * ') + bold('Collecting dynamic linking informations'))
- libraries, la_libraries, libraries_links, symlink_pairs = collect_libraries_from_dir(lib_dirs, masked_dirs, logger)
+ logger.info(green(' * ') +
+ bold('Collecting dynamic linking informations'))
+ libraries, la_libraries, libraries_links, symlink_pairs = \
+ collect_libraries_from_dir(lib_dirs, masked_dirs, logger)
binaries = collect_binaries_from_dir(bin_dirs, masked_dirs, logger)
if settings['USE_TMP_FILES']:
)
- logger.debug('Found '+ str(len(libraries)) + ' libraries (+' + str(len(libraries_links)) + ' symlinks) and ' + str(len(binaries)) + ' binaries')
+ logger.debug('Found '+ str(len(libraries)) +
+ ' libraries (+' + str(len(libraries_links)) +
+ ' symlinks) and ' + str(len(binaries)) +
+ ' binaries')
logger.warn(green(' * ') + bold('Checking dynamic linking consistency'))
- logger.debug('Search for ' + str(len(binaries)+len(libraries)) + ' within ' + str(len(libraries)+len(libraries_links)))
+ logger.debug('Search for ' + str(len(binaries)+len(libraries)) +
+ ' within ' + str(len(libraries)+len(libraries_links)))
libs_and_bins = libraries+binaries
- #l = []
- #for line in call_program(['scanelf', '-M', '64', '-BF', '%F',] + libraries).strip().split('\n'):
- #l.append(line)
- #libraries = l
-
found_libs = []
dependencies = []
elif _bits.startswith('64'):
bits = 64
- import time
broken = []
for av_bits in glob.glob('/lib[0-9]*') or ('/lib32',):
bits = int(av_bits[4:])
- #_libraries = scan(['-M', str(bits), '-BF', '%F'], libraries+libraries_links, settings['CMD_MAX_ARGS'])
_libraries = libraries+libraries_links
- found_libs, dependencies = prepare_checks(libs_and_bins, _libraries, bits, settings['CMD_MAX_ARGS'])
+ found_libs, dependencies = prepare_checks(libs_and_bins,
+ _libraries, bits, settings['CMD_MAX_ARGS'])
broken = find_broken(found_libs, _libraries, _libs_to_check)
bits /= 2
bits = int(bits)
- broken_la = extract_dependencies_from_la(la_libraries, libraries+libraries_links, _libs_to_check, logger)
+ broken_la = extract_dependencies_from_la(la_libraries,
+ libraries+libraries_links, _libs_to_check, logger)
broken_pathes = main_checks(found_libs, broken, dependencies, logger)
import re
import portage
+from portage.versions import catpkgsplit
from portage import portdb
-from portage.output import bold, red, blue, yellow, green, nocolor
+from portage.output import bold, red, yellow
def assign_packages(broken, logger, settings):
assigned = set()
for group in os.listdir(settings['PKG_DIR']):
for pkg in os.listdir(settings['PKG_DIR'] + group):
- f = settings['PKG_DIR'] + group + '/' + pkg + '/CONTENTS'
- if os.path.exists(f):
+ _file = settings['PKG_DIR'] + group + '/' + pkg + '/CONTENTS'
+ if os.path.exists(_file):
try:
- with open(f, 'r') as cnt:
+ with open(_file, 'r') as cnt:
for line in cnt:
- m = re.match('^obj (/[^ ]+)', line)
- if m is not None:
- m = m.group(1)
- if m in broken:
+ matches = re.match('^obj (/[^ ]+)', line)
+ if matches is not None:
+ match = matches.group(1)
+ if match in broken:
found = group+'/'+pkg
if found not in assigned:
assigned.add(found)
- logger.info('\t' + m + ' -> ' + bold(found))
- except Exception as e:
- logger.warn(red(' !! Failed to read ' + f))
+ logger.info('\t' + match + ' -> '
+ + bold(found))
+ except Exception as ex:
+ logger.warn(red(' !! Failed to read ' + _file) +
+ " Original exception was:\n" + str(ex))
return assigned
logger.warn(yellow('Warning: ebuild "' + cpv + '" not found.'))
logger.info('Looking for %s:%s' %(cp, slot))
try:
- m = portdb.match('%s:%s' %(cp, slot))
+ match = portdb.match('%s:%s' %(cp, slot))
except portage.exception.InvalidAtom:
- m = None
+ match = None
- if not m:
- logger.warn(red('!!') + ' ' + yellow('Could not find ebuild for %s:%s' %(cp, slot)))
+ if not match:
+ logger.warn(red('!!') + ' ' + yellow(
+ 'Could not find ebuild for %s:%s' %(cp, slot)))
slot = ['']
- m = portdb.match(cp)
- if not m:
- logger.warn(red('!!') + ' ' + yellow('Could not find ebuild for ' + cp))
- return m, slot
+ match = portdb.match(cp)
+ if not match:
+ logger.warn(red('!!') + ' ' +
+ yellow('Could not find ebuild for ' + cp))
+ return match, slot
def get_slotted_cps(cpvs, logger):
"""Uses portage to reduce the cpv list into a cp:slot list and returns it
"""
- from portage.versions import catpkgsplit
- from portage import portdb
cps = []
for cpv in cpvs:
try:
slot = portdb.aux_get(cpv, ["SLOT"])
except KeyError:
- m, slot = get_best_match(cpv, cp, logger)
- if not m:
- logger.warn(red("Installed package: %s is no longer available" %cp))
+ match, slot = get_best_match(cpv, cp, logger)
+ if not match:
+ logger.warn(red("Installed package: "
+ "%s is no longer available" %cp))
continue
if slot[0]:
This function does not checks if files exists nor timestamps,
check_temp_files should be called first
@param temp_path: directory where all temp files should reside
- @return tuple with values of: libraries, la_libraries, libraries_links, symlink_pairs, binaries
+ @return tuple with values of:
+ libraries, la_libraries, libraries_links, symlink_pairs, binaries
'''
- ret = {'libraries':[], 'la_libraries':[], 'libraries_links':[], 'binaries':[]}
+ ret = {
+ 'libraries':[],
+ 'la_libraries':[],
+ 'libraries_links':[],
+ 'binaries':[]
+ }
try:
- for key,val in list(ret.items()):
- f = open(os.path.join(temp_path, key))
- for line in f.readlines():
+ for key, val in list(ret.items()):
+ _file = open(os.path.join(temp_path, key))
+ for line in _file .readlines():
val.append(line.strip())
#libraries.remove('\n')
- f.close()
+ _file .close()
except EnvironmentError:
pass
- return (ret['libraries'], ret['la_libraries'], ret['libraries_links'], ret['binaries'])
+ return (ret['libraries'], ret['la_libraries'],
+ ret['libraries_links'], ret['binaries'])
-def save_cache(logger, to_save={}, temp_path=DEFAULTS['DEFAULT_TMP_DIR']):
+def save_cache(logger, to_save=None, temp_path=DEFAULTS['DEFAULT_TMP_DIR']):
''' Tries to store caching information.
@param logger
- @param to_save have to be dict with keys: libraries, la_libraries, libraries_links and binaries
+ @param to_save have to be dict with keys:
+ libraries, la_libraries, libraries_links and binaries
'''
+
+ if to_save is None:
+ to_save = {}
if not os.path.exists(temp_path):
os.makedirs(temp_path)
try:
- f = open(os.path.join(temp_path, 'timestamp'), 'w')
- f.write(str(int(time.time())))
- f.close()
+ _file = open(os.path.join(temp_path, 'timestamp'), 'w')
+ _file.write(str(int(time.time())))
+ _file.close()
- for key,val in list(to_save.items()):
- f = open(os.path.join(temp_path, key), 'w')
+ for key, val in list(to_save.items()):
+ _file = open(os.path.join(temp_path, key), 'w')
for line in val:
- f.write(line + '\n')
- f.close()
+ _file.write(line + '\n')
+ _file.close()
except Exception as ex:
logger.warn(red('Could not save cache: %s' %str(ex)))
-def check_temp_files(temp_path=DEFAULTS['DEFAULT_TMP_DIR'], max_delay=3600):
+def check_temp_files(temp_path=DEFAULTS['DEFAULT_TMP_DIR'], max_delay=3600,
+ logger=None):
''' Checks if temporary files from previous run are still available
and if they aren't too old
@param temp_path is directory, where temporary files should be found
- @param max_delay is maximum time difference (in seconds) when those files
- are still considered fresh and useful
+ @param max_delay is maximum time difference (in seconds)
+ when those files are still considered fresh and useful
returns True, when files can be used, or False, when they don't
exists or they are too old
'''
return False
try:
- f = open(timestamp_path)
- timestamp = int(f.readline())
- f.close()
- except:
+ _file = open(timestamp_path)
+ timestamp = int(_file.readline())
+ _file .close()
+ except Exception as ex:
+ if logger:
+ logger.debug("check_temp_files(); error retrieving"
+ " timestamp_path:\n" + str(ex))
timestamp = 0
return False
if __name__ == '__main__':
print('Preparing cache ... ')
- from .collect import *
+ from .collect import (prepare_search_dirs, parse_revdep_config,
+ collect_libraries_from_dir, collect_binaries_from_dir)
+
import logging
- bin_dirs, lib_dirs = prepare_search_dirs()
+ bin_dirs, lib_dirs = prepare_search_dirs(logging, DEFAULTS)
- masked_dirs, masked_files, ld = parse_revdep_config()
+ masked_dirs, masked_files, ld = parse_revdep_config("/etc/revdep-rebuild/")
lib_dirs.update(ld)
bin_dirs.update(ld)
- masked_dirs = masked_dirs.update(['/lib/modules', '/lib32/modules', '/lib64/modules',])
+ masked_dirs = masked_dirs.update([
+ '/lib/modules',
+ '/lib32/modules',
+ '/lib64/modules'
+ ]
+ )
- libraries, la_libraries, libraries_links, symlink_pairs = collect_libraries_from_dir(lib_dirs, masked_dirs, logging)
+ libraries, la_libraries, libraries_links, symlink_pairs = \
+ collect_libraries_from_dir(lib_dirs, masked_dirs, logging)
binaries = collect_binaries_from_dir(bin_dirs, masked_dirs, logging)
save_cache(logger=logging,
import stat
import portage
-from portage.output import bold, red, blue, yellow, green, nocolor
+from portage.output import blue, yellow
def parse_conf(conf_file, visited=None, logger=None):
lib_dirs = set(['/lib', '/usr/lib', ])
#try:
- with open(os.path.join(portage.root, settings['DEFAULT_ENV_FILE']), 'r') as _file:
+ with open(os.path.join(
+ portage.root, settings['DEFAULT_ENV_FILE']), 'r') as _file:
for line in _file:
line = line.strip()
- m = re.match("^export (ROOT)?PATH='([^']+)'", line)
- if m is not None:
- bin_dirs.update(set(m.group(2).split(':')))
+ match = re.match("^export (ROOT)?PATH='([^']+)'", line)
+ if match is not None:
+ bin_dirs.update(set(match.group(2).split(':')))
#except EnvironmentError:
#logger.debug(yellow('Could not open file %s' % f))
def parse_revdep_config(revdep_confdir):
- ''' Parses all files under /etc/revdep-rebuild/ and returns
+ ''' Parses all files under and returns
tuple of: (masked_dirs, masked_files, search_dirs)'''
search_dirs = set()
masked_dirs = set()
masked_files = set()
- #TODO: remove hard-coded path
for _file in os.listdir(revdep_confdir):
- for line in open(os.path.join('/etc/revdep-rebuild', _file)):
+ for line in open(os.path.join(revdep_confdir, _file)):
line = line.strip()
#first check for comment, we do not want to regex all lines
if not line.startswith('#'):
- m = re.match('LD_LIBRARY_MASK=\\"([^"]+)\\"', line)
- if m is not None:
- s = m.group(1).split(' ')
- masked_files = masked_files.union(s)
+ match = re.match('LD_LIBRARY_MASK=\\"([^"]+)\\"', line)
+ if match is not None:
+ masks = match.group(1).split(' ')
+ masked_files = masked_files.union(masks)
continue
- m = re.match('SEARCH_DIRS_MASK=\\"([^"]+)\\"', line)
- if m is not None:
- s = m.group(1).split(' ')
- for ss in s:
- masked_dirs = masked_dirs.union(glob.glob(ss))
+ match = re.match('SEARCH_DIRS_MASK=\\"([^"]+)\\"', line)
+ if match is not None:
+ searches = match.group(1).split(' ')
+ for search in searches:
+ masked_dirs = masked_dirs.union(glob.glob(search))
continue
- m = re.match('SEARCH_DIRS=\\"([^"]+)\\"', line)
- if m is not None:
- s = m.group(1).split()
- for ss in s:
- search_dirs = search_dirs.union(glob.glob(ss))
+ match = re.match('SEARCH_DIRS=\\"([^"]+)\\"', line)
+ if match is not None:
+ searches = match.group(1).split()
+ for search in searches:
+ search_dirs = search_dirs.union(glob.glob(search))
continue
return (masked_dirs, masked_files, search_dirs)
found_la_files = [] # la libraries
symlink_pairs = [] # list of pairs symlink_id->library_id
- for d in dirs:
- if d in mask:
+ for _dir in dirs:
+ if _dir in mask:
continue
try:
- for l in os.listdir(d):
- l = os.path.join(d, l)
- if l in mask:
+ for listing in os.listdir(_dir):
+ listing = os.path.join(_dir, listing)
+ if listing in mask:
continue
- if os.path.isdir(l):
- if os.path.islink(l):
+ if os.path.isdir(listing):
+ if os.path.islink(listing):
#we do not want scan symlink-directories
pass
else:
- found_directories.append(l)
- elif os.path.isfile(l):
- if l.endswith('.so') or l.endswith('.a') or '.so.' in l:
- if l in found_files or l in found_symlinks:
+ found_directories.append(listing)
+ elif os.path.isfile(listing):
+ if (listing.endswith('.so') or
+ listing.endswith('.a') or
+ '.so.' in listing
+ ):
+ if listing in found_files or listing in found_symlinks:
continue
- if os.path.islink(l):
- found_symlinks.append(l)
- abs_path = os.path.realpath(l)
+ if os.path.islink(listing):
+ found_symlinks.append(listing)
+ abs_path = os.path.realpath(listing)
if abs_path in found_files:
- i = found_files.index(abs_path)
+ index = found_files.index(abs_path)
else:
found_files.append(abs_path)
- i = len(found_files)-1
- symlink_pairs.append((len(found_symlinks)-1, i,))
+ index = len(found_files)-1
+ symlink_pairs.append((len(found_symlinks)-1, index,))
else:
- found_files.append(l)
+ found_files.append(listing)
continue
- elif l.endswith('.la'):
- if l in found_la_files:
+ elif listing.endswith('.la'):
+ if listing in found_la_files:
continue
- found_la_files.append(l)
+ found_la_files.append(listing)
else:
- # sometimes there are binaries in libs' subdir, for example in nagios
- if not os.path.islink(l):
- if l in found_files or l in found_symlinks:
+ # sometimes there are binaries in libs' subdir,
+ # for example in nagios
+ if not os.path.islink(listing):
+ if listing in found_files or listing in found_symlinks:
continue
- prv = os.stat(l)[stat.ST_MODE]
+ prv = os.stat(listing)[stat.ST_MODE]
if prv & stat.S_IXUSR == stat.S_IXUSR or \
prv & stat.S_IXGRP == stat.S_IXGRP or \
prv & stat.S_IXOTH == stat.S_IXOTH:
- found_files.append(l)
+ found_files.append(listing)
except Exception as ex:
logger.debug(
yellow('Exception during collecting libraries: ' +
if found_directories:
- f, a, l, p = collect_libraries_from_dir(found_directories, mask, logger)
- found_files += f
- found_la_files += a
- found_symlinks += l
- symlink_pairs += p
+ _file, la_file, link, pair = \
+ collect_libraries_from_dir(found_directories, mask, logger)
+ found_files += _file
+ found_la_files += la_file
+ found_symlinks += link
+ symlink_pairs += pair
return (found_files, found_la_files, found_symlinks, symlink_pairs)
def collect_binaries_from_dir(dirs, mask, logger):
''' Collects all binaries from specified list of directories.
- mask is list of pathes, that are ommited in scanning, can be eighter single file or entire directory
+ mask is list of pathes, that are ommited in scanning,
+ can be eighter single file or entire directory
Returns list of binaries
'''
found_directories = []
found_files = []
- for d in dirs:
- if d in mask:
+ for _dir in dirs:
+ if _dir in mask:
continue
try:
- for l in os.listdir(d):
- l = os.path.join(d, l)
- if d in mask:
+ for listing in os.listdir(_dir):
+ listing = os.path.join(_dir, listing)
+ if listing in mask:
continue
- if os.path.isdir(l):
- if os.path.islink(l):
+ if os.path.isdir(listing):
+ if os.path.islink(listing):
#we do not want scan symlink-directories
pass
else:
- found_directories.append(l)
- elif os.path.isfile(l):
+ found_directories.append(listing)
+ elif os.path.isfile(listing):
# we're looking for binaries
# and with binaries we do not need links
# thus we can optimize a bit
- if not os.path.islink(l):
- prv = os.stat(l)[stat.ST_MODE]
+ if not os.path.islink(listing):
+ prv = os.stat(listing)[stat.ST_MODE]
if prv & stat.S_IXUSR == stat.S_IXUSR or \
prv & stat.S_IXGRP == stat.S_IXGRP or \
prv & stat.S_IXOTH == stat.S_IXOTH:
- found_files.append(l)
- except Exception as e:
+ found_files.append(listing)
+ except Exception as ex:
logger.debug(
yellow('Exception during binaries collecting: '+
- blue('%s') %str(e)))
+ blue('%s') %str(ex)))
if found_directories:
found_files += collect_binaries_from_dir(found_directories, mask, logger)
if __name__ == '__main__':
import logging
- mbin_dirs, mlib_dirs = prepare_search_dirs(logging)
+ from .settings import DEFAULTS
+ mbin_dirs, mlib_dirs = prepare_search_dirs(logging, DEFAULTS)
- mmasked_dirs, mmasked_files, mld = parse_revdep_config()
+ mmasked_dirs, mmasked_files, mld = parse_revdep_config("/etc/revdep-rebuild/")
mlib_dirs.update(mld)
mbin_dirs.update(mld)
mmasked_dirs.update(['/lib/modules', '/lib32/modules', '/lib64/modules'])
- libraries, la_libraries, libraries_links, msymlink_pairs = collect_libraries_from_dir(
- mlib_dirs, mmasked_dirs, logging)
+ libraries, la_libraries, libraries_links, msymlink_pairs = \
+ collect_libraries_from_dir(mlib_dirs, mmasked_dirs, logging)
binaries = collect_binaries_from_dir(mbin_dirs, mmasked_dirs, logging)
logging.debug(
from __future__ import print_function
-import subprocess
import os
import sys
import getopt
from portage.output import bold, red, blue, yellow, green, nocolor
from .analyse import analyse
-from .stuff import exithandler, get_masking_status
+from .stuff import get_masking_status
from .cache import check_temp_files, read_cache
from .assign import get_slotted_cps
from .settings import DEFAULTS
'installed as revdep-rebuild.sh'))
if settings['USE_TMP_FILES'] \
- and check_temp_files(settings['DEFAULT_TMP_DIR']):
+ and check_temp_files(settings['DEFAULT_TMP_DIR'], logger=logger):
libraries, la_libraries, libraries_links, binaries = read_cache(
settings['DEFAULT_TMP_DIR'])
assigned = analyse(
# util. functions
def call_program(args):
- ''' Calls program with specified parameters and returns stdout as a str object '''
+ ''' Calls program with specified parameters
+ and returns the stdout as a str object.
+
+ @param, args: arument list to pass to subprocess
+ @return str
+ '''
subp = subprocess.Popen(args, stdout=subprocess.PIPE, \
stderr=subprocess.PIPE)
stdout, stderr = subp.communicate()
def scan(params, files, max_args):
''' Calls scanelf with given params and files to scan.
- @param params is list of parameters that should be passed into scanelf app.
+ @param params is list of parameters that should
+ be passed into scanelf app.
@param files list of files to scan.
@param max_args number of files to process at once
@param stri: string
@return boolean or list menber that matches stri.endswith(member)
"""
- for l in lst:
- if stri.endswith(l):
- return l
+ for item in lst:
+ if stri.endswith(item):
+ return item
return False
projects / gentoolkit.git / commitdiff