import errno

import getopt

import gettext

import locale

import os

import six

import sys

import traceback

import warnings

import pkg

import pkg.actions as actions

import pkg.client.api as api

import pkg.client.api_errors as api_errors

import pkg.client.progress as progress

import pkg.manifest as manifest

import pkg.misc as misc

import pkg.publish.dependencies as dependencies

from pkg.misc import msg, emsg, PipeError

from pkg.client.pkgdefs import EXIT_OK, EXIT_OOPS, EXIT_BADOPT

CLIENT_API_VERSION = 82

PKG_CLIENT_NAME = "pkgdepend"

DEFAULT_SUFFIX = ".res"

def format_update_error(e):

# This message is displayed to the user whenever an

# ImageFormatUpdateNeeded exception is encountered.

emsg("\n")

emsg(str(e))

emsg(_("To continue, the target image must be upgraded "

"before it can be used. See pkg(1) update-format for more "

"information."))

def error(text, cmd=None):

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

if cmd:

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

else:

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

emsg(ws + "pkgdepend: " + text_nows)

def usage(usage_error=None, cmd=None, retcode=EXIT_BADOPT):

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

if usage_error:

error(usage_error, cmd=cmd)

emsg (_("""\

PKG_IMAGE"""))

sys.exit(retcode)

def generate(args):

"""Produce a list of file dependencies from a manfiest and a proto

try:

opts, pargs = getopt.getopt(args, "d:D:Ik:Mm?",

["help"])

except getopt.GetoptError as e:

usage(_("illegal global option -- {0}").format(e.opt))

remove_internal_deps = True

echo_manf = False

show_missing = False

show_usage = False

isa_paths = []

run_paths = []

platform_paths = []

dyn_tok_conv = {}

proto_dirs = []

for opt, arg in opts:

if opt == "-d":

if not os.path.isdir(arg):

usage(_("The proto directory {0} could not be "

"found.".format(arg)), retcode=EXIT_BADOPT)

proto_dirs.append(os.path.abspath(arg))

elif opt == "-D":

try:

dyn_tok_name, dyn_tok_val = arg.split("=", 1)

except:

usage(_("-D arguments must be of the form "

"'name=value'."))

if not dyn_tok_name[0] == "$":

dyn_tok_name = "$" + dyn_tok_name

dyn_tok_conv.setdefault(dyn_tok_name, []).append(

dyn_tok_val)

elif opt == "-I":

remove_internal_deps = False

elif opt == "-k":

run_paths.append(arg)

elif opt == "-m":

echo_manf = True

elif opt == "-M":

show_missing = True

elif opt in ("--help", "-?"):

show_usage = True

if show_usage:

usage(retcode=EXIT_OK)

if len(pargs) > 2 or len(pargs) < 1:

usage(_("Generate only accepts one or two arguments."))

if "$ORIGIN" in dyn_tok_conv:

usage(_("ORIGIN may not be specified using -D. It will be "

"inferred from the\ninstall paths of the files."))

retcode = EXIT_OK

manf = pargs[0]

if not os.path.isfile(manf):

usage(_("The manifest file {0} could not be found.").format(manf),

retcode=EXIT_BADOPT)

if len(pargs) > 1:

if not os.path.isdir(pargs[1]):

usage(_("The proto directory {0} could not be found.").format(

pargs[1]), retcode=EXIT_BADOPT)

proto_dirs.insert(0, os.path.abspath(pargs[1]))

if not proto_dirs:

usage(_("At least one proto directory must be provided."),

retcode=EXIT_BADOPT)

try:

ds, es, ms, pkg_attrs = dependencies.list_implicit_deps(manf,

proto_dirs, dyn_tok_conv, run_paths, remove_internal_deps)

except (actions.MalformedActionError, actions.UnknownActionError) as e:

error(_("Could not parse manifest {manifest} because of the "

"following line:\n{line}").format(manifest=manf,

line=e.actionstr))

return EXIT_OOPS

except api_errors.ApiException as e:

error(e)

return EXIT_OOPS

if echo_manf:

fh = open(manf, "r")

for l in fh:

msg(l.rstrip())

fh.close()

for d in sorted(ds):

msg(d)

for key, value in six.iteritems(pkg_attrs):

msg(actions.attribute.AttributeAction(**{key: value}))

if show_missing:

for m in ms:

emsg(m)

for e in es:

emsg(e)

retcode = EXIT_OOPS

return retcode

def resolve(args, img_dir):

"""Take a list of manifests and resolve any file dependencies, first

out_dir = None

echo_manifest = False

output_to_screen = False

suffix = None

verbose = False

use_system_to_resolve = True

constraint_files = []

extra_external_info = False

try:

opts, pargs = getopt.getopt(args, "d:e:Emos:Sv")

except getopt.GetoptError as e:

usage(_("illegal global option -- {0}").format(e.opt))

for opt, arg in opts:

if opt == "-d":

out_dir = arg

elif opt == "-e":

constraint_files.append(arg)

elif opt == "-E":

extra_external_info = True

elif opt == "-m":

echo_manifest = True

elif opt == "-o":

output_to_screen = True

elif opt == "-s":

suffix = arg

elif opt == "-S":

use_system_to_resolve = False

elif opt == "-v":

verbose = True

if (out_dir or suffix) and output_to_screen:

usage(_("-o cannot be used with -d or -s"))

manifest_paths = [os.path.abspath(fp) for fp in pargs]

for manifest in manifest_paths:

if not os.path.isfile(manifest):

usage(_("The manifest file {0} could not be found.").format(

manifest), retcode=EXIT_BADOPT)

if out_dir:

out_dir = os.path.abspath(out_dir)

if not os.path.isdir(out_dir):

usage(_("The output directory {0} is not a directory.").format(

out_dir), retcode=EXIT_BADOPT)

provided_image_dir = True

pkg_image_used = False

if img_dir == None:

orig_cwd = None

try:

orig_cwd = os.getcwd()

except OSError:

# May be unreadable by user or have other problem.

pass

img_dir, provided_image_dir = api.get_default_image_root(

orig_cwd=orig_cwd)

if os.environ.get("PKG_IMAGE"):

# It's assumed that this has been checked by the above

# function call and hasn't been removed from the

# environment.

pkg_image_used = True

if not img_dir:

error(_("Could not find image. Use the -R option or set "

"$PKG_IMAGE to the\nlocation of an image."))

return EXIT_OOPS

system_patterns = misc.EmptyI

if constraint_files:

system_patterns = []

for f in constraint_files:

try:

with open(f, "r") as fh:

for l in fh:

l = l.strip()

if l and not l.startswith("#"):

system_patterns.append(

l)

except EnvironmentError as e:

if e.errno in (errno.ENOENT, errno.EISDIR):

error("{0}: '{1}'".format(

e.args[1], e.filename),

cmd="resolve")

return EXIT_OOPS

raise api_errors._convert_error(e)

if not system_patterns:

error(_("External package list files were provided but "

"did not contain any fmri patterns."))

return EXIT_OOPS

elif use_system_to_resolve:

system_patterns = ["*"]

# Becuase building an ImageInterface permanently changes the cwd for

# python, it's necessary to do this step after resolving the paths to

# the manifests.

try:

api_inst = api.ImageInterface(img_dir, CLIENT_API_VERSION,

progress.QuietProgressTracker(), None, PKG_CLIENT_NAME,

exact_match=provided_image_dir)

except api_errors.ImageNotFoundException as e:

if e.user_specified:

if pkg_image_used:

error(_("No image rooted at '{0}' "

"(set by $PKG_IMAGE)").format(e.user_dir))

else:

error(_("No image rooted at '{0}'").format(

e.user_dir))

else:

error(_("No image found."))

return EXIT_OOPS

except api_errors.PermissionsException as e:

error(e)

return EXIT_OOPS

except api_errors.ImageFormatUpdateNeeded as e:

# This should be a very rare error case.

format_update_error(e)

return EXIT_OOPS

try:

pkg_deps, errs, warnings, unused_fmris, external_deps = \

dependencies.resolve_deps(manifest_paths, api_inst,

system_patterns, prune_attrs=not verbose)

except (actions.MalformedActionError, actions.UnknownActionError) as e:

error(_("Could not parse one or more manifests because of "

"the following line:\n{0}").format(e.actionstr))

return EXIT_OOPS

except dependencies.DependencyError as e:

error(e)

return EXIT_OOPS

except api_errors.ApiException as e:

error(e)

return EXIT_OOPS

ret_code = EXIT_OK

if output_to_screen:

ret_code = pkgdeps_to_screen(pkg_deps, manifest_paths,

echo_manifest)

elif out_dir:

ret_code = pkgdeps_to_dir(pkg_deps, manifest_paths, out_dir,

suffix, echo_manifest)

else:

ret_code = pkgdeps_in_place(pkg_deps, manifest_paths, suffix,

echo_manifest)

if extra_external_info:

if constraint_files and unused_fmris:

msg(_("\nThe following fmris matched a pattern in a "

"constraint file but were not used in\ndependency "

"resolution:"))

for pfmri in sorted(unused_fmris):

msg("\t{0}".format(pfmri))

if not constraint_files and external_deps:

msg(_("\nThe following fmris had dependencies resolve "

"to them:"))

for pfmri in sorted(external_deps):

msg("\t{0}".format(pfmri))

for e in errs:

if ret_code == EXIT_OK:

ret_code = EXIT_OOPS

emsg(e)

for w in warnings:

emsg(w)

return ret_code

def __resolve_echo_line(l):

"""Given a line from a manifest, determines whether that line should

try:

act = actions.fromstr(l.rstrip())

except KeyboardInterrupt:

raise

except actions.ActionError:

return True

else:

return not act.name == "depend"

def __echo_manifest(pth, out_func, strip_newline=False):

try:

with open(pth, "r") as fh:

text = ""

act = ""

for l in fh:

text += l

act += l.rstrip()

if act.endswith("\\"):

act = act.rstrip("\\")

continue

if __resolve_echo_line(act):

if strip_newline:

text = text.rstrip()

elif text[-1] != "\n":

text += "\n"

out_func(text)

text = ""

act = ""

if text != "" and __resolve_echo_line(act):

if text[-1] != "\n":

text += "\n"

out_func(text)

except EnvironmentError:

ret_code = EXIT_OOPS

emsg(_("Could not open {0} to echo manifest").format(

manifest_path))

def pkgdeps_to_screen(pkg_deps, manifest_paths, echo_manifest):

"""Write the resolved package dependencies to stdout.

ret_code = EXIT_OK

first = True

for p in manifest_paths:

if not first:

msg("\n\n")

first = False

msg("# {0}".format(p))

if echo_manifest:

__echo_manifest(p, msg, strip_newline=True)

for d in pkg_deps[p]:

msg(d)

return ret_code

def write_res(deps, out_file, echo_manifest, manifest_path):

"""Write the dependencies resolved, and possibly the manifest, to the

ret_code = EXIT_OK

try:

out_fh = open(out_file, "w")

except EnvironmentError:

ret_code = EXIT_OOPS

emsg(_("Could not open output file {0} for writing").format(

out_file))

return ret_code

if echo_manifest:

__echo_manifest(manifest_path, out_fh.write)

for d in deps:

out_fh.write("{0}\n".format(d))

out_fh.close()

return ret_code

def pkgdeps_to_dir(pkg_deps, manifest_paths, out_dir, suffix, echo_manifest):

"""Given an output directory, for each manifest given, writes the

ret_code = EXIT_OK

if not os.path.exists(out_dir):

try:

os.makedirs(out_dir)

except EnvironmentError as e:

e_dic = {"dir": out_dir}

if len(e.args) > 0:

e_dic["err"] = e.args[1]

else:

e_dic["err"] = e.args[0]

emsg(_("Out dir {out_dir} does not exist and could "

"not be created. Error is: {err}").format(**e_dic))

return EXIT_OOPS

if suffix and suffix[0] != ".":

suffix = "." + suffix

for p in manifest_paths:

out_file = os.path.join(out_dir, os.path.basename(p))

if suffix:

out_file += suffix

tmp_rc = write_res(pkg_deps[p], out_file, echo_manifest, p)

if not ret_code:

ret_code = tmp_rc

return ret_code

def pkgdeps_in_place(pkg_deps, manifest_paths, suffix, echo_manifest):

"""Given an output directory, for each manifest given, writes the

ret_code = EXIT_OK

if not suffix:

suffix = DEFAULT_SUFFIX

if suffix[0] != ".":

suffix = "." + suffix

for p in manifest_paths:

out_file = p + suffix

tmp_rc = write_res(pkg_deps[p], out_file, echo_manifest, p)

if not ret_code:

ret_code = tmp_rc

return ret_code

def main_func():

try:

opts, pargs = getopt.getopt(sys.argv[1:], "R:?",

["help"])

except getopt.GetoptError as e:

usage(_("illegal global option -- {0}").format(e.opt))

show_usage = False

img_dir = None

for opt, arg in opts:

if opt == "-R":

img_dir = arg

elif opt in ("--help", "-?"):

show_usage = True

subcommand = None

if pargs:

subcommand = pargs.pop(0)

if subcommand == "help":

show_usage = True

if show_usage:

usage(retcode=EXIT_OK)

elif not subcommand:

usage()

if subcommand == "generate":

if img_dir:

usage(_("generate subcommand doesn't use -R"))

return generate(pargs)

elif subcommand == "resolve":

return resolve(pargs, img_dir)

else:

usage(_("unknown subcommand '{0}'").format(subcommand))

if __name__ == "__main__":

misc.setlocale(locale.LC_ALL, "", error)

gettext.install("pkg", "/usr/share/locale",

codeset=locale.getpreferredencoding())

misc.set_fd_limits(printer=error)

# Make all warnings be errors.

warnings.simplefilter('error')

if six.PY3:

# disable ResourceWarning: unclosed file

warnings.filterwarnings("ignore", category=ResourceWarning)

try:

__ret = main_func()

except api_errors.MissingFileArgumentException as e:

error("The manifest file {0} could not be found.".format(e.path))

__ret = EXIT_OOPS

except api_errors.VersionException as __e:

error(_("The {cmd} command appears out of sync with the lib"

"raries provided\nby pkg:/package/pkg. The client version "

"is {client} while the library\nAPI version is {api}").format(

cmd=PKG_CLIENT_NAME,

client=__e.received_version,

api=__e.expected_version

))

__ret = EXIT_OOPS

except api_errors.ApiException as e:

error(e)

__ret = EXIT_OOPS

except RuntimeError as _e:

emsg("{0}: {1}".format(PKG_CLIENT_NAME, _e))

__ret = EXIT_OOPS

except (PipeError, KeyboardInterrupt):

# We don't want to display any messages here to prevent

# possible further broken pipe (EPIPE) errors.

__ret = EXIT_OOPS

except SystemExit as _e:

raise _e

except:

traceback.print_exc()

error(misc.get_traceback_message())

__ret = 99

sys.exit(__ret)