home *** CD-ROM | disk | FTP | other *** search
/ PC World 2002 May / PCWorld_2002-05_cd.bin / Software / TemaCD / activepython / ActivePython-2.1.1.msi / Python21_PPM_ppmerrors.py < prev    next >
Encoding:
Python Source  |  2001-07-26  |  10.1 KB  |  317 lines
  1. # Copyright 2001 (C) ActiveState Tool Corp., All Rights Reserved.
  2. #
  3. import string
  4. import ppmconfig
  5. import traceback
  6. from sys import exc_info, stderr
  7. from types import *
  8. from formatter import DumbWriter
  9. from cStringIO import StringIO
  10.  
  11.  
  12. class ErrorReporter:
  13.     def __init__(self, tracer, formatter):
  14.         self.tracer = tracer
  15.         self.formatter = formatter
  16.         
  17.     def LowError(self, msg):
  18.         #low priority errors are considered level 2 tracing messages
  19.         self.tracer.log('Error: '+str(msg) , 2)
  20.  
  21.     def Error(self, msg):
  22.         #errors are considered level 1 tracing messages
  23.         self.tracer.log('ERROR: '+str(msg) , 1)
  24.  
  25.     def Fatal(self, msg):
  26.         #fatal errors are considered level 0 tracing messages and cause the
  27.         #program to halt
  28.         self.tracer.log('FATAL ERROR: '+ str(msg) , 0)
  29.  
  30.     def Warn(self, msg):
  31.         #warnings are considered level 3 messages.
  32.         self.tracer.log('WARNING :' + str(msg) , 3)
  33.  
  34.     def Msg(self, msg):
  35.         #this is just a message which is considered level 4 tracing message
  36.         self.tracer.log(str(msg) , 4)
  37.  
  38. class basic(Exception):
  39.         def __init__(self):
  40.                 self.__msg__ = self.__doc__
  41.         
  42.         def __repr__(self):
  43.                 return self.__msg__
  44.         __str__ = __repr__
  45.  
  46. class AlreadyInstalled(basic):
  47.     """Package is already installed"""
  48.     def __init__(self):
  49.         basic.__init__(self)
  50.     
  51. class InvalidRegx(basic):
  52.     ""
  53.     def __init__(self,msg):
  54.         self.__doc__ += str(msg)
  55.         basic.__init__(self)
  56.         
  57. class BadPPD(basic):
  58.     """bad ppd found: """
  59.     def __init__(self,msg):
  60.         self.__doc__ +=str(msg)
  61.         basic.__init__(self)
  62.  
  63. class NodeNotFound(basic):
  64.     """The specified node can not be found."""
  65.     def __init__(self):
  66.         basic.__init__(self)
  67.     
  68. class ProtocolError(basic):
  69.     """protocol error"""
  70.     def __init__(self,msg):
  71.         self.__doc__ += str(msg)
  72.         basic.__init__(self)
  73.  
  74. class FailInstall(basic):
  75.     """Package can not be installed: """
  76.     def __init__(self,msg):
  77.         self.__doc__ += str(msg)
  78.         basic.__init__(self)
  79.  
  80. class PackageNotFound(basic):
  81.     """Package can not be found."""
  82.     def __inti__(self):
  83.         basic.__init__(self)
  84.  
  85. class BadConfigFile(basic):
  86.     """Error reading config file: """
  87.     def __init__(self,msg):
  88.         self.__doc__ += msg
  89.         basic.__init__(self)
  90.  
  91. class StderrErrorDisplay:
  92.     def display(self, msg, severity):
  93.         stderr.write("\n"+msg+"\n")
  94.  
  95. class Win32ErrorDisplay:
  96.     def display(self, msg, severity):
  97.         from win32ui import MessageBox
  98.         MessageBox(msg, "PPM")
  99.  
  100. class Tracer:
  101.         def __init__(self): 
  102.             # for now, override the displayer like this:
  103.             # errorreporter.tracer.displayer = Win32Displayer()
  104.             self.displayer = StderrErrorDisplay() # by default...
  105.             self.disable_log = 0
  106.             self.fname = ''
  107.             self.file = None
  108.             self.tl = 0
  109.             self.verbose = 0
  110.  
  111.         def init(self, fname):
  112.             try:
  113.                 import os
  114.                 if os.path.getsize(fname)>1.024e+6:
  115.                     os.remove(fname)
  116.             except (OSError, IOError), e:
  117.                 pass
  118.  
  119.             try: 
  120.                 self.file = open(fname , 'a+')
  121.                 self.fname = fname 
  122.             except IOError, e:
  123.                 printfunc('Can not access the log file. Logging is disabled: %s' % e)
  124.                 self.disable_log = 1
  125.  
  126.         def SetLogName(self, fname):
  127.             if hasattr(self, "file") and hasattr(self, "fname"):
  128.                 if self.file and self.fname != fname:
  129.                     self.file.close()
  130.                 else:
  131.                     import os
  132.                     try:
  133.                         if os.path.getsize(fname)>1.024e+6:
  134.                             os.remove(fname)
  135.                         self.file = open(fname , 'a+')
  136.                         self.fname = fname
  137.                     except IOError, e:
  138.                         print 'Can not access the log file. Logging is disabled: %s' % e
  139.                         self.disable_log = 1
  140.             else:
  141.                 import os
  142.                 try:
  143.                     if os.path.getsize(fname)>1.024e+6:
  144.                         os.remove(fname)
  145.                 except (OSError, IOError):
  146.                     pass
  147.                 try:
  148.                     self.file = open(fname , 'a+')
  149.                     self.fname = fname
  150.                 except IOError, e:
  151.                     print 'Can not access the log file. Logging is disabled: %s' % e
  152.                     self.disable_log = 1
  153.             
  154.         def log(self, msg, msg_tl = 0 ): # XXX this is not how you do
  155.                                    # optional arguments in pyhon.
  156.             if not self.file:
  157.                 self.init('PPM.LOG')
  158.  
  159.             # warnings and low priority errors are not
  160.             # printed on the screen in any mode.
  161.             if (self.verbose and int(msg_tl)>3) or msg_tl<2:
  162.                 self.displayer.display(msg, msg_tl)
  163.  
  164.             # add stack trace to the error messages, prior to logging
  165.             if int(self.tl) >= int(msg_tl):
  166.                 if msg_tl<3:
  167.                     tracebak = exc_info()[2]
  168.                     if tracebak:
  169.                         info = traceback.extract_tb(tracebak , 1)[0]
  170.                         msg += '<'+'FILENAME:'+str(info[0])+'--FUNCTION:'+str(info[2])+\
  171.                                '--LINE NO:'+str(info[1])+'>'
  172.                 if not self.disable_log:
  173.                     self.file.write(msg+'\n')
  174.                 self.file.flush()
  175.  
  176. def cnvrtVersion(versionStr,ln):
  177.     versionStr=str(versionStr) # un-unicode if necessary
  178.     versions = []
  179.     for ver in versionStr.split("."):
  180.         try:
  181.             versions.append(int(ver))
  182.         except ValueError:
  183.             versions.append(0)
  184.  
  185.     versionStr = ".".join([str(version) for version in versions])
  186.         
  187.     if len(versionStr)<ln:
  188.         versionStr += ' '*(ln - len(versionStr))
  189.     elif len(versionStr)>ln:
  190.         versionStr = versionStr[:ln]
  191.     return versionStr
  192.  
  193. # adjust the index to word boundaries
  194. def AdjustWordBoundaryBackward(str,pos):
  195.     SPACE = ' '
  196.     try:
  197.         if str[pos] != SPACE:
  198.             while str[pos-1]!=SPACE:
  199.                 pos -= 1
  200.         return pos
  201.     except IndexError:
  202.         return pos
  203.  
  204. def AdjustWordBoundaryForward(str,pos):
  205.     SPACE = ' '
  206.     try:
  207.         while str[pos]==SPACE:
  208.                 pos +=1
  209.         return pos
  210.     except IndexError:
  211.         return pos
  212.  
  213. def formatAbs(str, column, indent):
  214.     out = StringIO()
  215.     writer = DumbWriter(out, 49)
  216.     writer.send_flowing_data(str)
  217.     lines = out.getvalue().strip().splitlines()
  218.     prefix = " " * indent
  219.     lines = [lines[0]] + [prefix + line for line in lines[1:]]
  220.     return "\n".join(lines)
  221.  
  222. def oldformatAbs(abs,ln,margin):
  223.     TAB_SIZE = 8
  224.     LARGEST_WORD_SIZE = 15
  225.     abs = string.replace(abs,'\n',' ')
  226.     abs = string.replace(abs,'\t',' '*TAB_SIZE)
  227.     abs = string.replace(abs,'\r','')
  228.     abs.strip()
  229.     if len(abs)<=ln or len(abs)==0:
  230.         return abs
  231.     else:
  232.         MyAbs = ''
  233.         LineNo = 0
  234.         i =0
  235.         OldEndPos = 0
  236.         while i<=len(abs):
  237.             dummy = ln*(1+LineNo)
  238.             EndPos = AdjustWordBoundaryBackward(abs,dummy)
  239.             StartPos = AdjustWordBoundaryForward(abs,OldEndPos)
  240.             if LineNo: MyAbs += ' '*margin
  241.             # do not wrap if the following happens
  242.             if EndPos<StartPos or \
  243.                (dummy-EndPos)>LARGEST_WORD_SIZE:
  244.                 MyAbs += abs[StartPos:dummy]
  245.                 if dummy < len(abs):
  246.                     MyAbs += '\n'
  247.                 i += dummy - OldEndPos
  248.                 OldEndPos = dummy
  249.             else:
  250.                 MyAbs += abs[StartPos:EndPos]
  251.                 if EndPos < len(abs):
  252.                     MyAbs += '\n'
  253.                 i += EndPos - OldEndPos
  254.                 OldEndPos = EndPos
  255.             LineNo += 1
  256.  
  257.         return MyAbs
  258.     
  259. class Formatter:
  260.  
  261.     def __init__(self):
  262.         self.interactive = 0
  263.         self.verbose = 0
  264.         self.TotalLines = 0
  265.         self.maxname=18
  266.         self.maxversion=7
  267.         import os
  268.         if os.environ.has_key('COLUMNS'):
  269.             self.columns = os.environ['COLUMNS']
  270.         else:
  271.             self.columns = 80
  272.         self.maxabs = self.columns - self.maxname - self.maxversion - 6
  273.  
  274.     def reInit(self):
  275.         self.maxabs = self.columns - self.maxname - self.maxversion - 6
  276.         
  277.     def FormatPackage(self,obj):
  278.         if len(obj.name) > self.maxname:
  279.             PackName = obj.name[:self.maxname]
  280.         else:
  281.             PackName = obj.name+' '*(self.maxname - len(obj.name))
  282.         Version = cnvrtVersion(obj.version, self.maxversion)
  283.         Abstract = formatAbs(obj.abstract,self.maxabs,\
  284.                              self.columns-self.maxabs)
  285.         FormatStr = '%s'+' '*1+'[ %s ]'+' '*1+'%s'
  286.         return FormatStr % (PackName , Version, Abstract)
  287.         
  288.     def formatPackage(self,obj):
  289.         self.reInit()
  290.         if isinstance(obj, ppmconfig.InstalledPackage):
  291.             s = self.FormatPackage(obj)
  292.             self.TotalLines += string.count(s,'\n')+1
  293.             return s
  294.         
  295.         if isinstance(obj, ppmconfig.Package):
  296.             s = self.FormatPackage(obj)
  297.             self.TotalLines += string.count(s,'\n')+1
  298.             return s
  299.         
  300.     def formatOptions(self, obj, printfunc):
  301.         if type(obj) is DictType:
  302.             for x in obj.keys():
  303.                 printfunc( x+' = '+str(obj[x]))
  304.                     
  305.         if isinstance(obj, ppmconfig.Repository):
  306.             printfunc( 'Repository Name: %s ' % obj.name)
  307.             printfunc( '\t Address: '+obj.uri)
  308.             printfunc( '\t Namespace: '+obj.namespace)
  309.  
  310.         if type(obj) is ListType:
  311.             # calls itself with every item in the list
  312.             for o in obj:
  313.                 self.formatOptions(o, printfunc)
  314.  
  315. errorreporter = ErrorReporter(Tracer(), Formatter())
  316.  
  317.