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)
