Example #1
0
    def __init__(self, template=None, user=None):
        self._name = None
        self._user = user
        self._uuid = None
        self._version = None
        self._title = None
        self._description = None

        self._includes = []  # includes in template
        self._includes_resolved = [
        ]  # data structs for all includes in template
        self._meta = {}

        self._repos = RepoSet()  # repos in template
        self._includes_repos = RepoSet()  # repos from includes in template
        self._delta_repos = RepoSet()  # repos to add/remove in template

        self._packages = PackageSet()  # packages in template
        self._includes_packages = PackageSet(
        )  # packages from includes in template
        self._delta_packages = PackageSet(
        )  # packages to add/remove in template

        self._stores = []  # remote stores for machine

        self._objects = ObjectSet()  # archive definitions in machine
        self._includes_objects = ObjectSet()  # archive definitions in machine
        self._delta_objects = ObjectSet()  # archive definitions in machine

        self._db = None

        self._parse_template(template)
Example #2
0
    def clear(self):
        """
        Clears all includes, objects, packages, repos and stores from the
        template. Also removes all kickstart meta information.

        Args:
          None

        Returns:
          Nothing.
        """

        self._includes = []  # includes in template
        self._includes_resolved = [
        ]  # data structs for all includes in template
        self._repos = RepoSet()  # repos in template
        self._includes_repos = RepoSet()  # repos from includes in template
        self._delta_repos = RepoSet()  # repos to add/remove in template

        self._packages = PackageSet()  # packages in template
        self._includes_packages = PackageSet(
        )  # packages from includes in template
        self._delta_packages = PackageSet(
        )  # packages to add/remove in template

        self._stores = []  # remote stores for machine

        self._objects = ObjectSet()  # archive definitions in machine
        self._includes_objects = ObjectSet()  # archive definitions in machine
        self._delta_objects = ObjectSet()  # archive definitions in machine

        if 'kickstart' in self._meta:
            del self._meta['kickstart']
Example #3
0
    def test_reposet_equality(self):
        r1 = Repository({'n': 'test', 's': 'foo', 'bu': 'x'})
        r2 = Repository({'n': 'test', 's': 'foo', 'bu': 'y'})

        l1 = RepoSet()
        l2 = RepoSet()

        l1.add(r1)
        l2.add(r2)
        self.assertEqual(l1, l2)
Example #4
0
    def test_reposet_difference(self):
        r1 = Repository({'n': 'test', 's': 'foo', 'bu': 'x'})
        r2 = Repository({'n': 'test', 's': 'bar', 'bu': 'y'})
        r3 = Repository({'n': 'test', 's': 'baz'})
        r4 = Repository({'n': 'test', 's': 'car'})

        l1 = RepoSet([r1, r2, r3])
        l2 = RepoSet([r2, r3, r4])

        (luniq1, luniq2) = l1.difference(l2)

        self.assertEqual(RepoSet([r1]), luniq1)
        self.assertEqual(RepoSet([r4]), luniq2)
Example #5
0
    def test_template_create_empty(self):
        t1 = Template({})

        self.assertEqual(None, t1.name)
        self.assertEqual(None, t1.user)
        self.assertEqual(None, t1.uuid)
        self.assertEqual(None, t1.description)

        self.assertEqual([], t1.includes)

        self.assertEqual([], t1._includes_resolved)
        self.assertEqual({}, t1._meta)

        self.assertEqual(RepoSet(), t1.repos)
        self.assertEqual(RepoSet(), t1._includes_repos)
        self.assertEqual(RepoSet(), t1._delta_repos)

        self.assertEqual(PackageSet(), t1._packages)
        self.assertEqual(PackageSet(), t1._includes_packages)
        self.assertEqual(PackageSet(), t1._delta_packages)

        self.assertEqual([], t1._stores)
        self.assertEqual(ObjectSet(), t1._objects)
Example #6
0
    def test_reposet_uniqueness(self):
        r1 = Repository({'n': 'test', 's': 'foo', 'bu': 'x'})
        r2 = Repository({'n': 'test', 's': 'foo', 'bu': 'y'})
        r3 = Repository({'n': 'test', 's': 'bar', 'bu': 'x'})

        l1 = RepoSet()

        l1.add(r1)
        self.assertTrue(len(l1) == 1)

        l1.add(r2)
        self.assertTrue(len(l1) == 1)
        self.assertEqual(l1[0].baseurl, 'x')

        l1.add(r3)
        self.assertTrue(len(l1) == 2)
Example #7
0
    def _parse_template(self, template):
        # parse the string short form
        if isinstance(template, str):
            (user, name, version) = self._parse_unv(template)

            if user:
                self._user = user

            if name:
                self._name = name

            if version:
                self._version = version

            if not self._user or len(self._user) == 0:
                raise ValueError("template format invalid")

            if not self._name or len(self._name) == 0:
                raise ValueError("template format invalid")

        # parse the dict form, the most common form and directly
        # relates to the json structures returned by canvas server
        elif isinstance(template, dict):
            self._uuid = template.get('uuid', None)
            self._user = template.get('user', template.get('username', None))
            self._name = template.get('stub', None)
            self._version = template.get('version', None)
            self._title = template.get('name', self._name)
            self._description = template.get('description', None)

            self._includes = template.get('includes', [])

            self._repos = RepoSet(
                Repository(r, template=self.unv)
                for r in template.get('repos', []))
            self._packages = PackageSet(
                Package(p, template=self.unv)
                for p in template.get('packages', []))

            self._stores = template.get('stores', [])
            self._objects = ObjectSet(
                Object(o) for o in template.get('objects', []))

            self._meta = template.get('meta', {})