def test_basic_trackers(self):
"""Basic testing of all trackers; reset, and then retest."""
sio_c = six.StringIO()
sio_c2 = six.StringIO()
sio_f = six.StringIO()
sio_d = six.StringIO()
tc = progress.CommandLineProgressTracker(output_file=sio_c)
tc2 = progress.CommandLineProgressTracker(output_file=sio_c2,
term_delay=1)
tf = progress.FunctionProgressTracker(output_file=sio_f)
td = progress.DotProgressTracker(output_file=sio_d)
tq = progress.QuietProgressTracker()
mt = progress.MultiProgressTracker([tc, tc2, tf, tq, td])
# run everything twice; this exercises that after a
# reset(), everything still works correctly.
for x in [1, 2]:
progress.test_progress_tracker(mt, gofast=True)
self.assertTrue(len(sio_c.getvalue()) > 100)
self.assertTrue(len(sio_c2.getvalue()) > 100)
self.assertTrue(len(sio_f.getvalue()) > 100)
self.assertTrue(len(sio_d.getvalue()) > 1)
# check that dot only printed dots
self.assertTrue(len(sio_d.getvalue()) * "." == sio_d.getvalue())
for f in [sio_c, sio_c2, sio_f, sio_d]:
f.seek(0)
f.truncate(0)
# Reset them all, and go again, as a test of reset().
mt.flush()
mt.reset()
def test_prog_track_image_args(self):
'''Test that setting progtrack in image args works'''
self.tr_ips.image_args = {"progtrack": progress.QuietProgressTracker()}
try:
self.tr_ips.execute(dry_run=DRY_RUN)
except Exception as err:
self.fail(str(err))
def _get_image(image_dir):
"""Return a pkg.client.api.ImageInterface for the provided
image directory."""
cdir = os.getcwd()
if not image_dir:
image_dir = "/"
api_inst = None
tracker = progress.QuietProgressTracker()
try:
api_inst = pkg.client.api.ImageInterface(
image_dir, CLIENT_API_VERSION,
tracker, None, PKG_CLIENT_NAME)
if api_inst.root != image_dir:
msg(_("Problem getting image at {0}").format(
image_dir))
except Exception as err:
raise SysrepoException(
_("Unable to get image at {dir}: {reason}").format(
dir=image_dir,
reason=str(err)))
# restore the current directory, which ImageInterace had changed
os.chdir(cdir)
return api_inst
def get_tracker(quiet=False):
if quiet:
progresstracker = progress.QuietProgressTracker()
else:
try:
progresstracker = \
progress.FancyUNIXProgressTracker()
except progress.ProgressTrackerException:
progresstracker = progress.CommandLineProgressTracker()
return progresstracker
def resolve(args, img_dir):
"""Take a list of manifests and resolve any file dependencies, first
against the other published manifests and then against what is installed
on the machine."""
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=2)
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=2)
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 1
system_patterns = misc.EmptyI
if constraint_files:
system_patterns = []
for f in constraint_files:
try:
with open(f, "rb") 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 == errno.ENOENT:
error("{0}: '{1}'".format(e.args[1], e.filename),
cmd="resolve")
return 1
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 1
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 1
except api_errors.PermissionsException as e:
error(e)
return 1
except api_errors.ImageFormatUpdateNeeded as e:
# This should be a very rare error case.
format_update_error(e)
return 1
try:
pkg_deps, errs, 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 1
except dependencies.DependencyError as e:
error(e)
return 1
except api_errors.ApiException as e:
error(e)
return 1
ret_code = 0
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 == 0:
ret_code = 1
emsg(e)
return ret_code
def test_11_ClientInterface(self):
"""Test the clientInterface class."""
pt = progress.QuietProgressTracker()
cli_inst = cli_api.ClientInterface(
pkg_image=self.img_path(),
prog_tracker=pt,
opts_mapping={"be_name": "boot_env"})
opts = {"repo_uri": self.rurl1}
retjson = cli_inst.publisher_set(json.dumps([]), json.dumps(opts))
epset_schema_in = cli_inst.get_pkg_input_schema("set-publisher")
epset_schema_out = cli_inst.get_pkg_output_schema("set-publisher")
epset_input = {"pargs_json": [], "opts_json": opts}
self.assert_(self.__schema_validation(epset_input, epset_schema_in))
self.assert_(self.__schema_validation(retjson, epset_schema_out))
# Test uninstalling an not installed pkg.
opts = {}
args = ["no_install"]
retjson = cli_inst.uninstall(json.dumps(args), json.dumps(opts))
self.assert_(retjson["status"] == 1)
self.assert_("errors" in retjson)
eunins_schema_in = cli_inst.get_pkg_input_schema("uninstall")
# Test input schema was replaced by an mapped option name.
self.assert_("boot_env" in json.dumps(eunins_schema_in))
eunins_schema_out = cli_inst.get_pkg_output_schema("uninstall")
eunins_input = {"pargs_json": args, "opts_json": opts}
self.assert_(self.__schema_validation(eunins_input, eunins_schema_in))
self.assert_(self.__schema_validation(retjson, eunins_schema_out))
# Test be related exception does not crash the system.
opts = {"boot_env": "s12"}
args = ["no_install"]
retjson = cli_inst.uninstall(json.dumps(args), json.dumps(opts))
self.assert_(retjson["status"] == 1)
self.assert_("errors" in retjson)
self.assert_("boot_env" not in json.dumps(retjson))
retjson = cli_inst.uninstall(json.dumps(["newpkg2"]), json.dumps({}))
self.assert_(retjson["status"] == 1)
self.assert_("errors" in retjson)
opts = {"parsable_version": 0}
args = ["[email protected]"]
retjson = cli_inst.install(json.dumps(args), json.dumps(opts))
self.assert_(retjson["status"] == 0)
self.assert_("errors" not in retjson)
eins_schema_in = cli_inst.get_pkg_input_schema("install")
eins_schema_out = cli_inst.get_pkg_output_schema("install")
eins_input = {"pargs_json": args, "opts_json": opts}
self.assert_(self.__schema_validation(eins_input, eins_schema_in))
self.assert_(self.__schema_validation(retjson, eins_schema_out))
retjson = cli_inst.list_inventory()
self.assert_(retjson["status"] == 0)
self.assert_("errors" not in retjson)
self.assert_("newpkg2" in json.dumps(retjson))
retjson = cli_inst.uninstall(json.dumps(args), json.dumps(opts))
self.assert_(retjson["status"] == 0)
self.assert_("errors" not in retjson)
retjson = cli_inst.publisher_set(json.dumps(["test1"]))
self.assert_(retjson["status"] == 0)
self.assert_("errors" not in retjson)
