Python Params类代码示例

def display_msg(msg, status = None, color = None):
	Configure.g_maxlen = max(Configure.g_maxlen, len(msg))
	if status:
		print "%s :" % msg.ljust(Configure.g_maxlen),
		Params.pprint(color, status)
	else:
		print "%s" % msg.ljust(Configure.g_maxlen)

 def __init__(self, path=None):
     """
     The path is an `wget -r` path. Meaning it has the parts:
     host/path?query. The cache implementation will determine the final
     local path name. 
     """
     super(File, self).__init__()
     os.chdir(Params.ROOT)
     if path:
         rpath = self.apply_rules(path)
         self.init(rpath)
         # symlink to rewritten path
         # if path != rpath and not os.path.exists(path):
         #    Params.log("Symlink: %s -> %s" %(path, rpath))
         #    os.makedirs(os.path.dirname(path))
         #    os.symlink(rpath, path)
         # check if target is symlink, must exist
         if os.path.islink(rpath):
             target = os.readlink(rpath)
             if not os.path.exists(target):
                 Params.log("Warning: broken symlink, replacing: %s" % target)
                 os.unlink(rpath)
         # check if target is partial, rename
         i = 1
         if os.path.exists(rpath + Params.PARTIAL):
             while os.path.exists("%s.%s%s" % (rpath, i, Params.PARTIAL)):
                 i += 1
             shutil.copyfile(rpath + Params.PARTIAL, "%s.%s%s" % (rpath, i, Params.PARTIAL))
             Params.log("Warning: backed up duplicate incomplete %s" % i)
             # XXX: todo: keep largest partial only
         assert len(self.path) < 255, "LBYL, cache location path to long for Cache.File! "

def get_backend(main=True):
    global backend
    if main:
        if not backend:
            backend = Params.descriptor_storage_type(Params.RESOURCES)
        return backend
    return Params.descriptor_storage_type(Params.RESOURCES, 'r') 

    def send( self, sock ):

        assert not self.Done
        if self.__sendbuf:
            bytecnt = sock.send( self.__sendbuf )
            self.__sendbuf = self.__sendbuf[ bytecnt: ]
        else:
            bytecnt = Params.MAXCHUNK
            if 0 <= self.__end < self.__pos + bytecnt:
                bytecnt = self.__end - self.__pos

            chunk = self.__protocol.read( self.__pos, bytecnt )
            if self.__protocol.rewrite:
                delta, chunk = Rules.Rewrite.run(chunk)
                self.__protocol.size += delta
            try:
                self.__pos += sock.send( chunk )
            except:
                Params.log("Error writing to client, aborted!")
                self.Done = True
                # Unittest 2: keep partial file 
                #if not self.__protocol.cache.full():
                #    self.__protocol.cache.remove_partial()
                return
        self.Done = not self.__sendbuf and ( 
                self.__pos >= self.__protocol.size >= 0 
                or self.__pos >= self.__end >= 0 )

 def init(self, path):
     Params.log("FileTreeQH.init %r" % path, 5)
     # encode query if present
     sep = path.find( '?' )
     # other encoding in query/fragment part        
     if sep != -1:
         if '&' in path[sep:]:
             qsep='&'
             parts = path[sep:].split('&')
         elif ';' in path[sep:]:
             qsep=';'
             parts = path[sep:].split(';')
         else:
             qsep=''
             parts = [path[sep:]]
         parts.sort()   
         path = path[ :sep ] + os.sep + '#' + md5(qsep.join(parts)).hexdigest()
     # optional removal of directories in entire path
     psep = Params.ENCODE_PATHSEP
     if psep:
         path = path.replace( '/', psep)
     # make archive path    
     if Params.ARCHIVE:
         path = time.strftime( Params.ARCHIVE, time.gmtime() ) + path 
     self.path = os.path.join(Params.ROOT, path)
     self.file = None

 def __init__(self, path):
     Params.log("RefHash.__init__ %r" % path, 5)
     super(RefHash, self).__init__(path)
     self.refhash = md5(path).hexdigest()
     self.path = Params.ROOT + self.refhash
     self.file = None
     if not os.path.exists(Params.ROOT + Params.PARTIAL):
         os.mkdir(Params.ROOT + Params.PARTIAL)

 def close( self ):
     self.path = Params.ROOT + Params.PARTIAL + os.sep + self.refhash
     size = self.tell()
     self.file.close()
     if self.mtime >= 0:
         os.utime( self.path, ( self.mtime, self.mtime ) )
     if self.size == size:
         os.rename( self.path, Params.ROOT + self.refhash )
         Params.log('Finalized %s' % self.path, 2)

 def open_partial(self, offset=-1):
     self.path = Params.ROOT + Params.PARTIAL + os.sep + self.refhash
     self.mtime = os.stat( self.path ).st_mtime
     self.file = open( self.path, 'a+' )
     if offset >= 0:
         assert offset <= self.tell(), 'range does not match file in cache'
         self.file.seek( offset )
         self.file.truncate()
     Params.log('Resuming partial file in cache at byte %i' % self.tell(), 2)

 def prepare_nocache_response(self):
     "Blindly respond for NoCache rule matches. "
     for pattern, compiled in Params.NOCACHE:
         p = self.requri.find(':') # split scheme
         if compiled.match(self.requri[p+3:]):
             Params.log('Not caching request, matches pattern: %r.' %
                 pattern)
             self.Response = Response.BlindResponse
             return True

 def rewrite(klass, pathref):
     if Params.JOIN:
         for pattern, regex, repl in Params.JOIN:
             m = regex.match(pathref)
             if m:
                 capture = True
                 pathref = regex.sub(repl, pathref)
                 Params.log("Joined URL matching rule %r" % pattern, threshold=1)
     return pathref

def display_msg(msg, status = None, color = None):
    sr = msg
    global g_maxlen
    g_maxlen = max(g_maxlen, len(msg))
    if status:
        print "%s :" % msg.ljust(g_maxlen),
        Params.pprint(color, status)
    else:
        print "%s" % msg.ljust(g_maxlen)

def connect( addr ):
    assert Params.ONLINE, 'operating in off-line mode'
    if addr not in DNSCache:
        Params.log('Requesting address info for %s:%i' % addr, 2)
        try:
            DNSCache[ addr ] = socket.getaddrinfo(
                addr[ 0 ], addr[ 1 ], Params.FAMILY, socket.SOCK_STREAM )
        except Exception, e:
            raise DNSLookupException(addr, e)

 def __handle_size( self, code, line ):
     if code == 550:
         self.Response = Response.NotFoundResponse
         return
     assert code == 213,\
         'server sends %i; expected 213 (file status)' % code
     self.size = int( line )
     Params.log('File size: %s' % self.size)
     self.__sendbuf = 'MDTM %s\r\n' % self.__path
     self.__handle = FtpProtocol.__handle_mtime

 def run(klass, chunk):
     delta = 0
     Params.log("Trying to rewrite chunk. ", 3)
     for regex, repl in Params.REWRITE:
         if regex.search(chunk):
             new_chunk, count = regex.subn(repl, chunk)
             delta += len(new_chunk)-len(chunk)
             chunk = new_chunk
         else:
             Params.log("No match on chunk", 4)
     return delta, chunk

 def step( self, throw=None ):
     stdout = sys.stdout
     stderr = sys.stderr
     try:
         sys.stdout = sys.stderr = self
         Fiber.step( self, throw )
         if self.state:
             Params.log('Waiting at %s'% self, 1)
     finally:
         sys.stdout = stdout
         sys.stderr = stderr