def run(self, config, args):
store = PackagesStore(config)
p_name = args.package[0]
if args.list_files:
m.message('\n'.join(store.get_package_files_list(p_name)))
else:
p = store.get_package(p_name)
licenses = [p.license]
if not isinstance(p, MetaPackage):
recipes_licenses = p.recipes_licenses()
recipes_licenses.update(p.devel_recipes_licenses())
for recipe_name, categories_licenses in \
six.iteritems(recipes_licenses):
for category_licenses in six.itervalues(
categories_licenses):
licenses.extend(category_licenses)
licenses = sorted(list(set(licenses)))
d = {
'name':
p.name,
'version':
p.version,
'url':
p.url,
'licenses':
' and '.join([l.acronym for l in licenses]),
'desc':
p.shortdesc,
'deps':
', '.join(
[p.name for p in store.get_package_deps(p_name, True)])
}
m.message(INFO_TPL % d)
def run(self, config, args):
store = PackagesStore(config)
p_name = args.package[0]
if args.list_files:
m.message('\n'.join(store.get_package_files_list(p_name)))
else:
p = store.get_package(p_name)
licenses = [p.license]
if not isinstance(p, MetaPackage):
recipes_licenses = p.recipes_licenses()
recipes_licenses.update(p.devel_recipes_licenses())
for recipe_name, categories_licenses in \
recipes_licenses.items():
for category_licenses in categories_licenses.values():
licenses.extend(category_licenses)
licenses = sorted(list(set(licenses)))
d = {'name': p.name, 'version': p.version, 'url': p.url,
'licenses': ' and '.join([l.acronym for l in licenses]),
'desc': p.shortdesc,
'deps': ', '.join([p.name for p in
store.get_package_deps(p_name, True)])}
m.message(INFO_TPL % d)
def run(self, config, args):
store = PackagesStore(config)
p_name = args.package[0]
if args.list_files:
m.message("\n".join(store.get_package_files_list(p_name)))
else:
p = store.get_package(p_name)
licenses = [p.license]
if not isinstance(p, MetaPackage):
recipes_licenses = p.recipes_licenses()
recipes_licenses.update(p.devel_recipes_licenses())
for recipe_name, categories_licenses in recipes_licenses.iteritems():
for category_licenses in categories_licenses.itervalues():
licenses.extend(category_licenses)
licenses = sorted(list(set(licenses)))
d = {
"name": p.name,
"version": p.version,
"url": p.url,
"licenses": " and ".join([l.acronym for l in licenses]),
"desc": p.shortdesc,
"deps": ", ".join([p.name for p in store.get_package_deps(p_name, True)]),
}
m.message(INFO_TPL % d)
class Graph(Command):
doc = N_('Create a graph of dependencies using dot from graphviz')
name = 'graph'
def __init__(self):
Command.__init__(self, [
ArgparseArgument(
'name',
nargs=1,
help=_('name of the recipe or package to generate deps from')),
ArgparseArgument('-r',
'--recipe',
action='store_true',
help=_('generate deps for the given recipe')),
ArgparseArgument('-p',
'--package',
action='store_true',
help=_('generate deps for the given package')),
ArgparseArgument(
'-pr',
'--package-recipes',
action='store_true',
help=_('generate recipe deps for the given package')),
ArgparseArgument('-o',
'--output',
nargs=1,
help=_('output file for the SVG graph')),
])
def run(self, config, args):
if args.recipe + args.package + args.package_recipes == 0:
m.error(
'Error: You need to specify either recipe, package or package-recipes '
'mode to generate the dependency graph')
return
if args.recipe + args.package + args.package_recipes > 1:
m.error(
'Error: You can only specify recipe, package or package-recipes but not more than one'
)
return
if not shutil.which('dot'):
m.error(
'Error: dot command not found. Please install graphviz it using '
'your package manager. e.g. apt/dnf/brew install graphviz')
return
label = ''
if args.recipe:
self.graph_type = GraphType.RECIPE
label = 'recipe'
elif args.package:
self.graph_type = GraphType.PACKAGE
label = 'package'
elif args.package_recipes:
self.graph_type = GraphType.PACKAGE_RECIPES
label = 'package\'s recipes'
if self.graph_type == GraphType.RECIPE or self.graph_type == GraphType.PACKAGE_RECIPES:
self.cookbook = CookBook(config)
if self.graph_type == GraphType.PACKAGE or self.graph_type == GraphType.PACKAGE_RECIPES:
self.package_store = PackagesStore(config)
name = args.name[0]
output = args.output[0] if args.output else name + '.svg'
tmp = tempfile.NamedTemporaryFile()
dot = 'digraph {{\n\tlabel="{} {}";\n{}}}\n'.format(
name, label, self._dot_gen(name, self.graph_type))
with open(tmp.name, 'w') as f:
f.write(dot)
shell.new_call(['dot', '-Tsvg', tmp.name, '-o', output])
m.message("Dependency graph for %s generated at %s" % (name, output))
def _dot_gen(self, name, graph_type, already_parsed=[]):
already_parsed.append(name)
if graph_type == GraphType.RECIPE:
deps = self.cookbook.get_recipe(name).list_deps()
elif graph_type == GraphType.PACKAGE:
deps = [p.name for p in self.package_store.get_package_deps(name)]
elif graph_type == GraphType.PACKAGE_RECIPES:
deps = self.package_store.get_package(name).recipes_dependencies()
graph_type = GraphType.RECIPE
line = ''
for dep in deps:
line += '\t"{}" -> "{}";\n'.format(name, dep)
if dep not in already_parsed:
line += self._dot_gen(dep, graph_type, already_parsed)
return line
class PackageTest(unittest.TestCase):
def setUp(self):
self.config = common.DummyConfig()
self.config.packages_dir = '/test'
self.config.target_platform = Platform.LINUX
self.store = PackagesStore(self.config, False)
def testAddPackage(self):
package = common.Package1(self.config, None, None)
self.assertEqual(len(self.store._packages), 0)
self.store.add_package(package)
self.assertEqual(len(self.store._packages), 1)
self.assertEqual(package, self.store._packages[package.name])
def testGetPackage(self):
package = common.Package1(self.config, None, None)
self.store.add_package(package)
self.assertEqual(package, self.store.get_package(package.name))
def testPackageNotFound(self):
self.assertRaises(PackageNotFoundError, self.store.get_package,
'unknown')
def testPackagesList(self):
package = common.Package1(self.config, None, None)
metapackage = common.MetaPackage(self.config, None)
self.store.add_package(package)
self.store.add_package(metapackage)
l = sorted([package, metapackage], key=lambda x: x.name)
self.assertEqual(l, self.store.get_packages_list())
def testPackageDeps(self):
package = common.Package1(self.config, None, None)
package2 = common.Package2(self.config, None, None)
self.store.add_package(package)
self.store.add_package(package2)
self.assertEqual(
package.deps,
[x.name for x in self.store.get_package_deps(package.name)])
def testMetaPackageDeps(self):
metapackage = common.MetaPackage(self.config, None)
self.store.add_package(metapackage)
# the metapackage depends on package that are not yet in the store
self.assertRaises(PackageNotFoundError, self.store.get_package_deps,
metapackage.name)
for klass in [
common.Package1, common.Package2, common.Package3,
common.Package4
]:
p = klass(self.config, None, None)
self.store.add_package(p)
for klass in [common.MetaPackage]:
p = klass(self.config, None)
self.store.add_package(p)
deps = [
'gstreamer-test-bindings', 'gstreamer-test1', 'gstreamer-test2',
'gstreamer-test3'
]
res = [x.name for x in self.store.get_package_deps(metapackage.name)]
self.assertEqual(sorted(deps), sorted(res))
def testLoadPackageFromFile(self):
package_file = tempfile.NamedTemporaryFile()
package_file.write(PACKAGE)
package_file.flush()
p = self.store._load_package_from_file(package_file.name)
self.assertIsInstance(p, Package)
self.assertEqual('test-package', p.name)
def testLoadMetaPackageFromFile(self):
for x, t in [(SDKPACKAGE, SDKPackage),
(INSTALLERPACKAGE, InstallerPackage)]:
package_file = tempfile.NamedTemporaryFile()
package_file.write(x)
package_file.flush()
p = self.store._load_package_from_file(package_file.name)
print(p, type(p))
self.assertIsInstance(p, t)
self.assertEqual('test-package', p.name)
def testImports(self):
package_file = tempfile.NamedTemporaryFile()
package_file.write(PACKAGE)
package_file.flush()
p = self.store._load_package_from_file(package_file.name)
self.assertIsInstance(p, Package)
try:
p.test_imports()
except ImportError as e:
self.fail("Import error raised, %s", e)
class Package(object):
def __init__(self,config ):
self.config = config
self.store = PackagesStore(config)
self.cookbook = CookBook(config)
self.packages_ = None
def _recipes(self,package):
'''
return the recipes (name:version) dict included in the package (not include in deps packages)
'''
all = package.recipes_dependencies()
rdeps=[]
for pkg in self.store.get_package_deps( package.name):
rdeps.extend( pkg.recipes_dependencies())
rnames = list(set(all).difference(set(rdeps)))
recipes ={}
for name in rnames:
recipes[name] = self.cookbook.get_recipe(name).version
return recipes
def get_recipes(self,package):
'''
return the recipes (name:version) dict included in the package (not include in deps packages)
'''
if isinstance (package,SDKPackage):
recipes={}
for p in self.store.get_package_deps(package):
recipes.update( self._recipes( p) )
return recipes
return self._recipes(package)
def get_packages_deps(self,package):
'''
return the packages of the SDK/package dependent.
'''
dependencies = []
if isinstance (package,SDKPackage):
if hasattr(package, 'dependencies'):
dependencies = package.dependencies
return []
else:
dependencies = [p.name for p in self.store.get_package_deps(package.name, False)]
deps = {}
for name in dependencies:
version = self.store.get_package(name).version
deps[name] = version
return deps
def _pkg(self,package):
t = DistTarball(self.config,package,self.store)
tarball={}
for ptype in [PackageType.DEVEL,PackageType.RUNTIME]:
TNAME={PackageType.DEVEL:'devel',PackageType.RUNTIME:'runtime'}
tarball[TNAME[ptype]]={
'filename':t._get_name(ptype)
}
profile = {
'name':package.name,
'version':package.version,
'platform':self.config.target_platform,
'arch':self.config.target_arch,
'recipes': self.get_recipes(package),
'dependencies': self.get_packages_deps(package),
#'deps': [p.name for p in self.store.get_package_deps(package.name, True)],
#'direct.deps': [p.name for p in self.store.get_package_deps(package.name, False)],
'tarball': tarball
}
if self.config.build_type == 'debug':
profile['debug'] = True
return profile
def get(self,name):
if self.packages_ is None:
self.packages()
return self.packages_[name]
def packages(self):
if self.packages_ is None:
self.packages_ = {}
for pkg in self.store.get_packages_list():
#if isinstance (pkg,SDKPackage):
# continue
self.packages_[pkg.name] = self._pkg( pkg )
return self.packages_
class PackageTest(unittest.TestCase):
def setUp(self):
self.config = common.DummyConfig()
self.config.packages_dir = '/test'
self.config.target_platform = Platform.LINUX
self.store = PackagesStore(self.config, False)
def testAddPackage(self):
package = common.Package1(self.config, None, None)
self.assertEquals(len(self.store._packages), 0)
self.store.add_package(package)
self.assertEquals(len(self.store._packages), 1)
self.assertEquals(package, self.store._packages[package.name])
def testGetPackage(self):
package = common.Package1(self.config, None, None)
self.store.add_package(package)
self.assertEquals(package, self.store.get_package(package.name))
def testPackageNotFound(self):
self.failUnlessRaises(PackageNotFoundError, self.store.get_package,
'unknown')
def testPackagesList(self):
package = common.Package1(self.config, None, None)
metapackage = common.MetaPackage(self.config, None)
self.store.add_package(package)
self.store.add_package(metapackage)
l = sorted([package, metapackage], key=lambda x: x.name)
self.assertEquals(l, self.store.get_packages_list())
def testPackageDeps(self):
package = common.Package1(self.config, None, None)
package2 = common.Package2(self.config, None, None)
self.store.add_package(package)
self.store.add_package(package2)
self.assertEquals(package.deps,
[x.name for x in self.store.get_package_deps(package.name)])
def testMetaPackageDeps(self):
metapackage = common.MetaPackage(self.config, None)
self.store.add_package(metapackage)
# the metapackage depends on package that are not yet in the store
self.failUnlessRaises(PackageNotFoundError,
self.store.get_package_deps, metapackage.name)
for klass in [common.Package1, common.Package2, common.Package3,
common.Package4]:
p = klass(self.config, None, None)
self.store.add_package(p)
for klass in [common.MetaPackage]:
p = klass(self.config, None)
self.store.add_package(p)
deps = ['gstreamer-test-bindings', 'gstreamer-test1',
'gstreamer-test2', 'gstreamer-test3']
res = [x.name for x in self.store.get_package_deps(metapackage.name)]
self.assertEquals(sorted(deps), sorted(res))
def testLoadPackageFromFile(self):
package_file = tempfile.NamedTemporaryFile()
package_file.write(PACKAGE)
package_file.flush()
p = self.store._load_package_from_file(package_file.name)
self.assertIsInstance(p, Package)
self.assertEquals('test-package', p.name)
def testLoadMetaPackageFromFile(self):
for x, t in [(SDKPACKAGE, SDKPackage),
(INSTALLERPACKAGE, InstallerPackage)]:
package_file = tempfile.NamedTemporaryFile()
package_file.write(x)
package_file.flush()
p = self.store._load_package_from_file(package_file.name)
print p, type(p)
self.assertIsInstance(p, t)
self.assertEquals('test-package', p.name)
def testImports(self):
package_file = tempfile.NamedTemporaryFile()
package_file.write(PACKAGE)
package_file.flush()
p = self.store._load_package_from_file(package_file.name)
self.assertIsInstance(p, Package)
try:
p.test_imports()
except ImportError, e:
self.fail("Import error raised, %s", e)
