transfer_view.py

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

        # change main window status bar
        if self.__main_window.statusbar_type \
               == MainWindow.STATUSBAR_TYPE_GENERAL:
            self.__main_window.create_transfer_statusbar()

        # setup default option
        self.__show_upload_confirm_dialog = True
        self.__show_download_confirm_dialog = True
        self.__action_for_upload_conflict = RESPONSE_OVERWRITE
        self.__action_for_download_conflict = RESPONSE_RESUME
        idle_add(self.transfer_next)
        return

    def transfer_next(self):
        """
        This method find the next item require transfer and add self.transfer
        to gtk idle sequence. This method is always called through gtk idle.
        """
        
        # if the stuatus of current item is skipped or finished,
        # save it as original item
        status = self.__model.get_value(self.trans_iter,
                                        TransferView.COL_DATA_STATUS)
        if status == TransferView.TRANSFER_STATUS_FINISHED \
               or status == TransferView.TRANSFER_STATUS_SKIPPED or \
               status == TransferView.TRANSFER_STATUS_FAILED:
            oi = self.trans_iter
        elif status == TransferView.TRANSFER_STATUS_SKIPPED:
            oi = self.trans_iter
        else:
            oi = None

        # if the status of ftp_engine is ABORT, run finish_transfer
        rview = self.__main_window.remote_view
        if rview.ftp_engine != None \
               and rview.ftp_engine.status == STATUS_ABORT:
            self.finish_transfer()

        # find the next ready item
        while status != TransferView.TRANSFER_STATUS_READY:
            self.trans_iter = self.__model.iter_next(self.trans_iter)
            if self.trans_iter != None:
                status = self.__model.get_value(
                    self.trans_iter, TransferView.COL_DATA_STATUS)
            else:
                break
        if status == TransferView.TRANSFER_STATUS_READY:
            # change site if need
            direction = self.__model.get_value(
                self.trans_iter, TransferView.COL_DATA_DIRECTION)
            if direction == TransferView.DIRECTION_UP:
                site = self.__model.get_value(
                    self.trans_iter, TransferView.COL_DATA_TARGET_SITE)
            elif direction == TransferView.DIRECTION_DOWN:
                site = self.__model.get_value(
                    self.trans_iter, TransferView.COL_DATA_SOURCE_SITE)
            if site != self.__main_window.remote_view.site_info \
                  or self.__main_window.remote_view.ftp_engine == None:
                self.__main_window.remote_view.connect_site(site)

            # start real transfer method
            name = self.__model.get_value(
                self.trans_iter, TransferView.COL_NAME)
            if name[-1] == '/':
                gtk.idle_add(self.transfer_dir)
            else:
                gtk.idle_add(self.transfer_file)
        else:
            self.trans_iter = None

        # if the status of original item is skipped, change it back to ready
        # otherwise, delete the orginal item
        if oi != None:
            status = self.__model.get_value(oi, TransferView.COL_DATA_STATUS)
            if status == TransferView.TRANSFER_STATUS_SKIPPED:
                self.__model.set_value(oi, TransferView.COL_DATA_STATUS,
                                       TransferView.TRANSFER_STATUS_READY)
            elif status == TransferView.TRANSFER_STATUS_FINISHED:
                self.__model.remove(oi)
            elif status == TransferView.TRANSFER_STATUS_FAILED:
                pixbuf = gdk.pixbuf_new_from_file(
                    os.path.join(coralftp_datadir, 'failed.png'))
                self.__model.set_value(oi, TransferView.COL_DIRECTION,
                                       pixbuf)
            else:
                raise ValueError
        if self.trans_iter == None:
            self.finish_transfer()
        return FALSE

    def finish_transfer(self):
        """When transfer finished, this method is called."""
        from main import MainWindow
        # restore local and remote view
        lview = self.__main_window.local_view
        rview = self.__main_window.remote_view
        if self.orig_local_path != lview.current_path:
            lview.set_path(self.orig_local_path)
        elif self.local_need_refresh:
            lview.refresh()
        if self.orig_remote_path != rview.current_path:
            rview.ftp_cd_path(self.orig_remote_path)
        elif self.remote_need_refresh:
            rview.ftp_refresh(1)
        # restore the status bar
        if self.__main_window.statusbar_type == MainWindow.STATUSBAR_TYPE_TRANSFER:
            self.__main_window.create_general_statusbar()
        return FALSE

    def transfer_dir(self):
        """
        Upload or download directories.
        """
        from local_view import LocalView
        from remote_view import RemoteView

        self.__lock.acquire()
        if self.__main_window.mode == self.__main_window.MODE_FTP:
            lview = self.__main_window.local_view
            rview = self.__main_window.remote_view
            model = self.__model
            iter = self.trans_iter
            direction = model.get_value(iter,
                                        TransferView.COL_DATA_DIRECTION)
            name = model.get_value(iter, TransferView.COL_NAME)
            target = model.get_value(iter, TransferView.COL_TARGET)
            data_target = model.get_value(iter, TransferView.COL_DATA_TARGET)

            if direction == TransferView.DIRECTION_UP:
                ids = []
                def on_succeeded(*args):
                    for id in ids:
                        ftpe.disconnect(id)
                    lview.set_path(utf8_to_unicode(name))
                    lview.add_all_to_queue(iter, target)
                    model.set_value(iter, TransferView.COL_DATA_STATUS,
                                    TransferView.TRANSFER_STATUS_FINISHED)
                    gtk.idle_add(self.transfer_next)
                    self.__lock.release()

                def on_failed(*args):
                    for id in ids:
                        ftpe.disconnect(id)
                    model.set_value(iter, TransferView.COL_DATA_STATUS,
                                    TransferView.TRANSFER_STATUS_FAILED)
                    gtk.idle_add(tview.transfer_next)
                    self.__lock.release()

                # check existence, if not exist create one
                ftpe = rview.ftp_engine
                ids.append(ftpe.connect(
                    'interrupted', lambda *args: idle_add(on_failed, *args)))
                ids.append(ftpe.connect(
                    'listd-succeeded',
                    lambda *args: idle_add(on_succeeded, *args)))
                ids.append(ftpe.connect(
                    'listd-failed',
                    lambda *args: idle_add(ftpe.mkdir, target)))
                ids.append(ftpe.connect(
                    'mkdir-succeeded',
                    lambda *args: idle_add(on_succeeded)))
                ids.append(ftpe.connect(
                    'mkdir-failed',
                    lambda *args: idle_add(on_failed)))

                ftpe.listd(utf8_to_unicode(target))
                    
            elif direction == TransferView.DIRECTION_DOWN:
                failed = FALSE
                # check existence of local dir
                if path.exists(target):
                    if not path.isdir(target):
                        failed = TRUE
                else:
                    # create dir
                    try:
                        os.mkdir(target)
                    except OSError, (errno, errmsg):
                        failed = TRUE
                if failed:
                    model.set_value(iter, TransferView.COL_DATA_STATUS,
                                    TransferView.TRANSFER_STATUS_FAILED)
                    gtk.idle_add(tview.transfer_next)
                    lock.release()
                else:
                    ids = []
                    def on_succeeded(obj, *args):
                        logging.debug('transfer_dir.down.on_succeded')
                        for id in ids:
                            rview.ftp_engine.disconnect(id)
                        rview.add_all_to_queue(iter, data_target)
                        gtk.idle_add(self.transfer_next)
                        model.set_value(iter, TransferView.COL_DATA_STATUS,
                                        TransferView.TRANSFER_STATUS_FINISHED)
                        self.__lock.release()
                    def on_failed(obj, *args):
                        logging.debug('transfer_dir.down.on_failed')
                        for id in ids:
                            rview.ftp_engine.disconnect(id)
                        gtk.idle_add(self.transfer_next)
                        model.set_value(iter, TransferView.COL_DATA_STATUS,
                                        TransferView.TRANSFER_STATUS_FAILED)
                        self.__lock.release()
                        
                    ids.append(rview.ftp_engine.connect(
                        'list-succeeded',
                        lambda *args: idle_add(on_succeeded, *args)))
                    ids.append(rview.ftp_engine.connect(
                        'cd-failed',
                        lambda *args: idle_add(on_failed, *args)))
                    ids.append(rview.ftp_engine.connect(
                        'list-failed',
                        lambda *args: idle_add(on_failed, *args)))
                    ids.append(rview.ftp_engine.connect(
                        'interrupted',
                        lambda *args: idle_add(on_failed, *args)))
                    rview.ftp_cd_path(utf8_to_unicode(name))
            else:
                self.__lock.release()
                raise ValueError

        return FALSE

    def transfer_file(self):
        """
        Upload or download files.
        """
        from local_view import LocalView
        from remote_view import RemoteView

        self.__lock.acquire()
        if self.__main_window.mode == self.__main_window.MODE_FTP:
            lview = self.__main_window.local_view
            rview = self.__main_window.remote_view
            model = self.__model
            iter = self.trans_iter
            direction = model.get_value(iter, self.COL_DATA_DIRECTION)
            source = utf8_to_unicode(model.get_value(iter, self.COL_NAME))
            target = utf8_to_unicode(model.get_value(iter, self.COL_TARGET))
            data_target = model.get_value(iter, TransferView.COL_DATA_TARGET)
            
            # Upload
            if direction == TransferView.DIRECTION_UP:
                ids = []
                
                def step3(transfer_option):
                    if transfer_option == 1:
                        self.__model.set_value(
                            self.trans_iter, TransferView.COL_DATA_STATUS,
                            TransferView.TRANSFER_STATUS_DOING)
                        rview.ftp_engine.put(
                            source, local_target, 'b',
                            TransferRunningUpdater(self))
                        self.remote_need_refresh = 1
                    elif transfer_option == 0:
                        gtk.idle_add(self.transfer_next)
                    else:
                        # do nothing means cancel the transfer
                        self.finish_transfer()
                    self.__lock.release()
                    return

                def step2(obj, resp, *args):
                    if obj != None:
                        if not obj.ask_again:
                            self.__show_upload_confirm_dialog = False
                            self.__action_for_upload_conflict = resp
                        obj.destroy()
                    if resp == RESPONSE_CANCEL:
                        transfer_option = -1
                    elif resp == RESPONSE_CLOSE:
                        # close is considered as cancel
                        transfer_option = -1
                    elif resp == RESPONSE_OVERWRITE:
                        transfer_option = 1
                    elif resp == RESPONSE_SKIP:
                        transfer_option = 0
                        self.__model.set_value(
                            self.trans_iter,
                            TransferView.COL_DATA_STATUS,
                            TransferView.TRANSFER_STATUS_SKIPPED)
                    elif resp == RESPONSE_RESUME:
                        # resume is disabled
                        raise ValueError
                    elif resp == RESPONSE_RENAME:
                        p = self.__model.get_value(
                            self.trans_iter, TransferView.COL_TARGET)
                        p = '%s/%s' % (path.dirname(p),
                                       confirm_file_replace.new_name)
                        self.__model.set_value(
                            self.trans_iter, TransferView.COL_TARGET, p)
                        local_target = utf8_to_unicode(p)
                        transfer_option = 0
                    step3(transfer_option)
                    return

                # in order to wait for list finish, a function is defined here.
                def on_list_succeeded(obj):
                                        
                    for id in ids:
                        rview.ftp_engine.disconnect(id)
                    transfer_option = 1