home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / share / pycentral / python-apt / site-packages / apt / progress.py < prev   
Encoding:
Python Source  |  2006-03-02  |  7.7 KB  |  232 lines
  1. # Progress.py - progress reporting classes
  2. #  
  3. #  Copyright (c) 2005 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import sys, apt_pkg, os, fcntl, string, re
  23.  
  24. class OpProgress(object):
  25.     """ Abstract class to implement reporting on cache opening
  26.         Subclass this class to implement simple Operation progress reporting
  27.     """
  28.     def __init__(self):
  29.         pass
  30.     def update(self, percent):
  31.         pass
  32.     def done(self):
  33.         pass
  34.  
  35. class OpTextProgress(OpProgress):
  36.     """ A simple text based cache open reporting class """
  37.     def __init__(self):
  38.         OpProgress.__init__(self)
  39.     def update(self, percent):
  40.         sys.stdout.write("\r%s: %.2i  " % (self.subOp,percent))
  41.         sys.stdout.flush()
  42.     def done(self):
  43.         sys.stdout.write("\r%s: Done\n" % self.op)
  44.  
  45.  
  46.  
  47. class FetchProgress(object):
  48.     """ Report the download/fetching progress
  49.         Subclass this class to implement fetch progress reporting
  50.     """
  51.  
  52.     # download status constants
  53.     dlDone = 0
  54.     dlQueued = 1
  55.     dlFailed = 2
  56.     dlHit = 3
  57.     dlIgnored = 4
  58.     dlStatusStr = {dlDone : "Done",
  59.                    dlQueued : "Queued",
  60.                    dlFailed : "Failed",
  61.                    dlHit : "Hit",
  62.                    dlIgnored : "Ignored"}
  63.     
  64.     def __init__(self):
  65.         self.eta = 0.0
  66.         self.percent = 0.0
  67.         pass
  68.     
  69.     def start(self):
  70.         pass
  71.     
  72.     def stop(self):
  73.         pass
  74.     
  75.     def updateStatus(self, uri, descr, shortDescr, status):
  76.         pass
  77.  
  78.     def pulse(self):
  79.         """ called periodically (to update the gui), importend to
  80.             return True to continue or False to cancel
  81.         """
  82.         self.percent = ((self.currentBytes + self.currentItems)*100.0)/float(self.totalBytes+self.totalItems)
  83.         if self.currentCPS > 0:
  84.             self.eta = (self.totalBytes-self.currentBytes)/float(self.currentCPS)
  85.         return True
  86.     def mediaChange(self, medium, drive):
  87.         pass
  88.  
  89. class TextFetchProgress(FetchProgress):
  90.     """ Ready to use progress object for terminal windows """
  91.     def __init__(self):
  92.         self.items = {}
  93.     def updateStatus(self, uri, descr, shortDescr, status):
  94.         if status != self.dlQueued:
  95.             print "\r%s %s" % (self.dlStatusStr[status], descr)
  96.         self.items[uri] = status
  97.     def pulse(self):
  98.         FetchProgress.pulse(self)
  99.         if self.currentCPS > 0:
  100.             s = "[%2.f%%] %sB/s %s" % (self.percent,
  101.                                        apt_pkg.SizeToStr(int(self.currentCPS)),
  102.                                        apt_pkg.TimeToStr(int(self.eta)))
  103.         else:
  104.             s = "%2.f%% [Working]" % (self.percent)
  105.         print "\r%s" % (s),
  106.         sys.stdout.flush()
  107.         return True
  108.     def stop(self):
  109.         print "\rDone downloading            " 
  110.     def mediaChange(self, medium, drive):
  111.         """ react to media change events """
  112.         res = True;
  113.         print "Media change: please insert the disc labeled \
  114.                '%s' in the drive '%s' and press enter" % (medium,drive)
  115.         s = sys.stdin.readline()
  116.         if(s == 'c' or s == 'C'):
  117.             res = false;
  118.         return res
  119.  
  120. class DumbInstallProgress(object):
  121.     """ Report the install progress
  122.         Subclass this class to implement install progress reporting
  123.     """
  124.     def __init__(self):
  125.         pass
  126.     def startUpdate(self):
  127.         pass
  128.     def run(self, pm):
  129.         return pm.DoInstall()
  130.     def finishUpdate(self):
  131.         pass
  132.     def updateInterface(self):
  133.         pass
  134.  
  135. class InstallProgress(DumbInstallProgress):
  136.     """ A InstallProgress that is pretty useful.
  137.         It supports the attributes 'percent' 'status' and callbacks
  138.         for the dpkg errors and conffiles and status changes 
  139.      """
  140.     def __init__(self):
  141.         DumbInstallProgress.__init__(self)
  142.         (read, write) = os.pipe()
  143.         self.writefd=write
  144.         self.statusfd = os.fdopen(read, "r")
  145.         fcntl.fcntl(self.statusfd.fileno(), fcntl.F_SETFL,os.O_NONBLOCK)
  146.         self.read = ""
  147.         self.percent = 0.0
  148.         self.status = ""
  149.     def error(self, pkg, errormsg):
  150.         " called when a error is detected during the install "
  151.         pass
  152.     def conffile(self,current,new):
  153.         " called when a conffile question from dpkg is detected "
  154.         pass
  155.     def statusChange(self, pkg, percent, status):
  156.     " called when the status changed "
  157.     pass
  158.     def updateInterface(self):
  159.         if self.statusfd != None:
  160.                 try:
  161.             while not self.read.endswith("\n"):
  162.                         self.read += os.read(self.statusfd.fileno(),1)
  163.                 except OSError, (errno,errstr):
  164.                     # resource temporarly unavailable is ignored
  165.                     if errno != 11:
  166.                         print errstr
  167.                 if self.read.endswith("\n"):
  168.                     s = self.read
  169.                     #print s
  170.                     (status, pkg, percent, status_str) = string.split(s, ":")
  171.                     #print "percent: %s %s" % (pkg, float(percent)/100.0)
  172.                     if status == "pmerror":
  173.                         self.error(pkg,status_str)
  174.                     elif status == "pmconffile":
  175.                         # we get a string like this:
  176.                         # 'current-conffile' 'new-conffile' useredited distedited
  177.                         match = re.compile("\s*\'(.*)\'\s*\'(.*)\'.*").match(status_str)
  178.                         if match:
  179.                             self.conffile(match.group(1), match.group(2))
  180.                     elif status == "pmstatus":
  181.                         if float(percent) != self.percent or \
  182.                            status_str != self.status:
  183.                             self.statusChange(pkg, float(percent), status_str.strip())
  184.                         self.percent = float(percent)
  185.                         self.status = string.strip(status_str)
  186.                     self.read = ""
  187.                     
  188.     def fork(self):
  189.         return os.fork()
  190.     def waitChild(self):
  191.         while True:
  192.             (pid, res) = os.waitpid(self.child_pid,os.WNOHANG)
  193.             if pid == self.child_pid:
  194.                 break
  195.             self.updateInterface()
  196.         return os.WEXITSTATUS(res)
  197.     def run(self, pm):
  198.         pid = self.fork()
  199.         if pid == 0:
  200.             # child
  201.             res = pm.DoInstall(self.writefd)
  202.             sys.exit(res)
  203.         self.child_pid = pid
  204.         res = self.waitChild()
  205.         return res
  206.  
  207. class CdromProgress:
  208.     """ Report the cdrom add progress
  209.         Subclass this class to implement cdrom add progress reporting
  210.     """
  211.     def __init__(self):
  212.         pass
  213.     def update(self, text, step):
  214.         """ update is called regularly so that the gui can be redrawn """
  215.         pass
  216.     def askCdromName(self):
  217.         pass
  218.     def changeCdrom(self):
  219.         pass
  220.  
  221. # module test code
  222. if __name__ == "__main__":
  223.     import apt_pkg
  224.     apt_pkg.init()
  225.     progress = OpTextProgress()
  226.     cache = apt_pkg.GetCache(progress)
  227.     depcache = apt_pkg.GetDepCache(cache)
  228.     depcache.Init(progress)
  229.  
  230.     fprogress = TextFetchProgress()
  231.     cache.Update(fprogress)
  232.