path: root/ranger/core/loader.py

# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.

from __future__ import (absolute_import, division, print_function)

import errno
import math
import os.path
import select
from collections import deque
from io import open
from subprocess import Popen, PIPE
from time import time, sleep

try:
    import chardet  # pylint: disable=import-error
    HAVE_CHARDET = True
except ImportError:
    HAVE_CHARDET = False

from ranger import PY3
from ranger.core.shared import FileManagerAware
from ranger.ext.human_readable import human_readable
from ranger.ext.safe_path import get_safe_path
from ranger.ext.signals import SignalDispatcher


class Loadable(object):
    paused = False
    progressbar_supported = False

    def __init__(self, gen, descr):
        self.load_generator = gen
        self.description = descr
        self.percent = 0

    def get_description(self):
        return self.description

    def pause(self):
        self.paused = True

    def unpause(self):
        try:
            del self.paused
        except AttributeError:
            pass

    def destroy(self):
        pass


class CopyLoader(Loadable, FileManagerAware):  # pylint: disable=too-many-instance-attributes
    progressbar_supported = True

    def __init__(self, copy_buffer, do_cut=False, overwrite=False, dest=None,
                 make_safe_path=get_safe_path):
        self.copy_buffer = tuple(copy_buffer)
        self.do_cut = do_cut
        self.original_copy_buffer = copy_buffer
        self.original_path = dest if dest is not None else self.fm.thistab.path
        self.overwrite = overwrite
        self.make_safe_path = make_safe_path
        self.percent = 0
        if self.copy_buffer:
            self.one_file = self.copy_buffer[0]
        Loadable.__init__(self, self.generate(), 'Calculating size...')

    def _calculate_size(self, step):
        from os.path import join
        size = 0
        stack = [fobj.path for fobj in self.copy_buffer]
        while stack:
            fname = stack.pop()
            if os.path.islink(fname):
                continue
            if os.path.isdir(fname):
                stack.extend([join(fname, item) for item in os.listdir(fname)])
            else:
                try:
                    fstat = os.stat(fname)
                except OSError:
                    continue
                size += max(step, math.ceil(fstat.st_size / step) * step)
        return size

    def generate(self):
        if not self.copy_buffer:
            return

        from ranger.ext import shutil_generatorized as shutil_g
        # TODO: Don't calculate size when renaming (needs detection)
        bytes_per_tick = shutil_g.BLOCK_SIZE
        size = max(1, self._calculate_size(bytes_per_tick))
        size_str = " (" + human_readable(self._calculate_size(1)) + ")"
        done = 0
        if self.do_cut:
            self.original_copy_buffer.clear()
            if len(self.copy_buffer) == 1:
                self.description = "moving: " + self.one_file.path + size_str
            else:
                self.description = "moving files from: " + self.one_file.dirname + size_str
            for fobj in self.copy_buffer:
                for path in self.fm.tags.tags:
                    if path == fobj.path or str(path).startswith(fobj.path):
                        tag = self.fm.tags.tags[path]
                        self.fm.tags.remove(path)
                        new_path = path.replace(
                            fobj.path,
                            os.path.join(self.original_path, fobj.basename))
                        self.fm.tags.tags[new_path] = tag
                        self.fm.tags.dump()
                n = 0
                for n in shutil_g.move(src=fobj.path, dst=self.original_path,
                                       overwrite=self.overwrite,
                                       make_safe_path=self.make_safe_path):
                    self.percent = ((done + n) / size) * 100.
                    yield
                done += n
        else:
            if len(self.copy_buffer) == 1:
                self.description = "copying: " + self.one_file.path + size_str
            else:
                self.description = "copying files from: " + self.one_file.dirname + size_str
            for fobj in self.copy_buffer:
                if os.path.isdir(fobj.path) and not os.path.islink(fobj.path):
                    n = 0
                    for n in shutil_g.copytree(
                            src=fobj.path,
                            dst=os.path.join(self.original_path, fobj.basename),
                            symlinks=True,
                            overwrite=self.overwrite,
                            make_safe_path=self.make_safe_path,
                    ):
                        self.percent = ((done + n) / size) * 100.
                        yield
                    done += n
                else:
                    n = 0
                    for n in shutil_g.copy2(fobj.path, self.original_path,
                                            symlinks=True, overwrite=self.overwrite,
                                            make_safe_path=self.make_safe_path):
                        self.percent = ((done + n) / size) * 100.
                        yield
                    done += n
        cwd = self.fm.get_directory(self.original_path)
        cwd.load_content()


class CommandLoader(  # pylint: disable=too-many-instance-attributes
        Loadable, SignalDispatcher, FileManagerAware):
    """Run an external command with the loader.

    Output from stderr will be reported.  Ensure that the process doesn't
    ever ask for input, otherwise the loader will be blocked until this
    object is removed from the queue (type ^C in ranger)
    """
    finished = False
    process = None

    def __init__(self, args, descr,  # pylint: disable=too-many-arguments
                 silent=False, read=False, input=None,  # pylint: disable=redefined-builtin
                 kill_on_pause=False, popenArgs=None):
        SignalDispatcher.__init__(self)
        Loadable.__init__(self, self.generate(), descr)
        self.args = args
        self.silent = silent
        self.read = read
        self.stdout_buffer = ""
        self.input = input
        self.kill_on_pause = kill_on_pause
        self.popenArgs = popenArgs  # pylint: disable=invalid-name

    def generate(self):
        # pylint: disable=too-many-branches,too-many-statements
        # TODO: Check whether we can afford to wait for processes and use a
        #       with-statement for Popen.
        # pylint: disable=consider-using-with
        popenargs = {} if self.popenArgs is None else self.popenArgs
        popenargs['stdout'] = popenargs['stderr'] = PIPE
        popenargs['stdin'] = (
            PIPE if self.input else open(os.devnull, 'r', encoding="utf-8")
        )
        self.process = process = Popen(self.args, **popenargs)
        self.signal_emit('before', process=process, loader=self)
        if self.input:
            if PY3:
                import io
                stdin = io.TextIOWrapper(process.stdin)
            else:
                stdin = process.stdin
            try:
                stdin.write(self.input)
            except IOError as ex:
                if ex.errno not in (errno.EPIPE, errno.EINVAL):
                    raise
            stdin.close()
        if self.silent and not self.read:  # pylint: disable=too-many-nested-blocks
            while process.poll() is None:
                yield
                if self.finished:
                    break
                sleep(0.03)
        else:
            selectlist = []
            if self.read:
                selectlist.append(process.stdout)
            if not self.silent:
                selectlist.append(process.stderr)
            read_stdout = None
            while process.poll() is None:
                yield
                if self.finished:
                    break
                try:
                    robjs, _, _ = select.select(selectlist, [], [], 0.03)
                    if robjs:
                        robjs = robjs[0]
                        if robjs == process.stderr:
                            read = robjs.readline()
                            if PY3:
                                read = safe_decode(read)
                            if read:
                                self.fm.notify(read, bad=True)
                        elif robjs == process.stdout:
                            read = robjs.read(512)
                            if read:
                                if read_stdout is None:
                                    read_stdout = read
                                else:
                                    read_stdout += read
                except select.error:
                    sleep(0.03)
            if not self.silent:
                for line in process.stderr:
                    if PY3:
                        line = safe_decode(line)
                    self.fm.notify(line, bad=True)
            if self.read:
                read = process.stdout.read()
                if read:
                    read_stdout += read
            if