def run(self, config, args):
store = PackagesStore(config)
packages = store.get_packages_list()
if len(packages) == 0:
m.message(_("No packages found"))
for p in packages:
m.message("%s - %s" % (p.name, p.version))
def run(self, config, args):
store = PackagesStore(config)
packages = store.get_packages_list()
if len(packages) == 0:
m.message(_("No packages found"))
for p in packages:
m.message("%s - %s" % (p.name, p.version))
def run(self, config, args):
cookbook = CookBook(config)
failed = []
p_name = args.package[0]
store = PackagesStore(config)
p = store.get_package(p_name)
ordered_recipes = map(lambda x: cookbook.get_recipe(x),
p.recipes_dependencies())
for recipe in ordered_recipes:
if cookbook.recipe_needs_build(recipe.name):
raise CommandError(
_("Recipe %s is not built yet" % recipe.name))
for recipe in ordered_recipes:
# call step function
stepfunc = None
try:
stepfunc = getattr(recipe, 'check')
except:
m.message('%s has no check step, skipped' % recipe.name)
if stepfunc:
try:
m.message('Running checks for recipe %s' % recipe.name)
stepfunc()
except Exception as ex:
failed.append(recipe.name)
m.warning(_("%s checks failed: %s") % (recipe.name, ex))
if failed:
raise CommandError(
_("Error running %s checks on:\n " + "\n ".join(failed))
% p_name)
def run(self, config, args):
store = PackagesStore(config)
recipes = []
for package_name in args.packages:
package = store.get_package(package_name)
recipes += package.recipes_dependencies()
return self.fetch(store.cookbook, recipes, False, args.reset_rdeps)
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):
cookbook = CookBook(config)
failed = []
p_name = args.package[0]
store = PackagesStore(config)
p = store.get_package(p_name)
ordered_recipes = map(lambda x: cookbook.get_recipe(x),
p.recipes_dependencies())
for recipe in ordered_recipes:
if cookbook.recipe_needs_build(recipe.name):
raise CommandError(_("Recipe %s is not built yet" % recipe.name))
for recipe in ordered_recipes:
# call step function
stepfunc = None
try:
stepfunc = getattr(recipe, 'check')
except:
m.message('%s has no check step, skipped' % recipe.name)
if stepfunc:
try:
m.message('Running checks for recipe %s' % recipe.name)
stepfunc()
except Exception, ex:
failed.append(recipe.name)
m.warning(_("%s checks failed: %s") % (recipe.name, ex))
def run(self, config, args):
self.store = PackagesStore(config)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p, args.no_devel)
if args.only_build_deps:
return
if p is None:
raise PackageNotFoundError(args.package[0])
if args.tarball:
pkg = DistTarball(config, p, self.store)
else:
pkg = Packager(config, p, self.store)
m.action(_("Creating package for %s") % p.name)
if args.tarball:
paths = pkg.pack(os.path.abspath(args.output_dir), args.no_devel,
args.force, args.keep_temp, split=not args.no_split)
else:
paths = pkg.pack(os.path.abspath(args.output_dir), args.no_devel,
args.force, args.keep_temp)
if None in paths:
paths.remove(None)
p.post_install(paths)
m.action(_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
def run(self, config, args):
self.store = PackagesStore(config, offline=args.offline)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(
_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p, args.no_devel, args.offline,
args.dry_run, args.jobs)
if args.only_build_deps or args.dry_run:
return
if args.compress_method != 'default':
m.message('Forcing tarball compression method as ' +
args.compress_method)
config.package_tarball_compression = args.compress_method
if p is None:
raise PackageNotFoundError(args.package[0])
p.pre_package()
packager_class = Packager
if args.tarball:
if config.target_platform == Platform.ANDROID and \
config.target_arch == Architecture.UNIVERSAL:
packager_class = AndroidPackager
else:
packager_class = DistTarball
elif config.variants.uwp:
# Split devel/runtime packages are useless for UWP since we will
# need both when building the package, and all needed runtime DLLs
# are packaged with the app as assets.
m.warning('Forcing single-tarball output for UWP package')
args.no_split = True
packager_class = DistTarball
m.action(_("Creating package for %s") % p.name)
pkg = packager_class(config, p, self.store)
output_dir = os.path.abspath(args.output_dir)
if isinstance(pkg, DistTarball):
paths = pkg.pack(output_dir,
args.no_devel,
args.force,
args.keep_temp,
split=not args.no_split,
strip_binaries=p.strip)
else:
paths = pkg.pack(output_dir, args.no_devel, args.force,
args.keep_temp)
if None in paths:
paths.remove(None)
paths = p.post_package(paths, output_dir) or paths
m.action(
_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
def run(self, config, args):
store = PackagesStore(config)
allfiles = [p.all_files_list() for p in store.get_packages_list() if\
isinstance(p, Package)]
allfiles = list(itertools.chain(*allfiles))
self.find_duplicates(allfiles)
self.find_orphan_files(allfiles, config.prefix, args.exclude)
def run(self, config, args):
store = PackagesStore(config)
allfiles = [p.all_files_list() for p in store.get_packages_list() if\
isinstance(p, Package)]
allfiles = list(itertools.chain(*allfiles))
self.find_duplicates(allfiles)
self.find_orphan_files(allfiles, config.prefix, args.exclude)
def run(self, config, args):
name = args.name[0]
version = args.version[0]
store = PackagesStore(config)
filename = os.path.join(config.packages_dir, '%s.package' % name)
if not args.force and os.path.exists(filename):
m.warning(
_("Package '%s' (%s) already exists, "
"use -f to replace" % (name, filename)))
return
template_args = {}
template = RECEIPT_TPL
template_args['name'] = name
template_args['version'] = version
if args.short_desc:
template_args['shortdesc'] = args.short_desc
else:
template_args['shortdesc'] = name
if args.codename:
template += CODENAME_TPL
template_args['codename'] = args.codename
if args.vendor:
template += VENDOR_TPL
template_args['vendor'] = args.vendor
if args.url:
template += URL_TPL
template_args['url'] = args.url
if args.license:
self.validate_licenses([args.license])
template += LICENSE_TPL
template_args['license'] = \
'License.' + self.supported_licenses[args.license]
deps = []
if args.deps:
template += DEPS_TPL
deps = args.deps.split(',')
for dname in deps:
try:
package = store.get_package(dname)
except Exception, ex:
raise UsageError(
_("Error creating package: "
"dependant package %s does not exist") % dname)
template_args['deps'] = deps
def run(self, config, args):
name = args.name[0]
version = args.version[0]
store = PackagesStore(config)
filename = os.path.join(config.packages_dir, '%s.package' % name)
if not args.force and os.path.exists(filename):
m.warning(_("Package '%s' (%s) already exists, "
"use -f to replace" % (name, filename)))
return
template_args = {}
template = RECEIPT_TPL
template_args['name'] = name
template_args['version'] = version
if args.short_desc:
template_args['shortdesc'] = args.short_desc
else:
template_args['shortdesc'] = name
if args.codename:
template += CODENAME_TPL
template_args['codename'] = args.codename
if args.vendor:
template += VENDOR_TPL
template_args['vendor'] = args.vendor
if args.url:
template += URL_TPL
template_args['url'] = args.url
if args.license:
self.validate_licenses([args.license])
template += LICENSE_TPL
template_args['license'] = \
'License.' + self.supported_licenses[args.license]
deps = []
if args.deps:
template += DEPS_TPL
deps = args.deps.split(',')
for dname in deps:
try:
package = store.get_package(dname)
except Exception, ex:
raise UsageError(_("Error creating package: "
"dependant package %s does not exist") % dname)
template_args['deps'] = deps
def run(self, config, args):
self.store = PackagesStore(config, offline=args.offline)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(
_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p, args.no_devel, args.offline,
args.dry_run)
if args.only_build_deps or args.dry_run:
return
if args.xz:
config.package_tarball_compression = 'xz'
if p is None:
raise PackageNotFoundError(args.package[0])
p.pre_package()
if args.tarball:
if config.target_platform == Platform.ANDROID and \
config.target_arch == Architecture.UNIVERSAL:
pkg = AndroidPackager(config, p, self.store)
else:
pkg = DistTarball(config, p, self.store)
else:
pkg = Packager(config, p, self.store)
m.action(_("Creating package for %s") % p.name)
output_dir = os.path.abspath(args.output_dir)
if args.tarball:
paths = pkg.pack(output_dir,
args.no_devel,
args.force,
args.keep_temp,
split=not args.no_split,
strip_binaries=p.strip)
else:
paths = pkg.pack(output_dir, args.no_devel, args.force,
args.keep_temp)
if None in paths:
paths.remove(None)
paths = p.post_package(paths, output_dir) or paths
m.action(
_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
class Package(Command):
doc = N_('Creates a distribution package')
name = 'package'
def __init__(self):
Command.__init__(self,
[ArgparseArgument('package', nargs=1,
help=_('name of the package to create')),
ArgparseArgument('-o', '--output-dir', default='.',
help=_('Output directory for the tarball file')),
ArgparseArgument('-t', '--tarball', action='store_true',
default=False,
help=_('Creates a tarball instead of a native package')),
ArgparseArgument('-f', '--force', action='store_true',
default=False, help=_('Delete any existing package file')),
ArgparseArgument('-d', '--no-devel', action='store_false',
default=True, help=_('Do not create the development version '
'of this package')),
ArgparseArgument('-s', '--skip-deps-build', action='store_true',
default=False, help=_('Do not build the recipes needed to '
'create this package (conflicts with --only-build-deps)')),
ArgparseArgument('-b', '--only-build-deps', action='store_true',
default=False, help=_('Only build the recipes needed to '
'create this package (conflicts with --skip-deps-build)')),
ArgparseArgument('-k', '--keep-temp', action='store_true',
default=False, help=_('Keep temporary files for debug')),
])
def run(self, config, args):
self.store = PackagesStore(config)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p)
if args.only_build_deps:
return
if p is None:
raise PackageNotFoundError(args.package[0])
if args.tarball:
pkg = DistTarball(config, p, self.store)
else:
pkg = Packager(config, p, self.store)
m.action(_("Creating package for %s") % p.name)
paths = pkg.pack(os.path.abspath(args.output_dir), args.no_devel,
args.force, args.keep_temp)
if None in paths:
paths.remove(None)
m.action(_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
def _build_deps(self, config, package):
build_command = build.Build()
build_command.runargs(config, package.recipes_dependencies(),
cookbook=self.store.cookbook)
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 __getattr__(self, name):
if name not in self.__dict__:
if name == 'store':
self.__dict__[name] = PackagesStore(self.config)
if name == 'cookbook':
self.__dict__[name] = CookBook(self.config)
return self.__dict__[name]
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)
def start_cooking(self,
recipes,
use_binaries=False,
upload_binaries=False,
build_missing=True):
'''
Cooks the provided recipe names
'''
if isinstance(recipes, str):
recipes = [recipes]
m.message(
_("Building the following recipes: %s") %
' '.join([x for x in recipes]))
if use_binaries or upload_binaries:
def _build(recipe, i, length):
self.cook_recipe(recipe, i, length)
if upload_binaries:
try:
fridge.freeze_recipe(recipe, i, length)
except RecipeNotFreezableError:
pass
if not self.store:
self.store = PackagesStore(self.cookbook.get_config())
fridge = Fridge(self.store, force=self.force, dry_run=self.dry_run)
i = 1
for recipe in recipes:
if use_binaries:
try:
fridge.unfreeze_recipe(recipe, i, len(recipes))
except (RecipeNotFreezableError, BuildStepError) as e:
if build_missing or isinstance(
e, RecipeNotFreezableError):
_build(recipe, i, len(recipes))
else:
raise e
else:
_build(recipe, i, len(recipes))
i += 1
else:
i = 1
for recipe in recipes:
self.cook_recipe(recipe, i, len(recipes))
i += 1
def create_store(config):
cookbook = create_cookbook(config)
store = PackagesStore(config, False)
for klass in [Package1, Package2, Package3, Package4, App]:
package = klass(config, store, cookbook)
package.__file__ = 'test/test_packages_common.py'
store.add_package(package)
for klass in [MetaPackage]:
package = klass(config, store)
package.__file__ = 'test/test_packages_common.py'
store.add_package(package)
return store
def runargs(self, config, recipes, missing_files=False, force=False,
no_deps=False, store=None, dry_run=False, use_binaries=False,
upload_binaries=False, build_missing=False):
if not store:
store = PackagesStore(config)
cookbook = store.cookbook
oven = Oven(cookbook, force=self.force, missing_files=missing_files,
dry_run=dry_run, store=store)
if isinstance(recipes, str):
recipes = [recipes]
if no_deps:
ordered_recipes = recipes
else:
ordered_recipes = cookbook.list_recipes_deps(recipes)
oven.start_cooking(ordered_recipes, use_binaries, upload_binaries,
build_missing)
def run(self, config, args):
store = PackagesStore(config)
cookbook = store.cookbook
recipes = cookbook.get_recipes_list()
fridge = Fridge(store, args.force, args.dry_run)
built_recipes = []
# get all built recipes
for recipe in recipes:
bv = cookbook.recipe_built_version(recipe.name)
cv = recipe.built_version()
if bv == cv:
built_recipes.append(recipe)
# finally freeze them
i = 1
for recipe in built_recipes:
try:
fridge.freeze_recipe(recipe, i, len(built_recipes))
except:
pass
i += 1
def run(self, config, args):
self.store = PackagesStore(config)
packages = []
for name in args.package:
p = self.store.get_package(name)
if p is None:
raise PackageNotFoundError(name)
packages.append(p)
if args.skip_deps_build and args.only_build_deps:
raise UsageError(_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, packages, args)
if args.only_build_deps:
return
package_outputs = []
for package in packages:
package_outputs += self._create_package(config, package, args)
print package_outputs
return
def _get(self):
tools = Build_Tools(self.config)
store = PackagesStore(self.config)
cookbook = CookBook(self.config)
names = tools.BUILD_TOOLS
names += tools.PLAT_BUILD_TOOLS.get(self.config.platform, [])
recipes ={}
path = os.path.join(self.config.packages_dir,'custom.py')
d={}
parse_file(path,d )
version = d['GStreamer'].version
for name in names:
recipes[name] = cookbook.get_recipe(name).version
pkgname ='build-tools'
tarball = '%s-%s-%s-%s'%( pkgname,
self.config.platform,
self.config.arch,
version
)
return {
'name':pkgname,
'version': version,
'prefix':self.config.build_tools_prefix,
'deps':[],
'platform':self.config.platform,
'arch':self.config.arch,
'tarball':{
'runtime':{ 'filename':tarball +'.tar.bz2'}
},
'recipes': recipes
}
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 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 Package(Command):
doc = N_('Creates a distribution package')
name = 'package'
def __init__(self):
Command.__init__(self, [
ArgparseArgument(
'package', nargs=1, help=_('name of the package to create')),
ArgparseArgument('-o',
'--output-dir',
default='.',
help=_('Output directory for the tarball file')),
ArgparseArgument(
'-t',
'--tarball',
action='store_true',
default=False,
help=_('Creates a tarball instead of a native package')),
ArgparseArgument(
'-n',
'--no-split',
action='store_true',
default=False,
help=_(
'(only meaningfull when --tarball is set) Create one single '
'tarball with devel and runtime files')),
ArgparseArgument('-f',
'--force',
action='store_true',
default=False,
help=_('Delete any existing package file')),
ArgparseArgument('-d',
'--no-devel',
action='store_false',
default=True,
help=_('Do not create the development version '
'of this package')),
ArgparseArgument(
'-s',
'--skip-deps-build',
action='store_true',
default=False,
help=_(
'Do not build the recipes needed to '
'create this package (conflicts with --only-build-deps)')),
ArgparseArgument(
'-b',
'--only-build-deps',
action='store_true',
default=False,
help=_(
'Only build the recipes needed to '
'create this package (conflicts with --skip-deps-build)')),
ArgparseArgument('-k',
'--keep-temp',
action='store_true',
default=False,
help=_('Keep temporary files for debug')),
ArgparseArgument('--offline',
action='store_true',
default=False,
help=_('Use only the source cache, no network')),
ArgparseArgument(
'--dry-run',
action='store_true',
default=False,
help=_('Only print the packages that will be built')),
ArgparseArgument('--compress-method',
type=str,
choices=['default', 'xz', 'bz2'],
default='default',
help=_('Select compression method for tarballs')),
ArgparseArgument('--jobs',
'-j',
action='store',
type=int,
default=0,
help=_('How many recipes to build concurrently. '
'0 = number of CPUs.')),
])
def run(self, config, args):
self.store = PackagesStore(config, offline=args.offline)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(
_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p, args.no_devel, args.offline,
args.dry_run, args.jobs)
if args.only_build_deps or args.dry_run:
return
if args.compress_method != 'default':
m.message('Forcing tarball compression method as ' +
args.compress_method)
config.package_tarball_compression = args.compress_method
if p is None:
raise PackageNotFoundError(args.package[0])
p.pre_package()
packager_class = Packager
if args.tarball:
if config.target_platform == Platform.ANDROID and \
config.target_arch == Architecture.UNIVERSAL:
packager_class = AndroidPackager
else:
packager_class = DistTarball
elif config.variants.uwp:
# Split devel/runtime packages are useless for UWP since we will
# need both when building the package, and all needed runtime DLLs
# are packaged with the app as assets.
m.warning('Forcing single-tarball output for UWP package')
args.no_split = True
packager_class = DistTarball
m.action(_("Creating package for %s") % p.name)
pkg = packager_class(config, p, self.store)
output_dir = os.path.abspath(args.output_dir)
if isinstance(pkg, DistTarball):
paths = pkg.pack(output_dir,
args.no_devel,
args.force,
args.keep_temp,
split=not args.no_split,
strip_binaries=p.strip)
else:
paths = pkg.pack(output_dir, args.no_devel, args.force,
args.keep_temp)
if None in paths:
paths.remove(None)
paths = p.post_package(paths, output_dir) or paths
m.action(
_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
def _build_deps(self, config, package, has_devel, offline, dry_run, jobs):
build_command = build.Build()
build_command.runargs(config,
package.recipes_dependencies(has_devel),
cookbook=self.store.cookbook,
dry_run=dry_run,
offline=offline,
jobs=jobs)
class Package(Command):
doc = N_('Creates a distribution package')
name = 'package'
def __init__(self):
Command.__init__(self, [
ArgparseArgument(
'package', nargs=1, help=_('name of the package to create')),
ArgparseArgument('-o',
'--output-dir',
default='.',
help=_('Output directory for the tarball file')),
ArgparseArgument(
'-t',
'--tarball',
action='store_true',
default=False,
help=_('Creates a tarball instead of a native package')),
ArgparseArgument(
'-n',
'--no-split',
action='store_true',
default=False,
help=_(
'(only meaningfull when --tarball is set) Create one single '
'tarball with devel and runtime files')),
ArgparseArgument('-f',
'--force',
action='store_true',
default=False,
help=_('Delete any existing package file')),
ArgparseArgument('-d',
'--no-devel',
action='store_false',
default=True,
help=_('Do not create the development version '
'of this package')),
ArgparseArgument(
'-s',
'--skip-deps-build',
action='store_true',
default=False,
help=_(
'Do not build the recipes needed to '
'create this package (conflicts with --only-build-deps)')),
ArgparseArgument(
'-b',
'--only-build-deps',
action='store_true',
default=False,
help=_(
'Only build the recipes needed to '
'create this package (conflicts with --skip-deps-build)')),
ArgparseArgument('-k',
'--keep-temp',
action='store_true',
default=False,
help=_('Keep temporary files for debug')),
ArgparseArgument('--offline',
action='store_true',
default=False,
help=_('Use only the source cache, no network')),
ArgparseArgument(
'--dry-run',
action='store_true',
default=False,
help=_('Only print the packages that will be built')),
ArgparseArgument('--xz',
action='store_true',
default=False,
help=_(
'Use xz instead of bzip2 for compression if '
'creating a tarball')),
])
def run(self, config, args):
self.store = PackagesStore(config, offline=args.offline)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(
_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p, args.no_devel, args.offline,
args.dry_run)
if args.only_build_deps or args.dry_run:
return
if args.xz:
config.package_tarball_compression = 'xz'
if p is None:
raise PackageNotFoundError(args.package[0])
p.pre_package()
if args.tarball:
if config.target_platform == Platform.ANDROID and \
config.target_arch == Architecture.UNIVERSAL:
pkg = AndroidPackager(config, p, self.store)
else:
pkg = DistTarball(config, p, self.store)
else:
pkg = Packager(config, p, self.store)
m.action(_("Creating package for %s") % p.name)
output_dir = os.path.abspath(args.output_dir)
if args.tarball:
paths = pkg.pack(output_dir,
args.no_devel,
args.force,
args.keep_temp,
split=not args.no_split,
strip_binaries=p.strip)
else:
paths = pkg.pack(output_dir, args.no_devel, args.force,
args.keep_temp)
if None in paths:
paths.remove(None)
paths = p.post_package(paths, output_dir) or paths
m.action(
_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
def _build_deps(self, config, package, has_devel, offline, dry_run):
build_command = build.Build()
build_command.runargs(config,
package.recipes_dependencies(has_devel),
cookbook=self.store.cookbook,
dry_run=dry_run,
offline=offline)
class Package(Command):
doc = N_('Creates a distribution package')
name = 'package'
def __init__(self):
Command.__init__(self,
[ArgparseArgument('package', nargs=1,
help=_('name of the package to create')),
ArgparseArgument('-o', '--output-dir', default='.',
help=_('Output directory for the tarball file')),
ArgparseArgument('-t', '--tarball', action='store_true',
default=False,
help=_('Creates a tarball instead of a native package')),
ArgparseArgument('-n', '--no-split', action='store_true',
default=False,
help=_('(only meaningfull when --tarball is set) Create one single '
'tarball with devel and runtime files')),
ArgparseArgument('-f', '--force', action='store_true',
default=False, help=_('Delete any existing package file')),
ArgparseArgument('-d', '--no-devel', action='store_false',
default=True, help=_('Do not create the development version '
'of this package')),
ArgparseArgument('-s', '--skip-deps-build', action='store_true',
default=False, help=_('Do not build the recipes needed to '
'create this package (conflicts with --only-build-deps)')),
ArgparseArgument('-b', '--only-build-deps', action='store_true',
default=False, help=_('Only build the recipes needed to '
'create this package (conflicts with --skip-deps-build)')),
ArgparseArgument('-k', '--keep-temp', action='store_true',
default=False, help=_('Keep temporary files for debug')),
])
def run(self, config, args):
self.store = PackagesStore(config)
p = self.store.get_package(args.package[0])
if args.skip_deps_build and args.only_build_deps:
raise UsageError(_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, p, args.no_devel)
if args.only_build_deps:
return
if p is None:
raise PackageNotFoundError(args.package[0])
if args.tarball:
pkg = DistTarball(config, p, self.store)
else:
pkg = Packager(config, p, self.store)
m.action(_("Creating package for %s") % p.name)
if args.tarball:
paths = pkg.pack(os.path.abspath(args.output_dir), args.no_devel,
args.force, args.keep_temp, split=not args.no_split)
else:
paths = pkg.pack(os.path.abspath(args.output_dir), args.no_devel,
args.force, args.keep_temp)
if None in paths:
paths.remove(None)
p.post_install(paths)
m.action(_("Package successfully created in %s") %
' '.join([os.path.abspath(x) for x in paths]))
def _build_deps(self, config, package, has_devel):
build_command = build.Build()
build_command.runargs(config, package.recipes_dependencies(has_devel),
cookbook=self.store.cookbook)
def run(self, config, args):
store = PackagesStore(config)
package = store.get_package(args.package[0])
return self.fetch(store.cookbook, package.recipes_dependencies(),
True, args.reset_rdeps, args.full_reset)
class Package(Command):
doc = N_('Creates a distribution package for one or several packages')
name = 'package'
def __init__(self):
Command.__init__(self,
[ArgparseArgument('package', nargs='*',
help=_('name of the package to create')),
ArgparseArgument('-o', '--output-dir', default='.',
help=_('Output directory for the tarball file')),
ArgparseArgument('-t', '--type', type=str, default='native',
choices=['native', ArchiveType.TARBALL , ArchiveType.ZIP],
help=_('Choose a package type, native or archive')),
ArgparseArgument('-f', '--force', action='store_true',
default=False, help=_('Delete any existing package file')),
ArgparseArgument('-d', '--no-devel', action='store_true',
default=False, help=_('Do not create the development version '
'of this package')),
ArgparseArgument('-s', '--skip-deps-build', action='store_true',
default=False, help=_('Do not build the recipes needed to '
'create this package (conflicts with --only-build-deps)')),
ArgparseArgument('-b', '--only-build-deps', action='store_true',
default=False, help=_('Only build the recipes needed to '
'create this package (conflicts with --skip-deps-build)')),
ArgparseArgument('-k', '--keep-temp', action='store_true',
default=False, help=_('Keep temporary files for debug')),
ArgparseArgument('-u', '--use-binaries', action='store_true',
default=False,
help=_('use binaries from the repo before building')),
ArgparseArgument('-p', '--upload-binaries', action='store_true',
default=False,
help=_('after a recipe is built upload the corresponding binary package')),
ArgparseArgument('-m', '--build-missing', action='store_true',
default=False,
help=_('in case a binary package is missing try to build it')),
])
def run(self, config, args):
self.store = PackagesStore(config)
packages = []
for name in args.package:
p = self.store.get_package(name)
if p is None:
raise PackageNotFoundError(name)
packages.append(p)
if args.skip_deps_build and args.only_build_deps:
raise UsageError(_("Cannot use --skip-deps-build together with "
"--only-build-deps"))
if not args.skip_deps_build:
self._build_deps(config, packages, args)
if args.only_build_deps:
return
package_outputs = []
for package in packages:
package_outputs += self._create_package(config, package, args)
print package_outputs
return
def _create_package(self, config, p, args):
if args.type == 'native':
pkg = Packager(config, p, self.store)
else:
pkg = DistArchive(config, p, self.store, args.type)
m.action(_("Creating package for %s") % p.name)
p.pre_package()
paths = pkg.pack(os.path.abspath(args.output_dir), not args.no_devel,
args.force, args.keep_temp)
if None in paths:
paths.remove(None)
if '' in paths:
paths.remove('')
paths = p.post_package(paths) or paths
for p in paths:
BUF_SIZE = 65536 # 64kb chunks
sha1 = hashlib.sha1()
with open(os.path.abspath(p), 'rb') as f:
while True:
data = f.read(BUF_SIZE)
if not data:
break
sha1.update(data)
sha1sum = sha1.hexdigest()
m.action(_("Package successfully created in %s %s") % (os.path.abspath(p), sha1sum))
# Generate the sha1sum file
with open('%s.sha1' % p, 'w+') as sha1file:
sha1file.write(sha1sum)
return paths
def _build_deps(self, config, packages, args):
recipes = []
for package in packages:
recipes += package.recipes_dependencies()
build_command = build.Build()
build_command.runargs(config, set(recipes),
store=self.store, use_binaries=args.use_binaries,
upload_binaries=args.upload_binaries,
build_missing=args.build_missing)
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 run(self, config, args):
packages = []
recipes = []
bundle_recipes = []
bundle_dirs = []
setup_args = ['sdist']
if not config.uninstalled:
m.error("Can only be run on cerbero-uninstalled")
store = PackagesStore(config)
cookbook = CookBook(config)
packages = list(args.bundlepackages)
for p in packages:
package = store.get_package(p)
if hasattr(package, 'list_packages'):
packages += package.list_packages()
packages = remove_list_duplicates(packages)
for p in packages:
package = store.get_package(p)
if hasattr(package, 'deps'):
packages += package.deps
packages = remove_list_duplicates(packages)
for p in packages:
package = store.get_package(p)
recipes += package.recipes_dependencies()
recipes += args.add_recipe
for r in recipes:
bundle_recipes += cookbook.list_recipe_deps(r)
bundle_recipes = remove_list_duplicates(bundle_recipes)
for p in packages:
setup_args.append('--package=' + p)
for r in bundle_recipes:
setup_args.append('--recipe=' + r.name)
if r.stype != SourceType.CUSTOM:
bundle_dirs.append(r.repo_dir)
if not args.no_bootstrap:
build_tools = BuildTools(config)
bs_recipes = build_tools.BUILD_TOOLS + \
build_tools.PLAT_BUILD_TOOLS.get(config.platform, [])
b_recipes = []
for r in bs_recipes:
b_recipes += cookbook.list_recipe_deps(r)
b_recipes = remove_list_duplicates(b_recipes)
for r in b_recipes:
if r.stype != SourceType.CUSTOM:
bundle_dirs.append(r.repo_dir)
setup_args.append('--source-dirs=' + ','.join(bundle_dirs))
command = str(config._relative_path('setup.py'))
run_setup(command, setup_args)
def __init__(self,config ):
self.config = config
self.store = PackagesStore(config)
self.cookbook = CookBook(config)
self.packages_ = None
def run(self, config, args):
name = args.name[0]
version = args.version[0]
store = PackagesStore(config)
filename = os.path.join(config.packages_dir, '%s.package' % name)
if not args.force and os.path.exists(filename):
m.warning(_("Package '%s' (%s) already exists, "
"use -f to replace" % (name, filename)))
return
template_args = {}
template = RECEIPT_TPL
template_args['name'] = name
template_args['version'] = version
if args.short_desc:
template_args['shortdesc'] = args.short_desc
else:
template_args['shortdesc'] = name
if args.codename:
template += CODENAME_TPL
template_args['codename'] = args.codename
if args.vendor:
template += VENDOR_TPL
template_args['vendor'] = args.vendor
if args.url:
template += URL_TPL
template_args['url'] = args.url
if args.license:
self.validate_licenses([args.license])
template += LICENSE_TPL
template_args['license'] = \
'License.' + self.supported_licenses[args.license]
deps = []
if args.deps:
template += DEPS_TPL
deps = args.deps.split(',')
for dname in deps:
try:
package = store.get_package(dname)
except Exception as ex:
raise UsageError(_("Error creating package: "
"dependant package %s does not exist") % dname)
template_args['deps'] = deps
include_files = []
include_files_devel = []
platform_include_files = {}
platform_include_files_devel = {}
if args.includes:
includes = args.includes.split(',')
if list(set(deps) & set(includes)):
raise UsageError(_("Error creating package: "
"param --deps intersects with --includes"))
for pname in includes:
try:
package = store.get_package(pname)
except Exception as ex:
raise UsageError(_("Error creating package: "
"included package %s does not exist") % pname)
include_files.extend(package.files)
include_files_devel.extend(package.files_devel)
platform_include_files = self.merge_dict(
platform_include_files,
package.platform_files)
platform_include_files_devel = self.merge_dict(
platform_include_files_devel,
package.platform_files_devel)
include_files = list(set(include_files))
include_files_devel = list(set(include_files_devel))
if args.files or include_files:
template += FILES_TPL
files = []
if args.files:
files = args.files.split(',')
if include_files:
files.extend(include_files)
template_args['files'] = files
if args.files_devel or include_files_devel:
template += FILES_DEVEL_TPL
files_devel = []
if args.files_devel:
files_devel = args.files_devel.split(',')
if include_files_devel:
files_devel.extend(include_files_devel)
template_args['files_devel'] = files_devel
if args.platform_files or platform_include_files:
template += PLATFORM_FILES_TPL
platform_files = self.parse_platform_files(
args.platform_files, platform_include_files)
template_args['platform_files'] = platform_files
if args.platform_files_devel or platform_include_files_devel:
template += PLATFORM_FILES_DEVEL_TPL
platform_files_devel = self.parse_platform_files(
args.platform_files_devel,
platform_include_files_devel)
template_args['platform_files_devel'] = platform_files_devel
try:
f = open(filename, 'w')
f.write(template % template_args)
f.close()
m.action(_("Package '%s' successfully created in %s") %
(name, filename))
except IOError as ex:
raise FatalError(_("Error creating package: %s") % ex)
def run(self, config, args):
store = PackagesStore(config)
package = store.get_package(args.package[0])
return self.fetch(store.cookbook, package.recipes_dependencies(),
False, args.reset_rdeps)
def run(self, config, args):
store = PackagesStore(config)
package = store.get_package(args.package[0])
return self.fetch(store.cookbook, package.recipes_dependencies(),
args.deps, args.reset_rdeps, args.full_reset,
args.print_only, args.jobs)
def run(self, config, args):
packages = []
recipes = []
bundle_recipes = []
bundle_dirs = []
setup_args = ['sdist']
if not config.uninstalled:
m.error("Can only be run on cerbero-uninstalled")
store = PackagesStore(config)
cookbook = CookBook(config)
packages = list(args.bundlepackages)
for p in packages:
package = store.get_package(p)
if hasattr(package, 'list_packages'):
packages += package.list_packages()
packages = remove_list_duplicates(packages)
for p in packages:
package = store.get_package(p)
if hasattr(package, 'deps'):
packages += package.deps
packages = remove_list_duplicates(packages)
for p in packages:
package = store.get_package(p)
recipes += package.recipes_dependencies()
recipes += args.add_recipe
for r in recipes:
bundle_recipes += cookbook.list_recipe_deps(r)
bundle_recipes = remove_list_duplicates(bundle_recipes)
for p in packages:
setup_args.append('--package=' + p)
for r in bundle_recipes:
setup_args.append('--recipe=' + r.name)
if r.stype != SourceType.CUSTOM:
bundle_dirs.append(r.repo_dir)
if not args.no_bootstrap:
build_tools = BuildTools(config)
bs_recipes = build_tools.BUILD_TOOLS + \
build_tools.PLAT_BUILD_TOOLS.get(config.platform, [])
b_recipes = []
for r in bs_recipes:
b_recipes += cookbook.list_recipe_deps(r)
b_recipes = remove_list_duplicates(b_recipes)
for r in b_recipes:
if r.stype != SourceType.CUSTOM:
bundle_dirs.append(r.repo_dir)
setup_args.append('--source-dirs=' + ','.join(bundle_dirs))
command = str(config._relative_path('setup.py'))
run_setup(command, setup_args)
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)
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 run(self, config, args):
name = args.name[0]
version = args.version[0]
store = PackagesStore(config)
filename = os.path.join(config.packages_dir, '%s.package' % name)
if not args.force and os.path.exists(filename):
m.warning(_("Package '%s' (%s) already exists, "
"use -f to replace" % (name, filename)))
return
template_args = {}
template = RECEIPT_TPL
template_args['name'] = name
template_args['version'] = version
if args.short_desc:
template_args['shortdesc'] = args.short_desc
else:
template_args['shortdesc'] = name
if args.vendor:
template += VENDOR_TPL
template_args['vendor'] = args.vendor
if args.url:
template += URL_TPL
template_args['url'] = args.url
if args.license:
self.validate_licenses([args.license])
template += LICENSE_TPL
template_args['license'] = \
'License.' + self.supported_licenses[args.license]
deps = []
if args.deps:
template += DEPS_TPL
deps = args.deps.split(',')
for dname in deps:
try:
package = store.get_package(dname)
except Exception as ex:
raise UsageError(_("Error creating package: "
"dependant package %s does not exist") % dname)
template_args['deps'] = deps
include_files = []
include_files_devel = []
platform_include_files = {}
platform_include_files_devel = {}
if args.includes:
includes = args.includes.split(',')
if list(set(deps) & set(includes)):
raise UsageError(_("Error creating package: "
"param --deps intersects with --includes"))
for pname in includes:
try:
package = store.get_package(pname)
except Exception as ex:
raise UsageError(_("Error creating package: "
"included package %s does not exist") % pname)
include_files.extend(package.files)
include_files_devel.extend(package.files_devel)
platform_include_files = self.merge_dict(
platform_include_files,
package.platform_files)
platform_include_files_devel = self.merge_dict(
platform_include_files_devel,
package.platform_files_devel)
include_files = list(set(include_files))
include_files_devel = list(set(include_files_devel))
if args.files or include_files:
template += FILES_TPL
files = []
if args.files:
files = args.files.split(',')
if include_files:
files.extend(include_files)
template_args['files'] = files
if args.files_devel or include_files_devel:
template += FILES_DEVEL_TPL
files_devel = []
if args.files_devel:
files_devel = args.files_devel.split(',')
if include_files_devel:
files_devel.extend(include_files_devel)
template_args['files_devel'] = files_devel
if args.platform_files or platform_include_files:
template += PLATFORM_FILES_TPL
platform_files = self.parse_platform_files(
args.platform_files, platform_include_files)
template_args['platform_files'] = platform_files
if args.platform_files_devel or platform_include_files_devel:
template += PLATFORM_FILES_DEVEL_TPL
platform_files_devel = self.parse_platform_files(
args.platform_files_devel,
platform_include_files_devel)
template_args['platform_files_devel'] = platform_files_devel
try:
f = open(filename, 'w')
f.write(template % template_args)
f.close()
m.action(_("Package '%s' successfully created in %s") %
(name, filename))
except IOError as ex:
raise FatalError(_("Error creating package: %s") % ex)
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_
