Source Code for Module pulp.server.api.consumer_group

  1  #!/usr/bin/python 
  2  # 
  3  # Copyright (c) 2010 Red Hat, Inc. 
  4  # 
  5  # This software is licensed to you under the GNU General Public License, 
  6  # version 2 (GPLv2). There is NO WARRANTY for this software, express or 
  7  # implied, including the implied warranties of MERCHANTABILITY or FITNESS 
  8  # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 
  9  # along with this software; if not, see 
 10  # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 
 11  # 
 12  # Red Hat trademarks are not licensed under GPLv2. No permission is 
 13  # granted to use or replicate Red Hat trademarks that are incorporated 
 14  # in this software or its documentation. 
 15   
 16  import logging 
 17   
 18  from pulp.server.agent import Agent 
 19  from pulp.server.api.base import BaseApi 
 20  from pulp.server.api.consumer import ConsumerApi 
 21  from pulp.server.api.repo import RepoApi 
 22  from pulp.server.auditing import audit 
 23  from pulp.server.db import model 
 24  from pulp.server.db.connection import get_object_db 
 25  from pulp.server.pexceptions import PulpException 
 26   
 27  log = logging.getLogger(__name__) 
 28   
 29   
 30 -class ConsumerGroupApi(BaseApi): 
 31   
 32 -    def __init__(self): 
 33          BaseApi.__init__(self) 
 34          self.consumerApi = ConsumerApi() 
 35          self.repoApi = RepoApi() 
 36   
 37 -    def _getcollection(self): 
 38          return get_object_db('consumergroups', 
 39                               self._unique_indexes, 
 40                               self._indexes) 
 41   
 42   
 43      @audit(params=['id', 'consumerids']) 
 44 -    def create(self, id, description, consumerids=()): 
 45          """ 
 46          Create a new ConsumerGroup object and return it 
 47          """ 
 48          consumergroup = self.consumergroup(id) 
 49          if(consumergroup): 
 50              raise PulpException("A Consumer Group with id %s already exists" % id) 
 51           
 52          for consumerid in consumerids: 
 53              consumer = self.consumerApi.consumer(consumerid) 
 54              if (consumer is None): 
 55                  raise PulpException("No Consumer with id: %s found" % consumerid) 
 56                   
 57          c = model.ConsumerGroup(id, description, consumerids) 
 58          self.insert(c) 
 59          return c 
 60   
 61   
 62 -    def consumergroups(self): 
 63          """ 
 64          List all consumergroups. 
 65          """ 
 66          consumergroups = list(self.objectdb.find()) 
 67          return consumergroups 
 68   
 69 -    def consumergroup(self, id): 
 70          """ 
 71          Return a single ConsumerGroup object 
 72          """ 
 73          return self.objectdb.find_one({'id': id}) 
 74   
 75   
 76 -    def consumers(self, id): 
 77          """ 
 78          Return consumer ids belonging to this ConsumerGroup 
 79          """ 
 80          consumer = self.objectdb.find_one({'id': id}) 
 81          return consumer['consumerids'] 
 82   
 83   
 84      @audit() 
 85 -    def add_consumer(self, groupid, consumerid): 
 86          """ 
 87          Adds the passed in consumer to this group 
 88          """ 
 89          consumergroup = self.consumergroup(groupid) 
 90          if (consumergroup is None): 
 91              raise PulpException("No Consumer Group with id: %s found" % groupid) 
 92          consumer = self.consumerApi.consumer(consumerid) 
 93          if (consumer is None): 
 94              raise PulpException("No Consumer with id: %s found" % consumerid) 
 95          self._add_consumer(consumergroup, consumer) 
 96          self.update(consumergroup) 
 97   
 98 -    def _add_consumer(self, consumergroup, consumer): 
 99          """ 
100          Responsible for properly associating a Consumer to a ConsumerGroup 
101          """ 
102          consumerids = consumergroup['consumerids'] 
103          if consumer["id"] in consumerids: 
104              return 
105           
106          consumerids.append(consumer["id"]) 
107          consumergroup["consumerids"] = consumerids 
108   
109      @audit() 
110 -    def delete_consumer(self, groupid, consumerid): 
111          consumergroup = self.consumergroup(groupid) 
112          if (consumergroup is None): 
113              raise PulpException("No Consumer Group with id: %s found" % groupid) 
114          consumerids = consumergroup['consumerids'] 
115          if consumerid not in consumerids: 
116              return 
117          consumerids.remove(consumerid) 
118          consumergroup["consumerids"] = consumerids 
119          self.update(consumergroup) 
120   
121      @audit() 
122 -    def bind(self, id, repoid): 
123          """ 
124          Bind (subscribe) a consumer group to a repo. 
125          @param id: A consumer group id. 
126          @type id: str 
127          @param repoid: A repo id to bind. 
128          @type repoid: str 
129          @raise PulpException: When consumer group is not found. 
130          """ 
131          consumergroup = self.consumergroup(id) 
132          if consumergroup is None: 
133              raise PulpException("No Consumer Group with id: %s found" % id) 
134          repo = self.repoApi.repository(repoid) 
135          if repo is None: 
136              raise PulpException("No Repository with id: %s found" % repoid) 
137   
138          consumerids = consumergroup['consumerids'] 
139          for consumerid in consumerids: 
140              self.consumerApi.bind(consumerid, repoid) 
141   
142      @audit() 
143 -    def unbind(self, id, repoid): 
144          """ 
145          Unbind (unsubscribe) a consumer group from a repo. 
146          @param id: A consumer group id. 
147          @type id: str 
148          @param repoid: A repo id to unbind. 
149          @type repoid: str 
150          @raise PulpException: When consumer group not found. 
151          """ 
152          consumergroup = self.consumergroup(id) 
153          if consumergroup is None: 
154              raise PulpException("No Consumer Group with id: %s found" % id) 
155          repo = self.repoApi.repository(repoid) 
156          if (repo is None): 
157              raise PulpException("No Repository with id: %s found" % repoid) 
158   
159          consumerids = consumergroup['consumerids'] 
160          for consumerid in consumerids: 
161              self.consumerApi.unbind(consumerid, repoid) 
162               
163               
164      @audit() 
165 -    def installpackages(self, id, packagenames=[]): 
166          """ 
167          Install packages on the consumers in a consumer group. 
168          @param id: A consumer group id. 
169          @type id: str 
170          @param packagenames: The package names to install. 
171          @type packagenames: [str,..] 
172          """ 
173          consumergroup = self.consumergroup(id) 
174          if consumergroup is None:    
175              raise PulpException("No Consumer Group with id: %s found" % id) 
176          consumerids = consumergroup['consumerids'] 
177          for consumerid in consumerids: 
178              agent = Agent(consumerid) 
179              agent.packages.install(packagenames) 
180          return packagenames 
181       
182 -    def installerrata(self, id, errataids=[], types=[]): 
183          """ 
184          Install errata on a consumer group. 
185          @param id: A consumergroup id. 
186          @type id: str 
187          @param errataids: The errata ids to install. 
188          @type errataids: [str,..] 
189          @param types: Errata type filter 
190          @type types: str 
191          """ 
192          consumergroup = self.consumergroup(id) 
193          if consumergroup is None:    
194              raise PulpException("No Consumer Group with id: %s found" % id) 
195          consumerids = consumergroup['consumerids'] 
196          consumer_pkg = {} 
197          for consumerid in consumerids: 
198              consumer = self.consumerApi.consumer(consumerid) 
199              agent = Agent(consumerid) 
200              pkgs = [] 
201              if errataids: 
202                  applicable_errata = self.consumerApi._applicable_errata(consumer, types) 
203                  for eid in errataids: 
204                      for pobj in applicable_errata[eid]: 
205                          if pobj["arch"] != "src": 
206                              pkgs.append(pobj["name"]) # + "." + pobj["arch"]) 
207              else: 
208                  #apply all updates 
209                  pkgobjs = self.consumerApi.list_package_updates(id, types) 
210                  for pobj in pkgobjs: 
211                      if pobj["arch"] != "src": 
212                          pkgs.append(pobj["name"]) # + "." + pobj["arch"]) 
213              log.error("Foe consumer id %s Packages to install %s" % (consumerid, pkgs)) 
214              agent.packages.install(pkgs) 
215              consumer_pkg[consumerid] = pkgs 
216          return consumer_pkg 
217