def read_resource(self, filename, baseuri): """read_resource_rdf( filename, baseuri) Parse resource rdf file given by <filename>. Returns a list of dictionaries with the rdf-elements as keys.""" node = self.read_rdf(filename) try: provided_by_node = node.children["rdf:Description"].children[\ "spi:provided_by"] alt_node = provided_by_node.children["rdf:Alt"] resource_list = [] for resource_node in alt_node.children.values(): uri = resource_node.children["spi:resource"].attr[\ "rdf:resource"] uri = utils.normalize_uri(os.path.join(baseuri, uri)) version = resource_node.children["spi:version"].value release = resource_node.children["spi:release"].value name = resource_node.children["spi:name"].value resource_list.append({ "uri": uri, "name": name, "version": version, "release": release }) except KeyError: raise parse_error, "Unable to parse file : '%s'" % filename return resource_list
def read_package_short(self, filename, baseuri): node = self.read_rdf(filename) dict = {} if node.children == None: raise parse_error, "Unable to parse file %s" % filename try: uri = node.children["rdf:Description"].attr["rdf:about"] uri = utils.normalize_uri(os.path.join(baseuri, uri)) dict["uri"] = uri description = node.children["rdf:Description"].children dict["name"] = description["spi:name"].value # print "debug: name is", description["spi:name"].value dict["version"] = description["spi:version"].value dict["release"] = description["spi:release"].value obsoletes = [] if description.has_key("spi:obsoletes"): obs_node = description["spi:obsoletes"].children if obs_node: for li in obs_node["rdf:Bag"].children.values(): obsoletes.append(li.value) dict["obsoletes"] = obsoletes except KeyError: raise parse_error, "Unable to parse file '%s'" % uri return dict
def read_package_short(self, filename, baseuri): node = self.read_rdf(filename) dict = {} if node.children == None: raise parse_error, "Unable to parse file %s" % filename try: uri = node.children["rdf:Description"].attr["rdf:about"] uri = utils.normalize_uri(os.path.join(baseuri, uri)) dict["uri"] = uri description = node.children["rdf:Description"].children dict["name"] = description["spi:name"].value #print "debug: name is", description["spi:name"].value dict["version"] = description["spi:version"].value dict["release"] = description["spi:release"].value obsoletes = [] if description.has_key("spi:obsoletes"): obs_node = description["spi:obsoletes"].children if obs_node: for li in obs_node["rdf:Bag"].children.values(): obsoletes.append(li.value) dict["obsoletes"] = obsoletes except KeyError: raise parse_error, "Unable to parse file '%s'" % uri return dict
def read_resources( self, filename, baseuri ): """read_resources_rdf( filename, baseuri) Parse resources rdf file given by <filename>. Returns a dictionary with the resources as keys and a list of providers as values.""" node = self.read_rdf( filename ) resources = {} try: main_node = node.children['rdf:Description'] bag_node = main_node.children['rdf:Bag'] for index in bag_node.children: res_node = bag_node.children[index] resource_list = [] namenode = res_node.children['spi:name'] resourcename = namenode.value provider_nodes = res_node.children['rdf:Bag'] for key in provider_nodes.children: provider_node = provider_nodes.children[key] uri = provider_node.children['spi:uri'].value if utils.is_absolute(uri): pass else: uri = utils.normalize_uri( \ os.path.join(baseuri, uri) ) name = provider_node.children["spi:name"].value if provider_node.children.has_key("spi:epoch"): epoch = provider_node.children["spi:epoch"].value else: epoch = None version = provider_node.children["spi:version"].value release = provider_node.children["spi:release"].value resource_list.append( {"uri": uri, "epoch":epoch, "name": name, "version": version, "release": release, "resourcename": resourcename} ) tmpdict = {} uniqlist = [] for package in resource_list: name = package['name'] if not tmpdict.has_key(name): tmpdict[name] = True uniqlist.append(package) resources[resourcename] = uniqlist except: raise return resources
def retrieve_latest(self, uri): """Parse package list rdf, given the uri to the rdf-file. Returns a dictionary with package name as key, and the a dictionary of name, version, release, summary, uri and obsoletes as value for keys.""" # Check md5sum, pickle.load and/or dump -- to be implemented. # Get the md5sum uri: if uri[-3:] == '.gz': md5sum_uri = uri[:-3] + '.md5' noncompressed_uri = uri[:-3] else: noncompressed_uri = uri md5sum_uri = uri + '.md5' dict = None # Check if md5sum has changed. The check will update md5sums # if they are changed. if self.md5sum_isequal(md5sum_uri, noncompressed_uri): # Pickle already parsed latest-information. pickle_file = os.path.join(self.config['listsdir'], uri) pickle_file = utils.normalize_uri(pickle_file + '.pickle') if os.path.isfile(pickle_file): dict = self.load_data(pickle_file) if not dict: # Get latest, parse, and pickle-dump. local_filename = self.download_file(uri) (baseuri, basename) = os.path.split(uri) self.log.write_tty('\nParsing file: %s -' % basename) dict = self.reader.read_latest( local_filename, baseuri ) self.log.write_tty('\rParsing file: %s - done\n' % basename) pickle_file = os.path.join(self.config['listsdir'], uri) pickle_file = utils.normalize_uri(pickle_file + '.pickle') self.save_data(dict, pickle_file) return dict
def retrieve_latest(self, uri): """Parse package list rdf, given the uri to the rdf-file. Returns a dictionary with package name as key, and the a dictionary of name, version, release, summary, uri and obsoletes as value for keys.""" # Check md5sum, pickle.load and/or dump -- to be implemented. # Get the md5sum uri: if uri[-3:] == '.gz': md5sum_uri = uri[:-3] + '.md5' noncompressed_uri = uri[:-3] else: noncompressed_uri = uri md5sum_uri = uri + '.md5' dict = None # Check if md5sum has changed. The check will update md5sums # if they are changed. if self.md5sum_isequal(md5sum_uri, noncompressed_uri): # Pickle already parsed latest-information. pickle_file = os.path.join(self.config['listsdir'], uri) pickle_file = utils.normalize_uri(pickle_file + '.pickle') if os.path.isfile(pickle_file): dict = self.load_data(pickle_file) if not dict: # Get latest, parse, and pickle-dump. local_filename = self.download_file(uri) (baseuri, basename) = os.path.split(uri) self.log.write_tty('\nParsing file: %s -' % basename) dict = self.reader.read_latest(local_filename, baseuri) self.log.write_tty('\rParsing file: %s - done\n' % basename) pickle_file = os.path.join(self.config['listsdir'], uri) pickle_file = utils.normalize_uri(pickle_file + '.pickle') self.save_data(dict, pickle_file) return dict
def read_latest( self, filename, baseuri ): topnode = self.read_rdf( filename ) packagedict = {} if topnode.children == None: raise ex.spi_parse_error, filename try: firstnode = topnode.children["rdf:Description"] latest_nodes = firstnode.children[\ "spi:package_list"].children["rdf:Bag"].children.values() protocol_regexp = re.compile("(^http:)|(^ftp:)|(^file:)") for node in latest_nodes: name = node.children["spi:name"].value if node.children.has_key("spi:epoch"): epoch = node.children["spi:epoch"].value else: epoch = None version = node.children["spi:version"].value release = node.children["spi:release"].value summary = node.children["spi:summary"].value resource = node.children["spi:resource"].attr["rdf:resource"] if utils.is_absolute(resource): pass else: resource = os.path.join(baseuri, resource) resource = utils.normalize_uri(resource) obsoletes = [] if node.children.has_key("spi:obsoletes"): obs_node = node.children["spi:obsoletes"].children if obs_node: for li in obs_node["rdf:Bag"].children.values(): obsoletes.append(li.value) packagedict[name] = { "name": name, "epoch":epoch, "version": version, "release": release, "obsoletes": obsoletes, "uri": resource, "summary": summary} except KeyError: raise ex.spi_parse_error, filename except: raise return packagedict
def read_resource( self, filename, baseuri ): """read_resource_rdf( filename, baseuri) Parse resource rdf file given by <filename>. Returns a list of dictionaries with the rdf-elements as keys.""" node = self.read_rdf( filename ) try: resourcename = node.children["rdf:Description"].attr["rdf:ID"] provided_by_node = node.children["rdf:Description"].children[\ "spi:provided_by"] alt_node = provided_by_node.children["rdf:Alt"] resource_list = [] for resource_node in alt_node.children.values(): uri = resource_node.children["spi:resource"].attr[\ "rdf:resource"] if utils.is_absolute(uri): pass else: uri = utils.normalize_uri( os.path.join(baseuri, uri) ) name = resource_node.children["spi:name"].value if resource_node.children.has_key("spi:epoch"): epoch = resource_node.children["spi:epoch"].value else: epoch = None version = resource_node.children["spi:version"].value release = resource_node.children["spi:release"].value resource_list.append( {"uri": uri, "epoch":epoch, "name": name, "version": version, "release": release, "resourcename": resourcename} ) except KeyError: raise ex.spi_parse_error, filename except: raise return resource_list
def read_latest(self, filename, baseuri): packagedict = {} topnode = self.read_rdf(filename) if topnode.children == None: raise parse_error, "Unable to parse file '%s'" % filename try: latest_nodes = ( topnode.children["rdf:Description"].children["spi:package_list"].children["rdf:Bag"].children.values() ) protocol_regexp = re.compile("(^http:)|(^ftp:)|(^file:)") for node in latest_nodes: name = node.children["spi:name"].value version = node.children["spi:version"].value release = node.children["spi:release"].value summary = node.children["spi:summary"].value resource = node.children["spi:resource"].attr["rdf:resource"] if not protocol_regexp.match(resource): resource = os.path.join(baseuri, resource) resource = utils.normalize_uri(resource) obsoletes = [] if node.children.has_key("spi:obsoletes"): obs_node = node.children["spi:obsoletes"].children if obs_node: for li in obs_node["rdf:Bag"].children.values(): obsoletes.append(li.value) packagedict[name] = { "name": name, "version": version, "release": release, "obsoletes": obsoletes, "uri": resource, "summary": summary, } except KeyError: raise parse_error, "Unable to parse file '%s'" % filename return packagedict
def read_latest(self, filename, baseuri): packagedict = {} topnode = self.read_rdf(filename) if topnode.children == None: raise parse_error, "Unable to parse file '%s'" % filename try: latest_nodes = topnode.children["rdf:Description"].children[\ "spi:package_list"].children["rdf:Bag"].children.values() protocol_regexp = re.compile("(^http:)|(^ftp:)|(^file:)") for node in latest_nodes: name = node.children["spi:name"].value version = node.children["spi:version"].value release = node.children["spi:release"].value summary = node.children["spi:summary"].value resource = node.children["spi:resource"].attr["rdf:resource"] if not protocol_regexp.match(resource): resource = os.path.join(baseuri, resource) resource = utils.normalize_uri(resource) obsoletes = [] if node.children.has_key("spi:obsoletes"): obs_node = node.children["spi:obsoletes"].children if obs_node: for li in obs_node["rdf:Bag"].children.values(): obsoletes.append(li.value) packagedict[name] = { "name": name, "version": version, "release": release, "obsoletes": obsoletes, "uri": resource, "summary": summary } except KeyError: raise parse_error, "Unable to parse file '%s'" % filename return packagedict
def read_resource(self, filename, baseuri): """read_resource_rdf( filename, baseuri) Parse resource rdf file given by <filename>. Returns a list of dictionaries with the rdf-elements as keys.""" node = self.read_rdf(filename) try: provided_by_node = node.children["rdf:Description"].children["spi:provided_by"] alt_node = provided_by_node.children["rdf:Alt"] resource_list = [] for resource_node in alt_node.children.values(): uri = resource_node.children["spi:resource"].attr["rdf:resource"] uri = utils.normalize_uri(os.path.join(baseuri, uri)) version = resource_node.children["spi:version"].value release = resource_node.children["spi:release"].value name = resource_node.children["spi:name"].value resource_list.append({"uri": uri, "name": name, "version": version, "release": release}) except KeyError: raise parse_error, "Unable to parse file : '%s'" % filename return resource_list
def read_package_short( self, filename, baseuri ): node = self.read_rdf( filename ) dict = {} if node.children == None: raise ex.spi_parse_error, filename try: uri = node.children["rdf:Description"].attr["rdf:about"] if utils.is_absolute(uri): pass else: uri = utils.normalize_uri( os.path.join(baseuri, uri) ) dict["uri"] = uri description = node.children["rdf:Description"].children if node.children.has_key("spi:epoch"): dict["epoch"] = description["spi:epoch"].value dict["name"] = description["spi:name"].value dict["version"] = description["spi:version"].value dict["release"] = description["spi:release"].value obsoletes = [] if description.has_key("spi:obsoletes"): obs_node = description["spi:obsoletes"].children if obs_node: for li in obs_node["rdf:Bag"].children.values(): obsoletes.append(li.value) dict["obsoletes"] = obsoletes except KeyError: raise ex.spi_parse_error, uri except: raise return dict
def _main( self, packages ): 'Common main loop for upgrade or install.' if string.lower( str(self.config["poll_only"]) ) == "yes": message = "Found these packages:\n" for pkg in packages: message = message + "\t%s: %s-%s-%s\n" %\ (pkg.flag, pkg.name, pkg.version, pkg.release) message = message + "\tTotal %i packages." % len( packages ) self.log.write_stdout(message) self.log.write_log(message) else: transactions = self.resolve_deps(packages) if not transactions: message = "Nothing to install or upgrade." self.log.write_stdout_info( message ) self.log.write_log( message ) return i = 0 errorflag = false for key in transactions.keys(): transaction = transactions[key] try: for package in transaction.values(): uri = utils.normalize_uri(package.uri) siguri = utils.normalize_uri(package.signature_uri) package.localfilename = self.download_file(uri, siguri) except DownloadException, errmsg: skipped = "" for name in transaction.keys(): skipped = skipped + name + " " skipped = string.rstrip( skipped ) errmsg = "%s\nSkipping packages %s" % (errmsg, skipped) self.log.write_log( errmsg ) self.log.write_stderr( errmsg ) del transactions[key] continue if self.config['save_to']: todir = self.config['save_to'] import shutil if not os.path.isdir( todir ): message = 'Can not save copy of packages.'\ ' No such directory'\ ': %s' % todir self.log.write_log( message ) self.log.write_stderr( message ) else: for package in transaction.values(): try: fromfile = package.localfilename basename = os.path.basename( fromfile ) tofile = os.path.join( todir, basename ) shutil.copyfile( fromfile, tofile ) except IOError: message = 'Unable to move file %s to %s' % \ (fromfile, tofile) self.log.write_stderr( message ) self.log.write_log( message ) if not string.lower( str(self.config["download_only"]) ) == \ "yes": errmsg = self.install( transaction ) if errmsg: errorflag = true self.log.write_log( errmsg ) self.log.write_stderr( errmsg ) else: self.flush_cache() i = i +1 self.log.write_tty( "\n" ) if errorflag: self.log.write_stderr( DEPENDENCY_ERROR_MESSAGE )
def read_package( self, filename, baseuri ): """read_package_rdf(filename) Parse package rdf file given by <filename>. Returns a dictionary with the rdf-elements as keys.""" node = self.read_rdf( filename ) try: description_node = node.children["rdf:Description"] if description_node.children.has_key("spi:epoch"): epoch = description_node.children["spi:epoch"].value else: epoch = None if description_node.children.has_key("spi:serial"): serial = description_node.children["spi:serial"].value else: serial = None version = description_node.children["spi:version"].value release = description_node.children["spi:release"].value arch = description_node.children["spi:arch"].value opsys = description_node.children["spi:os"].value group = description_node.children["spi:group"].value name = description_node.children["spi:name"].value pkg_uri = description_node.attr["rdf:about"] desc = description_node.children["spi:description"].value summary = description_node.children["spi:summary"].value distribution = description_node.children["spi:distribution"].value vendor = description_node.children["spi:vendor"].value copyright = description_node.children["spi:copyright"].value build_date = description_node.children["spi:build_date"].value size = description_node.children["spi:size"].value md5sum = description_node.children["spi:md5sum"].value if( utils.is_absolute(pkg_uri) ): pass else: pkg_uri = utils.normalize_uri( os.path.join(baseuri, pkg_uri) ) sig_uri = description_node.children["spi:signature"].attr[\ "rdf:resource"] if( utils.is_absolute(sig_uri) ): pass else: sig_uri = utils.normalize_uri( os.path.join(baseuri, sig_uri) ) #requires = [] # a list containing all requirements requires_node = description_node.children["spi:requires"] requires_list = [] if requires_node.children != None: requires_node = node.children["rdf:Description"].children[\ "spi:requires"].children["rdf:Bag"] if requires_node.children != None: for require_node in requires_node.children.values(): requirement = require_node.children[\ "spi:requirement"].value resource_uri = require_node.children[\ "spi:resource"].attr["rdf:resource"] if utils.is_absolute(resource_uri): pass else: resource_uri = utils.normalize_uri( os.path.join(baseuri, resource_uri) ) requirement = split_requirement( requirement ) requires_list.append( {"name": requirement[0], "operator": requirement[1], "epoch": requirement[2], "version": requirement[3], "release": requirement[4], "uri": resource_uri} ) conflicts = [] if description_node.children.has_key( "spi:conflicts" ): conflicts_node = description_node.children["spi:conflicts"] if conflicts_node.children: nodes = conflicts_node.children[\ "rdf:Bag"].children.values() for node in nodes: conflict = split_requirement( node.value) conflicts.append({"name": conflict[0], "flag": conflict[1], "epoch": conflict[2], "version": conflict[3], "release": conflict[4]}) else: if conflicts_node.value: conflict = split_requirement( conflicts_node.value) conflicts.append({"name": conflict[0], "flag": conflict[1], "epoch": conflict[2], "version": conflict[3], "release": conflict[4]}) except KeyError: raise ex.spi_parse_error, filename except: raise return {"name":name, "epoch":epoch, "serial":serial, "version":version, "release":release, "group":group, "arch": arch, "os": opsys, "uri": pkg_uri, "signature": sig_uri, "requirements": requires_list, "conflicts": conflicts, "summary": summary, "description": desc, "distribution": distribution, "vendor": vendor, "copyright": copyright, "build_date": build_date, "size": size, "md5sum": md5sum,}
def read_package(self, filename, baseuri): """read_package_rdf(filename) Parse package rdf file given by <filename>. Returns a dictionary with the rdf-elements as keys.""" node = self.read_rdf(filename) try: description_node = node.children["rdf:Description"] version = description_node.children["spi:version"].value release = description_node.children["spi:release"].value arch = description_node.children["spi:arch"].value opsys = description_node.children["spi:os"].value group = description_node.children["spi:group"].value name = description_node.children["spi:name"].value pkg_uri = description_node.attr["rdf:about"] pkg_uri = utils.normalize_uri(os.path.join(baseuri, pkg_uri)) sig_uri = description_node.children["spi:signature"].attr["rdf:resource"] sig_uri = utils.normalize_uri(os.path.join(baseuri, sig_uri)) # requires = [] # a list containing all requirements requires_node = description_node.children["spi:requires"] requires_list = [] if requires_node.children != None: requires_node = node.children["rdf:Description"].children["spi:requires"].children["rdf:Bag"] for require_node in requires_node.children.values(): requirement = require_node.children["spi:requirement"].value resource_uri = require_node.children["spi:resource"].attr["rdf:resource"] resource_uri = utils.normalize_uri(os.path.join(baseuri, resource_uri)) requirement = split_requirement(requirement) # print "debug: requirement ", requirement requires_list.append( { "name": requirement[0], "operator": requirement[1], "version": requirement[2], "release": requirement[3], "uri": resource_uri, } ) conflicts = [] if description_node.children.has_key("spi:conflicts"): conflicts_node = description_node.children["spi:conflicts"] if conflicts_node.children: nodes = conflicts_node.children["rdf:Bag"].children.values() for node in nodes: # print "debug: conflict %s %s" % ( name, node.value ) conflicts.append(node.value) else: if conflicts_node.value: conflicts.append(conflicts_node.value) except KeyError: raise parse_error, "Unable to parse file : '%s'" % filename return { "name": name, "version": version, "release": release, "group": group, "arch": arch, "os": opsys, "uri": pkg_uri, "signature": sig_uri, "requirements": requires_list, "conflicts": conflicts, }
def read_package(self, filename, baseuri): """read_package_rdf(filename) Parse package rdf file given by <filename>. Returns a dictionary with the rdf-elements as keys.""" node = self.read_rdf(filename) try: description_node = node.children["rdf:Description"] version = description_node.children["spi:version"].value release = description_node.children["spi:release"].value arch = description_node.children["spi:arch"].value opsys = description_node.children["spi:os"].value group = description_node.children["spi:group"].value name = description_node.children["spi:name"].value pkg_uri = description_node.attr["rdf:about"] pkg_uri = utils.normalize_uri(os.path.join(baseuri, pkg_uri)) sig_uri = description_node.children["spi:signature"].attr[\ "rdf:resource"] sig_uri = utils.normalize_uri(os.path.join(baseuri, sig_uri)) #requires = [] # a list containing all requirements requires_node = description_node.children["spi:requires"] requires_list = [] if requires_node.children != None: requires_node = node.children["rdf:Description"].children[\ "spi:requires"].children["rdf:Bag"] for require_node in requires_node.children.values(): requirement = require_node.children[\ "spi:requirement"].value resource_uri = require_node.children[\ "spi:resource"].attr["rdf:resource"] resource_uri = utils.normalize_uri( os.path.join(baseuri, resource_uri)) requirement = split_requirement(requirement) #print "debug: requirement ", requirement requires_list.append({ "name": requirement[0], "operator": requirement[1], "version": requirement[2], "release": requirement[3], "uri": resource_uri }) conflicts = [] if description_node.children.has_key("spi:conflicts"): conflicts_node = description_node.children["spi:conflicts"] if conflicts_node.children: nodes = conflicts_node.children[\ "rdf:Bag"].children.values() for node in nodes: #print "debug: conflict %s %s" % ( name, node.value ) conflicts.append(node.value) else: if conflicts_node.value: conflicts.append(conflicts_node.value) except KeyError: raise parse_error, "Unable to parse file : '%s'" % filename return { "name": name, "version": version, "release": release, "group": group, "arch": arch, "os": opsys, "uri": pkg_uri, "signature": sig_uri, "requirements": requires_list, "conflicts": conflicts }
def _main(self, packages): 'Common main loop for upgrade or install.' if string.lower(str(self.config["poll_only"])) == "yes": message = "Found these packages:\n" for pkg in packages: message = message + "\t%s: %s-%s-%s\n" %\ (pkg.flag, pkg.name, pkg.version, pkg.release) message = message + "\tTotal %i packages." % len(packages) self.log.write_stdout(message) self.log.write_log(message) else: transactions = self.resolve_deps(packages) if not transactions: message = "Nothing to install or upgrade." self.log.write_stdout_info(message) self.log.write_log(message) return i = 0 errorflag = false for key in transactions.keys(): transaction = transactions[key] try: for package in transaction.values(): uri = utils.normalize_uri(package.uri) siguri = utils.normalize_uri(package.signature_uri) package.localfilename = self.download_file(uri, siguri) except DownloadException, errmsg: skipped = "" for name in transaction.keys(): skipped = skipped + name + " " skipped = string.rstrip(skipped) errmsg = "%s\nSkipping packages %s" % (errmsg, skipped) self.log.write_log(errmsg) self.log.write_stderr(errmsg) del transactions[key] continue if self.config['save_to']: todir = self.config['save_to'] import shutil if not os.path.isdir(todir): message = 'Can not save copy of packages.'\ ' No such directory'\ ': %s' % todir self.log.write_log(message) self.log.write_stderr(message) else: for package in transaction.values(): try: fromfile = package.localfilename basename = os.path.basename(fromfile) tofile = os.path.join(todir, basename) shutil.copyfile(fromfile, tofile) except IOError: message = 'Unable to move file %s to %s' % \ (fromfile, tofile) self.log.write_stderr(message) self.log.write_log(message) if not string.lower( str(self.config["download_only"]) ) == \ "yes": errmsg = self.install(transaction) if errmsg: errorflag = true self.log.write_log(errmsg) self.log.write_stderr(errmsg) else: self.flush_cache() i = i + 1 self.log.write_tty("\n") if errorflag: self.log.write_stderr(DEPENDENCY_ERROR_MESSAGE)