ftplib_client.py

CoralFTP是一款用Python语言编写的工作在GTK2环境下的FTP客户端软件

        logging.debug(resp.__str__())
        if isinstance(resp, list):
            raise NetworkException(resp)
        else:
            raise NetworkException((0, resp.__str__()))
    
class OpenCommand:

    def __init__(self, client, site_info):
        self.client = client
        self.ftp = client.ftp
        self.site_info = site_info
        if site_info['remote_charset']:
            self.ftp.set_charset(site_info['remote_charset'])
            self.client.logger.set_charset(site_info['remote_charset'])

    def execute(self):
        # exception should be processed
        safe_execute(self.client.logger, self.ftp.connect,
                     self.site_info['server_addr'],
                     int(self.site_info['server_port']))

        sys.stdout = self.client.logger
        welcome = self.ftp.getwelcome()
        sys.stdout = self.client.sout
        
        if welcome and welcome != '':
            idle_add(self.client.ftp_engine.emit, 'welcome-message', welcome)
                                 
        username = self.site_info['username']
        password = self.site_info['password']
        if username == 'None' and (password == '' or password == None):
            password ='[e-mail]'

        safe_execute(self.client.logger, self.ftp.login, username, password)
        
class CdCommand:

    def __init__(self, client, path):
        if path == '':
            path = '/'
        self.client = client
        self.ftp = client.ftp
        self.path = path

    def execute(self):
        safe_execute(self.client.logger, self.ftp.cwd, self.path)

class ListCommand:

    def __init__(self, client, updater=None, dir='', clear_cache=0):
        self.client = client
        self.ftp = client.ftp
        self.updater = updater
        self.dir = dir
        self.clear_cache = clear_cache

    def execute(self):
        self.filelist = []
        self.rec = re.compile('([drwxsS\-]{10,11}) +(\d+) +(\w+) +(\w+) +(\d+) +(\w+) +(\d+) +([\w\:]+) +(.*)')
        safe_execute(self.client.logger, self.ftp.retrlines,
                     "LIST -a", self.update)
        if len(self.filelist) > 0 and self.updater:
            self.updater(self.filelist)

    def update(self, line):
        m = self.rec.match(line)
        if m != None:
            attr = m.group(1)
            childnum = m.group(2)
            owner = m.group(3)
            group = m.group(4)
            size = m.group(5)
            month = m.group(6)
            day = m.group(7)
            year_or_time = m.group(8)
            name = m.group(9)
            self.filelist.append((attr, childnum,
                            owner, group, size, month, day,
                            year_or_time, name))
            if len(self.filelist) == 10:
                if self.updater:
                    self.updater(self.filelist)
                    self.filelist = []
        
class ListdCommand(ListCommand):

    def __init__(self, client, dir):
        ListCommand.__init__(self, client, dir=dir, clear_cache=1)

    def execute(self):
        self.filelist = []
        self.rec = re.compile('([drwxsS\-]{10,11}) +(\d+) +(\w+) +(\w+) +(\d+) +(\w+) +(\d+) +([\w\:]+) +(.*)')
        safe_execute(self.client.logger, self.ftp.retrlines,
                     "LIST -d %s" % self.dir, self.update)
        return len(self.filelist) > 0

class QuitCommand:

    def __init__(self, client):
        self.client = client
        self.ftp = client.ftp

    def execute(self):
        safe_execute(self.client.logger, self.ftp.quit)
        safe_execute(self.client.logger, self.ftp.close)
        
class PwdCommand:

    def __init__(self, client, updater):
        self.client = client
        self.ftp = client.ftp
        self.updater = updater

    def execute(self):
        r = safe_execute(self.client.logger, self.ftp.pwd)
        gtk.idle_add(self.updater, r)

class PutCommand:

    def __init__(self, client, source, target, mode='b', rupdater=None):
        self.client = client
        self.ftp = client.ftp
        self.source = source
        self.target = target
        self.mode = mode
        self.rupdater = rupdater

    def execute(self):
        if self.mode == 'b':
            safe_execute(self.client.logger, self.ftp.voidcmd, 'TYPE I')
        else:
            safe_execute(self.client.logger, self.ftp.voidcmd, 'TYPE A')
        size = 0
        # if self.resume:
        #     size = os.stat(self.source)
        fp = open(self.source)
        # if size: fp.seek(size)
        cmd = 'STOR %s' % self.target
        try:
            conn = None
            conn = safe_execute(self.client.logger, self.ftp.transfercmd,
                                cmd, size)
            
            t1 = time.time()
            while 1:
                buf = fp.read(8192)
                if not buf: break
                try:
                    conn.sendall(buf)
                except socket.error, resp:
                    # if data socket error, it may be caused by abort command
                    if resp[0] == 32:
                        break
                    else:
                        raise NetworkException(resp)
                size = size + len(buf)
                t2 = time.time()
                if t2 - t1 > 1:
                    gtk.idle_add(self.rupdater, size, '')
                    t1 = time.time()
        finally:
            logging.debug('Close data connection')
            if conn:
                conn.close()
            fp.close()
        
        # if ABOR command is sent, leave all the message to abort method
        if self.client.ftp_engine.status == ftp_engine.STATUS_ABORT:
            return
        
        safe_execute(self.client.logger, self.ftp.voidresp)
    
class GetCommand:

    def __init__(self, client, source, target, mode='b', resume=0, rupdater=None, fupdater=None):
        self.client = client
        self.ftp = client.ftp
        self.source = source
        self.target = target
        self.mode = mode
        self.resume = resume
        self.rupdater = rupdater
        self.fupdater = fupdater

    def execute(self):
        if self.mode == 'b':
            safe_execute(self.client.logger, self.ftp.voidcmd, 'TYPE I')
            fm = 'wb'
        else:
            safe_execute(self.client.logger, self.ftp.voidcmd, 'TYPE A')
            fm = 'w'
        size = 0
        if self.resume:
            size = os.stat(self.target).st_size
            if fm == 'wb': fm = 'ab'
            else: fm = 'a'
            self.rupdater.start_bytes = size
        fp = open(self.target, fm)
        cmd = "RETR %s" % self.source
        try:
            conn = None
            conn = safe_execute(self.client.logger,
                                self.ftp.transfercmd,
                                cmd, size)
            
            t1 = time.time()
            while 1:
                try:
                    buf = conn.recv(1024)
                except socket.error, resp:
                    if resp[0] == 32:
                        break
                    else:
                        raise NetworkException(resp)
                if self.client.ftp_engine.status \
                       != ftp_engine.STATUS_RUNNING:
                    break
                if not buf:
                    break
                fp.write(buf)
                size = size + len(buf)
                t2 = time.time()
                if t2 - t1 > 1:
                    gtk.idle_add(self.rupdater, size, '')
                    t1 = time.time()

        finally:
            if conn:
                logging.debug('Close data connection')
                conn.close()
            fp.close()

        # if ABOR command is sent, leave all the message to abort method
        if self.client.ftp_engine.status == ftp_engine.STATUS_ABORT:
            return
        
        safe_execute(self.client.logger, self.ftp.voidresp)
        return
    
class DeleteCommand:

    def __init__(self, client, name, isdir):
        self.client = client
        self.ftp = client.ftp
        self.name = name
        self.isdir = isdir

    def execute(self):
        if self.isdir:
            safe_execute(self.client.logger, self.ftp.rmd, self.name)
        else:
            safe_execute(self.client.logger, self.ftp.delete, self.name)

class MoveCommand:

    def __init__(self, client, old_name, new_name):
        self.client = client
        self.ftp = client.ftp
        self.old_name = old_name
        self.new_name = new_name

    def execute(self):
        safe_execute(self.client.logger, self.ftp.rename,
                     self.old_name, self.new_name)

class MkdirCommand:

    def __init__(self, client, name):
        self.client = client
        self.ftp = client.ftp
        self.name = name

    def execute(self):
        safe_execute(self.client.logger, self.ftp.mkd, self.name)

class AborCommand:

    def __init__(self, client):
        self.client = client
        self.ftp = client.ftp

    def execute(self):
        safe_execute(self.client.logger, self.ftp.abort)

class SimpleCommand:

    def __init__(self, client, cmd):
        self.client = client
        self.ftp = client.ftp
        self.cmd = cmd

    def execute(self):
        safe_execute(self.client.logger, self.ftp.voidcmd, self.cmd)

class MonitorThread(Thread):

    quit = False

    def __init__(self, ftp_client):
        Thread.__init__(self)
        self.ftp_client = ftp_client
        self.ftp_engine = ftp_client.ftp_engine
        self.poll = ftp_client.poll

    def run(self):
        logging.debug('Monitor thread start')
        while True:
            l = self.poll.poll(1000)
            if self.quit: break
            if self.ftp_engine.status != ftp_engine.STATUS_IDLE: continue
            if not self.quit and len(l) > 0:
                try:
                    sys.stdout = self.ftp_client.logger
                    self.ftp_client.ftp.getresp()
                    sys.stdout = self.ftp_client.sout
                except EOFError:
                    logging.debug("EOFError")
                    break
                except ftplib.Error, resp:
                    resp = resp.__str__()
                    if resp[0:3] == '421':
                        gtk.idle_add(self.ftp_engine.emit,
                                     'idle-connection-closed')
                    break
                except socket.error, resp:
                    break
        logging.debug('Monitor thread quit')
        return