from __future__ import division

from __future__ import print_function

import inspect

import itertools

import math

import sys

import simplejson as json

import six

import time

from collections import deque

from functools import wraps

from six.moves import range

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

class ProgressTrackerException(Exception):

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

def __str__(self):

return "ProgressTrackerException: {0}".format(

" ".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

if scale:

v1 /= float(scale)

v2 /= float(scale)

realformat = format1

v2format = realformat.format(v2)

v2len = len(v2format)

if format2 and targetwidth and v2len > targetwidth:

# see if format2 is shorter.

# convert type 'float' to 'int'.

if "d" in format2:

v2format = format2.format(int(v2))

else:

v2format = format2.format(v2)

v2len1 = len(v2format)

if v2len1 < v2len:

realformat = format2

v2len = v2len1

formatcolon = realformat.find(":")

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

realformat[formatcolon + 1:]

if "d" in v1format:

return (v1format.format(int(v1))) + "/" + v2format

else:

return (v1format.format(v1)) + "/" + v2format

class SpeedEstimator(object):

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

# 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}")

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

speedstr = misc.bytes_to_str(speed,

"{num:d}{shortunit}")

speedstr += "/s"

return speedstr

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

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

# 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%.

# pylint is picky about this message:

# old-division; pylint: disable=W1619

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

self.__curtotal / 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.

#

self.__noestimate = bool(len(self.__deque) < 10 or

timelapse < (self.INTERVAL / 20.0))

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

try:

# pylint is picky about this message:

# old-division; pylint: disable=W1619

return self.goalbytes / self.elapsed()

except ZeroDivisionError:

return None

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={0:>.3f}, b={1:5d}), ".format(

timestamp - self.__starttime, nbytes)

s += "]>"

return s

class PrintTimer(object):

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

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

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 += " +'{0}'".format(str(chg))

s += ">"

return s

# Defining "boolness" of a class, Python 2 uses the special method

# called __nonzero__() while Python 3 uses __bool__(). For Python

# 2 and 3 compatibility, define __bool__() only, and let

# __nonzero__ = __bool__

def __bool__(self):

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

__nonzero__ = __bool__

class TrackerItem(object):

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

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 {0}={1} (is {2})".format(

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 = " ({0})".format(str(self.curinfo))

return "<{0}: {1}{2}>".format(self.name, self.items, info)

class GoalTrackerItem(TrackerItem):

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

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 {0}={1} (is {2})".format(

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=W0221

TrackerItem.done(self)

# See if we indeed met our goal.

if goalcheck and not self.metgoal():

exstr = _("Goal mismatch '{name}': "

"expected goal: {expected}, "

"current value: {current}").format(

name=self.name,

expected=self.goalitems,

current=self.items)

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("{0:d}", 0, 0)

return format_pair("{0: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("{0:d}", 1, 1)

if self.items == self.goalitems:

items = self.items

else:

items = self.items + 1

return format_pair("{0:d}", items, self.goalitems)

def pctdone(self):

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

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

return 0

# pylint is picky about this message:

# old-division; pylint: disable=W1619

return math.floor(100.0 *

self.items / self.goalitems)

def __str__(self):

info = ""

if self.curinfo:

info = " ({0})".format(str(self.curinfo))

return "<{0}: {1}{2}>".format(self.name, self.pair(), info)

def pt_abstract(func):

# Unused argument 'args', 'kwargs'; pylint: disable=W0613

@wraps(func)

def enforce_abstract(*args, **kwargs):

raise NotImplementedError("{0} is abstract in "

"superclass; you must implement it in your "

"subclass.".format(func.__name__))

return enforce_abstract

class ProgressTrackerBackend(object):

# allow def func(args): pass

# More than one statement on a line; pylint: disable=C0321

def __init__(self): pass

#

# This set of methods should be regarded as abstract *and* protected.

#

@pt_abstract

def _output_flush(self): pass

@pt_abstract

def _change_purpose(self, old_purpose, new_purpose): pass

@pt_abstract

def _cache_cats_output(self, outspec): pass

@pt_abstract

def _load_cat_cache_output(self, outspec): pass

@pt_abstract

def _refresh_output_progress(self, outspec): pass

@pt_abstract

def _plan_output(self, outspec, planitem): pass

@pt_abstract

def _plan_output_all_done(self): pass

@pt_abstract

def _mfst_fetch(self, outspec): pass

@pt_abstract

def _mfst_commit(self, outspec): pass

@pt_abstract

def _repo_ver_output(self, outspec, repository_scan=False): pass

@pt_abstract

def _repo_ver_output_error(self, errors): pass

@pt_abstract

def _repo_ver_output_done(self): pass

def _repo_fix_output(self, outspec): pass

@pt_abstract

def _repo_fix_output_error(self, errors): pass

@pt_abstract

def _repo_fix_output_info(self, errors): pass

@pt_abstract

def _repo_fix_output_done(self): pass

@pt_abstract

def _archive_output(self, outspec): pass

@pt_abstract

def _dl_output(self, outspec): pass

@pt_abstract

def _act_output(self, outspec, actionitem): pass

@pt_abstract

def _act_output_all_done(self): pass

@pt_abstract

def _job_output(self, outspec, jobitem): pass

@pt_abstract

def _republish_output(self, outspec): pass

@pt_abstract

def _lint_output(self, outspec): pass

@pt_abstract

def _li_recurse_start_output(self): pass

@pt_abstract

def _li_recurse_end_output(self): pass

@pt_abstract

def _li_recurse_output_output(self, lin, stdout, stderr): pass

@pt_abstract

def _li_recurse_status_output(self, done): pass

@pt_abstract

def _li_recurse_progress_output(self, lin): pass

@pt_abstract

def _reversion(self, pfmri, outspec): pass

class ProgressTrackerFrontend(object):

"""This essentially abstract class forms the interface that other

# More than one statement on a line; pylint: disable=C0321

# Major phases of operation

PHASE_PREPLAN = 1

PHASE_PLAN = 2

PHASE_DOWNLOAD = 3

PHASE_EXECUTE = 4

PHASE_FINALIZE = 5

# Extra phase used when we're doing some part of a subphase

# (such as rebuilding the search index) in a standalone operation.

PHASE_UTILITY = 6

MAJOR_PHASE = [PHASE_PREPLAN, PHASE_PLAN, PHASE_DOWNLOAD, PHASE_EXECUTE,

PHASE_FINALIZE, PHASE_UTILITY]

# Planning phases

PLAN_SOLVE_SETUP = 100

PLAN_SOLVE_SOLVER = 101

PLAN_FIND_MFST = 102

PLAN_PKGPLAN = 103

PLAN_ACTION_MERGE = 104

PLAN_ACTION_CONFLICT = 105

PLAN_ACTION_CONSOLIDATE = 106

PLAN_ACTION_MEDIATION = 107

PLAN_ACTION_FINALIZE = 108

PLAN_MEDIATION_CHG = 109 # for set-mediator

PLAN_PKG_VERIFY = 110

PLAN_PKG_FIX = 111

# Action phases

ACTION_REMOVE = 200

ACTION_INSTALL = 201

ACTION_UPDATE = 202

# Finalization/Job phases

JOB_STATE_DB = 300

JOB_IMAGE_STATE = 301

JOB_FAST_LOOKUP = 302

JOB_PKG_CACHE = 303

JOB_READ_SEARCH = 304

JOB_UPDATE_SEARCH = 305

JOB_REBUILD_SEARCH = 306

# pkgrepo job items

JOB_REPO_DELSEARCH = 307

JOB_REPO_UPDATE_CAT = 308

JOB_REPO_ANALYZE_RM = 309

JOB_REPO_ANALYZE_REPO = 310

JOB_REPO_RM_MFST = 311

JOB_REPO_RM_FILES = 312

JOB_REPO_VERIFY_REPO = 313

JOB_REPO_FIX_REPO = 314

# Operation purpose. This set of modes is used by callers to indicate

# to the progress tracker what's going on at a high level. This allows

# output to be customized by subclasses to meet the needs of a

# particular purpose.

#

# The purpose of current operations is in the "normal" set of things,

# including install, uninstall, change-variant, and other operations

# in which we can print arbitrary status information with impunity

#

PURPOSE_NORMAL = 0

#

# The purpose of current operations is in the service of trying to

# output a listing (list, contents, etc.) to the end user. Subclasses

# will likely want to suppress various bits of status (for non-tty

# output) or erase it (for tty output).

#

PURPOSE_LISTING = 1

#

# The purpose of current operations is in the service of figuring out

# if the packaging system itself is up to date.

#

PURPOSE_PKG_UPDATE_CHK = 2

#

# Types of lint phases

#

LINT_PHASETYPE_SETUP = 0

LINT_PHASETYPE_EXECUTE = 1

def __init__(self):

# needs to be here due to use of _()

self.phase_names = {

self.PHASE_PREPLAN: _("Startup"),

self.PHASE_PLAN: _("Planning"),

self.PHASE_DOWNLOAD: _("Download"),

self.PHASE_EXECUTE: _("Actions"),

self.PHASE_FINALIZE: _("Finalize"),

self.PHASE_UTILITY: "",

}

# find the widest string in the list of phases so we can

# set column width properly.

self.phase_max_width = \

max(len(x) for x in self.phase_names.values())

self.li_phase_names = {

self.PHASE_PREPLAN: _("Startup"),

self.PHASE_PLAN: _("Planning"),

self.PHASE_DOWNLOAD: _("Downloading"),

self.PHASE_FINALIZE: _("Executing"),

self.PHASE_UTILITY: _("Processing"),

}

@pt_abstract

def set_purpose(self, purpose): pass

@pt_abstract

def get_purpose(self): pass

@pt_abstract

def reset_download(self): pass

@pt_abstract

def reset(self): pass

@pt_abstract

def set_major_phase(self, majorphase): pass

@pt_abstract

def flush(self): pass

@pt_abstract

def cache_catalogs_start(self): pass

@pt_abstract

def cache_catalogs_done(self): pass

@pt_abstract

def load_catalog_cache_start(self): pass

@pt_abstract

def load_catalog_cache_done(self): pass

# fetching catalogs

@pt_abstract

def refresh_start(self, pub_cnt, full_refresh, target_catalog=False):

pass

@pt_abstract

def refresh_start_pub(self, pub): pass

@pt_abstract

def refresh_end_pub(self, pub): pass

@pt_abstract

def refresh_progress(self, pub, nbytes): pass

@pt_abstract

def refresh_done(self): pass

# planning an operation

@pt_abstract

def plan_all_start(self): pass

@pt_abstract

def plan_start(self, planid, goal=None): pass

@pt_abstract

def plan_add_progress(self, planid, nitems=1): pass

@pt_abstract

def plan_done(self, planid): pass

@pt_abstract

def plan_all_done(self): pass

# getting manifests over the network

@pt_abstract

def manifest_fetch_start(self, goal_mfsts): pass

@pt_abstract

def manifest_fetch_progress(self, completion): pass

@pt_abstract

def manifest_commit(self): pass

@pt_abstract

def manifest_fetch_done(self): pass

# verifying the content of a repository

@pt_abstract

def repo_verify_start(self, npkgs): pass

@pt_abstract

def repo_verify_start_pkg(self, pkgfmri, repository_scan=False): pass

@pt_abstract

def repo_verify_add_progress(self, pkgfmri): pass

@pt_abstract

def repo_verify_yield_error(self, pkgfmri, errors): pass

@pt_abstract

def repo_verify_yield_warning(self, pkgfmri, warnings): pass

@pt_abstract

def repo_verify_yield_info(self, pkgfmri, info): pass

@pt_abstract

def repo_verify_end_pkg(self, pkgfmri): pass

@pt_abstract

def repo_verify_done(self): pass

# fixing the content of a repository

@pt_abstract

def repo_fix_start(self, npkgs): pass

@pt_abstract

def repo_fix_add_progress(self, pkgfmri): pass

@pt_abstract

def repo_fix_yield_error(self, pkgfmri, errors): pass

@pt_abstract

def repo_fix_yield_info(self, pkgfmri, info): pass

@pt_abstract

def repo_fix_done(self): pass

# archiving to .p5p files

@pt_abstract

def archive_set_goal(self, arcname, nitems, nbytes): pass

@pt_abstract

def archive_add_progress(self, nitems, nbytes): pass

@pt_abstract

def archive_done(self): pass

# Called when bits arrive, either from on-disk cache or over-the-wire.

@pt_abstract

def download_set_goal(self, npkgs, nfiles, nbytes): pass

@pt_abstract

def download_start_pkg(self, pkgfmri): pass

@pt_abstract

def download_end_pkg(self, pkgfmri): pass

@pt_abstract

def download_add_progress(self, nfiles, nbytes, cachehit=False):

"""Call to provide news that the download has made progress."""

pass

@pt_abstract

def download_done(self, dryrun=False):

"""Call when all downloading is finished."""

pass

@pt_abstract

def download_get_progress(self): pass

# Running actions

@pt_abstract

def actions_set_goal(self, actionid, nactions): pass

@pt_abstract

def actions_add_progress(self, actionid): pass

@pt_abstract

def actions_done(self, actionid): pass

@pt_abstract

def actions_all_done(self): pass

@pt_abstract

def job_start(self, jobid, goal=None): pass

@pt_abstract

def job_add_progress(self, jobid, nitems=1): pass

@pt_abstract

def job_done(self, jobid): pass

@pt_abstract

def republish_set_goal(self, npkgs, ngetbytes, nsendbytes): pass

@pt_abstract

def republish_start_pkg(self, pkgfmri, getbytes=None, sendbytes=None):

pass

@pt_abstract

def republish_end_pkg(self, pkgfmri): pass

@pt_abstract

def upload_add_progress(self, nbytes):

"""Call to provide news that the upload has made progress."""

pass

@pt_abstract

def republish_done(self, dryrun=False):

"""Call when all republishing is finished."""

pass

@pt_abstract

def lint_next_phase(self, goalitems, lint_phasetype):

"""Call to indicate a new phase of lint progress."""

pass

@pt_abstract

def lint_add_progress(self): pass

@pt_abstract

def lint_done(self): pass

@pt_abstract

def set_linked_name(self, lin):

"""Called once an image determines its linked image name."""

pass

@pt_abstract

def li_recurse_start(self, pkg_op, total):

"""Call when we recurse into a child linked image."""

pass

@pt_abstract

def li_recurse_end(self):

"""Call when we return from a child linked image."""

pass

@pt_abstract

def li_recurse_status(self, lin_running, done):

"""Call to update the progress tracker with the list of

pass

@pt_abstract

def li_recurse_output(self, lin, stdout, stderr):

"""Call to display output from linked image operations."""

pass

@pt_abstract

def li_recurse_progress(self, lin):

"""Call to indicate that the named child made progress."""

pass

@pt_abstract

def reversion_start(self, goal_pkgs, goal_revs): pass

@pt_abstract

def reversion_add_progress(self, pfmri, pkgs=0, reversioned=0,

adjusted=0):

pass

@pt_abstract

def reversion_done(self): pass

class ProgressTracker(ProgressTrackerFrontend, ProgressTrackerBackend):

"""This class is used by the client to render and track progress

DL_MODE_DOWNLOAD = 1

DL_MODE_REPUBLISH = 2

def __init__(self):

ProgressTrackerBackend.__init__(self)

ProgressTrackerFrontend.__init__(self)

self.reset()

def reset_download(self):

# Attribute defined outside __init__; pylint: disable=W0201

self.dl_mode = None

self.dl_estimator = None

self.dl_pkgs = GoalTrackerItem(_("Download packages"))

self.dl_files = GoalTrackerItem(_("Download files"))

self.dl_bytes = GoalTrackerItem(_("Download bytes"))

self._dl_items = [self.dl_pkgs, self.dl_files, self.dl_bytes]

# republishing support; republishing also uses dl_bytes

self.repub_pkgs = \

GoalTrackerItem(_("Republished pkgs"))

self.repub_send_bytes = \

GoalTrackerItem(_("Republish sent bytes"))

def reset(self):

# Attribute defined outside __init__; pylint: disable=W0201

self.major_phase = self.PHASE_PREPLAN

self.purpose = self.PURPOSE_NORMAL

self.pub_refresh = GoalTrackerItem(_("Refresh Publishers"))

# We don't know the goal in advance for this one

self.pub_refresh_bytes = TrackerItem(_("Refresh bytes"))

self.refresh_target_catalog = None

self.refresh_full_refresh = False

self.mfst_fetch = GoalTrackerItem(_("Download Manifests"))

self.mfst_commit = GoalTrackerItem(_("Committed Manifests"))

self.repo_ver_pkgs = GoalTrackerItem(

_("Verify Repository Content"))

self.repo_fix = GoalTrackerItem(_("Fix Repository Content"))

# archiving support

self.archive_items = GoalTrackerItem(_("Archived items"))

self.archive_bytes = GoalTrackerItem(_("Archived bytes"))

# reversioning support

self.reversion_pkgs = GoalTrackerItem(_("Processed Packages"))

self.reversion_revs = GoalTrackerItem(_("Reversioned Packages"))

self.reversion_adjs = GoalTrackerItem(_("Adjusted Packages"))

# Used to measure elapsed time of entire planning; not otherwise

# rendered to the user.

self.plan_generic = TrackerItem("")

self._planitems = {

self.PLAN_SOLVE_SETUP:

TrackerItem(_("Solver setup")),

self.PLAN_SOLVE_SOLVER:

TrackerItem(_("Running solver")),

self.PLAN_FIND_MFST:

TrackerItem(_("Finding local manifests")),

self.PLAN_PKGPLAN:

GoalTrackerItem(_("Package planning")),

self.PLAN_ACTION_MERGE:

TrackerItem(_("Merging actions")),

self.PLAN_ACTION_CONFLICT:

TrackerItem(_("Checking for conflicting actions")),

self.PLAN_ACTION_CONSOLIDATE:

TrackerItem(_("Consolidating action changes")),

self.PLAN_ACTION_MEDIATION:

TrackerItem(_("Evaluating mediators")),

self.PLAN_ACTION_FINALIZE:

TrackerItem(_("Finalizing action plan")),

self.PLAN_MEDIATION_CHG:

TrackerItem(_("Evaluating mediator changes")),

self.PLAN_PKG_VERIFY:

GoalTrackerItem(_("Verifying Packages")),

self.PLAN_PKG_FIX:

GoalTrackerItem(_("Fixing Packages")),

}

self._actionitems = {

self.ACTION_REMOVE:

GoalTrackerItem(_("Removing old actions")),

self.ACTION_INSTALL:

GoalTrackerItem(_("Installing new actions")),

self.ACTION_UPDATE:

GoalTrackerItem(_("Updating modified actions")),

}

self._jobitems = {

self.JOB_STATE_DB:

TrackerItem(_("Updating package state database")),

self.JOB_IMAGE_STATE:

TrackerItem(_("Updating image state")),

self.JOB_FAST_LOOKUP:

TrackerItem(_("Creating fast lookup database")),

self.JOB_PKG_CACHE:

GoalTrackerItem(_("Updating package cache")),

self.JOB_READ_SEARCH:

TrackerItem(_("Reading search index")),

self.JOB_UPDATE_SEARCH:

GoalTrackerItem(_("Updating search index")),

self.JOB_REBUILD_SEARCH:

GoalTrackerItem(_("Building new search index")),

# pkgrepo job items

self.JOB_REPO_DELSEARCH:

TrackerItem(_("Deleting search index")),

self.JOB_REPO_UPDATE_CAT:

TrackerItem(_("Updating catalog")),

self.JOB_REPO_ANALYZE_RM:

GoalTrackerItem(_("Analyzing removed packages")),

self.JOB_REPO_ANALYZE_REPO:

GoalTrackerItem(_("Analyzing repository packages")),

self.JOB_REPO_RM_MFST:

GoalTrackerItem(_("Removing package manifests")),

self.JOB_REPO_RM_FILES:

GoalTrackerItem(_("Removing package files")),

self.JOB_REPO_VERIFY_REPO:

GoalTrackerItem(_("Verifying repository content")),

self.JOB_REPO_FIX_REPO:

GoalTrackerItem(_("Fixing repository content"))

}

self.reset_download()

self._archive_name = None

# Lint's interaction with the progresstracker probably

# needs further work.

self.lint_phase = None

self.lint_phasetype = None

# This GoalTrackerItem is created on the fly.

self.lintitems = None

# Linked images

self.linked_name = None

self.linked_running = []

self.linked_pkg_op = None

self.linked_total = 0

def set_major_phase(self, majorphase):

# Attribute defined outside __init__; pylint: disable=W0201

self.major_phase = majorphase

def flush(self):

"""Used to signal to the progresstracker that it should make

self._output_flush()

def set_purpose(self, purpose):

op = self.purpose

self.purpose = purpose # pylint: disable=W0201

if op != self.purpose:

self._change_purpose(op, purpose)

def get_purpose(self):

return self.purpose

def cache_catalogs_start(self):

self._cache_cats_output(OutSpec(first=True))

def cache_catalogs_done(self):

self._cache_cats_output(OutSpec(last=True))

def load_catalog_cache_start(self):

self._load_cat_cache_output(OutSpec(first=True))

def load_catalog_cache_done(self):

self._load_cat_cache_output(OutSpec(last=True))

def refresh_start(self, pub_cnt, full_refresh, target_catalog=False):

#

# We can wind up doing multiple refreshes in some cases,

# for example when we have to check if pkg(7) is up-to-date,

# so we reset these each time we start.

#

self.pub_refresh.reset()

self.pub_refresh.goalitems = pub_cnt

self.pub_refresh_bytes.reset()

# Attribute defined outside __init__; pylint: disable=W0201

self.refresh_full_refresh = full_refresh

self.refresh_target_catalog = target_catalog

if self.refresh_target_catalog:

assert self.refresh_full_refresh

def refresh_start_pub(self, pub):

outspec = OutSpec()

# for now we only refresh one at a time, so we stash

# this here, and then assert for it in end_pub and

# in refresh_progress.

self.pub_refresh.curinfo = pub

if not self.pub_refresh.printed:

outspec.first = True

outspec.changed.append("startpublisher")

self.pub_refresh.printed = True

self._refresh_output_progress(outspec)

def refresh_end_pub(self, pub):

assert pub == self.pub_refresh.curinfo

assert self.pub_refresh.printed

outspec = OutSpec()

outspec.changed.append("endpublisher")

self.pub_refresh.items += 1

self._refresh_output_progress(outspec)

def refresh_progress(self, pub, nbytes):

# when called back from the transport we lose the knowledge

# of what 'pub' is, at least for now.

assert pub is None or pub == self.pub_refresh.curinfo

assert self.pub_refresh.printed

self.pub_refresh_bytes.items += nbytes

self._refresh_output_progress(OutSpec())

def refresh_done(self):

# If refreshes fail, we might not meet the goal.

self.pub_refresh.done(goalcheck=False)

self.pub_refresh_bytes.done()

self._refresh_output_progress(OutSpec(last=True))

def plan_all_start(self):

self.set_major_phase(self.PHASE_PLAN)

self.plan_generic.reset()

self.plan_generic.start()

def plan_start(self, planid, goal=None):

planitem = self._planitems[planid]

planitem.reset()

if goal:

if not isinstance(planitem, GoalTrackerItem):

raise RuntimeError(

"can't set goal on non-goal tracker")

planitem.goalitems = goal

planitem.start()

def plan_add_progress(self, planid, nitems=1):

planitem = self._planitems[planid]

outspec = OutSpec(first=not planitem.printed)

planitem.items += nitems

self._plan_output(outspec, planitem)

planitem.printed = True

def plan_done(self, planid):

planitem = self._planitems[planid]

planitem.done()

if planitem.printed:

self._plan_output(OutSpec(last=True), planitem)

def plan_all_done(self):

self.plan_generic.done()

self._plan_output_all_done()

def manifest_fetch_start(self, goal_mfsts):

self.mfst_fetch.reset()

self.mfst_commit.reset()

self.mfst_fetch.goalitems = goal_mfsts

self.mfst_commit.goalitems = goal_mfsts

def manifest_fetch_progress(self, completion):

assert self.major_phase in [self.PHASE_PLAN, self.PHASE_UTILITY]

outspec = OutSpec(first=not self.mfst_fetch.printed)

self.mfst_fetch.printed = True

if completion:

self.mfst_fetch.items += 1

outspec.changed.append("manifests")

self._mfst_fetch(outspec)

def manifest_commit(self):

assert self.major_phase in [self.PHASE_PLAN, self.PHASE_UTILITY]

outspec = OutSpec(first=not self.mfst_commit.printed)

self.mfst_commit.printed = True

self.mfst_commit.items += 1

self._mfst_commit(outspec)

def manifest_fetch_done(self):

# These can fail to reach their goals due to various transport

# errors, depot misconfigurations, etc. So disable goal check.

self.mfst_fetch.done(goalcheck=False)

self.mfst_commit.done(goalcheck=False)

if self.mfst_fetch.printed:

self._mfst_fetch(OutSpec(last=True))

def repo_verify_start(self, npkgs):

self.repo_ver_pkgs.reset()

self.repo_ver_pkgs.goalitems = npkgs

def repo_verify_start_pkg(self, pkgfmri, repository_scan=False):

if pkgfmri != self.repo_ver_pkgs.curinfo:

self.repo_ver_pkgs.items += 1

self.repo_ver_pkgs.curinfo = pkgfmri

self._repo_ver_output(OutSpec(changed=["startpkg"]),

repository_scan=repository_scan)

def repo_verify_add_progress(self, pkgfmri):

self._repo_ver_output(OutSpec())

def repo_verify_yield_error(self, pkgfmri, errors):

self._repo_ver_output_error(errors)

def repo_verify_end_pkg(self, pkgfmri):

self._repo_ver_output(OutSpec(changed=["endpkg"]))

self.repo_ver_pkgs.curinfo = None

def repo_verify_done(self):

self.repo_ver_pkgs.done()

def repo_fix_start(self, nitems):

self.repo_fix.reset()

self.repo_fix.goalitems = nitems

def repo_fix_add_progress(self, pkgfmri):

self._repo_fix_output(OutSpec())

def repo_fix_yield_error(self, pkgfmri, errors):

self._repo_fix_output_error(errors)

def repo_fix_yield_info(self, pkgfmri, info):

self._repo_fix_output_info(info)

def repo_fix_done(self):

self.repo_fix.done()

def archive_set_goal(self, arcname, nitems, nbytes):

self._archive_name = arcname # pylint: disable=W0201

self.archive_items.goalitems = nitems

self.archive_bytes.goalitems = nbytes

def archive_add_progress(self, nitems, nbytes):

outspec = OutSpec()

if not self.archive_bytes.printed:

self.archive_bytes.printed = True

outspec.first = True

self.archive_items.items += nitems

self.archive_bytes.items += nbytes

self._archive_output(outspec)

def archive_done(self):

"""Call when all archiving is finished"""

self.archive_items.done()

self.archive_bytes.done()

# only print 'last' if we printed 'first'

if self.archive_bytes.printed:

self._archive_output(OutSpec(last=True))

def download_set_goal(self, npkgs, nfiles, nbytes):

# Attribute defined outside __init__; pylint: disable=W0201

self.dl_mode = self.DL_MODE_DOWNLOAD

self.dl_pkgs.goalitems = npkgs

self.dl_files.goalitems = nfiles

self.dl_bytes.goalitems = nbytes

self.dl_estimator = SpeedEstimator(self.dl_bytes.goalitems)

def download_start_pkg(self, pkgfmri):

self.set_major_phase(self.PHASE_DOWNLOAD)

self.dl_pkgs.curinfo = pkgfmri

outspec = OutSpec(changed=["startpkg"])

if self.dl_bytes.goalitems != 0:

if not self.dl_bytes.printed:

# indicate that this is the first _dl_output

# call

self.dl_bytes.printed = True

self.dl_estimator.start()

outspec.first = True

self._dl_output(outspec)

def download_end_pkg(self, pkgfmri):

self.dl_pkgs.items += 1

if self.dl_bytes.goalitems != 0:

self._dl_output(OutSpec(changed=["endpkg"]))

def download_add_progress(self, nfiles, nbytes, cachehit=False):

"""Call to provide news that the download has made progress"""

#

# These guards are present because download_add_progress can

# be called when an *upload* aborts; we want to prevent updates

# to these items, since they in this case might have no goals.

#

if self.dl_bytes.goalitems > 0:

self.dl_bytes.items += nbytes

if self.dl_files.goalitems > 0:

self.dl_files.items += nfiles

if cachehit:

self.dl_estimator.goalbytes -= nbytes

else:

self.dl_estimator.newdata(nbytes)

if self.dl_bytes.goalitems != 0:

outspec = OutSpec()

if nbytes > 0:

outspec.changed.append("dl_bytes")

if nfiles > 0:

outspec.changed.append("dl_files")

if self.dl_mode == self.DL_MODE_DOWNLOAD:

self._dl_output(outspec)

if self.dl_mode == self.DL_MODE_REPUBLISH:

self._republish_output(outspec)

def download_done(self, dryrun=False):

"""Call when all downloading is finished."""

if dryrun:

# Dryrun mode is used by pkgrecv in order to

# simulate a download; we do what we have to

# in order to fake up a download result.

self.dl_pkgs.items = self.dl_pkgs.goalitems

self.dl_files.items = self.dl_files.goalitems

self.dl_bytes.items = self.dl_bytes.goalitems

self.dl_estimator.start(timestamp=0)

self.dl_estimator.newdata(self.dl_bytes.goalitems,

timestamp=0)

self.dl_estimator.done(timestamp=0)

else:

self.dl_estimator.done()

self.dl_pkgs.done()

self.dl_files.done()

self.dl_bytes.done()

if self.dl_bytes.goalitems != 0:

self._dl_output(OutSpec(last=True))

def actions_set_goal(self, actionid, nactions):

"""Called to set the goal for a particular phase of action

assert self.major_phase == self.PHASE_EXECUTE

actionitem = self._actionitems[actionid]

actionitem.reset()

actionitem.goalitems = nactions

def actions_add_progress(self, actionid):

assert self.major_phase == self.PHASE_EXECUTE

actionitem = self._actionitems[actionid]

actionitem.items += 1

self._act_output(OutSpec(first=(actionitem.items == 1)),

actionitem)

def actions_done(self, actionid):

"""Called when done each phase of actions processing."""

assert self.major_phase == self.PHASE_EXECUTE

actionitem = self._actionitems[actionid]

actionitem.done()

if actionitem.goalitems != 0:

self._act_output(OutSpec(last=True), actionitem)

def actions_all_done(self):

total_actions = sum(x.items for x in self._actionitems.values())

if total_actions != 0:

self._act_output_all_done()

def job_start(self, jobid, goal=None):

jobitem = self._jobitems[jobid]

jobitem.reset()

outspec = OutSpec()

if goal:

if not isinstance(jobitem, GoalTrackerItem):

raise RuntimeError(

"can't set goal on non-goal tracker")

jobitem.goalitems = goal

jobitem.printed = True

self._job_output(outspec, jobitem)

def job_add_progress(self, jobid, nitems=1):

jobitem = self._jobitems[jobid]

outspec = OutSpec(first=not jobitem.printed)

jobitem.printed = True

jobitem.items += nitems

self._job_output(outspec, jobitem)

def job_done(self, jobid):

jobitem = self._jobitems[jobid]

# only print the 'done' if we printed the 'start'

jobitem.done()

if jobitem.printed:

self._job_output(OutSpec(last=True), jobitem)

def republish_set_goal(self, npkgs, ngetbytes, nsendbytes):

self.dl_mode = self.DL_MODE_REPUBLISH # pylint: disable=W0201

self.repub_pkgs.goalitems = npkgs

self.repub_send_bytes.goalitems = nsendbytes

self.dl_bytes.goalitems = ngetbytes

# We don't have a good value to set this to.

self.dl_files.goalitems = 1 << 64

# Attribute defined outside __init__; pylint: disable=W0201

self.dl_estimator = SpeedEstimator(self.dl_bytes.goalitems)

def republish_start_pkg(self, pkgfmri, getbytes=None, sendbytes=None):

assert isinstance(pkgfmri, pkg.fmri.PkgFmri)

if getbytes is not None:

# Allow reset of GET and SEND amounts on a per-package

# basis. This allows the user to monitor the overall

# progress of the operation in terms of total packages

# while not requiring the program to pre-process all

# packages to determine total byte sizes before starting

# the operation.

assert sendbytes is not None

self.dl_bytes.items = 0

self.dl_bytes.goalitems = getbytes

self.dl_estimator.goalbytes = getbytes

self.repub_send_bytes.items = 0

self.repub_send_bytes.goalitems = sendbytes

self.repub_pkgs.curinfo = pkgfmri

outspec = OutSpec(changed=["startpkg"])

#

# We can't do our normal trick of checking to see if

# dl_bytes.items is zero because it might have been reset

# above.

#

if not self.repub_pkgs.printed:

# indicate that this is the first _republish_output call

outspec.first = True

self.repub_pkgs.printed = True

self.dl_estimator.start()

if self.repub_pkgs.goalitems != 0:

self._republish_output(outspec)

def republish_end_pkg(self, pkgfmri):

self.repub_pkgs.items += 1

self._republish_output(OutSpec(changed=["endpkg"]))

def upload_add_progress(self, nbytes):

"""Call to provide news that the upload has made progress"""

#

# upload_add_progress can be called when a *download* aborts;

# this guard prevents us from updating the item (which has

# no goal set, and will raise an exception).

#

if self.repub_send_bytes.goalitems and \

self.repub_send_bytes.goalitems > 0:

self.repub_send_bytes.items += nbytes

self._republish_output(OutSpec())

def republish_done(self, dryrun=False):

"""Call when all republishing is finished"""

if dryrun:

self.repub_pkgs.items = self.repub_pkgs.goalitems

self.repub_send_bytes.items = \

self.repub_send_bytes.goalitems

self.dl_bytes.items = self.dl_bytes.goalitems

self.repub_pkgs.done()

self.repub_send_bytes.done()

self.dl_bytes.done()

if self.repub_pkgs.goalitems != 0:

outspec = OutSpec(last=True)

# Get the header printed if we've not printed

# anything else thus far (happens in dryrun mode).

outspec.first = not self.repub_pkgs.printed

self._republish_output(outspec)

self.repub_pkgs.printed = True

def lint_next_phase(self, goalitems, lint_phasetype):

# Attribute defined outside __init__; pylint: disable=W0201

self.lint_phasetype = lint_phasetype

if self.lint_phase is not None:

self._lint_output(OutSpec(last=True))

if self.lint_phase is None:

self.lint_phase = 0

self.lint_phase += 1

if lint_phasetype == self.LINT_PHASETYPE_SETUP:

phasename = _("Lint setup {0:d}".format(

self.lint_phase))

else:

phasename = _("Lint phase {0:d}".format(

self.lint_phase))

self.lintitems = GoalTrackerItem(phasename)

self.lintitems.goalitems = goalitems

self._lint_output(OutSpec(first=True))

def lint_add_progress(self):

self.lintitems.items += 1

self._lint_output(OutSpec())

def lint_done(self):

self.lint_phase = None # pylint: disable=W0201

if self.lintitems:

self._lint_output(OutSpec(last=True))

def set_linked_name(self, lin):

"""Called once an image determines its linked image name."""

self.linked_name = lin # pylint: disable=W0201

def li_recurse_start(self, pkg_op, total):

"""Called when we recurse into a child linked image."""

# Attribute defined outside __init__; pylint: disable=W0201

self.linked_pkg_op = pkg_op

self.linked_total = total

self._li_recurse_start_output()

def li_recurse_end(self):

"""Called when we return from a child linked image."""

self._li_recurse_end_output()

def li_recurse_status(self, lin_running, done):

"""Call to update the progress tracker with the list of

# Attribute defined outside __init__; pylint: disable=W0201

self.linked_running = sorted(lin_running)

self._li_recurse_status_output(done)

def li_recurse_output(self, lin, stdout, stderr):

"""Call to display output from linked image operations."""

self._li_recurse_output_output(lin, stdout, stderr)

def li_recurse_progress(self, lin):

"""Call to indicate that the named child made progress."""

self._li_recurse_progress_output(lin)

def reversion_start(self, goal_pkgs, goal_revs):

self.reversion_adjs.reset()

self.reversion_revs.reset()

self.reversion_pkgs.reset()

self.reversion_revs.goalitems = goal_revs

self.reversion_pkgs.goalitems = goal_pkgs

self.reversion_adjs.goalitems = -1

def reversion_add_progress(self, pfmri, pkgs=0, reversioned=0,

adjusted=0):

outspec = OutSpec()

if not self.reversion_pkgs.printed:

self.reversion_pkgs.printed = True

outspec.first = True

self.reversion_revs.items += reversioned

self.reversion_adjs.items += adjusted

self.reversion_pkgs.items += pkgs

self._reversion(pfmri, outspec)

def reversion_done(self):

self.reversion_pkgs.done()

self.reversion_revs.done()

self.reversion_adjs.done(goalcheck=False)

if self.reversion_pkgs.printed:

self._reversion("Done", OutSpec(last=True))

class MultiProgressTracker(ProgressTrackerFrontend):

"""This class is a proxy, dispatching incoming progress tracking calls

def __init__(self, ptlist):

ProgressTrackerFrontend.__init__(self)

self._trackers = [t for t in ptlist]

if len(self._trackers) == 0:

raise ProgressTrackerException("No trackers specified")

#

# Returns a multido closure, which will iterate and call the

# named method for each tracker registered with the class.

#

def make_multido(method_name):

# self and method_name are bound in this context.

def multido(*args, **kwargs):

for trk in self._trackers:

f = getattr(trk, method_name)

f(*args, **kwargs)

return multido

#

# Look in the ProgressTrackerFrontend for a list of frontend

# methods to multiplex.

#

for methname, m in six.iteritems(

ProgressTrackerFrontend.__dict__):

if methname == "__init__":

continue

if not inspect.isfunction(m):

continue

# Override all methods which aren't the constructor.

# Yes, this is a big hammer.

setattr(self, methname, make_multido(methname))

return

class QuietProgressTracker(ProgressTracker):

"""This progress tracker outputs nothing, but is semantically

#

# At construction, we inspect the ProgressTrackerBackend abstract

# superclass, and implement all of its methods as empty stubs.

#

def __init__(self):

ProgressTracker.__init__(self)

# We modify the object such that all of the methods it needs to

# implement are set to this __donothing empty method.

def __donothing(*args, **kwargs):

# Unused argument 'args', 'kwargs';

# pylint: disable=W0613

pass

for methname in ProgressTrackerBackend.__dict__:

if methname == "__init__":

continue

boundmeth = getattr(self, methname)

if not inspect.ismethod(boundmeth):

continue

setattr(self, methname, __donothing)

class NullProgressTracker(QuietProgressTracker):

"""This ProgressTracker is a subclass of QuietProgressTracker because

class FunctionProgressTracker(ProgressTracker):

"""This ProgressTracker is principally used for debugging.

#

# When an instance of this class is initialized, we use inspection to

# insert a new method for each method; for frontend methods "chain"

# the old one behind the new one. The new method dumps out the

# arguments.

#

def __init__(self, output_file=sys.stdout):

ProgressTracker.__init__(self)

self.output_file = output_file

def __donothing(*args, **kwargs):

# Unused argument 'args', 'kwargs';

# pylint: disable=W0613

pass

# We modify the instance such that all of the methods it needs

# to implement are set to this __printargs method.

def make_printargs(methname, chainedmeth):

def __printargs(*args, **kwargs):

s = ""

for x in args:

s += "{0}, ".format(str(x))

for x in sorted(kwargs):

s += "{0}={1}, ".format(x, kwargs[x])

s = s[:-2]

#

# Invoke chained method implementation; it's

# counter-intuitive, but we do this before

# printing things out, because under the

# circumstances we create in

# test_progress_tracker(), the chained method

# could throw an exception, aborting an

# upstream MultiProgressTracker's multido(),

# and spoiling the test_multi() test case.

#

chainedmeth(*args, **kwargs)

print("{0}({1})".format(methname, s),

file=self.output_file)

return __printargs

for methname in ProgressTrackerFrontend.__dict__:

if methname == "__init__":

continue

#

# this gets us the bound method, which we say here

# is "chained"-- we'll call it next after our inserted

# method.

#

chainedmeth = getattr(self, methname, None)

if not inspect.ismethod(chainedmeth):

continue

setattr(self, methname,

make_printargs(methname, chainedmeth))

for methname in ProgressTrackerBackend.__dict__:

if methname == "__init__":

continue

chainedmeth = getattr(self, methname, None)

if not inspect.ismethod(chainedmeth):

continue

chainedmeth = __donothing

setattr(self, methname,

make_printargs(methname, chainedmeth))

class DotProgressTracker(ProgressTracker):

"""This tracker writes a series of dots for every operation.

TERM_DELAY = 0.1

def __init__(self, output_file=sys.stdout, term_delay=TERM_DELAY):

ProgressTracker.__init__(self)

self._pe = printengine.POSIXPrintEngine(output_file,

ttymode=False)

self._ptimer = PrintTimer(term_delay)

def make_dot():

def dot(*args, **kwargs):

# Unused argument 'args', 'kwargs';

# pylint: disable=W0613

if self._ptimer.time_to_print():

self._pe.cprint(".", end='')

return dot

for methname in ProgressTrackerBackend.__dict__:

if methname == "__init__":

continue

boundmeth = getattr(self, methname, None)

if not inspect.ismethod(boundmeth):

continue

setattr(self, methname, make_dot())

class CommandLineProgressTracker(ProgressTracker):

"""This progress tracker is a generically useful tracker for command

# Default to printing periodic output every 5 seconds.

TERM_DELAY = 5.0

def __init__(self, output_file=sys.stdout, print_engine=None,

term_delay=TERM_DELAY):

ProgressTracker.__init__(self)

if not print_engine:

self._pe = printengine.POSIXPrintEngine(output_file,

ttymode=False)

else:

self._pe = print_engine

self._ptimer = PrintTimer(term_delay)

def _phase_prefix(self):

if self.major_phase == self.PHASE_UTILITY:

return ""

# The following string was originally expressed as

# "%*s: ". % \

# (self.phase_max_width, self.phase_names[self.major_phase]

# )

# however xgettext incorrectly flags this as an improper use of

# non-parameterized messages, which gets detected as an error

# during our build. So instead, we express the string using

# an equivalent <str>.format(..) function

s = _("{{phase:>{0:d}}}: ").format(self.phase_max_width)

return s.format(phase=self.phase_names[self.major_phase])

#

# Helper routines

#

def __generic_start(self, msg):

# In the case of listing/up-to-date check operations, we

# we don't want to output planning information, so skip.

if self.purpose != self.PURPOSE_NORMAL:

return

self._pe.cprint(self._phase_prefix() + msg, end='')

# indicate that we just printed.

self._ptimer.reset_now()

def __generic_done(self, msg=None):

# See __generic_start above.

if self.purpose != self.PURPOSE_NORMAL:

return

if msg is None:

msg = " " + _("Done")

self._pe.cprint(msg, end='\n')

self._ptimer.reset()

def __generic_done_item(self, item, msg=None):

# See __generic_start above.

if self.purpose != self.PURPOSE_NORMAL:

return

if msg is None:

if global_settings.client_output_verbose > 0:

msg = " " + _("Done ({elapsed:>.3f}s)")

else:

msg = " " + _("Done")

outmsg = msg.format(elapsed=item.elapsed())

self._pe.cprint(outmsg, end='\n')

self._ptimer.reset()

#

# Overridden methods from ProgressTrackerBackend

#

def _output_flush(self):

self._pe.flush()

def _change_purpose(self, op, np):

self._ptimer.reset()

if np == self.PURPOSE_PKG_UPDATE_CHK:

self._pe.cprint(self._phase_prefix() +

_("Checking that pkg(7) is up to date ..."), end='')

if op == self.PURPOSE_PKG_UPDATE_CHK:

self._pe.cprint(" " + _("Done"))

def _cache_cats_output(self, outspec):

if outspec.first:

self.__generic_start(_("Caching catalogs ..."))

if outspec.last:

self.__generic_done()

def _load_cat_cache_output(self, outspec):

if outspec.first:

self.__generic_start(_("Loading catalog cache ..."))

if outspec.last:

self.__generic_done()

def _refresh_output_progress(self, outspec):

# See __generic_start above.

if self.purpose != self.PURPOSE_NORMAL:

return

if "startpublisher" in outspec.changed:

p = self.pub_refresh.curinfo.prefix

if self.refresh_target_catalog:

m = _("Retrieving target catalog '{0}' "

"...").format(p)

elif self.refresh_full_refresh:

m = _("Retrieving catalog '{0}' ...").format(p)

else:

m = _("Refreshing catalog '{0}' ...").format(p)

self.__generic_start(m)

elif "endpublisher" in outspec.changed:

self.__generic_done()

def _plan_output(self, outspec, planitem):

if outspec.first:

self.__generic_start(_("{0} ...").format(planitem.name))

if outspec.last:

self.__generic_done_item(planitem)

def _plan_output_all_done(self):

self.__generic_done(self._phase_prefix() + \

_("Planning completed in {0:>.2f} seconds").format(

self.plan_generic.elapsed()))

def _mfst_fetch(self, outspec):

if not self._ptimer.time_to_print() and \

not outspec.first and not outspec.last:

return

if self.purpose != self.PURPOSE_NORMAL:

return

# Reset timer; this prevents double printing for

# outspec.first and then again for the timer expiration

if outspec.first:

self._ptimer.reset_now()

#

# There are a couple of reasons we might fetch manifests--

# pkgrecv, pkglint, etc. can all do this. _phase_prefix()

# adjusts the output based on the major phase.

#

self._pe.cprint(self._phase_prefix() +

_("Fetching manifests: {num} {pctcomplete}% "

"complete").format(

num=self.mfst_fetch.pair(),

pctcomplete=int(self.mfst_fetch.pctdone())))

def _mfst_commit(self, outspec):

# For now, manifest commit is hard to handle in this

# line-oriented prog tracker, as we alternate back and forth

# between fetching and committing, and we don't want to

# spam the user with this too much.

pass

def _repo_ver_output(self, outspec, repository_scan=False):

pass

def _repo_ver_output_error(self, errors):

self._pe.cprint(errors)

def _repo_ver_output_warning(self, warnings):

pass

def _repo_ver_output_info(self, info):

pass

def _repo_ver_output_done(self):

pass

def _repo_fix_output(self, outspec):

pass

def _repo_fix_output_error(self, errors):

self._pe.cprint(errors)

def _repo_fix_output_info(self, info):

self._pe.cprint(info)

def _repo_fix_output_done(self):

pass

def _dl_output(self, outspec):

if not self._ptimer.time_to_print() and not outspec.first and \

not outspec.last:

return

# Reset timer; this prevents double printing for

# outspec.first and then again for the timer expiration

if outspec.first:

self._ptimer.reset_now()

if not outspec.last:

speed = self.dl_estimator.get_speed_estimate()

else:

speed = self.dl_estimator.get_final_speed()

speedstr = "" if speed is None else \

"({0})".format(self.dl_estimator.format_speed(speed))

if not outspec.last:

# 'first' or time to print

mbs = format_pair("{0:.1f}", self.dl_bytes.items,

self.dl_bytes.goalitems, scale=(1024 * 1024))

self._pe.cprint(

_("Download: {num} items {mbs}MB "

"{pctcomplete}% complete {speed}").format(

num=self.dl_files.pair(), mbs=mbs,

pctcomplete=int(self.dl_bytes.pctdone()),

speed=speedstr))

else:

# 'last'

goal = misc.bytes_to_str(self.dl_bytes.goalitems)

self.__generic_done(

msg=_("Download: Completed {num} in {sec:>.2f} "

"seconds {speed}").format(

num=goal, sec=self.dl_estimator.elapsed(),

speed=speedstr))

def _republish_output(self, outspec):

if "startpkg" in outspec.changed:

pkgfmri = self.repub_pkgs.curinfo

self.__generic_start(_("Republish: {0} ... ").format(

pkgfmri.get_fmri(anarchy=True)))

if "endpkg" in outspec.changed:

self.__generic_done()

def _archive_output(self, outspec):

if not self._ptimer.time_to_print() and not outspec:

return

if outspec.first:

# tell ptimer that we just printed.

self._ptimer.reset_now()

if outspec.last:

goal = misc.bytes_to_str(self.archive_bytes.goalitems)

self.__generic_done(

msg=_("Archiving: Completed {num} in {secs:>.2f} "

"seconds").format(

num=goal, secs=self.archive_items.elapsed()))

return

mbs = format_pair("{0:.1f}", self.archive_bytes.items,

self.archive_bytes.goalitems, scale=(1024 * 1024))

self._pe.cprint(

_("Archiving: {pair} items {mbs}MB {pctcomplete}% "

"complete").format(

pair=self.archive_items.pair(), mbs=mbs,

pctcomplete=int(self.archive_bytes.pctdone())))

#

# The progress tracking infrastructure wants to tell us about each

# kind of action activity (install, remove, update). For this

# progress tracker, we don't really care to expose that to the user,

# so we work in terms of total actions instead.

#

def _act_output(self, outspec, actionitem):

if not self._ptimer.time_to_print() and not outspec.first:

return

# reset timer, since we're definitely printing now...

self._ptimer.reset_now()

total_actions = \

sum(x.items for x in self._actionitems.values())

total_goal = \

sum(x.goalitems for x in self._actionitems.values())

self._pe.cprint(self._phase_prefix() +

_("{num} actions ({type})").format(

num=format_pair("{0:d}", total_actions, total_goal),

type=actionitem.name))

def _act_output_all_done(self):

total_goal = \

sum(x.goalitems for x in self._actionitems.values())

total_time = \

sum(x.elapsed() for x in self._actionitems.values())

if total_goal == 0:

return

self._pe.cprint(self._phase_prefix() +

_("Completed {numactions:d} actions in {time:>.2f} "

"seconds.").format(

numactions=total_goal, time=total_time))

def _job_output(self, outspec, jobitem):

if outspec.first:

self.__generic_start("{0} ... ".format(jobitem.name))

if outspec.last:

self.__generic_done_item(jobitem)

def _lint_output(self, outspec):

if outspec.first:

if self.lint_phasetype == self.LINT_PHASETYPE_SETUP:

self._pe.cprint("{0} ... ".format(

self.lintitems.name), end='')

elif self.lint_phasetype == self.LINT_PHASETYPE_EXECUTE:

self._pe.cprint("# --- {0} ---".format(

self.lintitems.name))

if outspec.last:

if self.lint_phasetype == self.LINT_PHASETYPE_SETUP:

self.__generic_done()

elif self.lint_phasetype == self.LINT_PHASETYPE_EXECUTE:

pass

def _li_recurse_start_output(self):

if self.linked_pkg_op == pkgdefs.PKG_OP_PUBCHECK:

self.__generic_start(

_("Linked image publisher check ..."))

return

def _li_recurse_end_output(self):

if self.linked_pkg_op == pkgdefs.PKG_OP_PUBCHECK:

self.__generic_done()

return

self._pe.cprint(self._phase_prefix() +

_("Finished processing linked images."))

def __li_dump_output(self, output):

if not output:

return

lines = output.splitlines()

nlines = len(lines)

for linenum, line in enumerate(lines):

line = misc.force_str(line)

if linenum < nlines - 1:

self._pe.cprint("| " + line)

else:

if lines[linenum].strip() != "":

self._pe.cprint("| " + line)

self._pe.cprint("`")

def _li_recurse_output_output(self, lin, stdout, stderr):

if not stdout and not stderr:

return

self._pe.cprint(self._phase_prefix() +

_("Linked image '{0}' output:").format(lin))

self.__li_dump_output(stdout)

self.__li_dump_output(stderr)

def _li_recurse_status_output(self, done):

if self.linked_pkg_op == pkgdefs.PKG_OP_PUBCHECK:

return

running = " ".join([str(i) for i in self.linked_running])

msg = _("Linked images: {pair} done; {numworking:d} working: "

"{running}").format(

pair=format_pair("{0:d}", done, self.linked_total),

numworking=len(self.linked_running),

running=running)

self._pe.cprint(self._phase_prefix() + msg)

def _li_recurse_progress_output(self, lin):

if self.linked_pkg_op == pkgdefs.PKG_OP_PUBCHECK:

return

def _reversion(self, pfmri, outspec):

if not self._ptimer.time_to_print() and not outspec:

return

if outspec.first:

# tell ptimer that we just printed.

self._ptimer.reset_now()

if outspec.last:

self.__generic_done(

msg=_("Reversioned {revs} of {pkgs} packages "

"and adjusted {adjs} packages.").format(

revs=self.reversion_revs.items,

pkgs=self.reversion_pkgs.items,

adjs=self.reversion_adjs.items))

return

self._pe.cprint(

_("Reversioning: {pkgs} processed, {revs} reversioned, "

"{adjs} adjusted").format(

pkgs=self.reversion_pkgs.pair(),

revs=self.reversion_revs.pair(),

adjs=self.reversion_adjs.items))

class RADProgressTracker(CommandLineProgressTracker):

"""This progress tracker is a subclass of CommandLineProgressTracker

# Default to printing periodic output every 5 seconds.

TERM_DELAY = 5.0

# Output constants.

O_PHASE = "phase"

O_MESSAGE = "message"

O_TIME = "time_taken"

O_TIME_U = "time_unit"

O_TYPE = "type"

O_PRO_ITEMS = "processed_items"

O_GOAL_ITEMS = "goal_items"

O_PCT_DONE = "percent_done"

O_ITEM_U = "item_unit"

O_SPEED = "speed"

O_RUNNING = "running"

O_GOAL_PRO_ITEMS = "goal_processed_items"

O_REV_ITEMS = "reversioned_items"

O_GOAL_REV_ITEMS = "goal_reversion_items"

O_ADJ_ITEMS = "adjusted_items"

O_LI_OUTPUT = "li_output"

O_LI_ERROR = "li_errors"

def __init__(self, term_delay=TERM_DELAY, prog_event_handler=None):

CommandLineProgressTracker.__init__(self,

term_delay=term_delay)

self.__prog_event_handler = prog_event_handler

def _phase_prefix(self):

if self.major_phase == self.PHASE_UTILITY:

return "Utility"

return self.phase_names[self.major_phase]

#

# Helper routines

#

def __prep_prog_json(self, msg=None, phase=None, prog_json=None):

# prepare progress json.

phase_name = self._phase_prefix()

if phase:

phase_name = phase

if prog_json: