def bind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _('This consumer is not registered to the Pulp server')
self.prompt.render_failure_message(m)
return
repo_id = kwargs['repo-id']
try:
response = self.context.server.bind.bind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID)
msg = _('Bind tasks successfully created:')
self.context.prompt.render_success_message(msg)
tasks = [dict(task_id=str(t.task_id)) for t in response.response_body.spawned_tasks]
self.context.prompt.render_document_list(tasks)
except NotFoundException, e:
resources = e.extra_data['resources']
if 'consumer' in resources:
r_type = _('Consumer')
r_id = consumer_id
else:
r_type = _('Repository')
r_id = repo_id
msg = _('%(t)s [%(id)s] does not exist on the server')
self.context.prompt.write(msg % {'t': r_type, 'id': r_id}, tag='not-found')
def unbind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _('This consumer is not registered to the Pulp server')
self.prompt.render_failure_message(m)
return
repo_id = kwargs['repo-id']
force = kwargs['force']
try:
response = self.context.server.bind.unbind(consumer_id, repo_id,
YUM_DISTRIBUTOR_TYPE_ID, force)
msg = _('Unbind tasks successfully created:')
self.context.prompt.render_success_message(msg)
tasks = [dict(task_id=str(t.task_id)) for t in response.response_body.spawned_tasks]
self.context.prompt.render_document_list(tasks)
except NotFoundException, e:
bind_id = e.extra_data['resources']['bind_id']
m = _('Binding [consumer: %(c)s, repository: %(r)s] does not exist on the server')
d = {
'c': bind_id['consumer_id'],
'r': bind_id['repo_id'],
}
self.context.prompt.write(m % d, tag='not-found')
def run(self, **kwargs):
self.context.prompt.render_warning_message(CLI_DEPRECATION_WARNING)
repo_id = kwargs[OPTION_REPO_ID.keyword]
node_id = load_consumer_id(self.context)
dist_id = constants.HTTP_DISTRIBUTOR
strategy = kwargs[STRATEGY_OPTION.keyword]
binding_config = {constants.STRATEGY_KEYWORD: strategy}
if not node_activated(self.context, node_id):
msg = NOT_ACTIVATED_ERROR
self.context.prompt.render_failure_message(msg)
return os.EX_USAGE
if not repository_enabled(self.context, repo_id):
msg = BIND_FAILED_NOT_ENABLED
self.context.prompt.render_failure_message(msg)
return os.EX_USAGE
if strategy not in constants.STRATEGIES:
msg = STRATEGY_NOT_SUPPORTED % dict(n=strategy,
s=constants.STRATEGIES)
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
self.context.server.bind.bind(node_id,
repo_id,
dist_id,
notify_agent=False,
binding_config=binding_config)
self.context.prompt.render_success_message(BIND_SUCCEEDED)
warning = BIND_WARNING % dict(r=repo_id)
self.context.prompt.render_warning_message(warning)
def unregister(self, **kwargs):
force = kwargs['force']
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _("Write permission is required for %(d)s to perform this operation.")
self.prompt.render_failure_message(msg % {'d': id_cert_dir})
return exceptions.CODE_PERMISSIONS_EXCEPTION
# Get the consumer ID
try:
consumer_id = load_consumer_id(self.context)
if not consumer_id:
msg = _('This consumer is not registered to the Pulp server.')
self.context.prompt.render_failure_message(msg)
return exceptions.CODE_NOT_FOUND
except X509Error:
self.context.logger.exception('Consumer certificate not valid.')
if force:
self._delete_cert()
msg = _('Consumer certificate deleted.')
self.context.prompt.render_success_message(msg)
self._forced_warning()
return os.EX_OK
else:
msg = _('Consumer certificate not valid. Please retry using the --force option.')
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
# Unregister on the server
forced = True
try:
self.context.server.consumer.unregister(consumer_id)
forced = False
except NotFoundException:
if not force:
msg = _('This consumer does not exist on the server. Please retry using the --force option.')
self.prompt.render_failure_message(msg)
return exceptions.CODE_NOT_FOUND
except X509Error:
self.context.logger.exception('SSL connection failed.')
if not force:
msg = _('SSL connection failed. This error may be ignored by using the --force option.')
self.prompt.render_failure_message(msg)
return os.EX_OSERR
except Exception:
self.context.logger.exception('Unregistration failed')
if not force:
msg = _('Unregistration failed on the server. This error may be ignored by using the --force option.')
self.prompt.render_failure_message(msg)
return exceptions.CODE_UNEXPECTED
# Unregister locally
self._delete_cert()
msg = 'Consumer [%(c)s] successfully unregistered' % dict(c=consumer_id)
self.context.prompt.render_success_message(msg)
if forced:
self._forced_warning()
def bind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _("This consumer is not registered to the Pulp server")
self.prompt.render_failure_message(m)
return
repo_id = kwargs["repo-id"]
try:
response = self.context.server.bind.bind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID)
msg = _("Bind tasks successfully created:")
self.context.prompt.render_success_message(msg)
tasks = [dict(task_id=str(t.task_id)) for t in response.response_body]
self.context.prompt.render_document_list(tasks)
except NotFoundException, e:
resources = e.extra_data["resources"]
if "consumer" in resources:
r_type = _("Consumer")
r_id = consumer_id
else:
r_type = _("Repository")
r_id = repo_id
msg = _("%(t)s [%(id)s] does not exist on the server")
self.context.prompt.write(msg % {"t": r_type, "id": r_id}, tag="not-found")
def bind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _('This consumer is not registered to the Pulp server')
self.prompt.render_failure_message(m)
return
repo_id = kwargs['repo-id']
try:
response = self.context.server.bind.bind(consumer_id, repo_id,
YUM_DISTRIBUTOR_TYPE_ID)
msg = _('Bind tasks successfully created:')
self.context.prompt.render_success_message(msg)
tasks = [
dict(task_id=str(t.task_id))
for t in response.response_body.spawned_tasks
]
self.context.prompt.render_document_list(tasks)
except BadRequestException, e:
property_names = e.extra_data['property_names']
if 'repo_id' in property_names:
msg = _('Repository [%(r)s] does not exist on the server')
else:
msg = _('Repository [%(r)s] does not have a distributor')
self.context.prompt.render_failure_message(msg % {'r': repo_id},
tag='not-found')
def unbind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _('This consumer is not registered to the Pulp server')
self.prompt.render_failure_message(m)
return
repo_id = kwargs['repo-id']
force = kwargs['force']
try:
response = self.context.server.bind.unbind(
consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID, force)
msg = _('Unbind tasks successfully created:')
self.context.prompt.render_success_message(msg)
tasks = [
dict(task_id=str(t.task_id))
for t in response.response_body.spawned_tasks
]
self.context.prompt.render_document_list(tasks)
except NotFoundException, e:
resources = e.extra_data['resources']
if 'repo_id' in resources:
m = _('Repository [%(r)s] does not exist on the server')
d = {'r': repo_id}
else:
m = _(
'Binding [consumer: %(c)s, repository: %(r)s] does not exist on the server'
)
d = {
'c': consumer_id,
'r': repo_id,
}
self.context.prompt.render_failure_message(m % d, tag='not-found')
def run(self, **kwargs):
consumer_id = load_consumer_id(self.context)
strategy = kwargs[STRATEGY_OPTION.keyword]
delta = {'notes': {constants.NODE_NOTE_KEY: True, constants.STRATEGY_NOTE_KEY: strategy}}
if node_activated(self.context, consumer_id):
self.context.prompt.render_success_message(ALREADY_ACTIVATED_NOTHING_DONE)
return
if strategy not in constants.STRATEGIES:
msg = STRATEGY_NOT_SUPPORTED % dict(n=strategy, s=constants.STRATEGIES)
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
try:
self.context.server.consumer.update(consumer_id, delta)
self.context.prompt.render_success_message(NODE_ACTIVATED)
except NotFoundException, e:
for _id, _type in missing_resources(e):
if _type == 'consumer':
self.context.prompt.render_failure_message(NOT_REGISTERED_MESSAGE)
else:
raise
return os.EX_DATAERR
def run(self, **kwargs):
repo_id = kwargs[OPTION_REPO_ID.keyword]
node_id = load_consumer_id(self.context)
dist_id = constants.HTTP_DISTRIBUTOR
strategy = kwargs[STRATEGY_OPTION.keyword]
binding_config = {constants.STRATEGY_KEYWORD: strategy}
if not node_activated(self.context, node_id):
msg = NOT_ACTIVATED_ERROR
self.context.prompt.render_failure_message(msg)
return os.EX_USAGE
if strategy not in constants.STRATEGIES:
msg = STRATEGY_NOT_SUPPORTED % dict(n=strategy, s=constants.STRATEGIES)
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
try:
self.context.server.bind.bind(node_id, repo_id, dist_id, notify_agent=False, binding_config=binding_config)
self.context.prompt.render_success_message(BIND_SUCCEEDED)
warning = BIND_WARNING % dict(r=repo_id)
self.context.prompt.render_warning_message(warning)
except NotFoundException, e:
unhandled = self.missing_resources(self.context.prompt, e)
for _id, _type in unhandled:
if _type == "distributor":
msg = BIND_FAILED_NOT_ENABLED
self.context.prompt.render_failure_message(msg)
else:
raise
return os.EX_DATAERR
def update(self, **kwargs):
# Assemble the delta for all options that were passed in
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message(
"This consumer is not registered to the Pulp server.")
return
delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
if 'note' in delta.keys():
if delta['note']:
delta['notes'] = args_to_notes_dict(kwargs['note'],
include_none=False)
delta.pop('note')
# convert display-name to display_name
key = 'display-name'
if key in delta:
v = delta.pop(key)
key = key.replace('-', '_')
delta[key] = v
try:
self.context.server.consumer.update(consumer_id, delta)
self.prompt.render_success_message(
'Consumer [%s] successfully updated' % consumer_id)
except NotFoundException:
self.prompt.write('Consumer [%s] does not exist on the server' %
consumer_id,
tag='not-found')
def run(self, **kwargs):
self.context.prompt.render_warning_message(CLI_DEPRECATION_WARNING)
consumer_id = load_consumer_id(self.context)
strategy = kwargs[STRATEGY_OPTION.keyword]
delta = {
'notes': {
constants.NODE_NOTE_KEY: True,
constants.STRATEGY_NOTE_KEY: strategy
}
}
if node_activated(self.context, consumer_id):
self.context.prompt.render_success_message(
ALREADY_ACTIVATED_NOTHING_DONE)
return
if strategy not in constants.STRATEGIES:
msg = STRATEGY_NOT_SUPPORTED % dict(n=strategy,
s=constants.STRATEGIES)
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
try:
self.context.server.consumer.update(consumer_id, delta)
self.context.prompt.render_success_message(NODE_ACTIVATED)
except NotFoundException, e:
for _id, _type in missing_resources(e):
if _type == 'consumer':
self.context.prompt.render_failure_message(
NOT_REGISTERED_MESSAGE)
else:
raise
return os.EX_DATAERR
def run(self, **kwargs):
repo_id = kwargs[OPTION_REPO_ID.keyword]
node_id = load_consumer_id(self.context)
dist_id = constants.HTTP_DISTRIBUTOR
strategy = kwargs[STRATEGY_OPTION.keyword]
binding_config = {constants.STRATEGY_KEYWORD: strategy}
if not node_activated(self.context, node_id):
msg = NOT_ACTIVATED_ERROR
self.context.prompt.render_failure_message(msg)
return os.EX_USAGE
if not repository_enabled(self.context, repo_id):
msg = BIND_FAILED_NOT_ENABLED
self.context.prompt.render_failure_message(msg)
return os.EX_USAGE
if strategy not in constants.STRATEGIES:
msg = STRATEGY_NOT_SUPPORTED % dict(n=strategy, s=constants.STRATEGIES)
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
self.context.server.bind.bind(
node_id,
repo_id,
dist_id,
notify_agent=False,
binding_config=binding_config)
self.context.prompt.render_success_message(BIND_SUCCEEDED)
warning = BIND_WARNING % dict(r=repo_id)
self.context.prompt.render_warning_message(warning)
def unregister(self, **kwargs):
force = kwargs['force']
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _("Write permission is required for %(d)s to perform this operation.")
self.prompt.render_failure_message(msg % {'d': id_cert_dir})
return exceptions.CODE_PERMISSIONS_EXCEPTION
# Get the consumer ID
try:
consumer_id = load_consumer_id(self.context)
if not consumer_id:
msg = _('This consumer is not registered to the Pulp server.')
self.context.prompt.render_failure_message(msg)
return exceptions.CODE_NOT_FOUND
except X509Error:
self.context.logger.exception('Consumer certificate not valid.')
if force:
self._delete_cert()
msg = _('Consumer certificate deleted.')
self.context.prompt.render_success_message(msg)
self._forced_warning()
return os.EX_OK
else:
msg = _('Consumer certificate not valid. Please retry using the --force option.')
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
# Unregister on the server
forced = True
try:
self.context.server.consumer.unregister(consumer_id)
forced = False
except NotFoundException:
if not force:
msg = _('This consumer does not exist on the server. Please retry using the --force option.')
self.prompt.render_failure_message(msg)
return exceptions.CODE_NOT_FOUND
except X509Error:
self.context.logger.exception('SSL connection failed.')
if not force:
msg = _('SSL connection failed. This error may be ignored by using the --force option.')
self.prompt.render_failure_message(msg)
return os.EX_OSERR
except Exception:
self.context.logger.exception('Unregistration failed')
if not force:
msg = _('Unregistration failed on the server. This error may be ignored by using the --force option.')
self.prompt.render_failure_message(msg)
return exceptions.CODE_UNEXPECTED
# Unregister locally
self._delete_cert()
msg = 'Consumer [%(c)s] successfully unregistered' % dict(c=consumer_id)
self.context.prompt.render_success_message(msg)
if forced:
self._forced_warning()
def run(self, **kwargs):
self.context.prompt.render_warning_message(CLI_DEPRECATION_WARNING)
consumer_id = load_consumer_id(self.context)
delta = {
'notes': {
constants.NODE_NOTE_KEY: None,
constants.STRATEGY_NOTE_KEY: None
}
}
if not node_activated(self.context, consumer_id):
self.context.prompt.render_success_message(
NOT_ACTIVATED_NOTHING_DONE)
return
try:
self.context.server.consumer.update(consumer_id, delta)
self.context.prompt.render_success_message(NODE_DEACTIVATED)
except NotFoundException, e:
for _id, _type in missing_resources(e):
if _type == 'consumer':
self.context.prompt.render_failure_message(
NOT_REGISTERED_MESSAGE)
else:
raise
return os.EX_DATAERR
def status(self):
consumer_id = load_consumer_id(self.context)
if consumer_id:
m = 'This consumer is registered with the ID [%(i)s].'
self.prompt.render_success_message(_(m) % {'i' : consumer_id})
else:
m = 'This consumer is not currently registered.'
self.prompt.render_paragraph(_(m))
def status(self):
consumer_id = load_consumer_id(self.context)
if consumer_id:
server = self.context.config['server']['host']
m = 'This consumer is registered to the server [%(s)s] with the ID [%(i)s].'
self.prompt.render_success_message(_(m) % {'s': server, 'i' : consumer_id})
else:
m = 'This consumer is not currently registered.'
self.prompt.render_paragraph(_(m))
def status(self):
consumer_id = load_consumer_id(self.context)
if consumer_id:
server = self.context.config['server']['host']
m = 'This consumer is registered to the server [%(s)s] with the ID [%(i)s].'
self.prompt.render_success_message(_(m) % {'s': server, 'i' : consumer_id})
else:
m = 'This consumer is not currently registered.'
self.prompt.render_paragraph(_(m))
def status(self):
consumer_id = load_consumer_id(self.context)
if consumer_id:
server = self.context.config["server"]["host"]
m = "This consumer is registered to the server [%(s)s] with the ID [%(i)s]."
self.prompt.render_success_message(_(m) % {"s": server, "i": consumer_id})
else:
m = "This consumer is not currently registered."
self.prompt.render_paragraph(_(m))
def unbind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
repo_id = kwargs['repo-id']
distributor_id = kwargs['distributor-id']
try:
self.context.server.bind.unbind(consumer_id, repo_id, distributor_id)
self.prompt.render_success_message('Consumer [%s] successfully unbound from repository distributor [%s : %s]' % (consumer_id, repo_id, distributor_id))
except NotFoundException:
self.prompt.write('Consumer [%s] does not exist on the server' % consumer_id, tag='not-found')
def history(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
self.prompt.render_title(_('Consumer History [%(i)s]') % {'i' : consumer_id})
history_list = self.context.server.consumer_history.history(consumer_id, kwargs['event-type'], kwargs['limit'], kwargs['sort'],
kwargs['start-date'], kwargs['end-date']).response_body
filters = ['consumer_id', 'type', 'details', 'originator', 'timestamp']
order = filters
for history in history_list:
self.prompt.render_document(history, filters=filters, order=order)
def history(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
self.prompt.render_title(_('Consumer History [%(i)s]') % {'i' : consumer_id})
history_list = self.context.server.consumer_history.history(consumer_id, kwargs['event-type'], kwargs['limit'], kwargs['sort'],
kwargs['start-date'], kwargs['end-date']).response_body
filters = ['consumer_id', 'type', 'details', 'originator', 'timestamp']
order = filters
for history in history_list:
self.prompt.render_document(history, filters=filters, order=order)
def history(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
self.prompt.render_title(_("Consumer History [%(i)s]") % {"i": consumer_id})
history_list = self.context.server.consumer_history.history(
consumer_id, kwargs["event-type"], kwargs["limit"], kwargs["sort"], kwargs["start-date"], kwargs["end-date"]
).response_body
filters = ["consumer_id", "type", "details", "originator", "timestamp"]
order = filters
for history in history_list:
self.prompt.render_document(history, filters=filters, order=order)
def bind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
repo_id = kwargs["repo-id"]
distributor_id = kwargs["distributor-id"]
try:
self.context.server.bind.bind(consumer_id, repo_id, distributor_id)
self.prompt.render_success_message(
"Consumer [%s] successfully bound to repository distributor [%s : %s]"
% (consumer_id, repo_id, distributor_id)
)
except NotFoundException:
self.prompt.write("Consumer [%s] does not exist on the server" % consumer_id, tag="not-found")
def run(self, **kwargs):
consumer_id = load_consumer_id(self.context)
delta = {'notes': ACTIVATED_NOTE}
try:
self.context.server.consumer.update(consumer_id, delta)
self.context.prompt.render_success_message(NODE_ACTIVATED)
except NotFoundException, e:
for _id, _type in missing_resources(e):
if _type == 'consumer':
self.context.prompt.render_failure_message(NOT_REGISTERED_MESSAGE)
else:
raise
return os.EX_DATAERR
def unbind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = 'This consumer is not registered to the Pulp server'
self.prompt.render_failure_message(_(m))
return
repo_id = kwargs['repo-id']
try:
self.context.server.bind.unbind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID)
m = 'Consumer [%(c)s] successfully unbound from repository [%(r)s]'
self.prompt.render_success_message(_(m) % {'c' : consumer_id, 'r' : repo_id})
except NotFoundException:
m = 'Consumer [%(c)s] does not exist on the server'
self.prompt.render_failure_message(_(m) % {'c' : consumer_id}, tag='not-found')
def unregister(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.context.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
try:
self.context.server.consumer.unregister(consumer_id)
self._delete_cert()
self.context.prompt.render_success_message('Consumer [%s] successfully unregistered' % consumer_id)
except Exception:
if kwargs['force']:
self._delete_cert()
self.context.prompt.render_success_message('Consumer [%s] successfully unregistered' % consumer_id)
else:
raise
def register(self, **kwargs):
# Get consumer id
id = kwargs['consumer-id']
# Check if this consumer is already registered
existing_consumer = load_consumer_id(self.context)
if existing_consumer:
m = _(
'This system has already been registered as a consumer. Please '
'use the unregister command to remove the consumer before attempting '
'to re-register.')
self.prompt.render_failure_message(m)
return
# Get other consumer parameters
name = id
if 'display-name' in kwargs:
name = kwargs['display-name']
description = kwargs['description']
notes = None
if 'note' in kwargs.keys():
if kwargs['note']:
notes = args_to_notes_dict(kwargs['note'], include_none=False)
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _(
"Write permission is required for %(d)s to perform this operation."
)
self.prompt.render_failure_message(msg % {'d': id_cert_dir})
return exceptions.CODE_PERMISSIONS_EXCEPTION
# Call the server
consumer = self.context.server.consumer.register(
id, name, description, notes).response_body
# Write consumer cert
id_cert_name = self.context.config['filesystem']['id_cert_filename']
cert_filename = os.path.join(id_cert_dir, id_cert_name)
f = open(cert_filename, 'w')
f.write(consumer['certificate'])
f.close()
self.prompt.render_success_message(
'Consumer [%s] successfully registered' % id)
def unbind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = "This consumer is not registered to the Pulp server"
self.prompt.render_failure_message(_(m))
return
repo_id = kwargs["repo-id"]
force = kwargs["force"]
try:
self.context.server.bind.unbind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID, force)
m = "Consumer [%(c)s] successfully unbound from repository [%(r)s]"
self.prompt.render_success_message(_(m) % {"c": consumer_id, "r": repo_id})
except NotFoundException:
m = "Consumer [%(c)s] does not exist on the server"
self.prompt.render_failure_message(_(m) % {"c": consumer_id}, tag="not-found")
def update(self, **kwargs):
# Assemble the delta for all options that were passed in
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
if 'note' in delta.keys():
if delta['note']:
delta['notes'] = args_to_notes_dict(kwargs['note'], include_none=False)
delta.pop('note')
try:
self.context.server.consumer.update(consumer_id, delta)
self.prompt.render_success_message('Consumer [%s] successfully updated' % consumer_id)
except NotFoundException:
self.prompt.write('Consumer [%s] does not exist on the server' % consumer_id, tag='not-found')
def register(self, **kwargs):
# Get consumer id
id = kwargs["consumer-id"]
# Check if this consumer is already registered
existing_consumer = load_consumer_id(self.context)
if existing_consumer:
m = (
"This system has already been registered as a consumer. Please "
"use the unregister command to remove the consumer before attempting "
"to reregister."
)
self.prompt.render_failure_message(_(m))
return
# Get other consumer parameters
name = id
if "display-name" in kwargs:
name = kwargs["display-name"]
description = kwargs["description"]
notes = None
if "note" in kwargs.keys():
if kwargs["note"]:
notes = args_to_notes_dict(kwargs["note"], include_none=False)
# Check write permissions to cert directory
id_cert_dir = self.context.config["filesystem"]["id_cert_dir"]
if not os.access(id_cert_dir, os.W_OK):
msg = _("Write permission is required for %(d)s to perform this operation.")
self.prompt.render_failure_message(msg % {"d": id_cert_dir})
return os.EX_NOPERM
# Call the server
consumer = self.context.server.consumer.register(id, name, description, notes).response_body
# Write consumer cert
id_cert_name = self.context.config["filesystem"]["id_cert_filename"]
cert_filename = os.path.join(id_cert_dir, id_cert_name)
f = open(cert_filename, "w")
f.write(consumer["certificate"])
f.close()
self.prompt.render_success_message("Consumer [%s] successfully registered" % id)
def update(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message(
"This consumer is not registered to the Pulp "
"server.")
return
delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
if 'note' in delta.keys():
if delta['note']:
delta['notes'] = args_to_notes_dict(kwargs['note'],
include_none=False)
delta.pop('note')
# convert display-name to display_name
key = 'display-name'
if key in delta:
v = delta.pop(key)
key = key.replace('-', '_')
delta[key] = v
if kwargs.get(OPTION_EXCHANGE_KEYS.keyword):
path = self.context.config['authentication']['rsa_pub']
fp = open(path)
try:
delta['rsa_pub'] = fp.read()
finally:
fp.close()
try:
self.context.server.consumer.update(consumer_id, delta)
self.prompt.render_success_message(
'Consumer [%s] successfully updated' % consumer_id)
if not kwargs.get(OPTION_EXCHANGE_KEYS.keyword):
return
try:
update_server_key(self.context.config)
except Exception, e:
msg = _('Download server RSA key failed [%(e)s]' % {'e': e})
self.prompt.render_failure_message(msg)
except NotFoundException:
self.prompt.write('Consumer [%s] does not exist on the server' %
consumer_id,
tag='not-found')
def run(self, **kwargs):
consumer_id = load_consumer_id(self.context)
delta = {"notes": {constants.NODE_NOTE_KEY: None, constants.STRATEGY_NOTE_KEY: None}}
if not node_activated(self.context, consumer_id):
self.context.prompt.render_success_message(NOT_ACTIVATED_NOTHING_DONE)
return
try:
self.context.server.consumer.update(consumer_id, delta)
self.context.prompt.render_success_message(NODE_DEACTIVATED)
except NotFoundException, e:
for _id, _type in missing_resources(e):
if _type == "consumer":
self.context.prompt.render_failure_message(NOT_REGISTERED_MESSAGE)
else:
raise
return os.EX_DATAERR
def register(self, **kwargs):
# Get consumer id
id = kwargs['consumer-id']
# Check if this consumer is already registered
existing_consumer = load_consumer_id(self.context)
if existing_consumer:
m = _('This system has already been registered as a consumer. Please '
'use the unregister command to remove the consumer before attempting '
'to re-register.')
self.prompt.render_failure_message(m)
return
# Get other consumer parameters
name = id
if 'display-name' in kwargs:
name = kwargs['display-name']
description = kwargs['description']
notes = None
if 'note' in kwargs.keys():
if kwargs['note']:
notes = args_to_notes_dict(kwargs['note'], include_none=False)
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _("Write permission is required for %(d)s to perform this operation.")
self.prompt.render_failure_message(msg % {'d': id_cert_dir})
return exceptions.CODE_PERMISSIONS_EXCEPTION
# Call the server
consumer = self.context.server.consumer.register(id, name, description, notes).response_body
# Write consumer cert
id_cert_name = self.context.config['filesystem']['id_cert_filename']
cert_filename = os.path.join(id_cert_dir, id_cert_name)
f = open(cert_filename, 'w')
f.write(consumer['certificate'])
f.close()
self.prompt.render_success_message('Consumer [%s] successfully registered' % id)
def run(self, **kwargs):
repo_id = kwargs[OPTION_REPO_ID.keyword]
node_id = load_consumer_id(self.context)
dist_id = constants.HTTP_DISTRIBUTOR
try:
self.context.server.bind.unbind(node_id, repo_id, dist_id)
self.context.prompt.render_success_message(UNBIND_SUCCEEDED)
warning = UNBIND_WARNING % dict(r=repo_id)
self.context.prompt.render_warning_message(warning)
except NotFoundException, e:
unhandled = self.missing_resources(self.context.prompt, e)
for _id, _type in unhandled:
if _type == 'bind_id':
msg = NOT_BOUND_NOTHING_DONE
self.context.prompt.render_failure_message(msg)
else:
raise
return os.EX_DATAERR
def run(self, **kwargs):
repo_id = kwargs[OPTION_REPO_ID.keyword]
node_id = load_consumer_id(self.context)
dist_id = constants.HTTP_DISTRIBUTOR
try:
self.context.server.bind.unbind(node_id, repo_id, dist_id)
self.context.prompt.render_success_message(UNBIND_SUCCEEDED)
warning = UNBIND_WARNING % dict(r=repo_id)
self.context.prompt.render_warning_message(warning)
except NotFoundException, e:
unhandled = self.missing_resources(self.context.prompt, e)
for _id, _type in unhandled:
if _type == "bind_id":
msg = NOT_BOUND_NOTHING_DONE
self.context.prompt.render_success_message(msg)
else:
raise
return os.EX_DATAERR
def unbind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _("This consumer is not registered to the Pulp server")
self.prompt.render_failure_message(m)
return
repo_id = kwargs["repo-id"]
force = kwargs["force"]
try:
response = self.context.server.bind.unbind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID, force)
msg = _("Unbind tasks successfully created:")
self.context.prompt.render_success_message(msg)
tasks = [dict(task_id=str(t.task_id)) for t in response.response_body]
self.context.prompt.render_document_list(tasks)
except NotFoundException, e:
bind_id = e.extra_data["resources"]["bind_id"]
m = _("Binding [consumer: %(c)s, repository: %(r)s] does not exist on the server")
d = {"c": bind_id["consumer_id"], "r": bind_id["repo_id"]}
self.context.prompt.write(m % d, tag="not-found")
def update(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp "
"server.")
return
delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
if 'note' in delta.keys():
if delta['note']:
delta['notes'] = args_to_notes_dict(kwargs['note'], include_none=False)
delta.pop('note')
# convert display-name to display_name
key = 'display-name'
if key in delta:
v = delta.pop(key)
key = key.replace('-', '_')
delta[key] = v
if kwargs.get(OPTION_EXCHANGE_KEYS.keyword):
path = self.context.config['authentication']['rsa_pub']
fp = open(path)
try:
delta['rsa_pub'] = fp.read()
finally:
fp.close()
try:
self.context.server.consumer.update(consumer_id, delta)
self.prompt.render_success_message('Consumer [%s] successfully updated' % consumer_id)
if not kwargs.get(OPTION_EXCHANGE_KEYS.keyword):
return
try:
update_server_key(self.context.config)
except Exception, e:
msg = _('Download server RSA key failed [%(e)s]' % {'e': e})
self.prompt.render_failure_message(msg)
except NotFoundException:
self.prompt.write('Consumer [%s] does not exist on the server' % consumer_id,
tag='not-found')
def bind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = _('This consumer is not registered to the Pulp server')
self.prompt.render_failure_message(m)
return
repo_id = kwargs['repo-id']
try:
response = self.context.server.bind.bind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID)
msg = _('Bind tasks successfully created:')
self.context.prompt.render_success_message(msg)
tasks = [dict(task_id=str(t.task_id)) for t in response.response_body.spawned_tasks]
self.context.prompt.render_document_list(tasks)
except BadRequestException, e:
property_names = e.extra_data['property_names']
if 'repo_id' in property_names:
msg = _('Repository [%(r)s] does not exist on the server')
else:
msg = _('Repository [%(r)s] does not have a distributor')
self.context.prompt.render_failure_message(msg % {'r': repo_id}, tag='not-found')
def run(self, **kwargs):
repo_id = kwargs[OPTION_REPO_ID.keyword]
node_id = load_consumer_id(self.context)
dist_id = constants.HTTP_DISTRIBUTOR
strategy = kwargs[STRATEGY_OPTION.keyword]
binding_config = {constants.STRATEGY_KEYWORD: strategy}
if not node_activated(self.context, node_id):
msg = NOT_ACTIVATED_ERROR
self.context.prompt.render_failure_message(msg)
return os.EX_USAGE
if strategy not in constants.STRATEGIES:
msg = STRATEGY_NOT_SUPPORTED % dict(n=strategy, s=constants.STRATEGIES)
self.context.prompt.render_failure_message(msg)
return os.EX_DATAERR
try:
self.context.server.bind.bind(
node_id,
repo_id,
dist_id,
notify_agent=False,
binding_config=binding_config)
self.context.prompt.render_success_message(BIND_SUCCEEDED)
warning = BIND_WARNING % dict(r=repo_id)
self.context.prompt.render_warning_message(warning)
except NotFoundException, e:
unhandled = self.missing_resources(self.context.prompt, e)
for _id, _type in unhandled:
if _type == 'distributor':
msg = BIND_FAILED_NOT_ENABLED
self.context.prompt.render_failure_message(msg)
else:
raise
return os.EX_DATAERR
def bind(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
m = "This consumer is not registered to the Pulp server"
self.prompt.render_failure_message(_(m))
return
repo_id = kwargs["repo-id"]
try:
self.context.server.bind.bind(consumer_id, repo_id, YUM_DISTRIBUTOR_TYPE_ID)
m = "Consumer [%(c)s] successfully bound to repository [%(r)s]"
self.prompt.render_success_message(_(m) % {"c": consumer_id, "r": repo_id})
except NotFoundException, e:
resources = e.extra_data["resources"]
if "consumer" in resources:
r_type = _("Consumer")
r_id = consumer_id
else:
r_type = _("Repository")
r_id = repo_id
msg = _("%(t)s [%(id)s] does not exist on the server")
self.context.prompt.write(msg % {"t": r_type, "id": r_id}, tag="not-found")
def update(self, **kwargs):
# Assemble the delta for all options that were passed in
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
if "note" in delta.keys():
if delta["note"]:
delta["notes"] = args_to_notes_dict(kwargs["note"], include_none=False)
delta.pop("note")
# convert display-name to display_name
key = "display-name"
if key in delta:
v = delta.pop(key)
key = key.replace("-", "_")
delta[key] = v
try:
self.context.server.consumer.update(consumer_id, delta)
self.prompt.render_success_message("Consumer [%s] successfully updated" % consumer_id)
except NotFoundException:
self.prompt.write("Consumer [%s] does not exist on the server" % consumer_id, tag="not-found")
def unregister(self, **kwargs):
consumer_id = load_consumer_id(self.context)
if not consumer_id:
self.context.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
return
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _("Write permission is required for %(d)s to perform this operation.")
self.prompt.render_failure_message(msg % {'d' : id_cert_dir})
return os.EX_NOPERM
try:
self.context.server.consumer.unregister(consumer_id)
self._delete_cert()
self.context.prompt.render_success_message('Consumer [%s] successfully unregistered' % consumer_id)
except NotFoundException:
if kwargs['force']:
self._delete_cert()
self.context.prompt.render_success_message('Consumer [%s] successfully unregistered' % consumer_id)
else:
msg = _('This consumer does not exist on the server. Please retry using the --force option.')
self.prompt.render_failure_message(msg)
def register(self, **kwargs):
consumer_id = kwargs['consumer-id']
# Check if this consumer is already registered
existing_consumer = load_consumer_id(self.context)
if existing_consumer:
m = _(
'This system has already been registered as a consumer. Please '
'use the unregister command to remove the consumer before attempting '
'to re-register.')
self.prompt.render_failure_message(m)
return
# Get other consumer parameters
name = kwargs.get('display-name', consumer_id)
description = kwargs.get('description')
notes = kwargs.get('note')
if notes:
notes = args_to_notes_dict(notes, include_none=False)
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _(
"Write permission is required for %(d)s to perform this operation."
)
self.prompt.render_failure_message(msg % {'d': id_cert_dir})
return exceptions.CODE_PERMISSIONS_EXCEPTION
# RSA key
path = self.context.config['authentication']['rsa_key']
key = RSA.gen_key(2048, 65535, no_passphrase_callback)
key.save_key(path, None)
path = self.context.config['authentication']['rsa_pub']
key.save_pub_key(path)
fp = open(path)
try:
rsa_pub = fp.read()
finally:
fp.close()
# Call the server
reply = self.context.server.consumer.register(consumer_id,
name=name,
description=description,
notes=notes,
rsa_pub=rsa_pub)
certificate = reply.response_body['certificate']
# Write consumer certificate
id_cert_name = self.context.config['filesystem']['id_cert_filename']
cert_filename = os.path.join(id_cert_dir, id_cert_name)
fp = open(cert_filename, 'w')
try:
fp.write(certificate)
finally:
fp.close()
# download server public key
try:
update_server_key(self.context.config)
except Exception, e:
msg = _('Download server RSA key failed [%(e)s]' % {'e': e})
self.prompt.render_failure_message(msg)
def get_consumer_id(self, kwargs):
"""
Override this method to provide the consumer id to the run method.
"""
return kwargs.get(OPTION_CONSUMER_ID.keyword,
load_consumer_id(self.context))
def register(self, **kwargs):
consumer_id = kwargs['consumer-id']
# Check if this consumer is already registered
existing_consumer = load_consumer_id(self.context)
if existing_consumer:
m = _('This system has already been registered as a consumer. Please '
'use the unregister command to remove the consumer before attempting '
'to re-register.')
self.prompt.render_failure_message(m)
return
# Get other consumer parameters
name = kwargs.get('display-name', consumer_id)
description = kwargs.get('description')
notes = kwargs.get('note')
if notes:
notes = args_to_notes_dict(notes, include_none=False)
# Check write permissions to cert directory
id_cert_dir = self.context.config['filesystem']['id_cert_dir']
if not os.access(id_cert_dir, os.W_OK):
msg = _("Write permission is required for %(d)s to perform this operation.")
self.prompt.render_failure_message(msg % {'d': id_cert_dir})
return exceptions.CODE_PERMISSIONS_EXCEPTION
# RSA key
path = self.context.config['authentication']['rsa_key']
key = RSA.gen_key(2048, 65535, no_passphrase_callback)
key.save_key(path, None)
path = self.context.config['authentication']['rsa_pub']
key.save_pub_key(path)
fp = open(path)
try:
rsa_pub = fp.read()
finally:
fp.close()
# Call the server
reply = self.context.server.consumer.register(
consumer_id,
name=name,
description=description,
notes=notes,
rsa_pub=rsa_pub)
certificate = reply.response_body['certificate']
# Write consumer certificate
id_cert_name = self.context.config['filesystem']['id_cert_filename']
cert_filename = os.path.join(id_cert_dir, id_cert_name)
# os.WRONLY opens the file for writing only; os.O_CREAT will create the
# file if it does not already exist.
fp = os.fdopen(os.open(cert_filename, os.O_WRONLY | os.O_CREAT, 0600), 'w')
try:
fp.write(certificate)
finally:
fp.close()
update_server_key(self)
self.prompt.render_success_message('Consumer [%s] successfully registered' % consumer_id)
