Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on May 1st, 2012  |  syntax: None  |  size: 50.40 KB  |  hits: 15  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. diff --git a/playpen/mongodb/display_pkgs.py b/playpen/mongodb/display_pkgs.py
  2. new file mode 100755
  3. index 0000000..9e56c71
  4. --- /dev/null
  5. +++ b/playpen/mongodb/display_pkgs.py
  6. @@ -0,0 +1,35 @@
  7. +#!/usr/bin/env python
  8. +import time
  9. +from pymongo import Connection
  10. +from pymongo.son_manipulator import AutoReference, NamespaceInjector
  11. +from optparse import OptionParser
  12. +
  13. +import pulp.util
  14. +from pulp.api.package_version import PackageVersionApi
  15. +
  16. +if __name__ == "__main__":
  17. +    
  18. +    package_id = "pulp-test-package"
  19. +    checksum = "6bce3f26e1fc0fc52ac996f39c0d0e14fc26fb8077081d5b4dbfb6431b08aa9f"
  20. +    checksum_type = "sha256"
  21. +    filename = "pulp-test-package-0.3.1-1.fc11.x86_64.rpm"
  22. +
  23. +
  24. +    config = pulp.util.loadConfig("../../etc/pulp.ini")
  25. +    pvApi = PackageVersionApi(config)
  26. +
  27. +    found = pvApi.packageversion(filename=filename, checksum_type=checksum_type, checksum=checksum)
  28. +    print "Lookup for %s, %s, %s yielded %s" % (filename, checksum_type, checksum, found)
  29. +
  30. +    db = pvApi.objectdb
  31. +    print "db = %s" % (db)
  32. +    found = db.find({"filename":filename})
  33. +    print "Search for all PV's with %s: %s" % (filename, found)
  34. +    for f in found:
  35. +        print f
  36. +    found = db.find()
  37. +    print "%s PV objects found with an open search" % (found.count())
  38. +
  39. +    found = pvApi.packageversion()
  40. +    print "search with empty searchDict returned %s results" % (found.count())
  41. +
  42. diff --git a/src/pulp/api/base.py b/src/pulp/api/base.py
  43. index 1b9a123..7ae0fb9 100644
  44. --- a/src/pulp/api/base.py
  45. +++ b/src/pulp/api/base.py
  46. @@ -26,7 +26,8 @@ class BaseApi(object):
  47.  
  48.          # Mongo DB
  49.          self.connection = pymongo.Connection()
  50. -        self.db = self.connection._database
  51. +        #self.db = self.connection._database
  52. +        self.db = self.connection._database_model_changes
  53.          # Inject the collection's namespace into each object
  54.          self.db.add_son_manipulator(NamespaceInjector())
  55.          # Provides auto-referencing/auto-dereferencing ability
  56. diff --git a/src/pulp/api/package_version.py b/src/pulp/api/package_version.py
  57. index be076b3..ab0c364 100644
  58. --- a/src/pulp/api/package_version.py
  59. +++ b/src/pulp/api/package_version.py
  60. @@ -23,29 +23,62 @@ class PackageVersionApi(BaseApi):
  61.  
  62.      def __init__(self, config):
  63.          BaseApi.__init__(self, config)
  64. +        self.objectdb.ensure_index([('name', pymongo.DESCENDING),
  65. +            ('epoch', pymongo.DESCENDING),
  66. +            ('version', pymongo.DESCENDING),
  67. +            ('release', pymongo.DESCENDING),
  68. +            ('arch', pymongo.DESCENDING),
  69. +            ('filename', pymongo.DESCENDING),
  70. +            ('checksum', pymongo.DESCENDING)],
  71. +            unique=True, background=True)
  72.  
  73.      def _get_unique_indexes(self):
  74.          return []
  75.  
  76.      def _get_indexes(self):
  77. -        return ["packageid"]
  78. +        return ["name", "filename", "checksum", "epoch", "version", "release",
  79. +                "arch", "description"]
  80.  
  81.      def _getcollection(self):
  82.          return self.db.packageversions
  83.  
  84. -    def create(self, packageid, epoch, version, release, arch):
  85. +    def create(self, name, epoch, version, release, arch, description,
  86. +            checksum_type, checksum, filename):
  87.          """
  88.          Create a new PackageVersion object and return it
  89.          """
  90. -        pv = model.PackageVersion(packageid, epoch, version, release, arch)
  91. +        pv = model.PackageVersion(name, epoch, version, release, arch, description,
  92. +                checksum_type, checksum, filename)
  93.          self.objectdb.insert(pv)
  94.          return pv
  95. -        
  96. -    def packageversion(self, id, filter=None):
  97. +
  98. +    def delete(self, object):
  99. +        """
  100. +        Delete package version object based on "_id" key
  101. +        """
  102. +        self.objectdb.remove({"_id":object["_id"]})
  103. +
  104. +    def packageversion(self, name=None, epoch=None, version=None, release=None, arch=None,
  105. +            filename=None, checksum_type=None, checksum=None):
  106.          """
  107. -        Return a single PackageVersion object
  108. +        Return a list of all package version objects matching search terms
  109.          """
  110. -        return self.objectdb.find_one({'id': id})
  111. +        searchDict = {}
  112. +        if name:
  113. +            searchDict['name'] = name
  114. +        if epoch:
  115. +            searchDict['epoch'] = epoch
  116. +        if version:
  117. +            searchDict['version'] = version
  118. +        if release:
  119. +            searchDict['release'] = release
  120. +        if arch:
  121. +            searchDict['arch'] = arch
  122. +        if filename:
  123. +            searchDict['filename'] = filename
  124. +        if checksum_type and checksum:
  125. +            searchDict['checksum.%s' % checksum_type] = checksum
  126. +        return self.objectdb.find(searchDict)
  127.  
  128.      def packageversions(self):
  129.          """
  130. diff --git a/src/pulp/api/repo.py b/src/pulp/api/repo.py
  131. index 3ee8858..f2e1015 100644
  132. --- a/src/pulp/api/repo.py
  133. +++ b/src/pulp/api/repo.py
  134. @@ -29,7 +29,7 @@ from grinder.RepoFetch import YumRepoGrinder
  135.  from pulp import model
  136.  from pulp import repo_sync, upload
  137.  from pulp.api.base import BaseApi
  138. -from pulp.api.package import PackageApi
  139. +#from pulp.api.package import PackageApi
  140.  from pulp.api.package_version import PackageVersionApi
  141.  from pulp.api.package_group import PackageGroupApi
  142.  from pulp.api.package_group_category import PackageGroupCategoryApi
  143. @@ -46,13 +46,19 @@ class RepoApi(BaseApi):
  144.      def __init__(self, config):
  145.          BaseApi.__init__(self, config)
  146.  
  147. -        self.packageApi = PackageApi(config)
  148. +        #self.packageApi = PackageApi(config)
  149.          self.packageVersionApi = PackageVersionApi(config)
  150.          self.packageGroupApi = PackageGroupApi(config)
  151.          self.packageGroupCategoryApi = PackageGroupCategoryApi(config)
  152.  
  153.          # TODO: Extract this to a config
  154.          self.localStoragePath = config.get('paths', 'local_storage')
  155. +  
  156. +    def _get_indexes(self):
  157. +        return ["packages", "packagegroups", "packagegroupcategories"]
  158. +
  159. +    def _get_unique_indexes(self):
  160. +        return ["id"]
  161.  
  162.      def _getcollection(self):
  163.          return self.db.repos
  164. @@ -71,11 +77,128 @@ class RepoApi(BaseApi):
  165.          
  166.      def packages(self, id):
  167.          """
  168. -        Return list of Package objects in this Repo
  169. +        Return dictionary of PackageVersion objects in this Repo, key is package name
  170.          """
  171.          repo = self.repository(id)
  172. +        if (repo == None):
  173. +            raise PulpException("No Repo with id: %s found" % id)
  174.          return repo['packages']
  175.      
  176. +    def packageversions(self, repoid, name):
  177. +        """
  178. +        Return list of PackageVersions objects for this repo and package name
  179. +        """
  180. +        repo = self.repository(repoid)
  181. +        if (repo == None):
  182. +            raise PulpException("No Repo with id: %s found" % repoid)
  183. +        if not repo["packages"].has_key(name):
  184. +            return None
  185. +        return repo["packages"][name]
  186. +
  187. +    def add_package_version(self, repoid, pv):
  188. +        """
  189. +        Adds the passed in package version to this repo
  190. +        """
  191. +        repo = self.repository(repoid)
  192. +        if (repo == None):
  193. +            raise PulpException("No Repo with id: %s found" % repoid)
  194. +        if not repo["packages"].has_key(pv['name']):
  195. +            repo["packages"][pv['name']] = []
  196. +        # TODO:  We might want to restrict PackageVersions we add to only
  197. +        #        allow 1 NEVRA per repo and require filename to be unique
  198. +        for item in repo["packages"][pv['name']]:
  199. +            if item['_id'] == pv['_id']:
  200. +                # No need to update repo, this PackageVersion is already under this repo
  201. +                return
  202. +        # Note:  A DBRef() for the objects '_id' is what's added in mongo
  203. +        #        This is a reference to the PackageVersion collection's object
  204. +        repo["packages"][pv['name']].append(pv)
  205. +        self.update(repo)
  206. +
  207. +    def remove_package_version(self, repoid, pv):
  208. +        repo = self.repository(repoid)
  209. +        if (repo == None):
  210. +            raise PulpException("No Repo with id: %s found" % repoid)
  211. +        if not repo["packages"].has_key(pv['name']):
  212. +            raise PulpException("No Package with name: %s found in repo: %s" %
  213. +                    (pv['name'], repoid))
  214. +        for item in repo["packages"][pv['name']]:
  215. +            if item['name'] == pv['name'] and \
  216. +                item['version'] == pv['version'] and \
  217. +                item['epoch'] == pv['epoch'] and \
  218. +                item['release'] == pv['release'] and \
  219. +                item['arch'] == pv['arch']:
  220. +                    repo['packages'][pv['name']].remove(item)
  221. +                    if len(repo['packages'][pv['name']]) == 0:
  222. +                        # list is empty now, so cleanup and remove
  223. +                        # it from the packages
  224. +                        del repo['packages'][pv['name']]
  225. +        self.update(repo)
  226. +
  227. +    def remove_packagegroup(self, repoid, groupid):
  228. +        """
  229. +        Remove a packagegroup from a repo
  230. +        """
  231. +        repo = self.repository(repoid)
  232. +        if (repo == None):
  233. +            raise PulpException("No Repo with id: %s found" % repoid)
  234. +        if repo['packagegroups'].has_key(groupid):
  235. +            del repo['packagegroups'][groupid]
  236. +        self.update(repo)
  237. +
  238. +    def update_packagegroup(self, repoid, pg):
  239. +        """
  240. +        Save the passed in PackageGroup to this repo
  241. +        """
  242. +        repo = self.repository(repoid)
  243. +        if (repo == None):
  244. +            raise PulpException("No Repo with id: %s found" % repoid)
  245. +        repo['packagegroups'][pg['id']] = pg
  246. +        self.update(repo)
  247. +
  248. +    def update_packagegroups(self, repoid, pglist):
  249. +        """
  250. +        Save the list of passed in PackageGroup objects to this repo
  251. +        """
  252. +        repo = self.repository(repoid)
  253. +        if (repo == None):
  254. +            raise PulpException("No Repo with id: %s found" % repoid)
  255. +        for item in pglist:
  256. +            repo['packagegroups'][item['id']] = item
  257. +        self.update(repo)
  258. +
  259. +    def translate_packagegroup(self, obj):
  260. +        """
  261. +        Translate a SON Document to an object that yum.comps.Comps can work with
  262. +        """
  263. +        # Main reason for doing this is that yum.comps expects the passed in
  264. +        # object to support dot notation references, the returned SON document
  265. +        # does not support this, so yum.comps isn't able to read the info
  266. +        #TODO: More work is needed in this method before output of groups will work
  267. +        pg = model.PackageGroup(obj['id'], obj['name'], obj['description'],
  268. +                user_visible=obj['user_visible'], display_order=obj['display_order'],
  269. +                default=obj['default'], langonly=obj['langonly'])
  270. +        pg.groupid = obj['id']  
  271. +        pg.translated_name = {}
  272. +        for key in obj['translated_name']:
  273. +            pg.translated_name[key] = obj['translated_name'][key]
  274. +        pg.translated_description = {}
  275. +        for key in obj['translated_description']:
  276. +            pg.translated_description[key] = obj['translated_description']
  277. +        pg.mandatory_packages = {}
  278. +        for pkgname in obj['mandatory_package_names']:
  279. +            pg.mandatory_packages[pkgname] = 1
  280. +        pg.optional_packages = {}
  281. +        for pkgname in obj['optional_package_names']:
  282. +            pg.optional_packages[pkgname] = 1
  283. +        pg.default_packages = {}
  284. +        for pkgname in obj['default_package_names']:
  285. +            pg.default_packages[pkgname] = 1
  286. +        pg.conditional_packages = {}
  287. +        for key in obj['conditional_package_names']:
  288. +            pg.conditional_packages[key] = obj['conditional_package_names'][key]
  289. +        return pg
  290. +
  291.      def packagegroups(self, id):
  292.          """
  293.          Return list of PackageGroup objects in this Repo
  294. @@ -83,13 +206,98 @@ class RepoApi(BaseApi):
  295.          repo = self.repository(id)
  296.          return repo['packagegroups']
  297.      
  298. +    def packagegroup(self, repoid, groupid):
  299. +        """
  300. +        Return a PackageGroup from this Repo
  301. +        """
  302. +        repo = self.repository(repoid)
  303. +        if not repo['packagegroups'].has_key(groupid):
  304. +            return None
  305. +        return repo['packagegroups'][groupid]
  306. +
  307. +    def remove_packagegroupcategory(self, repoid, categoryid):
  308. +        """
  309. +        Remove a packagegroupcategory from a repo
  310. +        """
  311. +        repo = self.repository(repoid)
  312. +        if (repo == None):
  313. +            raise PulpException("No Repo with id: %s found" % repoid)
  314. +        if repo['packagegroupcategories'].has_key(categoryid):
  315. +            del repo['packagegroupcategories'][categoryid]
  316. +        self.update(repo)
  317. +    
  318. +    def update_packagegroupcategory(self, repoid, pgc):
  319. +        """
  320. +        Save the passed in PackageGroupCategory to this repo
  321. +        """
  322. +        repo = self.repository(repoid)
  323. +        if (repo == None):
  324. +            raise PulpException("No Repo with id: %s found" % repoid)
  325. +        repo['packagegroupcategories'][pgc['id']] = pgc
  326. +        self.update(repo)
  327. +    
  328. +    def update_packagegroupcategories(self, repoid, pgclist):
  329. +        """
  330. +        Save the list of passed in PackageGroupCategory objects to this repo
  331. +        """
  332. +        repo = self.repository(repoid)
  333. +        if (repo == None):
  334. +            raise PulpException("No Repo with id: %s found" % repoid)
  335. +        for item in pgclist:
  336. +            repo['packagegroupcategories'][item['id']] = item
  337. +        self.update(repo)
  338. +
  339. +    def translate_packagegroupcategory(self, obj):
  340. +        """
  341. +        Translate a SON Document to an object that yum.comps.Comps can work with
  342. +        """
  343. +        #TODO: More work is needed in this method before output of categories will work
  344. +        pgc = model.PackageGroupCategory(obj['id'], obj['name'], obj['description'],
  345. +                display_order=obj['display_order'])
  346. +        pgc.categoryid = obj['id']
  347. +        pgc.translated_name = {}
  348. +        for key in obj['translated_name']:
  349. +            pgc.translated_name[key] = obj['translated_name'][key]
  350. +        pgc.translated_description = {}
  351. +        for key in obj['translated_description']:
  352. +            pgc.translated_description[key] = obj['translated_description'][key]
  353. +        pgc._groups = {}
  354. +        for groupid in obj['packagegroupids']:
  355. +            pgc._groups[groupid] = groupid
  356. +        return pgc
  357. +
  358. +    def packagegroups(self, id):
  359. +        """
  360. +        Return list of PackageGroup objects in this Repo
  361. +        """
  362. +        repo = self.repository(id)
  363. +        return repo['packagegroups']
  364. +
  365. +    def packagegroup(self, repoid, groupid):
  366. +        """
  367. +        Return a PackageGroup from this Repo
  368. +        """
  369. +        repo = self.repository(repoid)
  370. +        if not repo['packagegroups'].has_key(groupid):
  371. +            return None
  372. +        return repo['packagegroups'][groupid]
  373. +
  374.      def packagegroupcategories(self, id):
  375.          """
  376.          Return list of PackageGroupCategory objects in this Repo
  377.          """
  378.          repo = self.repository(id)
  379.          return repo['packagegroupcategories']
  380. -    
  381. +
  382. +    def packagegroupcategory(self, repoid, categoryid):
  383. +        """
  384. +        Return a PackageGroupCategory object from this Repo
  385. +        """
  386. +        repo = self.repository(repoid)
  387. +        if not repo['packagegroupcategories'].has_key(categoryid):
  388. +            return None
  389. +        return repo['packagegroupcategories'][categoryid]
  390. +
  391.      def create(self, id, name, arch, feed):
  392.          """
  393.          Create a new Repository object and return it
  394. diff --git a/src/pulp/model.py b/src/pulp/model.py
  395. index 9384727..ce4d4a3 100644
  396. --- a/src/pulp/model.py
  397. +++ b/src/pulp/model.py
  398. @@ -64,30 +64,35 @@ class RepoSource(Base):
  399.  
  400.  
  401.  class Package(Base):
  402. -    def __init__(self, packageid, description):
  403. -        #TODO: move 'description' to PackageVersion
  404. +    def __init__(self, repoid, packageid):
  405.          #TODO: Consider getting rid of 'package', we might not need it
  406. +        self.repoid = repoid
  407.          self.packageid = packageid
  408. -        self.description = description
  409.          self.versions = []
  410.  
  411.  class PackageVersion(Base):
  412. -    def __init__(self, packageid, epoch, version, release, arch):
  413. -        self.packageid = packageid
  414. +    def __init__(self, name, epoch, version, release, arch, description,
  415. +            checksum_type, checksum, filename):
  416. +        #TODO: Can we enforce unique indexes between keys?
  417. +        self.name = name
  418.          self.epoch = epoch
  419.          self.version = version
  420.          self.release = release
  421.          self.arch = arch
  422. -        #TODO: add support for 'filename' and 'checksum' to constructor, apis, and tests
  423. -        #self.filename = ""
  424. -        #self.checksum = {}
  425. +        self.description = description
  426. +        self.filename = filename
  427. +        self.checksum = {checksum_type:checksum}
  428. +        # Add gpg keys
  429.          self.requires = []
  430.          self.provides = []
  431.  
  432.  class PackageGroup(Base):
  433. -    def __init__(self, groupid, name, description, user_visible=False,
  434. +    """
  435. +    Class represents a yum.comps.Group
  436. +    """
  437. +    def __init__(self, id, name, description, user_visible=False,
  438.              display_order=1024, default=True, langonly=None):
  439. -        self.groupid = groupid
  440. +        self.id = id
  441.          self.name = name
  442.          self.description = description
  443.          self.user_visible = user_visible
  444. @@ -102,8 +107,8 @@ class PackageGroup(Base):
  445.          self.translated_description = {}
  446.  
  447.  class PackageGroupCategory(Base):
  448. -    def __init__(self, categoryid, name, description, display_order=99):
  449. -        self.categoryid = categoryid
  450. +    def __init__(self, id, name, description, display_order=99):
  451. +        self.id = id
  452.          self.name = name
  453.          self.description = description
  454.          self.display_order = display_order
  455. diff --git a/src/pulp/repo_sync.py b/src/pulp/repo_sync.py
  456. index f5264ea..1fa9cf1 100644
  457. --- a/src/pulp/repo_sync.py
  458. +++ b/src/pulp/repo_sync.py
  459. @@ -17,6 +17,7 @@
  460.  import gzip
  461.  import logging
  462.  import os
  463. +import time
  464.  import traceback
  465.  from urlparse import urlparse
  466.  
  467. @@ -60,94 +61,87 @@ class BaseSynchronizer(object):
  468.          self.package_group_api = PackageGroupApi(config)
  469.  
  470.      def add_packages_from_dir(self, dir, repo):
  471. -
  472.          dir_list = os.listdir(dir)
  473.          package_count = 0
  474. +        startTime = time.time()
  475.          for fname in dir_list:
  476.              self.import_package(dir + fname, repo)
  477.              package_count = package_count + 1
  478. -        log.debug("read [%s] packages" % package_count)
  479. -        self._read_comps_xml(dir, repo)
  480. +        endTime = time.time()
  481. +        log.debug("Repo: %s read [%s] packages took %s seconds" %
  482. +                (repo['id'], package_count, endTime - startTime))
  483. +        # TODO: Parse repomd.xml and lookup name for groups element
  484. +        compsfile = None
  485. +        compspath = os.path.join(dir, 'repodata/comps.xml')
  486. +        if os.path.isfile(compspath):
  487. +            compsfile = open(compspath, "r")
  488. +        else:
  489. +            compspath = os.path.join(dir, 'repodata/comps.xml.gz')
  490. +            if os.path.isfile(compspath):
  491. +                compsfile = gzip.open(compspath, 'r')
  492. +        if compsfile:
  493. +            repo['comps_xml_path'] = compspath
  494. +            self.import_groups_data(compsfile, repo)
  495. +            log.debug("Loaded comps info from %s" % (compspath))
  496.  
  497.      def import_package(self, pkg_path, repo):
  498. -        packages = repo['packages']
  499.          if (pkg_path.endswith(".rpm")):
  500.              try:
  501. +                file_name = os.path.basename(pkg_path)
  502.                  info = pulp.util.get_rpm_information(pkg_path)
  503. -                p = self.package_api.package(info['name'])
  504. -                if not p:
  505. -                    p = self.package_api.create(info['name'], info['description'])
  506. -
  507. -                pv = self.package_version_api.packageversion_by_ivera(p['packageid'],
  508. -                                                                      info['version'],
  509. -                                                                      info['epoch'],
  510. -                                                                      info['release'],
  511. -                                                                      info['arch'],)
  512. -                if not pv:
  513. -                    pv = self.package_version_api.create(p["packageid"], info['epoch'],
  514. -                                              info['version'], info['release'], info['arch'])
  515. +                if not repo["packages"].has_key(info['name']):
  516. +                    repo["packages"][info['name']] = []
  517. +                hashtype = "sha256"
  518. +                checksum = pulp.util.getFileChecksum(hashtype=hashtype,
  519. +                        filename=pkg_path)
  520. +                found = self.package_version_api.packageversion(name=info['name'],
  521. +                        epoch=info['epoch'], version=info['version'],
  522. +                        release=info['release'], arch=info['arch'],filename=file_name,
  523. +                        checksum_type=hashtype, checksum=checksum)
  524. +                if found.count() == 1:
  525. +                    pv = found[0]
  526. +                else:
  527. +                    pv = self.package_version_api.create(info['name'], info['epoch'],
  528. +                        info['version'], info['release'], info['arch'], info['description'],
  529. +                        "sha256", checksum, file_name)
  530.                      for dep in info['requires']:
  531.                          pv.requires.append(dep)
  532.                      for dep in info['provides']:
  533.                          pv.provides.append(dep)
  534.                      self.package_version_api.update(pv)
  535. -
  536. -                p["versions"].append(pv)
  537. -                self.package_api.update(p)
  538. -                packages[p["packageid"]] = p
  539. -                log.debug("Repo <%s> added package <%s> with %s versions" %
  540. -                          (repo["id"], p["packageid"], len(p["versions"])))
  541. +                #TODO:  Ensure we don't add duplicate pv's to the 'packages' list
  542. +                repo['packages'][info['name']].append(pv)
  543.              except Exception, e:
  544. -                log.debug("Exception = %s" % (traceback.format_exc()))
  545. +                log.debug("%s" % (traceback.format_exc()))
  546.                  log.error("error reading package %s" % (pkg_path))
  547.  
  548. -    def _read_comps_xml(self, dir, repo):
  549. +    def import_groups_data(self, compsfile, repo):
  550.          """
  551.          Reads a comps.xml or comps.xml.gz under repodata from dir
  552.          Loads PackageGroup and Category info our db
  553.          """
  554. -
  555. -        compspath = os.path.join(dir, 'repodata/comps.xml')
  556. -        compsxml = None
  557. -        if os.path.isfile(compspath):
  558. -            compsxml = open(compspath, "r")
  559. -        else:
  560. -            compspath = os.path.join(dir, 'repodata/comps.xml.gz')
  561. -            if os.path.isfile(compspath):
  562. -                compsxml = gzip.open(compspath, 'r')
  563. -    
  564. -        if not compsxml:
  565. -            log.info("Not able to find a comps.xml(.gz) to read")
  566. -            return False
  567. -
  568. -        log.info("Reading comps info from %s" % (compspath))
  569. -        repo['comps_xml_path'] = compspath
  570.          try:
  571.              comps = yum.comps.Comps()
  572. -            comps.add(compsxml)
  573. +            comps.add(compsfile)
  574.              for c in comps.categories:
  575. -                ctg = self.package_group_category_api.create(c.categoryid, c.name,
  576. -                                                          c.description, c.display_order)
  577. +                ctg = model.PackageGroupCategory(c.categoryid, c.name,
  578. +                    c.description, c.display_order)
  579.                  groupids = [grp for grp in c.groups]
  580. -                ctg.packagegroupids.extend(groupids)
  581. -                ctg.translated_name = c.translated_name
  582. -                ctg.translated_description = c.translated_description
  583. -                self.package_group_category_api.update(ctg)
  584. -                repo['packagegroupcategories'][ctg.categoryid] = ctg
  585. -
  586. +                ctg['packagegroupids'].extend(groupids)
  587. +                ctg['translated_name'] = c.translated_name
  588. +                ctg['translated_description'] = c.translated_description
  589. +                repo['packagegroupcategories'][ctg['id']] = ctg
  590.              for g in comps.groups:
  591. -                grp = self.package_group_api.create(g.groupid, g.name, g.description,
  592. -                                              g.user_visible, g.display_order, g.default, g.langonly)
  593. +                grp = model.PackageGroup(g.groupid, g.name, g.description,
  594. +                    g.user_visible, g.display_order, g.default, g.langonly)
  595.                  grp.mandatory_package_names.extend(g.mandatory_packages.keys())
  596.                  grp.optional_package_names.extend(g.optional_packages.keys())
  597.                  grp.default_package_names.extend(g.default_packages.keys())
  598.                  grp.conditional_package_names = g.conditional_packages
  599.                  grp.translated_name = g.translated_name
  600.                  grp.translated_description = g.translated_description
  601. -                self.package_group_api.update(grp)
  602. -                repo['packagegroups'][grp.groupid] = grp
  603. -            log.info("Comps info added from %s" % (compspath))
  604. -        except yum.comps.CompsException:
  605. +                repo['packagegroups'][grp['id']] = grp
  606. +        except yum.Errors.CompsException:
  607.              log.error("Unable to parse comps info for %s" % (compspath))
  608.              return False
  609.          return True
  610. diff --git a/test/common/large_load.py b/test/common/large_load.py
  611. index 413cd0d..8098380 100644
  612. --- a/test/common/large_load.py
  613. +++ b/test/common/large_load.py
  614. @@ -87,9 +87,9 @@ class LargeLoad(unittest.TestCase):
  615.              # self.capi.update(c)
  616.              if (i % 100 == 0):
  617.                  print "created [%s] consumers" % i
  618. -                p = Package(TEST_PACKAGE_ID, 'random package to be found')
  619. +                p = Package(repo["id"], TEST_PACKAGE_ID, 'random package to be found')
  620.                  c.packageids.append(p.id)
  621. -                # self.capi.update(c)
  622. +                #self.capi.update(c)
  623.              last_desc = c.description
  624.              last_id = c.id
  625.              consumers.append(c)
  626. @@ -117,6 +117,11 @@ class LargeLoad(unittest.TestCase):
  627.          cwithp = ll.capi.consumerswithpackage(TEST_PACKAGE_ID)
  628.          print "Found [%s] consumers with packageid: [%s]" % (len(cwithp), TEST_PACKAGE_ID)
  629.  
  630. +
  631. +print "This has not been updated with the branch modelchanges yet"
  632. +print "More work is needed on the consumer side"
  633. +sys.exit(1)
  634. +
  635.  parser = optparse.OptionParser()
  636.  parser.add_option('--dirlist', dest='dirlist',
  637.                   action='store', help='File containing list of directories containing the repos you wish to use for this test')
  638. diff --git a/test/unit/test_api.py b/test/unit/test_api.py
  639. index eaa16d6..7eae1eb 100644
  640. --- a/test/unit/test_api.py
  641. +++ b/test/unit/test_api.py
  642. @@ -53,7 +53,7 @@ from testutil import load_test_config
  643.  class TestApi(unittest.TestCase):
  644.      def clean(self):
  645.          self.rapi.clean()
  646. -        self.papi.clean()
  647. +        #self.papi.clean()
  648.          self.capi.clean()
  649.          self.pvapi.clean()
  650.          self.pgapi.clean()
  651. @@ -63,7 +63,8 @@ class TestApi(unittest.TestCase):
  652.          config = load_test_config()
  653.  
  654.          self.rapi = RepoApi(config)
  655. -        self.papi = PackageApi(config)
  656. +        self.rapi.localStoragePath = "/tmp"
  657. +        #self.papi = PackageApi(config)
  658.          self.capi = ConsumerApi(config)
  659.          self.pvapi = PackageVersionApi(config)
  660.          self.pgapi = PackageGroupApi(config)
  661. @@ -154,8 +155,10 @@ class TestApi(unittest.TestCase):
  662.      def test_repo_packages(self):
  663.          repo = self.rapi.create('some-id','some name', \
  664.              'i386', 'yum:http://example.com')
  665. -        package = Package('test_repo_packages','test package')
  666. -        repo['packages'][package["packageid"]] = package
  667. +        pv = self.create_package_version('test_repo_packages')
  668. +        # package = PackageVersion('test_repo_packages','test package')
  669. +        self.rapi.add_package_version(repo["id"], pv)
  670. +        # repo['packages'][package["packageid"]] = package
  671.          self.rapi.update(repo)
  672.          
  673.          found = self.rapi.repository('some-id')
  674. @@ -170,42 +173,33 @@ class TestApi(unittest.TestCase):
  675.                  'test-group-description')
  676.          package = Package('test_repo_packages','test package')
  677.          pkggroup.default_package_names.append(package["packageid"])
  678. -        repo['packagegroups'][pkggroup["groupid"]] = pkggroup
  679. +        repo['packagegroups'][pkggroup["id"]] = pkggroup
  680.          repo['packages'][package["packageid"]] = package
  681. +        
  682.          self.rapi.update(repo)
  683.          
  684.          found = self.rapi.repository('some-id')
  685. -        packages = found['packages']
  686. -        assert(packages != None)
  687. -        assert(packages['test_repo_packages'] != None)
  688.          assert(found['packagegroups'] != None)
  689. -        print "test_repo_package_groups found['packagegroups'] = %s" % (found['packagegroups'])
  690. -        assert(pkggroup.groupid in found['packagegroups'])
  691. +        assert(pkggroup['id'] in found['packagegroups'])
  692.      
  693.      def test_repo_package_group_categories(self):
  694. -        repo = self.rapi.create('some-id','some name', \
  695. +        repo = self.rapi.create('some-id_pkg_group_categories','some name', \
  696.              'i386', 'yum:http://example.com')
  697. -        package = Package('test_repo_packages','test package')
  698.          pkggroup = PackageGroup('test-group-id', 'test-group-name',
  699.                  'test-group-description')
  700. -        pkggroup.default_package_names.append(package["packageid"])
  701. +        pkggroup.default_package_names.append("test-package-name")
  702.          ctg = PackageGroupCategory('test-group-cat-id', 'test-group-cat-name',
  703.                  'test-group-cat-description')
  704.          ctg.packagegroupids = pkggroup.id
  705. -        repo['packagegroupcategories'][ctg.categoryid] = ctg
  706. -        repo['packagegroups'][pkggroup.groupid] = pkggroup
  707. -        repo['packages'][package["packageid"]] = package
  708. +        repo['packagegroupcategories'][ctg.id] = ctg
  709. +        repo['packagegroups'][pkggroup.id] = pkggroup
  710.          self.rapi.update(repo)
  711.          
  712. -        found = self.rapi.repository('some-id')
  713. -        packages = found['packages']
  714. -        assert(packages != None)
  715. -        assert(packages['test_repo_packages'] != None)
  716. +        found = self.rapi.repository('some-id_pkg_group_categories')
  717.          assert(found['packagegroups'] != None)
  718. -        print "test_repo_package_groups found['packagegroups'] = %s" % (found['packagegroups'])
  719. -        assert(pkggroup.groupid in found['packagegroups'])
  720. +        assert(pkggroup['id'] in found['packagegroups'])
  721.          assert(found['packagegroupcategories'] != None)
  722. -        assert(ctg.categoryid in found['packagegroupcategories'])
  723. +        assert(ctg['id'] in found['packagegroupcategories'])
  724.      
  725.      def test_consumer_create(self):
  726.          c = self.capi.create('test-consumer', 'some consumer desc')
  727. @@ -235,8 +229,11 @@ class TestApi(unittest.TestCase):
  728.              
  729.      def test_consumerwithpackage(self):
  730.          c = self.capi.create('test-consumer', 'some consumer desc')
  731. -        package = Package('test_consumerwithpackage','test package search')
  732. -        c.packageids.append(package["packageid"])
  733. +        repo = self.rapi.create('some-id', 'some name',
  734. +                'i386', 'yum:http://example.com')
  735. +        test_pkg_name = "test_consumerwithpackage"
  736. +        #TODO: The consumer model/api needs to be updated, it's not setup to handle
  737. +        #       tracking a packageversion
  738.          for i in range(10):
  739.              package = Package(random_string(), random_string())
  740.              c.packageids.append(package["packageid"])
  741. @@ -257,7 +254,7 @@ class TestApi(unittest.TestCase):
  742.          assert(parsed != None)
  743.          print parsed
  744.      
  745. -    def test_sync_two_repos_share_common_package(self):
  746. +    def test_sync_two_repos_same_nevra_different_checksum(self):
  747.          """
  748.          Sync 2 repos that have a package with same NEVRA
  749.          but different checksum
  750. @@ -273,10 +270,9 @@ class TestApi(unittest.TestCase):
  751.          repo_a = self.rapi.create(repo_name_a,'some name', 'x86_64',
  752.                                    'local:file://%s' % datadir_a)
  753.          repo_b = self.rapi.create(repo_name_b,'some name', 'x86_64',
  754. -                                  'local:file://%s' % datadir_b)
  755. -        self.rapi.sync(repo_a.id)
  756. -        self.rapi.sync(repo_b.id)
  757. -
  758. +                                'local:file://%s' % datadir_b)
  759. +        self.rapi.sync(repo_a["id"])
  760. +        self.rapi.sync(repo_b["id"])
  761.          # Look up each repo from API
  762.          found_a = self.rapi.repository(repo_a.id)
  763.          found_b = self.rapi.repository(repo_b.id)
  764. @@ -286,15 +282,14 @@ class TestApi(unittest.TestCase):
  765.          assert (found_b["packages"].has_key(test_pkg_name))
  766.  
  767.          # Grab the associated package version (there should only be 1)
  768. -        # Ensure that the package versions have different md5sums, but all other
  769. +        # Ensure that the package versions have different checksums, but all other
  770.          # keys are identical
  771. -        assert (len(found_a["packages"][test_pkg_name]["versions"]) == 1)
  772. -        assert (len(found_b["packages"][test_pkg_name]["versions"]) == 1)
  773. -        pkgVerA = found_a["packages"][test_pkg_name]["versions"][0]
  774. -        pkgVerB = found_a["packages"][test_pkg_name]["versions"][0]
  775. -        for key in ['epoch', 'version', 'release', 'arch']:
  776. +        assert (len(found_a["packages"][test_pkg_name]) == 1)
  777. +        assert (len(found_b["packages"][test_pkg_name]) == 1)
  778. +        pkgVerA = found_a["packages"][test_pkg_name][0]
  779. +        pkgVerB = found_b["packages"][test_pkg_name][0]
  780. +        for key in ['epoch', 'version', 'release', 'arch', 'filename', 'name']:
  781.              assert (pkgVerA[key] == pkgVerB[key])
  782. -
  783.          #TODO:
  784.          # Add test to compare checksum when it's implemented in PackageVersion
  785.          # verify the checksums are different
  786. @@ -304,12 +299,12 @@ class TestApi(unittest.TestCase):
  787.          Sync 2 repos that share a common package, same NEVRA
  788.          same checksum
  789.          """
  790. -        test_pkg_name = "pulp-test-package-same-nevra"
  791. +        test_pkg_name = "pulp-test-package"
  792.          my_dir = os.path.abspath(os.path.dirname(__file__))
  793.          repo_name_a = "test_two_repos_share_common_pkg_repo_A"
  794.          repo_name_b = "test_two_repos_share_common_pkg_repo_B"
  795. -        datadir_a = my_dir + "/data/sameNEVRA_differentChecksums/A/repo/"
  796. -        datadir_b = my_dir + "/data/sameNEVRA_differentChecksums/B/repo/"
  797. +        datadir_a = my_dir + "/data/sameNEVRA_sameChecksums/A/repo/"
  798. +        datadir_b = my_dir + "/data/sameNEVRA_sameChecksums/B/repo/"
  799.          # Create & Sync Repos
  800.          repo_a = self.rapi.create(repo_name_a,'some name', 'x86_64',
  801.                                  'local:file://%s' % datadir_a)
  802. @@ -327,14 +322,14 @@ class TestApi(unittest.TestCase):
  803.          # Ensure that the package versions have different md5sums, but all other
  804.          # keys are identical
  805.  
  806. -        # BELOW TEST Needs more changes to model/sync code before it can pass
  807. -        #assert (len(found_a["packages"][test_pkg_name]["versions"]) == 1)
  808. -        #assert (len(found_b["packages"][test_pkg_name]["versions"]) == 1)
  809. -        #pkgVerA = found_a["packages"][test_pkg_name]["versions"][0]
  810. -        #pkgVerB = found_a["packages"][test_pkg_name]["versions"][0]
  811. +        assert (len(found_a["packages"][test_pkg_name]) == 1)
  812. +        assert (len(found_b["packages"][test_pkg_name]) == 1)
  813. +        pkgVerA = found_a["packages"][test_pkg_name][0]
  814. +        pkgVerB = found_b["packages"][test_pkg_name][0]
  815.          # Ensure that the 2 PackageVersions instances actually point
  816.          # to the same single instance
  817. -        #assert(pkgVerA['_id'] == pkgVerB['_id'])
  818. +        assert(repo_a['_id'] != repo_b['_id'])
  819. +        assert(pkgVerA['_id'] == pkgVerB['_id'])
  820.      
  821.      def test_sync(self):
  822.          repo = self.rapi.create('some-id','some name', 'i386',
  823. @@ -352,7 +347,9 @@ class TestApi(unittest.TestCase):
  824.          dirList = os.listdir(self.rapi.localStoragePath + '/' + repo.id)
  825.          assert(len(dirList) > 0)
  826.          found = self.rapi.repository(repo.id)
  827. +        print "found = ", found
  828.          packages = found['packages']
  829. +        print "packages = ", packages
  830.          assert(packages != None)
  831.          assert(len(packages) > 0)
  832.          
  833. @@ -369,27 +366,84 @@ class TestApi(unittest.TestCase):
  834.          assert(len(packages) > 0)
  835.          print packages
  836.          p = packages.values()[0]
  837. -        assert(p['versions'] != None)
  838. +        assert(p != None)
  839.          # versions = p['versions']
  840.          
  841. -    def test_package_versions(self):
  842. -        p = self.papi.create('some-package-id', 'some package desc')
  843. -        pv = self.pvapi.create(p.packageid, 0, '1.2.3', '1', 'i386')
  844. -        p.versions.append(pv)
  845. -        self.papi.update(p)
  846. +    def create_package_version(self, name):
  847. +        test_pkg_name = name
  848. +        test_epoch = "1"
  849. +        test_version = "1.2.3"
  850. +        test_release = "1.el5"
  851. +        test_arch = "x86_64"
  852. +        test_description = "test description text"
  853. +        test_checksum_type = "sha256"
  854. +        test_checksum = "9d05cc3dbdc94150966f66d76488a3ed34811226735e56dc3e7a721de194b42e"
  855. +        test_filename = "test-filename-1.2.3-1.el5.x86_64.rpm"
  856. +        pv = self.pvapi.create(name=test_pkg_name, epoch=test_epoch, version=test_version,
  857. +                release=test_release, arch=test_arch, description=test_description,
  858. +                checksum_type="sha256", checksum=test_checksum, filename=test_filename)
  859. +        return pv
  860.          
  861. -        found = self.papi.package(p.packageid)
  862. -        versions = found['versions']
  863. -        assert(versions != None)
  864. -        assert(versions[0]['packageid'] == p.packageid)
  865. -        print found
  866. -        
  867. -    def test_packages(self):
  868. -        p = self.papi.create('some-package-id', 'some package desc')
  869. -        packages = self.papi.packages()
  870. -        print "packages: %s" % packages
  871. -        assert(len(packages) > 0)
  872. -    
  873. +    def test_package_versions(self):
  874. +        repo = self.rapi.create('some-id','some name',
  875. +            'i386', 'yum:http://example.com')
  876. +        repo = self.rapi.repository(repo["id"])
  877. +        test_pkg_name = "test_package_versions_name"
  878. +        test_epoch = "1"
  879. +        test_version = "1.2.3"
  880. +        test_release = "1.el5"
  881. +        test_arch = "x86_64"
  882. +        test_description = "test description text"
  883. +        test_checksum_type = "sha256"
  884. +        test_checksum = "9d05cc3dbdc94150966f66d76488a3ed34811226735e56dc3e7a721de194b42e"
  885. +        test_filename = "test-filename-1.2.3-1.el5.x86_64.rpm"
  886. +        pv = self.pvapi.create(name=test_pkg_name, epoch=test_epoch, version=test_version,
  887. +                release=test_release, arch=test_arch, description=test_description,
  888. +                checksum_type="sha256", checksum=test_checksum, filename=test_filename)
  889. +        # Add this package version to the repo
  890. +        self.rapi.add_package_version(repo["id"], pv)
  891. +        # Lookup repo and confirm new package version was added
  892. +        repo = self.rapi.repository(repo["id"])
  893. +        self.assertTrue(repo["packages"].has_key(test_pkg_name))
  894. +        self.assertTrue(len(repo["packages"][test_pkg_name]) == 1)
  895. +        saved_pkg = repo["packages"][test_pkg_name][0]
  896. +        self.assertTrue(saved_pkg['name'] == test_pkg_name)
  897. +        self.assertTrue(saved_pkg['epoch'] == test_epoch)
  898. +        self.assertTrue(saved_pkg['version'] == test_version)
  899. +        self.assertTrue(saved_pkg['release'] == test_release)
  900. +        self.assertTrue(saved_pkg['arch'] == test_arch)
  901. +        self.assertTrue(saved_pkg['description'] == test_description)
  902. +        self.assertTrue(saved_pkg['checksum'].has_key(test_checksum_type))
  903. +        self.assertTrue(saved_pkg['checksum'][test_checksum_type] == test_checksum)
  904. +        self.assertTrue(saved_pkg['filename'] == test_filename)
  905. +        # Verify we can find this package version through repo api calls
  906. +        pkgs = self.rapi.packages(repo['id'])
  907. +        self.assertTrue(pkgs.has_key(test_pkg_name))
  908. +        self.assertTrue(len(pkgs[test_pkg_name]) == 1)
  909. +        self.assertTrue(pkgs[test_pkg_name][0]['filename'] == test_filename)
  910. +        pkgs = self.rapi.packageversions(repo['id'], test_pkg_name)
  911. +        self.assertTrue(len(pkgs) == 1)
  912. +        self.assertTrue(pkgs[0]['filename'] == test_filename)
  913. +
  914. +        # Remove package version from repo
  915. +        self.rapi.remove_package_version(repo['id'], pv)
  916. +        repo = self.rapi.repository(repo['id'])
  917. +        self.assertTrue(not repo["packages"].has_key(test_pkg_name))
  918. +        # Verify package version from repo
  919. +        found = self.pvapi.packageversion(name=test_pkg_name, epoch=test_epoch,
  920. +                version=test_version, release=test_release, arch=test_arch,
  921. +                filename=test_filename, checksum_type=test_checksum_type,
  922. +                checksum=test_checksum)
  923. +        self.assertTrue(found.count() == 1)
  924. +        # Remove from PackageVersion collection
  925. +        self.pvapi.delete(found[0])
  926. +        # Verify it's deleted
  927. +        found = self.pvapi.packageversion(name=test_pkg_name, epoch=test_epoch,
  928. +                version=test_version, release=test_release, arch=test_arch,
  929. +                filename=test_filename, checksum_type=test_checksum_type,
  930. +                checksum=test_checksum)
  931. +        self.assertTrue(found.count() == 0)
  932. +
  933.      def test_package_groups(self):
  934.          pkggroup = self.pgapi.create('test-pkg-group-id', 'test-pkg-group-name',
  935.                  'test-pkg-group-description')
  936. diff --git a/test/unit/test_comps.py b/test/unit/test_comps.py
  937. new file mode 100644
  938. index 0000000..a868805
  939. --- /dev/null
  940. +++ b/test/unit/test_comps.py
  941. @@ -0,0 +1,192 @@
  942. +#!/usr/bin/python
  943. +#
  944. +# Copyright (c) 2010 Red Hat, Inc.
  945. +#
  946. +#
  947. +# This software is licensed to you under the GNU General Public License,
  948. +# version 2 (GPLv2). There is NO WARRANTY for this software, express or
  949. +# implied, including the implied warranties of MERCHANTABILITY or FITNESS
  950. +# FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
  951. +# along with this software; if not, see
  952. +# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  953. +#
  954. +# Red Hat trademarks are not licensed under GPLv2. No permission is
  955. +# granted to use or replicate Red Hat trademarks that are incorporated
  956. +# in this software or its documentation.
  957. +#
  958. +import sys
  959. +import os
  960. +srcdir = os.path.abspath(os.path.dirname(__file__)) + "/../../src"
  961. +sys.path.append(srcdir)
  962. +import unittest
  963. +import logging
  964. +
  965. +import yum
  966. +
  967. +import pulp.util
  968. +import pulp.model
  969. +from pulp.api.repo import RepoApi
  970. +from pulp.repo_sync import BaseSynchronizer
  971. +
  972. +class TestComps(unittest.TestCase):
  973. +
  974. +    def setUp(self):
  975. +        config_file = os.path.join(srcdir, "../etc/pulp/pulp.ini")
  976. +        self.config = pulp.util.loadConfig(config_file)
  977. +        self.rapi = RepoApi(self.config)
  978. +        self.rapi.clean()
  979. +
  980. +    def tearDown(self):
  981. +        self.rapi.clean()
  982. +
  983. +
  984. +    def test_import_groups_data(self):
  985. +        repo = self.rapi.create('test_import_groups_data_id',
  986. +                'test_import_groups_data_id', 'i386',
  987. +                'yum:http://example.com/')
  988. +        # Parse existing comps.xml
  989. +        compspath = "./data/rhel-i386-server-5/comps.xml"
  990. +        compsfile = open(compspath)
  991. +        base = BaseSynchronizer(self.config)
  992. +        base.import_groups_data(compsfile, repo)
  993. +        # 'repo' object should now contain groups/categories
  994. +        # we need to save it to the db so we can query from it
  995. +        self.rapi.update(repo)
  996. +        # Testing for expected values
  997. +        found = self.rapi.packagegroup(repo['id'], "web-server")
  998. +        self.assertTrue(found != None)
  999. +        self.assertTrue("httpd" in found['mandatory_package_names'])
  1000. +        self.assertTrue("mod_auth_kerb" in found['optional_package_names'])
  1001. +        self.assertTrue("mod_auth_mysql" in found['optional_package_names'])
  1002. +        self.assertTrue("crypto-utils" in found['default_package_names'])
  1003. +        self.assertTrue("distcache" in found['default_package_names'])
  1004. +        # PackageGroupCategory, look up expected values,
  1005. +        found = self.rapi.packagegroupcategory(repo['id'], "BAD_VALUE_NOT_IN_CATEGORY")
  1006. +        self.assertTrue(found == None)
  1007. +        found = self.rapi.packagegroupcategory(repo['id'], "development")
  1008. +        self.assertTrue(found != None)
  1009. +
  1010. +    def test_basic_comps(self):
  1011. +        repo = self.rapi.create('test_comps_id','test_comps_name',
  1012. +            'i386', 'yum:http://example.com/')
  1013. +        grp = pulp.model.PackageGroup("groupid1", "groupname1",
  1014. +            "description", "user_visible", "display_order", "default"
  1015. +            "langonly")
  1016. +        grp['mandatory_package_names'] = ["mandatory_package_name1"]
  1017. +        grp['optional_package_names'] = ["optional_package_name1"]
  1018. +        grp['default_package_names'] = ["default_package_name1"]
  1019. +        grp['conditional_package_names'] = {"pkg1":"value pkg1"}
  1020. +        grp['translated_name'] = {"a":"value"}
  1021. +        grp['translated_description'] = {"b":"value"}
  1022. +        self.rapi.update_packagegroup(repo['id'], grp)
  1023. +        found = self.rapi.packagegroup(repo['id'], grp['id'])
  1024. +        self.assertTrue(found != None)
  1025. +        self.assertTrue(found['name'] == 'groupname1')
  1026. +        self.assertTrue("mandatory_package_name1" in found['mandatory_package_names'])
  1027. +
  1028. +        ctg = pulp.model.PackageGroupCategory("categoryid1",
  1029. +                    "categoryname", "description", "display_order")
  1030. +        ctg['packagegroupids'] = ["groupid1"]
  1031. +        ctg['translated_name'] = {"a":"name"}
  1032. +        ctg['translated_description'] = {"b":"description"}
  1033. +        self.rapi.update_packagegroupcategory(repo["id"], ctg)
  1034. +        found = self.rapi.packagegroupcategory(repo["id"], ctg["id"])
  1035. +        self.assertTrue(found != None)
  1036. +        self.assertTrue(found["name"] == "categoryname")
  1037. +        self.assertTrue("groupid1" in found["packagegroupids"])
  1038. +
  1039. +    def broken_intend_this_to_run_full_read_write_out_to_xml(self):
  1040. +        """
  1041. +        Test full cycle of Groups/Categories, import a comps.xml, parse it
  1042. +        modify the entries, then write them out to XML
  1043. +        """
  1044. +        #TODO: Writing to XML is broken
  1045. +        # Parse existing comps.xml
  1046. +        compsPath = "./data/rhel-i386-server-5/comps.xml"
  1047. +        comps = yum.comps.Comps()
  1048. +        comps.add(compsPath)
  1049. +        self.assertTrue(len(comps.get_groups()) != 0)
  1050. +        self.assertTrue(len(comps.get_categories()) != 0)
  1051. +        # Create Groups/Categories from parsed data
  1052. +        repo = self.rapi.create('test_comps_id','test_comps_name',
  1053. +                'i386', 'yum:http://example.com/')
  1054. +        found = self.rapi.packagegroups(repo['id'])
  1055. +        self.assertTrue(len(found) == 0)
  1056. +        found = self.rapi.packagegroupcategories(repo['id'])
  1057. +        self.assertTrue(len(found) == 0)
  1058. +
  1059. +        grp_list = []
  1060. +        groupids = []
  1061. +        for g in comps.get_groups():
  1062. +            grp = pulp.model.PackageGroup(g.groupid, g.name,
  1063. +                    g.description, g.user_visible, g.display_order, g.default,
  1064. +                    g.langonly)
  1065. +            grp['mandatory_package_names'].extend(g.mandatory_packages.keys())
  1066. +            grp['optional_package_names'].extend(g.optional_packages.keys())
  1067. +            grp['default_package_names'].extend(g.default_packages.keys())
  1068. +            grp['conditional_package_names'] = g.conditional_packages
  1069. +            grp['translated_name'] = g.translated_name
  1070. +            grp['translated_description'] = g.translated_description
  1071. +            grp_list.append(grp)
  1072. +            groupids.append(grp['id'])
  1073. +        self.rapi.update_packagegroups(repo['id'], grp_list)
  1074. +        ctg_list = []
  1075. +        categoryids = []
  1076. +        for c in comps.get_categories():
  1077. +            ctg = pulp.model.PackageGroupCategory(c.categoryid,
  1078. +                    c.name, c.description, c.display_order)
  1079. +            groupids = [grp for grp in c.groups]
  1080. +            ctg['packagegroupids'].extend(groupids)
  1081. +            ctg['translated_name'] = c.translated_name
  1082. +            ctg['translated_description'] = c.translated_description
  1083. +            ctg_list.append(ctg)
  1084. +            categoryids.append(ctg['id'])
  1085. +        self.rapi.update_packagegroupcategories(repo['id'], ctg_list)
  1086. +        # Lookup data from API calls
  1087. +        found = self.rapi.packagegroups(repo['id'])
  1088. +        self.assertTrue(len(found) > 0)
  1089. +        found = self.rapi.packagegroupcategories(repo['id'])
  1090. +        self.assertTrue(len(found) > 0)
  1091. +        # PackageGroup, look up expected values,
  1092. +        # good values come from known data in rhel-5 comps.xml
  1093. +        found = self.rapi.packagegroup(repo['id'], "BAD_VALUE_NOT_IN_GROUP")
  1094. +        self.assertTrue(found == None)
  1095. +        found = self.rapi.packagegroup(repo['id'], "web-server")
  1096. +        self.assertTrue(found != None)
  1097. +        self.assertTrue("httpd" in found['mandatory_package_names'])
  1098. +        self.assertTrue("mod_auth_kerb" in found['optional_package_names'])
  1099. +        self.assertTrue("mod_auth_mysql" in found['optional_package_names'])
  1100. +        self.assertTrue("crypto-utils" in found['default_package_names'])
  1101. +        self.assertTrue("distcache" in found['default_package_names'])
  1102. +        # PackageGroupCategory, look up expected values,
  1103. +        found = self.rapi.packagegroupcategory(repo['id'], "BAD_VALUE_NOT_IN_CATEGORY")
  1104. +        self.assertTrue(found == None)
  1105. +        found = self.rapi.packagegroupcategory(repo['id'], "development")
  1106. +        self.assertTrue(found != None)
  1107. +        # Test Removal
  1108. +        self.rapi.remove_packagegroup(repo['id'], "web-server")
  1109. +        found = self.rapi.packagegroup(repo['id'], "web-server")
  1110. +        self.assertTrue(found == None)
  1111. +        self.rapi.remove_packagegroupcategory(repo['id'], "development")
  1112. +        found = self.rapi.packagegroupcategory(repo['id'], "development")
  1113. +        self.assertTrue(found == None)
  1114. +
  1115. +        newComps = yum.comps.Comps()
  1116. +        # Look up categories from a repo
  1117. +        ctgs = self.rapi.packagegroupcategories(repo["id"])
  1118. +        grps = self.rapi.packagegroups(repo["id"])
  1119. +
  1120. +        for cid in ctgs:
  1121. +            category = self.rapi.translate_packagegroupcategory(ctgs[cid])
  1122. +            newComps.add_category(category)
  1123. +        for gid in grps:
  1124. +            pkggrp = self.rapi.translate_packagegroup(grps[gid])
  1125. +            newComps.add_group(pkggrp)
  1126. +        # Write back to xml
  1127. +        xml = newComps.xml()
  1128. +        print "Generated XML = %s" % (xml)
  1129. +        self.assertTrue(True)
  1130. +
  1131. +
  1132. +
  1133. +
create a new version of this paste RAW Paste Data