Source Code for Module backend.satellite_tools.xmlDiskSource

  1  # 
  2  # Abstraction for an XML importer with a disk base 
  3  # 
  4  # Copyright (c) 2008--2018 Red Hat, Inc. 
  5  # 
  6  # This software is licensed to you under the GNU General Public License, 
  7  # version 2 (GPLv2). There is NO WARRANTY for this software, express or 
  8  # implied, including the implied warranties of MERCHANTABILITY or FITNESS 
  9  # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 
 10  # along with this software; if not, see 
 11  # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 
 12  # 
 13  # Red Hat trademarks are not licensed under GPLv2. No permission is 
 14  # granted to use or replicate Red Hat trademarks that are incorporated 
 15  # in this software or its documentation. 
 16  # 
 17   
 18  import os 
 19  import gzip 
 20  from spacewalk.common.fileutils import createPath 
 21  from spacewalk.common.rhnLib import hash_object_id 
 22   
 23   
 24 -class MissingXmlDiskSourceFileError(Exception): 
 25      pass 
 26   
 27   
 28 -class MissingXmlDiskSourceDirError(Exception): 
 29      pass 
 30   
 31   
 32 -class DiskSource: 
 33      subdir = None 
 34      # Allow for compressed files by default 
 35      allow_compressed_files = 1 
 36   
 37 -    def __init__(self, mountPoint): 
 38          self.mountPoint = mountPoint 
 39   
 40      # Returns a data stream 
 41 -    def load(self): 
 42          # Returns a stream 
 43          filename = self._getFile() 
 44          return self._loadFile(filename) 
 45   
 46 -    def _getFile(self, create=0): 
 47          # Virtual 
 48          # pylint: disable=W0613,R0201 
 49          return None 
 50   
 51 -    def _loadFile(self, filename): 
 52          # Look for a gzip file first 
 53          if self.allow_compressed_files: 
 54              if filename[-3:] == '.gz' and os.path.exists(filename): 
 55                  return gzip.open(filename, "rb") 
 56   
 57              if os.path.exists(filename + '.gz'): 
 58                  return gzip.open(filename + ".gz", "rb") 
 59   
 60          if os.path.exists(filename): 
 61              return open(filename, "r") 
 62   
 63          raise MissingXmlDiskSourceFileError("unable to process file %s" % filename) 
 64   
 65 -    def _getDir(self, create=0): 
 66          dirname = "%s/%s" % (self.mountPoint, self.subdir) 
 67          if not create: 
 68              return dirname 
 69          if not os.path.exists(dirname): 
 70              createPath(dirname) 
 71          if not os.path.isdir(dirname): 
 72              raise MissingXmlDiskSourceDirError("%s is not a directory" % dirname) 
 73          return dirname 
 74   
 75   
 76 -class ArchesDiskSource(DiskSource): 
 77      subdir = 'arches' 
 78      filename = 'arches.xml' 
 79   
 80 -    def _getFile(self, create=0): 
 81          dirname = self._getDir(create) 
 82          if create and not os.path.isdir(dirname): 
 83              createPath(dirname) 
 84          return os.path.join(dirname, self.filename) 
 85   
 86   
 87 -class ArchesExtraDiskSource(ArchesDiskSource): 
 88      filename = "arches-extra.xml" 
 89   
 90   
 91 -class ProductnamesDiskSource(DiskSource): 
 92      subdir = 'product_names' 
 93   
 94 -    def _getFile(self, create=0): 
 95          dirname = self._getDir(create) 
 96          if create and not os.path.isdir(dirname): 
 97              createPath(dirname) 
 98          return "%s/product_names.xml" % dirname 
 99   
100   
101 -class ChannelFamilyDiskSource(DiskSource): 
102      subdir = 'channel_families' 
103   
104 -    def _getFile(self, create=0): 
105          dirname = self._getDir(create) 
106          if create and not os.path.isdir(dirname): 
107              createPath(dirname) 
108          return "%s/channel_families.xml" % dirname 
109   
110   
111 -class OrgsDiskSource(DiskSource): 
112      subdir = 'orgs' 
113   
114 -    def _getFile(self, create=0): 
115          dirname = self._getDir(create) 
116          if create and not os.path.isdir(dirname): 
117              createPath(dirname) 
118          return "%s/orgs.xml" % dirname 
119   
120   
121 -class ChannelDiskSource(DiskSource): 
122      subdir = 'channels' 
123   
124 -    def __init__(self, mountPoint): 
125          DiskSource.__init__(self, mountPoint) 
126          self.channel = None 
127   
128 -    def setChannel(self, channel): 
129          self.channel = channel 
130   
131 -    def list(self): 
132          # Lists the available channels 
133          dirname = self._getDir(create=0) 
134          if not os.path.isdir(dirname): 
135              # No channels available 
136              return [] 
137          return os.listdir(dirname) 
138   
139 -    def _getFile(self, create=0): 
140          dirname = "%s/%s" % (self._getDir(create), self.channel) 
141          if create and not os.path.isdir(dirname): 
142              createPath(dirname) 
143          return os.path.join(dirname, self._file_name()) 
144   
145      @staticmethod 
146 -    def _file_name(): 
147          return "channel.xml" 
148   
149   
150 -class ChannelCompsDiskSource(ChannelDiskSource): 
151   
152      @staticmethod 
153 -    def _file_name(): 
154          return "comps.xml" 
155   
156   
157 -class ChannelModulesDiskSource(ChannelDiskSource): 
158   
159      @staticmethod 
160 -    def _file_name(): 
161          return "modules.yaml" 
162   
163   
164 -class ShortPackageDiskSource(DiskSource): 
165      subdir = "packages_short" 
166   
167 -    def __init__(self, mountPoint): 
168          DiskSource.__init__(self, mountPoint) 
169          # Package ID 
170          self.id = None 
171          self._file_suffix = ".xml" 
172   
173 -    def setID(self, pid): 
174          self.id = pid 
175   
176      # limited dict behaviour 
177 -    def has_key(self, pid): 
178          # Save the old id 
179          old_id = self.id 
180          self.id = pid 
181          f = self._getFile() 
182          # Restore the old id 
183          self.id = old_id 
184          if os.path.exists(f + '.gz') or os.path.exists(f): 
185              return 1 
186          return 0 
187   
188 -    def _getFile(self, create=0): 
189          dirname = "%s/%s" % (self._getDir(create), self._hashID()) 
190          # Create the directoru if we have to 
191          if create and not os.path.exists(dirname): 
192              createPath(dirname) 
193          return "%s/%s%s" % (dirname, self.id, self._file_suffix) 
194   
195 -    def _hashID(self): 
196          # Hashes the package name 
197          return hash_object_id(self.id, 2) 
198   
199   
200 -class PackageDiskSource(ShortPackageDiskSource): 
201      subdir = "packages" 
202   
203   
204 -class SourcePackageDiskSource(ShortPackageDiskSource): 
205      subdir = "source_packages" 
206   
207   
208 -class ErrataDiskSource(ShortPackageDiskSource): 
209      subdir = "errata" 
210   
211 -    def _hashID(self): 
212          # Hashes the erratum name 
213          return hash_object_id(self.id, 1) 
214   
215   
216 -class BlacklistsDiskSource(DiskSource): 
217      subdir = "blacklists" 
218   
219 -    def _getFile(self, create=0): 
220          dirname = self._getDir(create) 
221          if create and not os.path.isdir(dirname): 
222              createPath(dirname) 
223          return "%s/blacklists.xml" % dirname 
224   
225   
226 -class BinaryRPMDiskSource(ShortPackageDiskSource): 
227      subdir = "rpms" 
228   
229 -    def __init__(self, mountPoint): 
230          ShortPackageDiskSource.__init__(self, mountPoint) 
231          self._file_suffix = '.rpm' 
232   
233   
234 -class SourceRPMDiskSource(BinaryRPMDiskSource): 
235      subdir = "srpms" 
236   
237   
238 -class KickstartDataDiskSource(DiskSource): 
239      subdir = "kickstart_trees" 
240   
241 -    def __init__(self, mountPoint): 
242          DiskSource.__init__(self, mountPoint) 
243          self.id = None 
244   
245 -    def setID(self, ks_label): 
246          self.id = ks_label 
247   
248 -    def _getFile(self, create=0): 
249          dirname = self._getDir(create) 
250          if create and not os.path.isdir(dirname): 
251              createPath(dirname) 
252          return os.path.join(dirname, self.id) + '.xml' 
253   
254   
255 -class KickstartFileDiskSource(KickstartDataDiskSource): 
256      subdir = "kickstart_files" 
257      allow_compressed_files = 0 
258   
259 -    def __init__(self, mountPoint): 
260          KickstartDataDiskSource.__init__(self, mountPoint) 
261          # the file's relative path 
262          self.relative_path = None 
263   
264 -    def set_relative_path(self, relative_path): 
265          self.relative_path = relative_path 
266   
267 -    def _getFile(self, create=0): 
268          path = os.path.join(self._getDir(create), self.id, 
269                              self.relative_path) 
270          dirname = os.path.dirname(path) 
271          if create and not os.path.isdir(dirname): 
272              createPath(dirname) 
273          return path 
274   
275   
276 -class MetadataDiskSource: 
277   
278 -    def __init__(self, mountpoint): 
279          self.mountpoint = mountpoint 
280   
281      @staticmethod 
282 -    def is_disk_loader(): 
283          return True 
284   
285 -    def getArchesXmlStream(self): 
286          return ArchesDiskSource(self.mountpoint).load() 
287   
288 -    def getArchesExtraXmlStream(self): 
289          return ArchesExtraDiskSource(self.mountpoint).load() 
290   
291 -    def getChannelFamilyXmlStream(self): 
292          return ChannelFamilyDiskSource(self.mountpoint).load() 
293   
294 -    def getOrgsXmlStream(self): 
295          return OrgsDiskSource(self.mountpoint).load() 
296   
297 -    def getProductNamesXmlStream(self): 
298          return ProductnamesDiskSource(self.mountpoint).load() 
299   
300 -    def getComps(self, label): 
301          sourcer = ChannelCompsDiskSource(self.mountpoint) 
302          sourcer.setChannel(label) 
303          return sourcer.load() 
304   
305 -    def getModules(self, label): 
306          sourcer = ChannelModulesDiskSource(self.mountpoint) 
307          sourcer.setChannel(label) 
308          return sourcer.load() 
309   
310 -    def getChannelXmlStream(self): 
311          sourcer = ChannelDiskSource(self.mountpoint) 
312          channels = sourcer.list() 
313          stream_list = [] 
314          for c in channels: 
315              sourcer.setChannel(c) 
316              stream_list.append(sourcer.load()) 
317          return stream_list 
318   
319 -    def getChannelShortPackagesXmlStream(self): 
320          return ShortPackageDiskSource(self.mountpoint) 
321   
322 -    def getPackageXmlStream(self): 
323          return PackageDiskSource(self.mountpoint) 
324   
325 -    def getSourcePackageXmlStream(self): 
326          return SourcePackageDiskSource(self.mountpoint) 
327   
328 -    def getKickstartsXmlStream(self): 
329          return KickstartDataDiskSource(self.mountpoint) 
330   
331 -    def getErrataXmlStream(self): 
332          return ErrataDiskSource(self.mountpoint) 
333   
334  if __name__ == '__main__': 
335      # TEST CODE 
336      s = ChannelDiskSource("/tmp") 
337      print(s.list()) 
338      s.setChannel("redhat-linux-i386-7.2") 
339      print(s.load()) 
340