#!/usr/bin/python

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

# Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.

#

#

# Missing docstring; pylint: disable-msg=C0111

#

import inspect

import itertools

import math

import sys

import time

from functools import wraps

import pkg.client.pkgdefs as pkgdefs

import pkg.client.publisher as publisher

import pkg.fmri

import pkg.misc as misc

from pkg.client import global_settings

from pkg.client import printengine

logger = global_settings.logger

from collections import deque

class ProgressTrackerException(Exception):

        """Thrown if a ProgressTracker determines that it can't be instantiated.

        For example, the tracker which depends on a UNIX style terminal should

        throw this exception if it can't find a valid terminal."""

        def __str__(self):

                return "ProgressTrackerException: %s" % " ".join(self.args)

def format_pair(format1, v1, v2, scale=None, targetwidth=None,

    format2=None):

        """Format a pair of numbers 'v1' and 'v2' representing a fraction, such

        as v1=3 v2=200, such that for all anticipated values of v1 (0 through

        v2) , the result is a fixed width pair separated by '/':

            format_pair("%d", 3, 200)               --> "  3/200"

        'format1' is the preferred number format.  In the event that targetwidth

        is specified and the width of (format1 % v2 > targetwidth), then

        'format2' is used instead:

            format_pair("%.1f", 20.322, 1000.23,

                targetwidth=5, format2="%d")             --> "  20/1000"

        This provides a mechanism for downshifting the accuracy of an output

        to preserve column width.

        Inputs are scaled (divided by 'scale') if scale is specified."""

        if scale:

                v1 /= float(scale)

                v2 /= float(scale)

        realformat = format1

        v2len = len(realformat % v2)

        if format2 and targetwidth and v2len > targetwidth:

                # see if format2 is shorter.

                if len(format2 % v2) < v2len:

                        realformat = format2

        v2len = len(realformat % v2)

        formatpercent = realformat.find("%")

        v1format = realformat[0:formatpercent + 1] + str(v2len) + \

            realformat[formatpercent + 1:]

        return (v1format % v1) + "/" + (realformat % v2)

class SpeedEstimator(object):

        """This class implements a rudimentary download speed estimator.

        newdata() is used to indicate download progress; curl calls

        us back pretty frequently so that's not a terrible way to

        go.  Download progress records are kept on a deque, and are

        expired after self.interval seconds have elapsed.  Speed estimates

        are smoothed so that things don't bounce around too fast.

        The class also implements some heuristics designed to prevent

        handing out crappy estimates early in the download."""

        # INTERVAL describes the interval, in seconds, which is used to

        # compute the download speed.

        INTERVAL = 10.0

        # This is the decay rate (or how much we mix in the historical

        # notion of speed into the current notion).

        SMOOTHING = 0.98

        def __init__(self, goalbytes):

                # Ok to modify this during operation.

                self.goalbytes = goalbytes

                self.__deque = deque()

                self.__intervalbytes = 0

                self.__curtotal = 0

                self.__last_smooth_speed = None

                self.__instartup = True

                self.__noestimate = True

                self.__starttime = None

                self.__donetime = None

        @staticmethod

        def format_speed(speed):

                if speed is None:

                        return None

                #

                # A little hack to keep things tidy: if the length of

                # the speedstr > 5, we whack off the floating point

                # portion.

                #

                speedstr = misc.bytes_to_str(speed, "%(num).1f%(shortunit)s")

                if speed < 1024 or len(speedstr) > 5:

                        speedstr = misc.bytes_to_str(speed,

                            "%(num)d%(shortunit)s")

                speedstr += "/s"

                return speedstr

        def newdata(self, nbytes, timestamp=None):

                """Add new data as it becomes available; timestamp can be

                overridden, although this is primarily designed for testing."""

                # must be started before adding data (sorry)

                assert self.__starttime

                #

                # Step 1: Insert latest datum

                #

                curtime = timestamp if timestamp else time.time()

                self.__curtotal += nbytes

                self.__deque.append((curtime, nbytes))

                self.__intervalbytes += nbytes

                #

                # Step 2: Expunge old data

                #

                while len(self.__deque) > 0:

                        (ts, val) = self.__deque[0]

                        if ts < curtime - self.INTERVAL:

                                self.__intervalbytes -= val

                                self.__deque.popleft()

                        else:

                                break

                #

                # Step 3: Recompute the estimate

                #

                # compute time delta between front and back of deque

                timelapse = self.__deque[-1][0] - self.__deque[0][0]

                if len(self.__deque) <= 1 or timelapse == 0.0:

                        # can't operate yet

                        self.__noestimate = True

                        return

                #

                # 'ratiocomplete' is just the percentage done.  It is

                # used to disable 'startup mode' if the d/l completes

                # very rapidly.  We'll always start giving the user an

                # estimate once ratiocomplete >= 50%.

                #

                ratiocomplete = 0.0 if self.goalbytes == 0 else \

                    self.__curtotal / float(self.goalbytes)

                #

                # Keep track of whether we're in the warmup phase.  This

                # is used to deny estimates to callers until we feel good

                # about them.  This is very heuristic; it's a higher bar than

                # we use below for disabling the estimate, basically because

                # we want to open with a solid estimate.

                #

                if self.__instartup and len(self.__deque) > 50 and \

                    timelapse > (self.INTERVAL / 5.0):

                        self.__instartup = False

                #

                # Even if we haven't accomplished the above requirements,

                # exit startup mode when we're 1/3 done or more.

                #

                if self.__instartup and ratiocomplete > 0.33:

                        self.__instartup = False

                #

                # Take a look at the deque length as well as how much an

                # interval's worth of data we have. If it is quite short,

                # maybe the download has stalled out, or perhaps the user

                # used ctrl-z and then resumed; disable the estimate until we

                # build up more data.

                #

                if len(self.__deque) < 10 or timelapse < (self.INTERVAL / 20.0):

                        self.__noestimate = True

                else:

                        self.__noestimate = False

                curspeed = self.__intervalbytes / timelapse

                if self.__last_smooth_speed is None:

                        self.__last_smooth_speed = curspeed

                else:

                        self.__last_smooth_speed = \

                            int((self.SMOOTHING * self.__last_smooth_speed) + \

                            ((1.0 - self.SMOOTHING) * curspeed))

        def start(self, timestamp=None):

                assert not self.__starttime

                self.__starttime = timestamp if timestamp else time.time()

        def done(self, timestamp=None):

                assert not self.__donetime

                self.__donetime = timestamp if timestamp else time.time()

        def get_speed_estimate(self):

                if self.__noestimate or self.__instartup or \

                    not self.__last_smooth_speed:

                        return None

                return int(self.__last_smooth_speed)

        def get_final_speed(self):

                if self.__donetime is None:

                        return None

                if self.elapsed == 0.0:  # div by 0 paranoia

                        return None

                return self.goalbytes / float(self.elapsed())

        def elapsed(self):

                return None if self.__donetime is None else \

                    self.__donetime - self.__starttime

        def __str__(self):

                s = "<SpeedEstimator: "

                d = self.__dict__.copy()

                d.pop("_SpeedEstimator__deque")

                s += str(d)

                s += " __deque=["

                for x, (timestamp, nbytes) in enumerate(self.__deque):

                        if x % 3 == 0:

                                s += "\n    "

                        s += "(t=%.3f, b=%-5d), " % \

                            (timestamp - self.__starttime, nbytes)

                s += "]>"

                return s

class PrintTimer(object):

        """This helper class is used to implement damping of excessive

        printing by progress trackers.

        'print_value': This is a handy 'clicker' attribute which can be

        read to get a monotonically increasing count of the number of times

        time_to_print() has returned True.  Can be used to key a spinner,

        e.g.:

                print "%c" % (pt.print_value % len(__spinner_chars))

        """

        def __init__(self, delay):

                self.print_value = 0

                self.__delay = delay

                self.__last_print_time = 0

        def reset(self):

                self.__last_print_time = 0

        def reset_now(self):

                self.__last_print_time = time.time()

        #

        # See if it has been more than __delay time since the last time we

        # indicated that it was time to print.  If this returns true, the

        # caller should go ahead and print; this will not return true again

        # until the 'delay' period has elapsed again.

        #

        def time_to_print(self):

                tt = time.time()

                if (tt - self.__last_print_time) < self.__delay:

                        return False

                self.__last_print_time = tt

                self.print_value += 1

                return True

class OutSpec(object):

        """OutSpec is used by the progress tracker frontend to convey

        contextual information to backend routines about the output

        being requested.  'first' means "this is the first output

        for this group of items" (so perhaps print a header).

        'last' similarly means "this is the last output for this

        group of items."  Additional strings can be passed via

        the 'changed' list, denoting other events of significance."""

        def __init__(self, first=False, last=False, changed=None):

                self.first = first

                self.last = last

                self.changed = [] if changed is None else changed

        def __str__(self):

                s = "<outspec:"

                s += " +first" if self.first else ""

                s += " +last" if self.last else ""

                if self.changed:

                        for chg in self.changed:

                                s += " +'%s'" % str(chg)

                s += ">"

                return s

        def __nonzero__(self):

                return (bool(self.first) or bool(self.last) or

                    bool(self.changed))

class TrackerItem(object):

        """This class describes an item of interest in tracking progress

        against some "bucket" of work (for example, searching a filesystem for

        some item).

        This provides a way to wrap together begin and end times of the

        operation, the operation's name, and 'curinfo'-- some additional

        tidbit of information (such as the current directory being scanned)."""

        def __init__(self, name):

                self.starttime = -1 # signal setattr that we're in __init__.

                self.name = name

                self.endtime = None

                self.items = 0

                #

                # Used by clients to track if this item has been printed yet.

                # The object itself does not care about the value of this

                # attribute but will clear it on reset()

                #

                self.printed = False

                #

                # This attribute allows us to hang some client data

                # off of this object; use this to store some information

                # about the thing we're currently working on.

                #

                self.curinfo = None

                self.starttime = None # done constructing

        def reset(self):

                # This is a kludge but I can't find a better way to do this

                # and keep pylint's "definied outside of __init__" rule (W0201)

                # happy, without either repeating all of this code twice, or

                # disabling the rule file-wide.  Both of which seem even worse.

                self.__init__(self.name)

        def __setattr__(self, attrname, value):

                #

                # Start 'starttime' when 'items' is first set (even to zero)

                # Note that starttime is initially set to -1 to avoid starting

                # the timer during __init__().

                #

                # Special behavior only for 'items' and only when not resetting

                if attrname != "items" or self.starttime == -1:

                        self.__dict__[attrname] = value

                        return

                if self.starttime is None:

                        assert not getattr(self, "endtime", None), \

                            "can't set items after explicit done(). " \

                            "Tried to set %s=%s (is %s)" % \

                            (attrname, value, self.__dict__[attrname])

                        self.starttime = time.time()

                self.__dict__[attrname] = value

        def start(self):

                assert self.endtime is None

                if not self.starttime:

                        self.starttime = time.time()

        def done(self):

                self.endtime = time.time()

        def elapsed(self):

                if not self.starttime:

                        return 0.0

                endtime = self.endtime

                if endtime is None:

                        endtime = time.time()

                return endtime - self.starttime

        def __str__(self):

                info = ""

                if self.curinfo:

                        info = " (%s)" % str(self.curinfo)

                return "<%s: %s%s>" % (self.name, self.items, info)

class GoalTrackerItem(TrackerItem):

        """This class extends TrackerItem to include the notion of progress

        towards some goal which is known in advance of beginning the operation

        (such as downloading 37 packages).  In addition to the features of

        TrackerItem, this class provides helpful routines for conversion to

        printable strings of the form "  3/100"."""

        def __init__(self, name):

                TrackerItem.__init__(self, name)

                self.goalitems = None

        def reset(self):

                # See comment in superclass.

                self.__init__(self.name)

        # start 'starttime' when items gets set to non-zero

        def __setattr__(self, attrname, value):

                # Special behavior only for 'items' and only when not resetting

                if attrname != "items" or self.starttime == -1:

                        self.__dict__[attrname] = value

                        return

                assert not getattr(self, "endtime", None), \

                    "can't set values after explicit done(). " \

                    "Tried to set %s=%s (is %s)" % \

                    (attrname, value, self.__dict__[attrname])

                # see if this is the first time we're setting items

                if self.starttime is None:

                        if self.goalitems is None:

                                raise RuntimeError(

                                    "Cannot alter items until goalitems is set")

                        self.starttime = time.time()

                self.__dict__[attrname] = value

        def done(self, goalcheck=True):

                # Arguments number differs from overridden method;

                #     pylint: disable-msg=W0221

                TrackerItem.done(self)

                # See if we indeed met our goal.

                if goalcheck and not self.metgoal():

                        logger.error("\n" + exstr)

                        assert self.metgoal(), exstr

        def metgoal(self):

                if self.items == 0 and self.goalitems is None:

                        return True

                return self.items == self.goalitems

        def pair(self):

                if self.goalitems is None:

                        assert self.items == 0

                        return format_pair("%d", 0, 0)

                return format_pair("%d", self.items, self.goalitems)

        def pairplus1(self):

                # For use when you want to display something happening,

                # such as: Downloading item 3/3, since typically items is

                # not incremented until after the operation completes.

                #

                # To ensure that we don't print 4/3 in the last iteration of

                # output, we also account for that case.

                if self.goalitems is None:

                        assert self.items == 0

                        return format_pair("%d", 1, 1)

                if self.items == self.goalitems:

                        items = self.items

                else:

                        items = self.items + 1

                return format_pair("%d", items, self.goalitems)

        def pctdone(self):

                """Returns progress towards a goal as a percentage.

                i.e. 37 / 100 would yield 37.0"""

                if self.goalitems is None or self.goalitems == 0:

                        return 0

                return math.floor(100.0 *

                    float(self.items) / float(self.goalitems))