Ejemplo n.º 1
0
    def completion_cache(self, cache_type, obj_class, mode):
        """
        The completion cache store items that can be used for bash
        autocompletion, like UUIDs.

        A resource listing will clear and re-populate the cache.

        A resource create will append to the cache.

        Delete is not handled because listings are assumed to be performed
        often enough to keep the cache reasonably up-to-date.
        """
        base_dir = utils.env('K2ACLIENT_UUID_CACHE_DIR',
                             default="~/.k2aclient")

        # NOTE(sirp): Keep separate UUID caches for each username + endpoint
        # pair
        username = utils.env('K2_USERNAME')
        url = utils.env('K2_URL')
        uniqifier = hashlib.md5(username + url).hexdigest()

        cache_dir = os.path.expanduser(os.path.join(base_dir, uniqifier))

        try:
            os.makedirs(cache_dir, 0755)
        except OSError:
            # NOTE(kiall): This is typicaly either permission denied while
            #              attempting to create the directory, or the directory
            #              already exists. Either way, don't fail.
            pass

        resource = obj_class.__name__.lower()
        filename = "%s-%s-cache" % (resource, cache_type.replace('_', '-'),)
        path = os.path.join(cache_dir, filename)

        cache_attr = "_%s_cache" % cache_type

        try:
            setattr(self, cache_attr, open(path, mode))
        except IOError:
            # NOTE(kiall): This is typicaly a permission denied while
            #              attempting to write the cache file.
            pass

        try:
            yield
        finally:
            cache = getattr(self, cache_attr, None)
            if cache:
                cache.close()
                delattr(self, cache_attr)
Ejemplo n.º 2
0
    def get_base_parser(self):
        parser = K2aClientArgumentParser(
            prog='k2a',
            description=__doc__.strip(),
            epilog=_('See "k2a help COMMAND" '
                     'for help on a specific command.'),
            add_help=False,
            formatter_class=OpenStackHelpFormatter,
        )

        # Global arguments
        parser.add_argument('-h', '--help',
                            action='store_true',
                            help=argparse.SUPPRESS)

#   TODO :bh: add version that conform's w/ PowerVC
#        parser.add_argument('--version',
#                            action='version',
#                            version=client.__version__)

        parser.add_argument('--debug',
                            action='store_true',
                            default=utils.env('K2_DEBUG',
                                              default=False),
                            help=_('Print debugging output'))

        parser.add_argument('--api-version',
                            metavar='<api-ver>',
                            default=utils.env('K2A_API_VERSION',
                            default=DEFAULT_K2A_API_VERSION),
                            help=_('Accepts 1,defaults '
                                   'to env[K2A_API_VERSION].'))

        msg = _('Number of retries when attempting k2 operations.')
        parser.add_argument('--retries',
                            metavar='<retries>',
                            type=int,
                            default=0,
                            help=msg)

        parser.add_argument('--k2-url',
                            metavar='<k2-url>',
                            default=utils.env('K2_URL'),
                            help=_('url for k2 hmc, defaults '
                                   'to env[K2_URL].'))

        parser.add_argument('--k2-username',
                            metavar='<k2-username>',
                            default=utils.env('K2_USERNAME'),
                            help=_('k2 username, defaults '
                                   'to env[K2_USERNAME].'))

        parser.add_argument('--k2-password',
                            metavar='<k2-password>',
                            default=utils.env('K2_PASSWORD'),
                            help=_('k2 password, defaults '
                                   'to env[K2_PASSWORD].'))

        parser.add_argument('--k2-auditmemento',
                            metavar='<k2-auditmemento>',
                            default=utils.env('K2_AUDITMEMENTO',
                                              default='k2a'),
                            help=_('k2 auditmemento, defaults '
                                   'to, if set, env[K2_AUDITMEMENTO], '
                                   'otherwise to "k2a".'))

        parser.add_argument('--k2-certpath',
                            metavar='<k2-certpath>',
                            default=utils.env('K2_CERTPATH', default=None),
                            help=_('k2 certpath, defaults '
                                   'to, if set, env[K2_CERTPATH], '
                                   'otherwise to None.'))

        parser.add_argument('--logdir',
                            metavar='<logdir>',
                            default=utils.env('K2A_LOGDIR', default=None),
                            help=_('log directory, defaults '
                                   'to, if set, env[K2A_LOGDIR], '
                                   'otherwise to None. None turns'
                                   'off file logging'))

#         parser.add_argument('--excdir',
#                             metavar='<excdir>',
#                             default=utils.env('K2A_EXCDIR', default=None),
#                             help='directory where k2aexc subdirectory'
#                                  'will be placed'
#                                  'ie "<excdir>/k2aexc", '
#                                  'defaults '
#                                  'to, if set, env[K2A_EXCDIR], '
#                                  'otherwise to None. None turns'
#                                  'off exception logging')

        parser.add_argument('--excdir',
                            metavar='<excdir>',
                            default=utils.env('K2A_EXCDIR', default="/tmp"),
                            help=_('directory where k2aexc subdirectory'
                                   'will be placed'
                                   'ie "<excdir>/k2aexc", '
                                   'defaults '
                                   'to, if set, env[K2A_EXCDIR], '
                                   'otherwise to /tmp'))

        return parser