c7480644202e5451fbed448508ea29a25cffc99cTimo Sirainen

9625595c47c665f5aee57ebfcb1fcbe9ad1bf3a0Martti Rannanjärvi

c7480644202e5451fbed448508ea29a25cffc99cTimo SirainenPKG_CLIENT_NAME = "pkgrepo"

70bb16e72afdcd87b6294501d035d5ba1e35af5fTimo Sirainen

c7480644202e5451fbed448508ea29a25cffc99cTimo SirainenEXIT_OK = 0

74ae32512357bdd4872bf160dc697ff7b54b54c5Timo SirainenEXIT_OOPS = 1

74ae32512357bdd4872bf160dc697ff7b54b54c5Timo SirainenEXIT_BADOPT = 2

c7480644202e5451fbed448508ea29a25cffc99cTimo SirainenEXIT_PARTIAL = 3

LISTING_FORMATS = ("default", "json", "json-formatted", "tsv")

tmpdirs = []

import atexit

import collections

import copy

import errno

import getopt

import gettext

import locale

import logging

import os

import shlex

import shutil

import sys

import tempfile

import textwrap

import traceback

import warnings

import itertools

from pkg.client import global_settings

from pkg.client.debugvalues import DebugValues

from pkg.misc import msg, PipeError

import pkg

import pkg.catalog

import pkg.client.api_errors as apx

import pkg.client.pkgdefs as pkgdefs

import pkg.client.progress

import pkg.client.publisher as publisher

import pkg.client.transport.transport as transport

import pkg.misc as misc

import pkg.server.repository as sr

logger = global_settings.logger

@atexit.register

def cleanup():

"""To be called at program finish."""

for d in tmpdirs:

shutil.rmtree(d, True)

def error(text, cmd=None):

"""Emit an error message prefixed by the command name """

if cmd:

text = "{0}: {1}".format(cmd, text)

pkg_cmd = "pkgrepo "

else:

pkg_cmd = "pkgrepo: "

# If we get passed something like an Exception, we can convert

# it down to a string.

text = str(text)

# If the message starts with whitespace, assume that it should come

# *before* the command-name prefix.

text_nows = text.lstrip()

ws = text[:len(text) - len(text_nows)]

# This has to be a constant value as we can't reliably get our actual

# program name on all platforms.

logger.error(ws + pkg_cmd + text_nows)

def get_tracker(quiet=False):

if quiet:

progtrack = pkg.client.progress.QuietProgressTracker()

else:

try:

progtrack = \

pkg.client.progress.FancyUNIXProgressTracker()

except pkg.client.progress.ProgressTrackerException:

progtrack = \

pkg.client.progress.CommandLineProgressTracker()

return progtrack

def usage(usage_error=None, cmd=None, retcode=2, full=False):

"""Emit a usage message and optionally prefix it with a more

if usage_error:

error(usage_error, cmd=cmd)

if not full:

# The full usage message isn't desired.

logger.error(_("Try `pkgrepo --help or -?' for more "

"information."))

sys.exit(retcode)

msg(_("""\

Displays a usage message."""))

sys.exit(retcode)

class OptionError(Exception):

"""Option exception. """

def __init__(self, *args):

Exception.__init__(self, *args)

def parse_uri(uri):

"""Parse the repository location provided and attempt to transform it

return publisher.RepositoryURI(misc.parse_uri(uri))

def subcmd_remove(conf, args):

subcommand = "remove"

opts, pargs = getopt.getopt(args, "np:s:")

dry_run = False

pubs = set()

for opt, arg in opts:

if opt == "-n":

dry_run = True

elif opt == "-p":

pubs.add(arg)

elif opt == "-s":

conf["repo_uri"] = parse_uri(arg)

if not pargs:

usage(_("At least one package pattern must be provided."),

cmd=subcommand)

# Get repository object.

if not conf.get("repo_uri", None):

usage(_("A package repository location must be provided "

"using -s."), cmd=subcommand)

repo = get_repo(conf, read_only=False, subcommand=subcommand)

if "all" in pubs:

pubs = set()

# Find matching packages.

try:

matching, refs = repo.get_matching_fmris(pargs, pubs=pubs)

except apx.PackageMatchErrors as e:

error(str(e), cmd=subcommand)

return EXIT_OOPS

if dry_run:

# Don't make any changes; display list of packages to be

# removed and exit.

packages = set(f for m in matching.values() for f in m)

count = len(packages)

plist = "\n".join("\t{0}".format(

p.get_fmri(include_build=False))

for p in sorted(packages))

logger.info(_("{count:d} package(s) will be removed:\n"

"{plist}").format(**locals()))

return EXIT_OK

progtrack = get_tracker()

packages = collections.defaultdict(list)

for m in matching.values():

for f in m:

packages[f.publisher].append(f)

for pub in packages:

logger.info(

_("Removing packages for publisher {0} ...").format(pub))

repo.remove_packages(packages[pub], progtrack=progtrack,

pub=pub)

if len(packages) > 1:

# Add a newline between each publisher.

logger.info("")

return EXIT_OK

def get_repo(conf, allow_invalid=False, read_only=True, subcommand=None):

"""Return the repository object for current program configuration.

repo_uri = conf["repo_uri"]

if repo_uri.scheme != "file":

usage(_("Network repositories are not currently supported "

"for this operation."), cmd=subcommand)

path = repo_uri.get_pathname()

if not path:

# Bad URI?

raise sr.RepositoryInvalidError(str(repo_uri))

return sr.Repository(allow_invalid=allow_invalid, read_only=read_only,

root=path)

def setup_transport(conf, subcommand=None, prefix=None, verbose=False,

remote_prefix=True, ssl_key=None, ssl_cert=None):

repo_uri = conf.get("repo_uri", None)

if not repo_uri:

usage(_("No repository location specified."), cmd=subcommand)

global tmpdirs

temp_root = misc.config_temp_root()

tmp_dir = tempfile.mkdtemp(dir=temp_root)

tmpdirs.append(tmp_dir)

incoming_dir = tempfile.mkdtemp(dir=temp_root)

tmpdirs.append(incoming_dir)

cache_dir = tempfile.mkdtemp(dir=temp_root)

tmpdirs.append(cache_dir)

# Create transport and transport config.

xport, xport_cfg = transport.setup_transport()

xport_cfg.add_cache(cache_dir, readonly=False)

xport_cfg.incoming_root = incoming_dir

xport_cfg.pkg_root = tmp_dir

if not prefix:

pub = "target"

else:

pub = prefix

# Configure target publisher.

src_pub = transport.setup_publisher(str(repo_uri), pub, xport,

xport_cfg, remote_prefix=remote_prefix, ssl_key=ssl_key,

ssl_cert=ssl_cert)

return xport, src_pub, tmp_dir

def subcmd_add_publisher(conf, args):

"""Add publisher(s) to the specified repository."""

subcommand = "add-publisher"

opts, pargs = getopt.getopt(args, "s:")

for opt, arg in opts:

if opt == "-s":

conf["repo_uri"] = parse_uri(arg)

repo_uri = conf.get("repo_uri", None)

if not repo_uri:

usage(_("No repository location specified."), cmd=subcommand)

if repo_uri.scheme != "file":

usage(_("Network repositories are not currently supported "

"for this operation."), cmd=subcommand)

if not pargs:

usage(_("At least one publisher must be specified"),

cmd=subcommand)

abort = False

for pfx in pargs:

if not misc.valid_pub_prefix(pfx):

error(_("Invalid publisher prefix '{0}'").format(pfx),

cmd=subcommand)

abort = True

if abort:

return EXIT_OOPS

repo = get_repo(conf, read_only=False, subcommand=subcommand)

make_default = not repo.publishers

existing = repo.publishers & set(pargs)

# Elide the publishers that already exist, but retain the order

# publishers were specified in.

new_pubs = [

pfx for pfx in pargs

if pfx not in repo.publishers

]

# Tricky logic; _set_pub will happily add new publishers if necessary

# and not set any properties if you didn't specify any.

rval = _set_pub(conf, subcommand, {}, new_pubs, repo)

if make_default:

# No publisher existed previously, so set the default publisher

# to be the first new one that was added.

_set_repo(conf, subcommand, { "publisher": {

"prefix": new_pubs[0] } }, repo)

if rval == EXIT_OK and existing:

# Some of the publishers that were requested for addition

# were already known.

error(_("specified publisher(s) already exist: {0}").format(

", ".join(existing)), cmd=subcommand)

if new_pubs:

return EXIT_PARTIAL

return EXIT_OOPS

return rval

def subcmd_remove_publisher(conf, args):

"""Remove publisher(s) from a repository"""

subcommand = "remove-publisher"

dry_run = False

synch = False

opts, pargs = getopt.getopt(args, "ns:", ["synchronous"])

for opt, arg in opts:

if opt == "-s":

conf["repo_uri"] = parse_uri(arg)

elif opt == "-n":

dry_run = True

elif opt == "--synchronous":

synch = True

repo_uri = conf.get("repo_uri", None)

if not repo_uri:

usage(_("No repository location specified."), cmd=subcommand)

if repo_uri.scheme != "file":

usage(_("Network repositories are not currently supported "

"for this operation."), cmd=subcommand)

if not pargs:

usage(_("At least one publisher must be specified"),

cmd=subcommand)

inv_pfxs = []

for pfx in pargs:

if not misc.valid_pub_prefix(pfx):

inv_pfxs.append(pfx)

if inv_pfxs:

error(_("Invalid publisher prefix(es):\n {0}").format(

"\n ".join(inv_pfxs)), cmd=subcommand)

return EXIT_OOPS

repo = get_repo(conf, read_only=False, subcommand=subcommand)

existing = repo.publishers & set(pargs)

noexisting = [pfx for pfx in pargs

if pfx not in repo.publishers]

# Publishers left if remove succeeds.

left = [pfx for pfx in repo.publishers if pfx not in pargs]

if noexisting:

error(_("The following publisher(s) could not be found:\n "

"{0}").format("\n ".join(noexisting)), cmd=subcommand)

return EXIT_OOPS

logger.info(_("Removing publisher(s)"))

for pfx in existing:

rstore = repo.get_pub_rstore(pfx)

numpkg = rstore.catalog.package_count

logger.info(_("\'{pfx}\'\t({num} package(s))").format(

pfx=pfx, num=str(numpkg)))

if dry_run:

return EXIT_OK

defaultpfx = repo.cfg.get_property("publisher", "prefix")

repo_path = repo_uri.get_pathname()

repo.remove_publisher(existing, repo_path, synch)

# Change the repository publisher/prefix property, if necessary.

if defaultpfx in existing:

if len(left) == 1:

_set_repo(conf, subcommand, { "publisher" : {

"prefix" : left[0]} }, repo)

msg(_("The default publisher was removed."

" Setting 'publisher/prefix' to '{0}',"

" the only publisher left").format(left[0]))

else:

_set_repo(conf, subcommand, { "publisher": {

"prefix" : ""} }, repo)

msg(_("The default publisher was removed."

" The 'publisher/prefix' property has been"

" unset"))

return EXIT_OK

def subcmd_create(conf, args):

"""Create a package repository at the given location."""

subcommand = "create"

opts, pargs = getopt.getopt(args, "s:", ["version="])

version = None

for opt, arg in opts:

if opt == "-s":

conf["repo_uri"] = parse_uri(arg)

elif opt == "--version":

# This option is currently private and allows creating a

# repository with a specific format based on version.

try:

version = int(arg)

except ValueError:

usage(_("Version must be an integer value."),

cmd=subcommand)

if len(pargs) > 1:

usage(_("Only one repository location may be specified."),

cmd=subcommand)

elif pargs:

conf["repo_uri"] = parse_uri(pargs[0])

repo_uri = conf.get("repo_uri", None)

if not repo_uri:

usage(_("No repository location specified."), cmd=subcommand)

if repo_uri.scheme != "file":

usage(_("Network repositories are not currently supported "

"for this operation."), cmd=subcommand)

# Attempt to create a repository at the specified location. Allow

# whatever exceptions are raised to bubble up.

sr.repository_create(repo_uri, version=version)

return EXIT_OK

def subcmd_get(conf, args):

"""Display repository properties."""

subcommand = "get"

omit_headers = False

out_format = "default"

pubs = set()

key = None

cert = None

opts, pargs = getopt.getopt(args, "F:Hp:s:", ["key=", "cert="])

for opt, arg in opts:

if opt == "-F":

if arg not in LISTING_FORMATS:

raise apx.InvalidOptionError(

apx.InvalidOptionError.ARG_INVALID,

[arg, opt])

out_format = arg

elif opt == "-H":

omit_headers = True

elif opt == "-p":

pubs.add(arg)

elif opt == "-s":

conf["repo_uri"] = parse_uri(arg)

elif opt == "--key":

key = arg

elif opt == "--cert":

cert = arg

# Setup transport so configuration can be retrieved.

if not conf.get("repo_uri", None):

usage(_("A package repository location must be provided "

"using -s."), cmd=subcommand)

xport, xpub, tmp_dir = setup_transport(conf, subcommand=subcommand,

ssl_key=key, ssl_cert=cert)

# Get properties.

if pubs:

return _get_pub(conf, subcommand, xport, xpub, omit_headers,

out_format, pubs, pargs)

return _get_repo(conf, subcommand, xport, xpub, omit_headers,

out_format, pargs)

def _get_repo(conf, subcommand, xport, xpub, omit_headers, out_format, pargs):

"""Display repository properties."""

# Configuration index is indexed by section name and property name.

# Retrieve and flatten it to simplify listing process.

stat_idx = xport.get_status(xpub)

cfg_idx = stat_idx.get("repository", {}).get("configuration", {})

props = set()

# Set minimum widths for section and property name columns by using the

# length of the column headers.

max_sname_len = len(_("SECTION"))

max_pname_len = len(_("PROPERTY"))

for sname in cfg_idx:

max_sname_len = max(max_sname_len, len(sname))

for pname in cfg_idx[sname]:

max_pname_len = max(max_pname_len, len(pname))

props.add("/".join((sname, pname)))

req_props = set(pargs)

if len(req_props) >= 1:

found = props & req_props

notfound = req_props - found

del props

else:

found = props

notfound = set()

def gen_listing():

for prop in sorted(found):

sname, pname = prop.rsplit("/", 1)

sval = cfg_idx[sname][pname]

yield {

"section": sname,

"property": pname,

"value": sval,

}

# SECTION PROPERTY VALUE

# <sec_1> <prop_1> <prop_1_value>

# <sec_2> <prop_2> <prop_2_value>

# ...

field_data = {

"section" : [("default", "json", "tsv"), _("SECTION"), ""],

"property" : [("default", "json", "tsv"), _("PROPERTY"), ""],

"value" : [("default", "json", "tsv"), _("VALUE"), ""],

}

desired_field_order = (_("SECTION"), _("PROPERTY"), _("VALUE"))

# Default output formatting.

def_fmt = "{0:" + str(max_sname_len) + "} {1:" + str(max_pname_len) + \

"} {2}"

if found or (not req_props and out_format == "default"):

# print without trailing newline.

sys.stdout.write(misc.get_listing(desired_field_order,

field_data, gen_listing(), out_format, def_fmt,

omit_headers))

if found and notfound:

return EXIT_PARTIAL

if req_props and not found:

if out_format == "default":

# Don't pollute other output formats.

error(_("no matching properties found"),

cmd=subcommand)

return EXIT_OOPS

return EXIT_OK

def _get_matching_pubs(subcommand, pubs, xport, xpub, out_format="default",

use_transport=False):

# Retrieve publisher information.

pub_data = xport.get_publisherdata(xpub)

known_pubs = set(p.prefix for p in pub_data)

if len(pubs) > 0 and "all" not in pubs:

found = known_pubs & pubs

notfound = pubs - found

pub_data = [p for p in pub_data if p.prefix in found]

else:

found = known_pubs

notfound = set()

if use_transport:

# Assign transport information.

for p in pub_data:

p.repository = xpub.repository

# Establish initial return value and perform early exit if appropriate.

rval = EXIT_OK

if found and notfound:

rval = EXIT_PARTIAL

elif pubs and not found:

if out_format == "default":

# Don't pollute other output formats.

error(_("no matching publishers found"),

cmd=subcommand)

return EXIT_OOPS, None, None

return rval, found, pub_data

def _get_pub(conf, subcommand, xport, xpub, omit_headers, out_format, pubs,

pargs):

"""Display publisher properties."""

rval, found, pub_data = _get_matching_pubs(subcommand, pubs, xport,

xpub, out_format=out_format)

if rval == EXIT_OOPS:

return rval

# Set minimum widths for section and property name columns by using the

# length of the column headers and data.

max_pubname_len = str(max(

[len(_("PUBLISHER"))] + [len(p) for p in found]

))

max_sname_len = len(_("SECTION"))

max_pname_len = len(_("PROPERTY"))

# For each requested publisher, retrieve the requested property data.

pub_idx = {}

for pub in pub_data:

pub_idx[pub.prefix] = {

"publisher": {

"alias": pub.alias,

"prefix": pub.prefix,

},

}

pub_repo = pub.repository

if pub_repo:

pub_idx[pub.prefix]["repository"] = {

"collection-type": pub_repo.collection_type,

"description": pub_repo.description,

"legal-uris": pub_repo.legal_uris,

"mirrors": pub_repo.mirrors,

"name": pub_repo.name,

"origins": pub_repo.origins,

"refresh-seconds": pub_repo.refresh_seconds,

"registration-uri": pub_repo.registration_uri,

"related-uris": pub_repo.related_uris,

}

else:

pub_idx[pub.prefix]["repository"] = {

"collection-type": "core",

"description": "",

"legal-uris": [],

"mirrors": [],

"name": "",

"origins": [],

"refresh-seconds": "",

"registration-uri": "",

"related-uris": [],

}

# Determine possible set of properties and lengths.

props = set()

for pub in pub_idx:

for sname in pub_idx[pub]:

max_sname_len = max(max_sname_len, len(sname))

for pname in pub_idx[pub][sname]:

max_pname_len = max(max_pname_len, len(pname))

props.add("/".join((sname, pname)))

# Determine properties to display.

req_props = set(pargs)

if len(req_props) >= 1:

found = props & req_props

notfound = req_props - found

del props

else:

found = props

notfound = set()

def gen_listing():

for pub in sorted(pub_idx.keys()):

for prop in sorted(found):

sname, pname = prop.rsplit("/", 1)

sval = pub_idx[pub][sname][pname]

yield {

"publisher": pub,

"section": sname,

"property": pname,

"value": sval,

}

# PUBLISHER SECTION PROPERTY VALUE

# <pub_1> <sec_1> <prop_1> <prop_1_value>

# <pub_1> <sec_2> <prop_2> <prop_2_value>

# ...

field_data = {

"publisher" : [("default", "json", "tsv"), _("PUBLISHER"), ""],

"section" : [("default", "json", "tsv"), _("SECTION"), ""],

"property" : [("default", "json", "tsv"), _("PROPERTY"), ""],

"value" : [("default", "json", "tsv"), _("VALUE"), ""],

}

desired_field_order = (_("PUBLISHER"), _("SECTION"), _("PROPERTY"),

_("VALUE"))

# Default output formatting.

def_fmt = "{0:" + str(max_pubname_len) + "} {1:" + str(max_sname_len) + \

"} {2:" + str(max_pname_len) + "} {3}"

if found or (not req_props and out_format == "default"):

# print without trailing newline.

sys.stdout.write(misc.get_listing(desired_field_order,

field_data, gen_listing(), out_format, def_fmt,

omit_headers))

if found and notfound:

rval = EXIT_PARTIAL

if req_props and not found:

if out_format == "default":

# Don't pollute other output formats.

error(_("no matching properties found"),

cmd=subcommand)

rval = EXIT_OOPS

return rval

def subcmd_info(conf, args):

"""Display a list of known publishers and a summary of known packages

subcommand = "info"

omit_headers = False

out_format = "default"

pubs = set()

key = None

cert = None

opts, pargs = getopt.getopt(args, "F:Hp:s:", ["key=", "cert="])

for opt, arg in opts:

if opt == "-F":

if arg not in LISTING_FORMATS:

raise apx.InvalidOptionError(

apx.InvalidOptionError.ARG_INVALID,

[arg, opt])

out_format = arg

elif opt == "-H":

omit_headers = True

elif opt == "-p":

pubs.add(arg)

elif opt == "-s":

conf["repo_uri"] = parse_uri(arg)

elif opt == "--key":

key = arg

elif opt == "--cert":

cert = arg

if pargs:

usage(_("command does not take operands"), cmd=subcommand)

# Setup transport so status can be retrieved.

if not conf.get("repo_uri", None):

usage(_("A package repository location must be provided "

"using -s."), cmd=subcommand)

xport, xpub, tmp_dir = setup_transport(conf, subcommand=subcommand,

ssl_key=key, ssl_cert=cert)

# Retrieve repository status information.

stat_idx = xport.get_status(xpub)

pub_idx = stat_idx.get("repository", {}).get("publishers", {})

if len(pubs) > 0 and "all" not in pubs:

found = set(pub_idx.keys()) & pubs

notfound = pubs - found

else:

found = set(pub_idx.keys())

notfound = set()

def gen_listing():

for pfx in found:

pdata = pub_idx[pfx]

pkg_count = pdata.get("package-count", 0)

last_update = pdata.get("last-catalog-update", "")

if last_update:

# Reformat the date into something more user

# friendly (and locale specific).

last_update = pkg.catalog.basic_ts_to_datetime(

last_update)

last_update = "{0}Z".format(

pkg.catalog.datetime_to_ts(last_update))

rstatus = _(pub_idx[pfx].get("status", "online"))

yield {

"publisher": pfx,

"packages": pkg_count,

"status": rstatus,

"updated": last_update,

}

# PUBLISHER PACKAGES STATUS UPDATED

# <pub_1> <num_uniq_pkgs> <status> <cat_last_modified>

# <pub_2> <num_uniq_pkgs> <status> <cat_last_modified>

# ...

field_data = {

"publisher" : [("default", "json", "tsv"), _("PUBLISHER"), ""],

"packages" : [("default", "json", "tsv"), _("PACKAGES"), ""],

"status" : [("default", "json", "tsv"), _("STATUS"), ""],

"updated" : [("default", "json", "tsv"), _("UPDATED"), ""],

}

desired_field_order = (_("PUBLISHER"), "", _("PACKAGES"), _("STATUS"),

_("UPDATED"))

# Default output formatting.

pub_len = str(max(

[len(desired_field_order[0])] + [len(p) for p in found]

))

def_fmt = "{0:" + pub_len + "} {1:8} {2:16} {3}"

if found or (not pubs and out_format == "default"):

# print without trailing newline.

sys.stdout.write(misc.get_listing(desired_field_order,

field_data, gen_listing(), out_format, def_fmt,

omit_headers))

if found and notfound:

return EXIT_PARTIAL

if pubs and not found:

if out_format == "default":

# Don't pollute other output formats.

error(_("no matching publishers found"),

cmd=subcommand)

return EXIT_OOPS

return EXIT_OK

def subcmd_list(conf, args):

"""List all packages matching the specified patterns."""

subcommand = "list"

omit_headers = False

out_format = "default"

pubs = set()

key = None

cert = None

opts, pargs = getopt.getopt(args, "F:Hp:s:", ["key=", "cert="])

for opt, arg in opts:

if opt == "-F":

if arg not in LISTING_FORMATS:

raise apx.InvalidOptionError(

apx.InvalidOptionError.ARG_INVALID,

[arg, opt])

out_format = arg

elif opt == "-H":

omit_headers = True

elif opt == "-p":

pubs.add(arg)

elif opt == "-s":

conf["repo_uri"] = parse_uri(arg)

elif opt == "--key":

key = arg

elif opt == "--cert":

cert = arg

# Setup transport so configuration can be retrieved.

if not conf.get("repo_uri", None):

usage(_("A package repository location must be provided "

"using -s."), cmd=subcommand)

xport, xpub, tmp_dir = setup_transport(conf, subcommand=subcommand,

ssl_key=key, ssl_cert=cert)

rval, found, pub_data = _get_matching_pubs(subcommand, pubs, xport,

xpub, out_format=out_format, use_transport=True)

if rval == EXIT_OOPS:

return rval

refresh_pub(pub_data, xport)

listed = {}

matched = set()

unmatched = set()

def gen_listing():

collect_attrs = out_format.startswith("json")

for pub in pub_data:

cat = pub.catalog

for f, states, attrs in cat.gen_packages(

collect_attrs=collect_attrs, matched=matched,

patterns=pargs, pubs=[pub.prefix],

unmatched=unmatched, return_fmris=True):

if not listed:

listed["packages"] = True

state = None

if out_format == "default" or \

out_format == "tsv":

if pkgdefs.PKG_STATE_OBSOLETE in \

states:

state = "o"

elif pkgdefs.PKG_STATE_RENAMED in \

states:

state = "r"

if out_format == "default":

fver = str(f.version.get_version(

include_build=False))

ffmri = str(f.get_fmri(include_build=False))

else:

fver = str(f.version)

ffmri = str(f)

ret = {

"publisher": f.publisher,

"name": f.pkg_name,

"version": fver,

"release": str(f.version.release),

"build-release":

str(f.version.build_release),

"branch": str(f.version.branch),

"timestamp":

str(f.version.timestr),

"pkg.fmri": ffmri,

"short_state": state,

}

for attr in attrs:

ret[attr] = []

for mods in attrs[attr]:

d = dict(mods)

d["value"] = \

attrs[attr][mods]

ret[attr].append(d)

yield ret

unmatched.difference_update(matched)

field_data = {

"publisher": [("default", "json", "tsv"), _("PUBLISHER"), ""],

"name": [("default", "json", "tsv"), _("NAME"), ""],

"version": [("default", "json"), _("VERSION"), ""],

"release": [("json", "tsv",), _("RELEASE"), ""],

"build-release": [("json", "tsv",), _("BUILD RELEASE"), ""],

"branch": [("json", "tsv",), _("BRANCH"), ""],

"timestamp": [("json", "tsv",), _("PACKAGING DATE"), ""],

"pkg.fmri": [("json", "tsv",), _("FMRI"), ""],

"short_state": [("default", "tsv"), "O", ""],

}

desired_field_order = (_("PUBLISHER"), _("NAME"), "O", _("VERSION"),

_("SUMMARY"), _("DESCRIPTION"), _("CATEGORIES"), _("RELEASE"),

_("BUILD RELEASE"), _("BRANCH"), _("PACKAGING DATE"), _("FMRI"),

_("STATE"))

# Default output formatting.

max_pub_name_len = str(

max(list(len(p) for p in found) + [len(_("PUBLISHER"))]))

def_fmt = "{0:" + max_pub_name_len + "} {1:45} {2:1} {3}"

# print without trailing newline.

sys.stdout.write(misc.get_listing(

desired_field_order, field_data, gen_listing(),

out_format, def_fmt, omit_headers))

if not listed and pargs:

# No matching packages.

logger.error("")

if not unmatched:

unmatched = pargs

error(apx.PackageMatchErrors(unmatched_fmris=unmatched),

cmd=subcommand)

return EXIT_OOPS

elif unmatched:

# One or more patterns didn't match a package from any

# publisher; only display the error.

logger.error("")

error(apx.PackageMatchErrors(unmatched_fmris=unmatched),

cmd=subcommand)

return EXIT_PARTIAL

return EXIT_OK

def refresh_pub(pub_data, xport):

"""A helper function to refresh all specified publishers."""

global tmpdirs

temp_root = misc.config_temp_root()

progtrack = get_tracker()

progtrack.set_purpose(progtrack.PURPOSE_LISTING)

progtrack.refresh_start(pub_cnt=len(pub_data), full_refresh=True,

target_catalog=False)

for pub in pub_data:

progtrack.refresh_start_pub(pub)

meta_root = tempfile.mkdtemp(dir=temp_root)

tmpdirs.append(meta_root)

pub.meta_root = meta_root

pub.transport = xport

try:

pub.refresh(True, True, progtrack=progtrack)

except apx.TransportError:

# Assume that a catalog doesn't exist for the target

# publisher and drive on.

pass

progtrack.refresh_end_pub(pub)

progtrack.refresh_done()

def subcmd_contents(conf, args):

"""List package contents."""

subcommand = "contents"

display_raw = False

pubs = set()

key = None

cert = None

attrs = []

action_types = []

opts, pargs = getopt.getopt(args, "ms:t:", ["key=", "cert="])

for opt, arg in opts:

if opt == "-s":

conf["repo_uri"] = parse_uri(arg)

elif opt == "-m":

display_raw = True

elif opt == "-t":

action_types.extend(arg.split(","))

elif opt == "--key":

key = arg

elif opt == "--cert":

cert = arg

# Setup transport so configuration can be retrieved.

if not conf.get("repo_uri", None):

usage(_("A package repository location must be provided "

"using -s."), cmd=subcommand)

xport, xpub, tmp_dir = setup_transport(conf, subcommand=subcommand,

ssl_key=key, ssl_cert=cert)

rval, found, pub_data = _get_matching_pubs(subcommand, pubs, xport,

xpub, use_transport=True)

if rval == EXIT_OOPS:

return rval

# Default output prints out the raw manifest. The -m option is implicit

# for now and supported to make the interface equivalent to pkg

# contents.

if not attrs or display_raw:

attrs = ["action.raw"]

refresh_pub(pub_data, xport)

listed = False

matched = set()

unmatched = set()

manifests = []

for pub in pub_data:

cat = pub.catalog

for f, states, attr in cat.gen_packages(matched=matched,

patterns=pargs, pubs=[pub.prefix],

unmatched=unmatched, return_fmris=True):

if not listed:

listed = True

manifests.append(xport.get_manifest(f))

unmatched.difference_update(matched)

# Build a generator expression based on whether specific action types

# were provided.

if action_types:

# If query is limited to specific action types, use the more

# efficient type-based generation mechanism.

gen_expr = (

(m.fmri, a, None, None, None)

for m in manifests

for a in m.gen_actions_by_types(action_types)

)

else:

gen_expr = (

(m.fmri, a, None, None, None)

for m in manifests

for a in m.gen_actions()

)

# Determine if the query returned any results by "peeking" at the first

# value returned from the generator expression.

try:

got = gen_expr.next()

except StopIteration:

got = None

actionlist = []

if got:

actionlist = itertools.chain([got], gen_expr)

rval = EXIT_OK

if action_types and manifests and not got:

logger.error(_(gettext.ngettext("""\

using the -t option""", """\

using the -t option.""", len(pargs))))

rval = EXIT_OOPS

if manifests and rval == EXIT_OK:

lines = misc.list_actions_by_attrs(actionlist, attrs)

for line in lines:

text = ("{0}".format(*line)).rstrip()

if not text:

continue

msg(text)

if unmatched:

if manifests:

logger.error("")

logger.error(_("""\

were found in the repository."""))

logger.error("")

for p in unmatched:

logger.error(" {0}".format(p))

rval = EXIT_OOPS

return rval

def __rebuild_local(subcommand, conf, pubs, build_catalog, build_index):

"""In an attempt to allow operations on potentially corrupt

repo = get_repo(conf, allow_invalid=build_catalog, read_only=False,

subcommand=subcommand)

rpubs = set(repo.publishers)

if not pubs:

found = rpubs

else:

found = rpubs & pubs

notfound = pubs - found

rval = EXIT_OK

if found and notfound:

rval = EXIT_PARTIAL

elif pubs and not found:

error(_("no matching publishers found"), cmd=subcommand)

return EXIT_OOPS

logger.info("Initiating repository rebuild.")

for pfx in found:

repo.rebuild(build_catalog=build_catalog,

build_index=build_index, pub=pfx)

return rval

def __rebuild_remote(subcommand, conf, pubs, key, cert, build_catalog,

build_index):

def do_rebuild(xport, xpub):

if build_catalog and build_index:

xport.publish_rebuild(xpub)

elif build_catalog:

xport.publish_rebuild_packages(xpub)

elif build_index:

xport.publish_rebuild_indexes(xpub)

xport, xpub, tmp_dir = setup_transport(conf, subcommand=subcommand,

ssl_key=key, ssl_cert=cert)

rval, found, pub_data = _get_matching_pubs(subcommand, pubs, xport,

xpub)

if rval == EXIT_OOPS:

return rval

logger.info("Initiating repository rebuild.")

for pfx in found:

xpub.prefix = pfx

do_rebuild(xport, xpub)

return rval

def subcmd_rebuild(conf, args):

"""Rebuild the repository's catalog and index data (as permitted)."""

subcommand = "rebuild"

build_catalog = True

build_index = True

key = None

cert = None

opts, pargs = getopt.getopt(args, "p:s:", ["no-catalog", "no-index",

"key=", "cert="])

pubs = set()

for opt, arg in opts:

if opt == "-p":

if not misc.valid_pub_prefix(arg):

error(_("Invalid publisher prefix '{0}'").format(

arg), cmd=subcommand)

pubs.add(arg)