Sindbad~EG File Manager

# Copyright (C) 2013-2016 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.  You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.

from __future__ import unicode_literals
from dnf.cli.format import format_number, format_time
from dnf.cli.term import _term_width
from dnf.pycomp import unicode
from time import time

import sys
import dnf.callback
import dnf.util


class MultiFileProgressMeter(dnf.callback.DownloadProgress):
    """Multi-file download progress meter"""

    STATUS_2_STR = {
        dnf.callback.STATUS_FAILED: 'FAILED',
        dnf.callback.STATUS_ALREADY_EXISTS: 'SKIPPED',
        dnf.callback.STATUS_MIRROR: 'MIRROR',
        dnf.callback.STATUS_DRPM: 'DRPM',
    }

    def __init__(self, fo=sys.stderr, update_period=0.3, tick_period=1.0, rate_average=5.0):
        """Creates a new progress meter instance

        update_period -- how often to update the progress bar
        tick_period -- how fast to cycle through concurrent downloads
        rate_average -- time constant for average speed calculation
        """
        self.fo = fo
        self.update_period = update_period
        self.tick_period = tick_period
        self.rate_average = rate_average
        self.unknown_progres = 0
        self.total_drpm = 0
        self.isatty = sys.stdout.isatty()
        self.done_drpm = 0
        self.done_files = 0
        self.done_size = 0
        self.active = []
        self.state = {}
        self.last_time = 0
        self.last_size = 0
        self.rate = None
        self.total_files = 0
        self.total_size = 0

    def message(self, msg):
        dnf.util._terminal_messenger('write_flush', msg, self.fo)

    def start(self, total_files, total_size, total_drpms=0):
        self.total_files = total_files
        self.total_size = total_size
        self.total_drpm = total_drpms

        # download state
        self.done_drpm = 0
        self.done_files = 0
        self.done_size = 0
        self.active = []
        self.state = {}

        # rate averaging
        self.last_time = 0
        self.last_size = 0
        self.rate = None

    def progress(self, payload, done):
        now = time()
        text = unicode(payload)
        total = int(payload.download_size)
        done = int(done)

        # update done_size
        if text not in self.state:
            self.state[text] = now, 0
            self.active.append(text)
        start, old = self.state[text]
        self.state[text] = start, done
        self.done_size += done - old

        # update screen if enough time has elapsed
        if now - self.last_time > self.update_period:
            if total > self.total_size:
                self.total_size = total
            self._update(now)

    def _update(self, now):
        if self.last_time:
            delta_time = now - self.last_time
            delta_size = self.done_size - self.last_size
            if delta_time > 0 and delta_size > 0:
                # update the average rate
                rate = delta_size / delta_time
                if self.rate is not None:
                    weight = min(delta_time/self.rate_average, 1)
                    rate = rate*weight + self.rate*(1 - weight)
                self.rate = rate
        self.last_time = now
        self.last_size = self.done_size
        if not self.isatty:
            return
        # pick one of the active downloads
        text = self.active[int(now/self.tick_period) % len(self.active)]
        if self.total_files > 1:
            n = '%d' % (self.done_files + 1)
            if len(self.active) > 1:
                n += '-%d' % (self.done_files + len(self.active))
            text = '(%s/%d): %s' % (n, self.total_files, text)

        # average rate, total done size, estimated remaining time
        if self.rate and self.total_size:
            time_eta = format_time((self.total_size - self.done_size) / self.rate)
        else:
            time_eta = '--:--'
        msg = ' %5sB/s | %5sB %9s ETA\r' % (
            format_number(self.rate) if self.rate else '---  ',
            format_number(self.done_size),
            time_eta)
        left = _term_width() - len(msg)
        bl = (left - 7)//2
        if bl > 8:
            # use part of the remaining space for progress bar
            if self.total_size:
                pct = self.done_size * 100 // self.total_size
                n, p = divmod(self.done_size * bl * 2 // self.total_size, 2)
                bar = '=' * n + '-' * p
                msg = '%3d%% [%-*s]%s' % (pct, bl, bar, msg)
                left -= bl + 7
            else:
                n = self.unknown_progres - 3
                p = 3
                n = 0 if n < 0 else n
                bar = ' ' * n + '=' * p
                msg = '     [%-*s]%s' % (bl, bar, msg)
                left -= bl + 7
                self.unknown_progres = self.unknown_progres + 3 if self.unknown_progres + 3 < bl \
                    else 0
        self.message('%-*.*s%s' % (left, left, text, msg))

    def end(self, payload, status, err_msg):
        start = now = time()
        text = unicode(payload)
        size = int(payload.download_size)
        done = 0

        # update state
        if status == dnf.callback.STATUS_MIRROR:
            pass
        elif status == dnf.callback.STATUS_DRPM:
            self.done_drpm += 1
        elif text in self.state:
            start, done = self.state.pop(text)
            self.active.remove(text)
            size -= done
            self.done_files += 1
            self.done_size += size
        elif status == dnf.callback.STATUS_ALREADY_EXISTS:
            self.done_files += 1
            self.done_size += size

        if status:
            # the error message, no trimming
            if status is dnf.callback.STATUS_DRPM and self.total_drpm > 1:
                msg = '[%s %d/%d] %s: ' % (self.STATUS_2_STR[status], self.done_drpm,
                                           self.total_drpm, text)
            else:
                msg = '[%s] %s: ' % (self.STATUS_2_STR[status], text)
            left = _term_width() - len(msg) - 1
            msg = '%s%-*s\n' % (msg, left, err_msg)
        else:
            if self.total_files > 1:
                text = '(%d/%d): %s' % (self.done_files, self.total_files, text)

            # average rate, file size, download time
            tm = max(now - start, 0.001)
            msg = ' %5sB/s | %5sB %9s    \n' % (
                format_number(float(done) / tm),
                format_number(done),
                format_time(tm))
            left = _term_width() - len(msg)
            msg = '%-*.*s%s' % (left, left, text, msg)
        self.message(msg)

        # now there's a blank line. fill it if possible.
        if self.active:
            self._update(now)