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)
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):
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)
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):
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 __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):
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 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 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 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 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 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 _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
}
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 __init__(self,config ):
self.config = config
self.store = PackagesStore(config)
self.cookbook = CookBook(config)
self.packages_ = None
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 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 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)
