ftp_engine.py

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

        logging.debug('start idle finished')
        return
            
    def stop_idle(self, change_idle, finished_event = None):
        logging.debug('stop_idle runs')
        self.__is_idle.clear()
        if self.status > STATUS_CONNECTING:
            logging.debug('before stop monitor')
            self.__ftp_client.stop_monitor()
            logging.debug('after stop monitor')
        
        if change_idle or self.status <= STATUS_CONNECTING:
            logging.debug('before idle_add emit')
            idle_add(self.emit, 'idle', -1)
            logging.debug('after idle_add emit')
            if self.idle_timer:
                self.idle_timer.cancel()
                self.idle_timer = None
        
        if change_idle:
            self.status = STATUS_RUNNING
        
        if finished_event != None:
            finished_event.set()
        logging.debug('stop_idle finished')
        return
            
    def do_idle(self, idle_time):
        def send_noop():
            if self.keep_alive_command == 'NOOP':
                cmd = self.__ftp_client.new_command(CMD_SIMPLE, 'NOOP')
                try:
                    self.__ftp_client.execute_command(cmd)
                except FTPException, (errno, errmsg):
                    if errno == 421:
                        idle_add(self.emit, 'idle-connection-closed')
            elif self.keep_alive_command == 'PWD':
                self.pwd()
                
        if self.send_keep_alive_command \
               and (not self.stop_send_keep_alive \
                    or self.total_idle <= self.stop_keep_alive_after) \
                    and idle_time % self.send_keep_alive_interval == 0:
            self.__change_idle = FALSE
            self.__execute_in_thread(send_noop)
            self.__change_idle = TRUE
        return

    def do_welcome_message(self, message):
        self.__welcome_message = message
        return
            
    def open(self, site_info):
        def on_delay():
            """This function is used to show delay message on status bar,
            and when delay time reached, send run command again."""
            # If user press disconnect button, stop idle counting
            if self.status != STATUS_CONNECTING:
                return FALSE
            if self.delayed != None:
                self.delayed = self.delayed - 1
                idle_add(self.emit, 'delay', self.delayed)
                if self.delayed == 0:
                    # run connect again
                    self.retried = self.retried + 1
                    self.delayed = None
                    self.delay_timer = None
                    self.__change_idle = FALSE
                    self.__execute_in_thread(self.open, site_info)
                    self.__change_idle = TRUE
                    return FALSE
                else:
                    return TRUE
            return
        
        logging.debug('open command executed in %s' \
                      % self.__coralftp.get_thread_name())
        if thread.get_ident() != self.__pid:
            self.retried = 1
            self.__change_idle = FALSE
            self.__execute_in_thread(self.open, site_info)
            self.__change_idle = TRUE
            return

        self.__site_info = site_info
        # change status to STATUS_CONNECTING
        self.status = STATUS_CONNECTING
        cmd = self.__ftp_client.new_command(CMD_OPEN, site_info)
        try:
            self.__ftp_client.execute_command(cmd)
            self.status = STATUS_IDLE
            idle_add(self.emit, 'open-succeeded')
        except FTPException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, errmsg + '\r\n')
            if self.retried >= self.connect_retry_count:
                idle_add(self.emit, 'log-message', 0, 'Failed to connect')
                idle_add(self.emit, 'open-failed', 0, '')
                # change status to NONE
                self.status = STATUS_NONE
            else:
                self.delayed = self.connect_retry_delay
                self.delay_timer = Timer(1, on_delay)
                self.delay_timer.start()
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, errmsg + '\r\n')
            if self.retried >= self.connect_retry_count:
                idle_add(self.emit, 'log-message', 0, 'Failed to connect')
                idle_add(self.emit, 'open-failed', 0, '')
                # change status to NONE
            else:
                self.delayed = self.connect_retry_delay
                self.delay_timer = Timer(1, on_delay)
                self.delay_timer.start()
        logging.debug('open command finished')

    def pwd(self, updater=None):
        logging.debug('pwd command run in %s' \
                      % self.__coralftp.get_thread_name())
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.pwd, updater)
            return

        cmd = self.__ftp_client.new_command(CMD_PWD, updater)
        try:
            self.__ftp_client.execute_command(cmd)
            idle_add(self.emit, 'pwd-succeeded')
        except FTPException, (errno, errmsg):
            idle_add(self.emit, 'pwd-failed', errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'pwd-failed', errno, errmsg)
        logging.debug('pwd command finished')

    def list(self, updater=None, dir='', clear_cache=FALSE):
        logging.debug('list command execute in %s' \
                      % self.__coralftp.get_thread_name())
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.list, updater, dir, clear_cache)
            return

        cmd = self.__ftp_client.new_command(CMD_LIST,
                                            updater, dir, clear_cache)
        try:
            self.__ftp_client.execute_command(cmd)
            logging.debug('list-succeeded')
            idle_add(self.emit, 'list-succeeded')
        except FTPException, (errno, errmsg):
            logging.debug('list-failed')
            idle_add(self.emit, 'list-failed', errno, errmsg)
        except NetworkException, error:
            if isinstance(error, list):
                errno, errmsg = error
            else:
                errno = 0
                errmsg = error.__str__() + '\n'
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'list-failed', errno, errmsg)
        logging.debug('list command finished')

    def listd(self, apath):
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.listd, apath)
            return

        cmd = self.__ftp_client.new_command(CMD_LISTD, apath)
        try:
            if self.__ftp_client.execute_command(cmd):
                logging.debug('listd-succeeded')
                idle_add(self.emit, 'listd-succeeded')
            else:
                logging.debug('listd-failed')
                idle_add(self.emit, 'listd-failed', 0, '')
        except FTPException, (errno, errmsg):
            logging.debug('listd-failed')
            idle_add(self.emit, 'list-failed', errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'listd-failed', errno, errmsg)

    def cd(self, new_path):
        logging.debug('cd command execute in %s'\
                      % self.__coralftp.get_thread_name())
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.cd, new_path)
            return

        cmd = self.__ftp_client.new_command(CMD_CD, new_path)
        try:
            self.__ftp_client.execute_command(cmd)
            logging.debug('cd-succeeded')
            idle_add(self.emit, 'cd-succeeded')
        except FTPException, (errno, errmsg):
            logging.debug('cd-failed')
            idle_add(self.emit, 'cd-failed', errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'cd-failed', errno, errmsg)
        logging.debug('cd command finished')

    def put(self, source, target, mode='b', rupdater=None, fupdater=None):
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.put, source, target, mode,
                                     rupdater)
            return

        cmd = self.__ftp_client.new_command(CMD_PUT, source, target, mode,
                                            rupdater)
        try:
            self.__ftp_client.execute_command(cmd)
            if self.status == STATUS_ABORT:
                idle_add(self.emit, 'put-failed', ERRNO_ABORT, 'Aborted by user')
                logging.debug('put-interrupted')
            else:
                idle_add(self.emit, 'put-succeeded')
                logging.debug('put-succeeded %s --> %s' % (source, target))
        except FTPException, (errno, errmsg):
            logging.debug('put-failed %d %s' % (errno, errmsg))
            idle_add(self.emit, 'put-failed', errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'put-failed', errno, errmsg)

    def get(self, source, target, mode='b', resume=0, rupdater=None, fupdater=None):
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.get, source, target, mode, resume,
                                     rupdater, fupdater)
            return

        cmd = self.__ftp_client.new_command(CMD_GET, source, target, mode,
                                            resume, rupdater, fupdater)
        try:
            self.__ftp_client.execute_command(cmd)
            if self.status == STATUS_ABORT:
                idle_add(self.emit, 'get-failed', ERRNO_ABORT, 'Aborted by user')
                logging.debug('get-interrupted')
            else:
                idle_add(self.emit, 'get-succeeded')
                logging.debug('get-succeeded %s --> %s' % (source, target))
        except FTPException, (errno, errmsg):
            logging.debug('get-failed %d %s' % (errno, errmsg))
            idle_add(self.emit, 'get-failed', errno, errmsg)
        except NetworkException, error:
            logging.debug("NetworkException: %s", error)
            if isinstance(error, list):
                errno, errmsg = error
            else:
                errno = 0
                errmsg = error + '\n'
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'get-failed', errno, errmsg)
        except IOError, ex:
            idle_add(self.emit, 'log-message', 0, ex.__str__())
            idle_add(self.emit, 'get-failed', 0, ex.__str__())
            
    def delete(self, name, isdir):
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.delete, name, isdir)
            return

        cmd = self.__ftp_client.new_command(CMD_DELETE, name, isdir)
        try:
            self.__ftp_client.execute_command(cmd)
            logging.debug('delete-succeeded %s' % name)
            idle_add(self.emit, 'delete-succeeded')
        except FTPException, (errno, errmsg):
            logging.debug('delete-failed: %d %s' % (errno, errmsg))
            idle_add(self.emit, 'delete-failed', errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'delete-failed', errno, errmsg)

    def move(self, old_name, new_name):
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.move, old_name, new_name)
            return

        cmd = self.__ftp_client.new_command(CMD_MOVE, old_name, new_name)
        try:
            self.__ftp_client.execute_command(cmd)
            idle_add(self.emit, 'move-succeeded')
        except FTPException, (errno, errmsg):
            idle_add(self.emit, 'move-failed', old_name, new_name, errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'move-failed', errno, errmsg)

    def mkdir(self, dirname):
        if thread.get_ident() != self.__pid:
            self.__execute_in_thread(self.mkdir, dirname)
            return

        cmd = self.__ftp_client.new_command(CMD_MKDIR, dirname)
        try:
            self.__ftp_client.execute_command(cmd)
            logging.debug('mkdir-succeeded')
            idle_add(self.emit, 'mkdir-succeeded')
        except FTPException, (errno, errmsg):
            logging.debug('mkdir-failed')
            idle_add(self.emit, 'mkdir-failed', dirname, errno, errmsg)
        except NetworkException, (errno, errmsg):
            idle_add(self.emit, 'log-message', 0, "%d %s" % (errno, errmsg))
            idle_add(self.emit, 'mkdir-failed', errno, errmsg)

gobject.type_register(FTPEngine)

class FTPClient:
    """
    FTPClient is a interface for FTP client programs used by CoralFTP. All the
    FTP command is running in FTPThread thread.
    """

    def __init__(self):
        pass

    def __del__(self):
        pass

    def new_command(self, command_type, *args):
        return None

    def execute_command(self, command, *args):
        return command.execute(*args)

    def interrupt(self):
        return None

    def quit(self):
        return None