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 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 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 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 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 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 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 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 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 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 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 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)