def test_columnize_multibyte(self, term_width_mock):
multibyte_str = u"このシステム用に"
term_width_mock.return_value = 40
result = columnize([multibyte_str], _echo, multibyte_str)
expected = u"このシステム用に このシステム用に"
self.assertEquals(result, expected)
term_width_mock.return_value = 14
result = columnize([multibyte_str], _echo, multibyte_str)
expected = u"このシ\nステム\n用に このシ\n ステム\n 用に"
self.assertEquals(result, expected)
def test_columnize_multibyte(self, term_width_mock):
multibyte_str = u"このシステム用に"
term_width_mock.return_value = 40
result = columnize([multibyte_str], _echo, multibyte_str)
expected = u"このシステム用に このシステム用に"
self.assertEquals(result, expected)
term_width_mock.return_value = 14
result = columnize([multibyte_str], _echo, multibyte_str)
expected = u"このシ\nステム\n用に このシ\n ステム\n 用に"
self.assertEquals(result, expected)
def test_columnize_with_small_term(self, term_width_mock):
result = columnize(["Hello Hello Hello Hello:", "Foo Foo Foo Foo:"],
_echo, "This is a testing string", "This_is_another_testing_string")
expected = 'Hello\nHello\nHello\nHello\n: This\n is a\n ' \
'testin\n g\n string\nFoo\nFoo\nFoo\nFoo: ' \
'This_i\n s_anot\n her_te\n sting_\n string'
self.assertNotEquals(result, expected)
term_width_mock.return_value = 12
result = columnize(["Hello Hello Hello Hello:", "Foo Foo Foo Foo:"],
_echo, "This is a testing string", "This_is_another_testing_string")
self.assertEquals(result, expected)
def test_columnize_with_small_term(self, term_width_mock):
result = columnize(["Hello Hello Hello Hello:", "Foo Foo Foo Foo:"],
_echo, "This is a testing string", "This_is_another_testing_string")
expected = 'Hello\nHello\nHello\nHello\n: This\n is a\n ' \
'testin\n g\n string\nFoo\nFoo\nFoo\nFoo: ' \
'This_i\n s_anot\n her_te\n sting_\n string'
self.assertNotEquals(result, expected)
term_width_mock.return_value = 12
result = columnize(["Hello Hello Hello Hello:", "Foo Foo Foo Foo:"],
_echo, "This is a testing string", "This_is_another_testing_string")
self.assertEquals(result, expected)
def print_consumed(self,
service_level=None,
filter_string=None,
pid_only=False):
# list all certificates that have not yet expired, even those
# that are not yet active.
service = entitlement.EntitlementService()
certs = service.get_consumed_product_pools(service_level=service_level,
matches=filter_string)
# Process and display our (filtered) certs:
if len(certs):
if pid_only:
for cert in certs:
print(cert.pool_id)
else:
print("+-------------------------------------------+")
print(" " + _("Consumed Subscriptions"))
print("+-------------------------------------------+")
for cert in certs:
kwargs = {
"filter_string": filter_string,
"match_columns": AVAILABLE_SUBS_MATCH_COLUMNS,
"is_atty": sys.stdout.isatty(),
}
if hasattr(cert, "roles") and hasattr(
cert, "usage") and hasattr(cert, "addons"):
print(
columnize(CONSUMED_LIST,
highlight_by_filter_string_columnize_cb,
*cert, **kwargs) + "\n")
else:
print(
columnize(OLD_CONSUMED_LIST,
highlight_by_filter_string_columnize_cb,
*cert, **kwargs) + "\n")
elif not pid_only:
if filter_string and service_level:
print(
_('No consumed subscription pools were found matching the expression "{filter}" and the service level "{level}".'
).format(filter=filter_string, level=service_level))
elif filter_string:
print(
_('No consumed subscription pools were found matching the expression "{filter}".'
).format(filter=filter_string))
elif service_level:
print(
_('No consumed subscription pools were found matching the service level "{level}".'
).format(level=service_level))
else:
print(_("No consumed subscription pools were found."))
def show_autosubscribe_output(uep, identity):
"""
Try to show auto-attach output
:param uep: object with connection to candlepin
:param identity: object with identity
:return: return 1, when all installed products are subscribed, otherwise return 0
"""
if is_simple_content_access(uep=uep, identity=identity):
return 0
installed_products = products.InstalledProducts(uep).list()
if not installed_products:
# Returning an error code here breaks registering when no products are installed, and the
# AttachCommand already performs this check before calling.
print(_("No products installed."))
return 0
log.debug("Attempted to auto-attach/heal the system.")
print(_("Installed Product Current Status:"))
subscribed = 1
all_subscribed = True
for product in installed_products:
if product[4] == SUBSCRIBED:
subscribed = 0
status = STATUS_MAP[product[4]]
if product[4] == NOT_SUBSCRIBED:
all_subscribed = False
print(columnize(PRODUCT_STATUS, echo_columnize_callback, product[0], status) + "\n")
if not all_subscribed:
print(_("Unable to find available subscriptions for all your installed products."))
return subscribed
def _list(self, all_overrides, specific_repos):
overrides = {}
for override in all_overrides:
repo = override.repo_id
name = override.name
value = override.value
# overrides is a hash of hashes. Like this: {'repo_x': {'enabled': '1', 'gpgcheck': '1'}}
overrides.setdefault(repo, {})[name] = value
to_show = set(overrides.keys())
if specific_repos:
specific_repos = set(specific_repos)
for r in specific_repos.difference(to_show):
print(_("Nothing is known about '{r}'").format(r=r))
# Take the intersection of the sets
to_show &= specific_repos
for repo in sorted(to_show):
print(_("Repository: {repo}").format(repo=repo))
repo_data = sorted(list(overrides[repo].items()),
key=lambda x: x[0])
# Split the list of 2-tuples into a list of names and a list of keys
names, values = list(zip(*repo_data))
names = ["{x}:".format(x=x) for x in names]
print(
columnize(names, echo_columnize_callback, *values, indent=2) +
"\n")
def test_columnize_with_small_term(self, term_width_mock):
term_width_mock.return_value = None
result = columnize(
["Hello Hello Hello Hello:", "Foo Foo Foo Foo:"],
echo_columnize_callback,
"This is a testing string",
"This_is_another_testing_string",
)
expected = (
"Hello\nHello\nHello\nHello\n: This\n is a\n "
"testin\n g\n string\nFoo\nFoo\nFoo\nFoo: "
"This_i\n s_anot\n her_te\n sting_\n string"
)
self.assertNotEqual(result, expected)
term_width_mock.return_value = 12
result = columnize(
["Hello Hello Hello Hello:", "Foo Foo Foo Foo:"],
echo_columnize_callback,
"This is a testing string",
"This_is_another_testing_string",
)
self.assertEqual(result, expected)
def _list_environments(self):
"""
List the environments based on the option selected in the command line
enabled/disabled/all
"""
if not self.cp.has_capability(MULTI_ENV) and (self.options.enabled or
self.options.disabled):
system_exit(
os.EX_UNAVAILABLE,
_("Error: Server does not support multi-environment operations."
))
environments = []
if self.options.enabled:
environments = self.cp.getConsumer(
self.identity.uuid)["environments"] or []
else:
org_environments = self._get_environments(self.org)
if self.options.disabled:
consumer_id_list = []
for env in self.cp.getConsumer(
self.identity.uuid)["environments"]:
consumer_id_list.append(env["id"])
for env in org_environments:
if env["id"] not in consumer_id_list:
environments.append(env)
else:
environments = org_environments
if len(environments):
print("+-------------------------------------------+")
print(" {env}".format(env=_("Environments")))
print("+-------------------------------------------+")
for env in environments:
print(
columnize(
ENVIRONMENT_LIST,
echo_columnize_callback,
env["name"],
env["description"] or "",
) + "\n")
else:
print(
_("This list operation does not have any environments to report."
))
def _do_command(self):
try:
# get a UEP
if self.options.token:
self.cp = self.cp_provider.get_keycloak_auth_cp(
self.options.token)
else:
self.cp_provider.set_user_pass(self.username, self.password)
self.cp = self.cp_provider.get_basic_auth_cp()
owners = self.cp.getOwnerList(self.username)
log.debug("Successfully retrieved org list from server.")
if len(owners):
print("+-------------------------------------------+")
print(" {name} {label}".format(
name=self.username, label=_("Organizations")))
print("+-------------------------------------------+")
print("")
for owner in owners:
print(
columnize(ORG_LIST, echo_columnize_callback,
owner["displayName"], owner["key"]) + "\n")
else:
print(
_("{username} cannot register with any organizations.").
format(username=self.username))
except connection.RestlibException as re:
log.exception(re)
log.error(
"Error: Unable to retrieve org list from server: {re}".format(
re=re))
mapped_message: str = ExceptionMapper().get_message(re)
system_exit(os.EX_SOFTWARE, mapped_message)
except Exception as e:
handle_exception(
_("Error: Unable to retrieve org list from server"), e)
def _do_command(self):
self._validate_options()
try:
if self.options.token:
self.cp = self.cp_provider.get_keycloak_auth_cp(
self.options.token)
else:
self.cp_provider.set_user_pass(self.username, self.password)
self.cp = self.cp_provider.get_basic_auth_cp()
supported_resources = get_supported_resources()
if 'environments' in supported_resources:
environments = self._get_environments(self.org)
if len(environments):
print("+-------------------------------------------+")
print(" {env}".format(env=_('Environments')))
print("+-------------------------------------------+")
for env in environments:
print(
columnize(ENVIRONMENT_LIST,
echo_columnize_callback, env['name'],
env['description'] or "") + "\n")
else:
print(_("This org does not have any environments."))
else:
system_exit(os.EX_UNAVAILABLE,
_("Error: Server does not support environments."))
log.debug("Successfully retrieved environment list from server.")
except connection.RestlibException as re:
log.exception(re)
log.error(
"Error: Unable to retrieve environment list from server: {re}".
format(re=re))
system_exit(os.EX_SOFTWARE, str(re))
except Exception as e:
handle_exception(
_("Error: Unable to retrieve environment list from server"), e)
def _do_columnize(self, items_list):
modules, descriptions = list(zip(*items_list))
print(
columnize(modules, echo_columnize_callback, *descriptions) + '\n')
def _do_columnize(self, items_list):
modules, descriptions = zip(*items_list)
print columnize(modules, echo_columnize_callback, *descriptions) + "\n"
def _do_command(self):
"""
Executes the command.
"""
self._validate_options()
if self.options.installed and not self.options.pid_only:
installed_products = products.InstalledProducts(self.cp).list(
self.options.filter_string)
if len(installed_products):
print("+-------------------------------------------+")
print(_(" Installed Product Status"))
print("+-------------------------------------------+")
for product in installed_products:
if is_simple_content_access(self.cp, self.identity):
print(
columnize(
INSTALLED_PRODUCT_STATUS_SCA,
none_wrap_columnize_callback,
product[0], # Name
product[1], # ID
product[2], # Version
product[3], # Arch
) + "\n")
else:
status = STATUS_MAP[product[4]]
print(
columnize(
INSTALLED_PRODUCT_STATUS,
none_wrap_columnize_callback,
product[0], # Name
product[1], # ID
product[2], # Version
product[3], # Arch
status, # Status
product[5], # Status details
product[6], # Start
product[7], # End
) + "\n")
else:
if self.options.filter_string:
print(
_('No installed products were found matching the expression "{filter}".'
).format(filter=self.options.filter_string))
else:
print(_("No installed products to list"))
if self.options.available:
self.assert_should_be_registered()
on_date = None
after_date = None
if self.options.on_date:
on_date = self._parse_date(self.options.on_date)
elif self.options.after_date:
after_date = self._parse_date(self.options.after_date)
epools = entitlement.EntitlementService().get_available_pools(
show_all=self.options.all,
on_date=on_date,
no_overlap=self.options.no_overlap,
match_installed=self.options.match_installed,
matches=self.options.filter_string,
service_level=self.options.service_level,
after_date=after_date,
)
if len(epools):
if self.options.pid_only:
for data in epools:
print(data["id"])
else:
print("+-------------------------------------------+")
print(" " + _("Available Subscriptions"))
print("+-------------------------------------------+")
for data in epools:
if PoolWrapper(data).is_virt_only():
entitlement_type = _("Virtual")
else:
entitlement_type = _("Physical")
if "management_enabled" in data and data[
"management_enabled"]:
data["management_enabled"] = _("Yes")
else:
data["management_enabled"] = _("No")
kwargs = {
"filter_string": self.options.filter_string,
"match_columns": AVAILABLE_SUBS_MATCH_COLUMNS,
"is_atty": sys.stdout.isatty(),
}
print(
columnize(
AVAILABLE_SUBS_LIST,
highlight_by_filter_string_columnize_cb,
data["productName"], data["providedProducts"],
data["productId"], data["contractNumber"]
or "", data["id"], data["management_enabled"],
data["quantity"], data["suggested"],
data["service_type"] or "",
self._split_mulit_value_field(
data["roles"]), data["service_level"]
or "", data["usage"] or "",
self._split_mulit_value_field(data["addons"]),
data["pool_type"], data["startDate"],
data["endDate"], entitlement_type, **kwargs) +
"\n")
elif not self.options.pid_only:
if self.options.filter_string and self.options.service_level:
print(
_('No available subscription pools were found matching the expression "{filter}" and the service level "{level}".'
).format(filter=self.options.filter_string,
level=self.options.service_level))
elif self.options.filter_string:
print(
_('No available subscription pools were found matching the expression "{filter}".'
).format(filter=self.options.filter_string))
elif self.options.service_level:
print(
_('No available subscription pools were found matching the service level "{level}".'
).format(level=self.options.service_level))
else:
print(_("No available subscription pools to list"))
if self.options.consumed:
self.print_consumed(
service_level=self.options.service_level,
filter_string=self.options.filter_string,
pid_only=self.options.pid_only,
)
def test_columnize_with_empty_list(self):
result = columnize(["Hello:", "Foo:"], echo_columnize_callback, [],
"bar")
self.assertEqual(result, "Hello: \nFoo: bar")
def _do_columnize(self, items_list):
modules, descriptions = list(zip(*items_list))
print(columnize(modules, echo_columnize_callback, *descriptions) + '\n')
def test_columnize(self):
result = columnize(["Hello:", "Foo:"], _echo, "world", "bar")
self.assertEquals(result, "Hello: world\nFoo: bar")
def test_columnize_with_list(self):
result = columnize(["Hello:", "Foo:"], _echo, ["world", "space"], "bar")
self.assertEquals(result, "Hello: world\n space\nFoo: bar")
def _do_command(self):
self._reconcile_list_options()
rc = 0
if not manage_repos_enabled():
print(_("Repositories disabled by configuration."))
return rc
# Pull down any new entitlements and refresh the entitlements directory
if self.identity.is_valid():
cert_action_client = ActionClient(skips=[PackageProfileActionInvoker])
cert_action_client.update()
self._request_validity_check()
if self.is_registered():
supported_resources = get_supported_resources()
self.use_overrides = "content_overrides" in supported_resources
else:
self.use_overrides = False
# specifically, yum repos, for now.
rl = RepoActionInvoker()
repos = rl.get_repos()
if self.options.repo_actions is not None:
rc = self._set_repo_status(repos, rl, self.options.repo_actions)
if self.identity.is_valid():
profile_action_client = ProfileActionClient()
profile_action_client.update()
if self.list:
if len(repos):
# TODO: Perhaps this should be abstracted out as well...?
def filter_repos(repo):
disabled_values = ["false", "0"]
repo_enabled = repo["enabled"].lower()
show_enabled = self.list_enabled and repo_enabled not in disabled_values
show_disabled = self.list_disabled and repo_enabled in disabled_values
return show_enabled or show_disabled
repos = list(filter(filter_repos, repos))
if len(repos):
print("+----------------------------------------------------------+")
print(_(" Available Repositories in {file}").format(file=rl.get_repo_file()))
print("+----------------------------------------------------------+")
for repo in repos:
print(
columnize(
REPOS_LIST,
echo_columnize_callback,
repo.id,
repo["name"],
repo["baseurl"],
repo["enabled"],
)
+ "\n"
)
else:
print(_("There were no available repositories matching the specified criteria."))
else:
print(_("This system has no repositories available through subscriptions."))
return rc
def test_columnize(self):
result = columnize(["Hello:", "Foo:"], _echo, "world", "bar")
self.assertEquals(result, "Hello: world\nFoo: bar")
def test_columnize(self):
result = columnize(["Hello:", "Foo:"], echo_columnize_callback,
"world", "bar")
self.assertEqual(result, "Hello: world\nFoo: bar")
def test_columnize_with_empty_list(self):
result = columnize(["Hello:", "Foo:"], _echo, [], "bar")
self.assertEquals(result, "Hello: \nFoo: bar")
def test_columnize_with_list(self):
result = columnize(["Hello:", "Foo:"], echo_columnize_callback,
["world", "space"], "bar")
self.assertEqual(result, "Hello: world\n space\nFoo: bar")
def _do_columnize(self, items_list):
modules, descriptions = zip(*items_list)
print columnize(modules, _echo, *descriptions) + '\n'
def _do_columnize(self, items_list):
modules, descriptions = zip(*items_list)
print columnize(modules, _echo, *descriptions) + '\n'
