def test_hostname_with_scheme(self):
# this is the default, so test it here
local_url = "https://cdn.redhat.com"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(DEFAULT_CDN_HOSTNAME, hostname)
self.assertEquals(DEFAULT_CDN_PORT, port)
self.assertEquals("/", prefix)
def create_content_connection(self):
(cdn_hostname, cdn_port, cdn_prefix) = parse_baseurl_info(cfg.get('rhsm', 'baseurl'))
self.cp_provider.set_content_connection_info(cdn_hostname=cdn_hostname,
cdn_port=cdn_port)
# ContentConnection now handles reading the proxy information
return self.cp_provider.get_content_connection()
def test_hostname_with_scheme(self):
# this is the default, so test it here
local_url = "https://cdn.redhat.com"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(DEFAULT_CDN_HOSTNAME, hostname)
self.assertEquals(DEFAULT_CDN_PORT, port)
self.assertEquals("/", prefix)
def create_content_connection(self):
(cdn_hostname, cdn_port, cdn_prefix) = parse_baseurl_info(cfg.get('rhsm', 'baseurl'))
self.cp_provider.set_content_connection_info(cdn_hostname=cdn_hostname,
cdn_port=cdn_port)
# ContentConnection now handles reading the proxy information
return self.cp_provider.get_content_connection()
def _create_content_connection(self):
(cdn_hostname, cdn_port, cdn_prefix) = parse_baseurl_info(cfg.get('rhsm', 'baseurl'))
return connection.ContentConnection(host=cdn_hostname,
ssl_port=cdn_port,
proxy_hostname=cfg.get('server', 'proxy_hostname'),
proxy_port=cfg.get_int('server', 'proxy_port'),
proxy_user=cfg.get('server', 'proxy_user'),
proxy_password=cfg.get('server', 'proxy_password'))
def _do_command(self):
cdn_url = conf['rhsm']['baseurl']
# note: parse_baseurl_info will populate with defaults if not found
(cdn_hostname, cdn_port, _cdn_prefix) = parse_baseurl_info(cdn_url)
# Base CliCommand has already setup proxy info etc
self.cp_provider.set_content_connection_info(cdn_hostname=cdn_hostname,
cdn_port=cdn_port)
self.release_backend = ReleaseBackend()
self.assert_should_be_registered()
repo_action_invoker = RepoActionInvoker()
if self.options.unset:
self.cp.updateConsumer(self.identity.uuid,
release="")
repo_action_invoker.update()
print(_("Release preference has been unset"))
elif self.options.release is not None:
# get first list of available releases from the server
try:
releases = self.release_backend.get_releases()
except MultipleReleaseProductsError as err:
log.error("Getting releases failed: {err}".format(err=err))
system_exit(os.EX_CONFIG, err.translated_message())
if self.options.release in releases:
self.cp.updateConsumer(
self.identity.uuid,
release=self.options.release
)
else:
system_exit(os.EX_DATAERR, _(
"No releases match '{release}'. "
"Consult 'release --list' for a full listing.").format(
release=self.options.release))
repo_action_invoker.update()
print(_("Release set to: {release}").format(release=self.options.release))
elif self.options.list:
try:
releases = self.release_backend.get_releases()
except MultipleReleaseProductsError as err:
log.error("Getting releases failed: {err}".format(err=err))
system_exit(os.EX_CONFIG, err.translated_message())
if len(releases) == 0:
system_exit(os.EX_CONFIG, _(
"No release versions available, please check subscriptions."))
print("+-------------------------------------------+")
print(" {label} ".format(label=_('Available Releases')))
print("+-------------------------------------------+")
for release in releases:
print(release)
else:
self.show_current_release()
def _create_content_connection(self):
(cdn_hostname, cdn_port,
cdn_prefix) = parse_baseurl_info(cfg.get('rhsm', 'baseurl'))
return connection.ContentConnection(
host=cdn_hostname,
ssl_port=cdn_port,
proxy_hostname=cfg.get('server', 'proxy_hostname'),
proxy_port=cfg.get_int('server', 'proxy_port'),
proxy_user=cfg.get('server', 'proxy_user'),
proxy_password=cfg.get('server', 'proxy_password'))
def test_format_not_fqdn_with_port(self):
local_url = "https://foo-bar:8088"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(prefix, DEFAULT_CDN_PREFIX)
self.assertEquals("https://foo-bar:8088",
format_baseurl(hostname, port, prefix))
def test_format_thumbslug_url_with_port(self):
local_url = "https://someserver.example.com:8088"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(prefix, DEFAULT_CDN_PREFIX)
self.assertEquals("https://someserver.example.com:8088",
format_baseurl(hostname, port, prefix))
def test_format_base_url_with_port(self):
local_url = "https://cdn.redhat.com:443"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(prefix, DEFAULT_CDN_PREFIX)
self.assertEquals("https://cdn.redhat.com",
format_baseurl(hostname, port, prefix))
def test_format_base_url(self):
local_url = "https://cdn.redhat.com"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(local_url, format_baseurl(hostname, port, prefix))
def test_format_not_fqdn_with_port(self):
local_url = "https://foo-bar:8088"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(prefix, DEFAULT_CDN_PREFIX)
self.assertEquals("https://foo-bar:8088", format_baseurl(hostname, port, prefix))
def test_format_thumbslug_url_with_port(self):
local_url = "https://someserver.example.com:8088"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(prefix, DEFAULT_CDN_PREFIX)
self.assertEquals("https://someserver.example.com:8088", format_baseurl(hostname, port, prefix))
def test_format_base_url_with_port(self):
local_url = "https://cdn.redhat.com:443"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(prefix, DEFAULT_CDN_PREFIX)
self.assertEquals("https://cdn.redhat.com", format_baseurl(hostname, port, prefix))
def test_format_base_url(self):
local_url = "https://cdn.redhat.com"
(hostname, port, prefix) = parse_baseurl_info(local_url)
self.assertEquals(local_url, format_baseurl(hostname, port, prefix))
def main(self, args=None):
# TODO: For now, we disable the CLI entirely. We may want to allow some commands in the future.
if rhsm.config.in_container():
system_exit(
os.EX_CONFIG,
_("subscription-manager is disabled when running inside a container. Please refer to your host system for subscription management.\n"
))
config_changed = False
# In testing we sometimes specify args, otherwise use the default:
if not args:
args = sys.argv[1:]
(self.options, self.args) = self.parser.parse_known_args(args)
# we dont need argv[0] in this list...
self.args = self.args[1:]
# check for unparsed arguments
if self.args:
for arg in self.args:
print(_("cannot parse argument: {}").format(arg))
system_exit(os.EX_USAGE)
if hasattr(self.options, "insecure") and self.options.insecure:
conf["server"]["insecure"] = "1"
config_changed = True
if hasattr(self.options, "server_url") and self.options.server_url:
try:
(self.server_hostname, self.server_port,
self.server_prefix) = parse_server_info(
self.options.server_url, conf)
except ServerUrlParseError as e:
print(_("Error parsing serverurl:"))
handle_exception("Error parsing serverurl:", e)
conf["server"]["hostname"] = self.server_hostname
conf["server"]["port"] = self.server_port
conf["server"]["prefix"] = self.server_prefix
if self.server_port:
self.server_port = int(self.server_port)
config_changed = True
if hasattr(self.options, "base_url") and self.options.base_url:
try:
(baseurl_server_hostname, baseurl_server_port,
baseurl_server_prefix) = parse_baseurl_info(
self.options.base_url)
except ServerUrlParseError as e:
print(_("Error parsing baseurl:"))
handle_exception("Error parsing baseurl:", e)
conf["rhsm"]["baseurl"] = format_baseurl(baseurl_server_hostname,
baseurl_server_port,
baseurl_server_prefix)
config_changed = True
# support foo.example.com:3128 format
if hasattr(self.options, "proxy_url") and self.options.proxy_url:
parts = remove_scheme(self.options.proxy_url).split(':')
self.proxy_hostname = parts[0]
# no ':'
if len(parts) > 1:
self.proxy_port = int(parts[1])
else:
# if no port specified, use the one from the config, or fallback to the default
self.proxy_port = conf['server'].get_int(
'proxy_port') or rhsm.config.DEFAULT_PROXY_PORT
config_changed = True
if hasattr(self.options, "proxy_user") and self.options.proxy_user:
self.proxy_user = self.options.proxy_user
if hasattr(self.options,
"proxy_password") and self.options.proxy_password:
self.proxy_password = self.options.proxy_password
if hasattr(self.options, "no_proxy") and self.options.no_proxy:
self.no_proxy = self.options.no_proxy
# Proxy information isn't written to the config, so we have to make sure
# the sorter gets it
connection_info = {}
if self.proxy_hostname:
connection_info['proxy_hostname_arg'] = self.proxy_hostname
if self.proxy_port:
connection_info['proxy_port_arg'] = self.proxy_port
if self.proxy_user:
connection_info['proxy_user_arg'] = self.proxy_user
if self.proxy_password:
connection_info['proxy_password_arg'] = self.proxy_password
if self.server_hostname:
connection_info['host'] = self.server_hostname
if self.server_port:
connection_info['ssl_port'] = self.server_port
if self.server_prefix:
connection_info['handler'] = self.server_prefix
if self.no_proxy:
connection_info['no_proxy_arg'] = self.no_proxy
self.cp_provider = inj.require(inj.CP_PROVIDER)
self.cp_provider.set_connection_info(**connection_info)
self.log.debug("X-Correlation-ID: {id}".format(id=self.correlation_id))
self.cp_provider.set_correlation_id(self.correlation_id)
self.log_client_version()
if self.require_connection():
# make sure we pass in the new server info, otherwise we
# we use the defaults from connection module init
# we've set self.proxy* here, so we'll use them if they
# are set
self.cp = self.cp_provider.get_consumer_auth_cp()
# no auth cp for get / (resources) and
# get /status (status and versions)
self.no_auth_cp = self.cp_provider.get_no_auth_cp()
self.entcertlib = EntCertActionInvoker()
if config_changed:
try:
# catch host/port issues; does not catch auth issues
if not self.test_proxy_connection():
system_exit(
os.EX_UNAVAILABLE,
_("Proxy connection failed, please check your settings."
))
# this tries to actually connect to the server and ping it
if not is_valid_server_info(self.no_auth_cp):
system_exit(
os.EX_UNAVAILABLE,
_("Unable to reach the server at {host}:{port}{handler}"
).format(host=self.no_auth_cp.host,
port=self.no_auth_cp.ssl_port,
handler=self.no_auth_cp.handler))
except MissingCaCertException:
system_exit(
os.EX_CONFIG,
_("Error: CA certificate for subscription service has not been installed."
))
except ProxyException:
system_exit(
os.EX_UNAVAILABLE,
_("Proxy connection failed, please check your settings."
))
else:
self.cp = None
# do the work, catch most common errors here:
try:
return_code = self._do_command()
# Only persist the config changes if there was no exception
if config_changed and self.persist_server_options():
conf.persist()
if return_code is not None:
return return_code
except (CertificateException, ssl.SSLError) as e:
log.error(e)
system_exit(os.EX_SOFTWARE,
_('System certificates corrupted. Please reregister.'))
except connection.GoneException as ge:
if ge.deleted_id == self.identity.uuid:
log.critical(
"Consumer profile \"{uuid}\" has been deleted from the server."
.format(uuid=self.identity.uuid))
system_exit(
os.EX_UNAVAILABLE,
_("Consumer profile \"{uuid}\" has been deleted from the server. You can use command clean or unregister to remove local profile."
).format(uuid=self.identity.uuid))
else:
raise ge
except InvalidCLIOptionError as err:
# This exception is handled in cli module
raise err
except Exception as err:
handle_exception("exception caught in subscription-manager", err)
