def run(self, config, args):
cookbook = CookBook(config)
if args.recipe == 'all':
recipes = cookbook.get_recipes_list()
else:
recipes = [cookbook.get_recipe(args.recipe)]
if len(recipes) == 0:
m.message(_("No recipes found"))
tagname = args.tagname
tagdescription = args.tagdescription
force = args.force
for recipe in recipes:
if recipe.stype != SourceType.GIT and \
recipe.stype != SourceType.GIT_TARBALL:
m.message(
_("Recipe '%s' has a custom source repository, "
"skipping") % recipe.name)
continue
recipe.fetch(checkout=False)
tags = git.list_tags(recipe.repo_dir)
exists = (tagname in tags)
if exists:
if not force:
m.warning(
_("Recipe '%s' tag '%s' already exists, "
"not updating" % (recipe.name, tagname)))
continue
git.delete_tag(recipe.repo_dir, tagname)
commit = 'origin/sdk-%s' % recipe.version
git.create_tag(recipe.repo_dir, tagname, tagdescription, commit)
def run(self, config, args):
cookbook = CookBook(config)
recipes = cookbook.get_recipes_list()
if len(recipes) == 0:
m.message(_("No recipes found"))
for recipe in recipes:
m.message("%s - %s" % (recipe.name, recipe.version))
def run(self, config, args):
cookbook = CookBook(config)
if args.recipe == 'all':
recipes = cookbook.get_recipes_list()
else:
recipes = [cookbook.get_recipe(args.recipe)]
if len(recipes) == 0:
m.message(_("No recipes found"))
tagname = args.tagname
tagdescription = args.tagdescription
force = args.force
for recipe in recipes:
if recipe.stype != SourceType.GIT and \
recipe.stype != SourceType.GIT_TARBALL:
m.message(_("Recipe '%s' has a custom source repository, "
"skipping") % recipe.name)
continue
recipe.fetch(checkout=False)
tags = git.list_tags(recipe.repo_dir)
exists = (tagname in tags)
if exists:
if not force:
m.warning(_("Recipe '%s' tag '%s' already exists, "
"not updating" % (recipe.name, tagname)))
continue
git.delete_tag(recipe.repo_dir, tagname)
commit = 'origin/sdk-%s' % recipe.version
git.create_tag(recipe.repo_dir, tagname, tagdescription,
commit)
def run(self, config, args):
cookbook = CookBook(config)
recipes = cookbook.get_recipes_list()
if len(recipes) == 0:
m.message(_("No recipes found"))
for recipe in recipes:
try:
current = recipe.built_version().split("\n")[0]
except:
current = "Not checked out"
m.message("%s - %s (current checkout: %s)" % (recipe.name, recipe.version, current))
def run(self, config, args):
cookbook = CookBook(config)
recipes = cookbook.get_recipes_list()
if len(recipes) == 0:
m.message(_("No recipes found"))
for recipe in recipes:
try:
current = recipe.built_version().split("\n")[0]
except:
current = "Not checked out"
m.message("%s - %s (current checkout: %s)" % (recipe.name, recipe.version, current))
def run(self, config, args):
if config.target_platform != Platform.WINDOWS:
raise UsageError(_('%s command can only be used targetting '
'Windows platforms') % self.name)
if args.output_dir is not None and not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
cookbook = CookBook(config)
recipes = cookbook.get_recipes_list()
for recipe in recipes:
try:
recipe.gen_library_file(args.output_dir)
except Exception, e:
m.message(_("Error generaring library files for %s:\n %s") %
(recipe.name, e))
def run(self, config, args):
if config.target_platform != Platform.WINDOWS:
raise UsageError(_('%s command can only be used targetting '
'Windows platforms') % self.name)
if args.output_dir is not None and not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
cookbook = CookBook(config)
recipes = cookbook.get_recipes_list()
for recipe in recipes:
try:
recipe.gen_library_file(args.output_dir)
except Exception as e:
m.message(_("Error generaring library files for %s:\n %s") %
(recipe.name, e))
class PackagesStore(object):
'''
Stores a list of L{cerbero.packages.package.Package}
'''
PKG_EXT = '.package'
def __init__(self, config, load=True):
self._config = config
self._packages = {} # package_name -> package
self.cookbook = CookBook(config, load)
# used in tests to skip loading a dir with packages definitions
if not load:
return
if not os.path.exists(config.packages_dir):
raise FatalError(
_("Packages dir %s not found") % config.packages_dir)
self._load_packages()
def get_packages_list(self):
'''
Gets the list of packages
@return: list of packages
@rtype: list
'''
packages = self._packages.values()
packages.sort(key=lambda x: x.name)
return packages
def get_package(self, name):
'''
Gets a recipe from its name
@param name: name of the package
@type name: str
@return: the package instance
@rtype: L{cerbero.packages.package.Package}
'''
if name not in self._packages:
raise PackageNotFoundError(name)
return self._packages[name]
def get_package_deps(self, pkg, recursive=False):
'''
Gets the dependencies of a package
@param package: name of the package or package instance
@type package: L{cerbero.packages.package.Package}
@return: a list with the package dependencies
@rtype: list
'''
if isinstance(pkg, str):
pkg = self.get_package(pkg)
if isinstance(pkg, package.MetaPackage):
ret = self._list_metapackage_deps(pkg)
else:
ret = [self.get_package(x) for x in pkg.deps]
# get deps recursively
if recursive:
for p in ret:
ret.extend(self.get_package_deps(p, recursive))
return remove_list_duplicates(ret)
def get_package_files_list(self, name):
'''
Gets the list of files provided by a package
@param name: name of the package
@type name: str
@return: the package instance
@rtype: L{cerbero.packages.package.PackageBase}
'''
p = self.get_package(name)
if isinstance(p, package.MetaPackage):
return sorted(self._list_metapackage_files(p))
else:
return sorted(p.files_list())
def add_package(self, package):
'''
Adds a new package to the store
@param package: the package to add
@type package: L{cerbero.packages.package.PackageBase}
'''
self._packages[package.name] = package
def get_package_recipes_deps(self, package_name):
'''
Gets the list of recipes needed to create this package
@param name: name of the package
@type name: str
@return: a list with the recipes required to build this package
@rtype: list
'''
deps = self.get_package_deps(package_name)
return [self.cookbok.get_recipe(x) for x in deps]
def _list_metapackage_deps(self, metapackage):
def get_package_deps(package_name, visited=[], depslist=[]):
if package_name in visited:
return
visited.append(package_name)
p = self.get_package(package_name)
depslist.append(p)
for p_name in p.deps:
get_package_deps(p_name, visited, depslist)
return depslist
deps = []
for p in metapackage.list_packages():
deps.extend(get_package_deps(p, [], []))
return remove_list_duplicates(deps)
def _list_metapackage_files(self, metapackage):
l = []
for p in self._list_metapackage_deps(metapackage):
l.extend(p.files_list())
# remove duplicates and sort
return sorted(list(set(l)))
def _load_packages(self):
self._packages = {}
packages = defaultdict(dict)
repos = self._config.get_packages_repos()
for reponame, (repodir, priority) in repos.iteritems():
packages[int(priority)].update(
self._load_packages_from_dir(repodir))
# Add packages by ascending pripority
for key in sorted(packages.keys()):
self._packages.update(packages[key])
# Add a package for every recipe
for recipe in self.cookbook.get_recipes_list():
if not recipe.allow_package_creation:
continue
p = self._package_from_recipe(recipe)
if p.name in self._packages.keys():
m.warning(
"Package with name '%s' already exists, not including it",
p.name)
else:
self._packages[p.name] = p
def _package_from_recipe(self, recipe):
p = package.Package(self._config, self, self.cookbook)
p.name = '%s-pkg' % recipe.name
p.license = recipe.licenses
if recipe.built_version():
version = recipe.built_version()
else:
version = recipe.version
p.version = '%s-%s' % (version,
self.cookbook.recipe_file_hash(recipe.name))
p.files = ['%s' % recipe.name]
p.load_files()
return p
def _load_packages_from_dir(self, repo):
packages_dict = {}
packages = shell.find_files('*%s' % self.PKG_EXT, repo)
packages.extend(shell.find_files('*/*%s' % self.PKG_EXT, repo))
for f in packages:
p = self._load_package_from_file(f)
if p is None:
m.warning(_("Could not found a valid package in %s") % f)
continue
packages_dict[p.name] = p
return packages_dict
def _load_package_from_file(self, filepath):
mod_name, file_ext = os.path.splitext(os.path.split(filepath)[-1])
try:
d = {
'Platform': Platform,
'Architecture': Architecture,
'Distro': Distro,
'DistroVersion': DistroVersion,
'License': License,
'package': package,
'PackageType': PackageType
}
parse_file(filepath, d)
if 'Package' in d:
p = d['Package'](self._config, self, self.cookbook)
elif 'SDKPackage' in d:
p = d['SDKPackage'](self._config, self)
elif 'InstallerPackage' in d:
p = d['InstallerPackage'](self._config, self)
elif 'App' in d:
p = d['App'](self._config, self, self.cookbook)
elif 'AppExtensionPackage' in d:
p = d['AppExtensionPackage'](self._config, self, self.cookbook)
else:
raise Exception('Package, SDKPackage, InstallerPackage or App '
'class not found')
p.__file__ = os.path.abspath(filepath)
p.prepare()
# reload files from package now that we called prepare that
# may have changed it
p.load_files()
return p
except Exception, ex:
import traceback
traceback.print_exc()
m.warning("Error loading package %s" % ex)
return None
class PackageTest(unittest.TestCase):
def setUp(self):
self.config = Config()
self.config.cache_file = '/dev/null'
self.cookbook = CookBook(self.config, False)
def testSetGetConfig(self):
self.assertEquals(self.config, self.cookbook.get_config())
self.cookbook.set_config(None)
self.assertIsNone(self.cookbook._config)
def testCacheMissing(self):
status = {'test': 'test'}
self.cookbook.set_status(status)
self.cookbook._restore_cache()
self.assertEquals(self.cookbook.status, {})
def testSaveCache(self):
tmp = tempfile.NamedTemporaryFile()
status = {'test': 'test'}
self.cookbook.set_status(status)
self.cookbook.get_config().cache_file = tmp.name
self.cookbook.save()
with open(self.cookbook._cache_file(self.config), 'rb') as f:
loaded_status = pickle.load(f)
self.assertEquals(status, loaded_status)
def testLoad(self):
tmp = tempfile.NamedTemporaryFile()
status = {'test': 'test'}
self.cookbook.get_config().cache_file = tmp.name
with open(tmp.name, 'wb') as f:
pickle.dump(status, f)
self.cookbook._restore_cache()
self.assertEquals(status, self.cookbook.status)
def testAddGetRecipe(self):
recipe = Recipe1(self.config)
self.failUnlessRaises(RecipeNotFoundError, self.cookbook.get_recipe,
recipe.name)
self.cookbook.add_recipe(recipe)
self.assertEquals(recipe, self.cookbook.recipes[recipe.name])
self.assertEquals(recipe, self.cookbook.get_recipe(recipe.name))
self.assertEquals(self.cookbook.get_recipes_list(), [recipe])
def testGetRecipesStatus(self):
recipe = Recipe1(self.config)
self.cookbook._restore_cache()
self.assertEquals(self.cookbook.status, {})
self.cookbook.add_recipe(recipe)
self.assertEquals(len(self.cookbook.status), 0)
status = self.cookbook._recipe_status(recipe.name)
self.assertEquals(len(self.cookbook.status), 1)
self.assertEquals(status.steps, [])
status.steps.append('1')
status = self.cookbook._recipe_status(recipe.name)
self.assertEquals(len(self.cookbook.status), 1)
self.assertEquals(status.steps[0], '1')
def testUpdateStatus(self):
recipe = Recipe1(self.config)
self.cookbook.add_recipe(recipe)
self.cookbook._restore_cache()
self.cookbook.update_step_status(recipe.name, 'fetch')
status = self.cookbook._recipe_status(recipe.name)
self.assertEquals(status.steps, ['fetch'])
self.cookbook.update_step_status(recipe.name, 'build')
status = self.cookbook._recipe_status(recipe.name)
self.assertEquals(status.steps, ['fetch', 'build'])
self.cookbook.update_step_status(recipe.name, 'install')
status = self.cookbook._recipe_status(recipe.name)
self.assertEquals(status.steps, ['fetch', 'build', 'install'])
for step in ['fetch', 'build', 'install']:
self.assertTrue(self.cookbook.step_done(recipe.name, step))
def testBuildStatus(self):
recipe = Recipe1(self.config)
self.cookbook.add_recipe(recipe)
self.cookbook._restore_cache()
self.cookbook.update_build_status(recipe.name, True)
self.assertTrue(self.cookbook.status[recipe.name].needs_build)
self.cookbook.update_build_status(recipe.name, False)
self.assertFalse(self.cookbook.status[recipe.name].needs_build)
def testResetRecipeStatus(self):
recipe = Recipe1(self.config)
self.cookbook.add_recipe(recipe)
self.cookbook._restore_cache()
self.cookbook.reset_recipe_status(recipe.name)
status = self.cookbook._recipe_status(recipe.name)
self.assertEquals(status.steps, [])
self.assertTrue(self.cookbook.status[recipe.name].needs_build)
class PackageTest(unittest.TestCase):
def setUp(self):
self.config = Config()
self.config.cache_file = '/dev/null'
self.cookbook = CookBook(self.config, False)
def testSetGetConfig(self):
self.assertEqual(self.config, self.cookbook.get_config())
self.cookbook.set_config(None)
self.assertIsNone(self.cookbook._config)
def testCacheMissing(self):
status = {'test': 'test'}
self.cookbook.set_status(status)
self.cookbook._restore_cache()
self.assertEqual(self.cookbook.status, {})
def testSaveCache(self):
tmp = tempfile.NamedTemporaryFile()
status = {'test': 'test'}
self.cookbook.set_status(status)
self.cookbook.get_config().cache_file = tmp.name
self.cookbook.save()
with open(self.cookbook._cache_file(self.config), 'rb') as f:
loaded_status = pickle.load(f)
self.assertEqual(status, loaded_status)
def testLoad(self):
tmp = tempfile.NamedTemporaryFile()
status = {'test': 'test'}
self.cookbook.get_config().cache_file = tmp.name
with open(tmp.name, 'wb') as f:
pickle.dump(status, f)
self.cookbook._restore_cache()
self.assertEqual(status, self.cookbook.status)
def testAddGetRecipe(self):
recipe = Recipe1(self.config)
self.assertRaises(RecipeNotFoundError, self.cookbook.get_recipe,
recipe.name)
self.cookbook.add_recipe(recipe)
self.assertEqual(recipe, self.cookbook.recipes[recipe.name])
self.assertEqual(recipe, self.cookbook.get_recipe(recipe.name))
self.assertEqual(self.cookbook.get_recipes_list(), [recipe])
def testGetRecipesStatus(self):
recipe = Recipe1(self.config)
self.cookbook._restore_cache()
self.assertEqual(self.cookbook.status, {})
self.cookbook.add_recipe(recipe)
self.assertEqual(len(self.cookbook.status), 0)
status = self.cookbook._recipe_status(recipe.name)
self.assertEqual(len(self.cookbook.status), 1)
self.assertEqual(status.steps, [])
status.steps.append('1')
status = self.cookbook._recipe_status(recipe.name)
self.assertEqual(len(self.cookbook.status), 1)
self.assertEqual(status.steps[0], '1')
def testUpdateStatus(self):
recipe = Recipe1(self.config)
self.cookbook.add_recipe(recipe)
self.cookbook._restore_cache()
self.cookbook.update_step_status(recipe.name, 'fetch')
status = self.cookbook._recipe_status(recipe.name)
self.assertEqual(status.steps, ['fetch'])
self.cookbook.update_step_status(recipe.name, 'build')
status = self.cookbook._recipe_status(recipe.name)
self.assertEqual(status.steps, ['fetch', 'build'])
self.cookbook.update_step_status(recipe.name, 'install')
status = self.cookbook._recipe_status(recipe.name)
self.assertEqual(status.steps, ['fetch', 'build', 'install'])
for step in ['fetch', 'build', 'install']:
self.assertTrue(self.cookbook.step_done(recipe.name, step))
def testBuildStatus(self):
recipe = Recipe1(self.config)
self.cookbook.add_recipe(recipe)
self.cookbook._restore_cache()
self.cookbook.update_build_status(recipe.name, '1.0')
self.assertTrue(self.cookbook.status[recipe.name].needs_build)
self.assertEqual(self.cookbook.status[recipe.name].built_version,
'1.0')
self.cookbook.update_build_status(recipe.name, None)
self.assertFalse(self.cookbook.status[recipe.name].needs_build)
self.assertEqual(self.cookbook.status[recipe.name].built_version, None)
def testResetRecipeStatus(self):
recipe = Recipe1(self.config)
self.cookbook.add_recipe(recipe)
self.cookbook._restore_cache()
self.cookbook.reset_recipe_status(recipe.name)
status = self.cookbook._recipe_status(recipe.name)
self.assertEqual(status.steps, [])
self.assertTrue(self.cookbook.status[recipe.name].needs_build)
class PackagesStore (object):
'''
Stores a list of L{cerbero.packages.package.Package}
'''
PKG_EXT = '.package'
def __init__(self, config, load=True):
self._config = config
self._packages = {} # package_name -> package
self.cookbook = CookBook(config, load)
# used in tests to skip loading a dir with packages definitions
if not load:
return
if not os.path.exists(config.packages_dir):
raise FatalError(_("Packages dir %s not found") %
config.packages_dir)
self._load_packages()
def get_packages_list(self):
'''
Gets the list of packages
@return: list of packages
@rtype: list
'''
packages = self._packages.values()
packages.sort(key=lambda x: x.name)
return packages
def get_package(self, name):
'''
Gets a recipe from its name
@param name: name of the package
@type name: str
@return: the package instance
@rtype: L{cerbero.packages.package.Package}
'''
if name not in self._packages:
raise PackageNotFoundError(name)
return self._packages[name]
def get_package_deps(self, pkg, recursive=False):
'''
Gets the dependencies of a package
@param package: name of the package or package instance
@type package: L{cerbero.packages.package.Package}
@return: a list with the package dependencies
@rtype: list
'''
if isinstance(pkg, str):
pkg = self.get_package(pkg)
if isinstance(pkg, package.MetaPackage):
ret = self._list_metapackage_deps(pkg)
else:
ret = [self.get_package(x) for x in pkg.deps]
# get deps recursively
if recursive:
for p in ret:
ret.extend(self.get_package_deps(p, recursive))
return remove_list_duplicates(ret)
def get_package_files_list(self, name):
'''
Gets the list of files provided by a package
@param name: name of the package
@type name: str
@return: the package instance
@rtype: L{cerbero.packages.package.PackageBase}
'''
p = self.get_package(name)
if isinstance(p, package.MetaPackage):
return sorted(self._list_metapackage_files(p))
else:
return sorted(p.files_list())
def add_package(self, package):
'''
Adds a new package to the store
@param package: the package to add
@type package: L{cerbero.packages.package.PackageBase}
'''
self._packages[package.name] = package
def get_package_recipes_deps(self, package_name):
'''
Gets the list of recipes needed to create this package
@param name: name of the package
@type name: str
@return: a list with the recipes required to build this package
@rtype: list
'''
deps = self.get_package_deps(package_name)
return [self.cookbok.get_recipe(x) for x in deps]
def _list_metapackage_deps(self, metapackage):
def get_package_deps(package_name, visited=[], depslist=[]):
if package_name in visited:
return
visited.append(package_name)
p = self.get_package(package_name)
depslist.append(p)
for p_name in p.deps:
get_package_deps(p_name, visited, depslist)
return depslist
deps = []
for p in metapackage.list_packages():
deps.extend(get_package_deps(p, [], []))
return remove_list_duplicates(deps)
def _list_metapackage_files(self, metapackage):
l = []
for p in self._list_metapackage_deps(metapackage):
l.extend(p.files_list())
# remove duplicates and sort
return sorted(list(set(l)))
def _load_packages(self):
self._packages = {}
packages = defaultdict(dict)
repos = self._config.get_packages_repos()
for reponame, (repodir, priority) in repos.iteritems():
packages[int(priority)].update(
self._load_packages_from_dir(repodir))
# Add packages by ascending pripority
for key in sorted(packages.keys()):
self._packages.update(packages[key])
# Add a package for every recipe
for recipe in self.cookbook.get_recipes_list():
if not recipe.allow_package_creation:
continue
p = self._package_from_recipe(recipe)
if p.name in self._packages.keys():
m.warning("Package with name '%s' already exists, not including it", p.name)
else:
self._packages[p.name] = p
def _package_from_recipe(self, recipe):
p = package.Package(self._config, self, self.cookbook)
p.name = '%s-pkg' % recipe.name
p.license = recipe.licenses
if recipe.built_version():
version = recipe.built_version()
else:
version = recipe.version
p.version = '%s-%s' % (version, self.cookbook.recipe_file_hash(recipe.name))
p.files = ['%s' % recipe.name]
p.load_files()
return p
def _load_packages_from_dir(self, repo):
packages_dict = {}
packages = shell.find_files('*%s' % self.PKG_EXT, repo)
packages.extend(shell.find_files('*/*%s' % self.PKG_EXT, repo))
for f in packages:
p = self._load_package_from_file(f)
if p is None:
m.warning(_("Could not found a valid package in %s") % f)
continue
packages_dict[p.name] = p
return packages_dict
def _load_package_from_file(self, filepath):
mod_name, file_ext = os.path.splitext(os.path.split(filepath)[-1])
try:
d = {'Platform': Platform, 'Architecture': Architecture,
'Distro': Distro, 'DistroVersion': DistroVersion,
'License': License, 'package': package,
'PackageType': PackageType}
parse_file(filepath, d)
if 'Package' in d:
p = d['Package'](self._config, self, self.cookbook)
elif 'SDKPackage' in d:
p = d['SDKPackage'](self._config, self)
elif 'InstallerPackage' in d:
p = d['InstallerPackage'](self._config, self)
elif 'App' in d:
p = d['App'](self._config, self, self.cookbook)
elif 'AppExtensionPackage' in d:
p = d['AppExtensionPackage'](self._config, self, self.cookbook)
else:
raise Exception('Package, SDKPackage, InstallerPackage or App '
'class not found')
p.__file__ = os.path.abspath(filepath)
p.prepare()
# reload files from package now that we called prepare that
# may have changed it
p.load_files()
return p
except Exception, ex:
import traceback
traceback.print_exc()
m.warning("Error loading package %s" % ex)
return None
