def get_parser(self):
parser = argparse.ArgumentParser(description=self.description)
ksc_session.Session.register_cli_options(parser)
ksc_auth.register_argparse_arguments(parser,
sys.argv,
default='v3password')
parser.add_argument('-s', '--section', dest='section', default='scope')
return parser
def get_parser(self):
parser = argparse.ArgumentParser(description=self.description)
ksc_session.Session.register_cli_options(parser)
ksc_auth.register_argparse_arguments(parser,
sys.argv,
default='v3password')
parser.add_argument('-s', '--section',
dest='section',
default='scope')
return parser
def main():
argv = sys.argv[1:]
# early setup for logging
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
parser.add_argument('--host',
'-H',
default=os.environ.get('CONTRAIL_API_HOST',
'localhost'),
type=str,
help="host to connect to (default='%(default)s')")
parser.add_argument('--port',
'-p',
default=os.environ.get('CONTRAIL_API_PORT', 8082),
type=int,
help="port to connect to (default='%(default)s')")
parser.add_argument('--protocol',
type=str,
default=os.environ.get('CONTRAIL_API_PROTOCOL',
'http'),
help="protocol used (default=%(default)s)")
parser.add_argument('--debug', '-d', action="store_true", default=False)
ksession.Session.register_cli_options(parser)
# Default auth plugin will be http unless OS_AUTH_PLUGIN envvar is set
auth.register_argparse_arguments(parser, argv, default="http")
# Add commands to the parser given the namespaces list
mgr = CommandManager.register_argparse_commands(parser, argv)
options = parser.parse_args()
if not os.path.exists(CONFIG_DIR):
os.makedirs(CONFIG_DIR)
command.make_api_session(options)
try:
subcmd, subcmd_kwargs = get_subcommand_kwargs(mgr, options.subcmd,
options)
logger.debug('Calling %s with %s' % (subcmd, subcmd_kwargs))
result = subcmd(**subcmd_kwargs)
except (HttpError, ClientException, CommandError, ResourceNotFound,
CollectionNotFound, NotFound) as e:
printo(text_type(e), std_type='stderr')
exit(1)
except KeyboardInterrupt:
pass
except EOFError:
pass
else:
if result:
printo(result)
def session_factory():
parser = argparse.ArgumentParser(description="")
ksc_session.Session.register_cli_options(parser)
ksc_auth.register_argparse_arguments(parser,
sys.argv,
default='v3password')
args = parser.parse_args()
auth_plugin = ksc_auth.load_from_argparse_arguments(args)
session = ksc_session.Session.load_from_cli_options(
args,
auth=auth_plugin)
return session
def parser_factory(resolver):
parser = argparse.ArgumentParser(description='')
ksc_session.Session.register_cli_options(parser)
ksc_auth.register_argparse_arguments(parser,
sys.argv,
default='v3password')
parser.add_argument('-s', '--section',
dest='section',
default='scope')
parser.add_argument('worker', nargs='?', default='all',
help='Worker to execute, defaults to "all"')
return parser
def parser_factory(resolver):
parser = argparse.ArgumentParser(description='')
ksc_session.Session.register_cli_options(parser)
ksc_auth.register_argparse_arguments(parser,
sys.argv,
default='v3password')
parser.add_argument('-s', '--section', dest='section', default='scope')
parser.add_argument('worker',
nargs='?',
default='all',
help='Worker to execute, defaults to "all"')
return parser
def main():
argv = sys.argv[1:]
# early setup for logging
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
parser.add_argument('--host', '-H',
default=os.environ.get('CONTRAIL_API_HOST', 'localhost'),
type=str,
help="host to connect to (default='%(default)s')")
parser.add_argument('--port', '-p',
default=os.environ.get('CONTRAIL_API_PORT', 8082),
type=int,
help="port to connect to (default='%(default)s')")
parser.add_argument('--protocol',
type=str,
default=os.environ.get('CONTRAIL_API_PROTOCOL', 'http'),
help="protocol used (default=%(default)s)")
parser.add_argument('--debug', '-d',
action="store_true", default=False)
ksession.Session.register_cli_options(parser)
# Default auth plugin will be http unless OS_AUTH_PLUGIN envvar is set
auth.register_argparse_arguments(parser, argv, default="http")
# Add commands to the parser given the namespaces list
mgr = CommandManager.register_argparse_commands(parser, argv)
options = parser.parse_args()
if not os.path.exists(CONFIG_DIR):
os.makedirs(CONFIG_DIR)
command.make_api_session(options)
try:
subcmd, subcmd_kwargs = get_subcommand_kwargs(mgr, options.subcmd, options)
logger.debug('Calling %s with %s' % (subcmd, subcmd_kwargs))
result = subcmd(**subcmd_kwargs)
except (HttpError, ClientException, CommandError,
ResourceNotFound, CollectionNotFound, NotFound) as e:
printo(text_type(e), std_type='stderr')
exit(1)
except KeyboardInterrupt:
pass
except EOFError:
pass
else:
if result:
printo(result)
def main():
argv = sys.argv[1:]
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser(
description="Command to generate load on database")
parser.add_argument('-f', '--force', action='store_true', default=False)
parser.add_argument('--resources-file',
required=True,
help='YAML file describing resources to load',
type=argparse.FileType('r'))
parser.add_argument('--cassandra-servers',
help="Cassandra server list' (default: %(default)s)",
nargs='+',
default=['localhost:9160'])
parser.add_argument('--cassandra-username',
help="Cassandra user name (default: %(default)s)",
default=None)
parser.add_argument('--cassandra-password',
help="Cassandra user password (default: %(default)s)",
default=None)
parser.add_argument('--db-prefix',
help="Cassandra keyspace prefix "
"(default: %(default)s)",
default="")
parser.add_argument('--cassandra-batch-size',
type=int,
help="Job queue size for cassandra batch "
"(default: %(default)s)",
default=LoadDataBase.BATCH_QUEUE_SIZE)
parser.add_argument('--dont-populate-zookeeper', action='store_true',
help="Do not populate zookeeper database which is "
"very slow and may take time "
"(default: %(default)s)",
default=False)
parser.add_argument('--zookeeper-servers',
help="Zookeeper server list (default: %(default)s)",
nargs='+',
default=['localhost:2181'])
parser.add_argument('--rules-per-security-group',
type=int,
help="Rules ramdomly generated per created security "
"group (default: %(default)s)",
default=LoadDataBase.RULES_PER_SG)
ksession.Session.register_cli_options(parser)
kauth.register_argparse_arguments(parser, argv)
params, _ = parser.parse_known_args(argv)
try:
keystone_auth = kauth.load_from_argparse_arguments(params)
keystone_session = ksession.Session.load_from_cli_options(
params, auth=keystone_auth)
keystone_client = kclient.Client(session=keystone_session)
except kexceptions.DiscoveryFailure:
keystone_client = None
param_dict = vars(params)
param_dict['keystone_client'] = keystone_client
for opt in ksession.Session.get_conf_options():
try:
param_dict.pop('os_%s' % opt.dest)
except KeyError:
param_dict.pop('%s' % opt.dest, None)
for opt in\
kauth.base.get_plugin_class(params.os_auth_plugin).get_options():
param_dict.pop('os_%s' % opt.dest)
param_dict = {k: v for k, v in param_dict.iteritems()
if not k.startswith('os_')}
database_loader = LoadDataBase(**param_dict)
database_loader.sanitize_resources()
database_loader.summarize_resources_to_create()
database_loader.create_resources()
def get_parser(self):
parser = argparse.ArgumentParser(description=self.description)
ksc_session.Session.register_cli_options(parser)
ksc_auth.register_argparse_arguments(parser, sys.argv, default="v3password")
parser.add_argument("-s", "--section", dest="section", default="scope")
return parser
def main():
argv = sys.argv[1:]
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser(
description="Command to generate load on database")
parser.add_argument('-f', '--force', action='store_true', default=False)
parser.add_argument('--resources-file',
required=True,
help='YAML file describing resources to load',
type=argparse.FileType('r'))
parser.add_argument('--cassandra-servers',
help="Cassandra server list' (default: %(default)s)",
nargs='+',
default=['localhost:9160'])
parser.add_argument('--cassandra-username',
help="Cassandra user name (default: %(default)s)",
default=None)
parser.add_argument('--cassandra-password',
help="Cassandra user password (default: %(default)s)",
default=None)
parser.add_argument('--db-prefix',
help="Cassandra keyspace prefix "
"(default: %(default)s)",
default="")
parser.add_argument('--cassandra-batch-size',
type=int,
help="Job queue size for cassandra batch "
"(default: %(default)s)",
default=LoadDataBase.BATCH_QUEUE_SIZE)
parser.add_argument('--zookeeper-servers',
help="Zookeeper server list' (default: %(default)s)",
nargs='+',
default=['localhost:2181'])
parser.add_argument('--rules-per-security-group',
type=int,
help="Rules ramdomly generated per created security "
"group (default: %(default)s)",
default=LoadDataBase.RULES_PER_SG)
ksession.Session.register_cli_options(parser)
kauth.register_argparse_arguments(parser, argv)
params, _ = parser.parse_known_args(argv)
try:
keystone_auth = kauth.load_from_argparse_arguments(params)
keystone_session = ksession.Session.load_from_cli_options(
params, auth=keystone_auth)
keystone_client = kclient.Client(session=keystone_session)
except kexceptions.DiscoveryFailure:
keystone_client = None
param_dict = vars(params)
param_dict['keystone_client'] = keystone_client
for opt in ksession.Session.get_conf_options():
try:
param_dict.pop('os_%s' % opt.dest)
except KeyError:
param_dict.pop('%s' % opt.dest, None)
for opt in\
kauth.base.get_plugin_class(params.os_auth_plugin).get_options():
param_dict.pop('os_%s' % opt.dest)
param_dict = {
k: v
for k, v in param_dict.iteritems() if not k.startswith('os_')
}
database_loader = LoadDataBase(**param_dict)
database_loader.sanitize_resources()
database_loader.summarize_resources_to_create()
database_loader.create_resources()
def main():
argv = sys.argv[1:]
# early setup for logging
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
if '--logging-conf' in argv:
try:
path = argv[argv.index('--logging-conf') + 1]
logging.config.fileConfig(path)
except IndexError:
pass
parser = argparse.ArgumentParser()
parser.add_argument('--host', '-H',
default=os.environ.get('CONTRAIL_API_HOST', 'localhost'),
type=str,
help="host to connect to (default='%(default)s')")
parser.add_argument('--port', '-p',
default=os.environ.get('CONTRAIL_API_PORT', 8082),
type=int,
help="port to connect to (default='%(default)s')")
parser.add_argument('--protocol',
type=str,
default=os.environ.get('CONTRAIL_API_PROTOCOL', 'http'),
help="protocol used (default=%(default)s)")
parser.add_argument('--debug', '-d',
action="store_true", default=False)
parser.add_argument('--schema-version',
default=os.environ.get('CONTRAIL_API_VERSION', None),
choices=list_available_schema_version(),
help="schema version used by contrail-api server (default=%(default)s)")
parser.add_argument('--logging-conf',
help="python logging configuration file")
ksession.Session.register_cli_options(parser)
# Default auth plugin will be http unless OS_AUTH_PLUGIN envvar is set
auth.register_argparse_arguments(parser, argv, default="http")
# Add commands to the parser given the namespaces list
mgr = CommandManager.register_argparse_commands(parser, argv)
options = parser.parse_args()
if not os.path.exists(CONFIG_DIR):
os.makedirs(CONFIG_DIR)
ContrailAPISession.make(**vars(options))
if options.schema_version:
Context().schema = create_schema_from_version(options.schema_version)
else:
Context().schema = DummySchema()
try:
subcmd, subcmd_kwargs = get_subcommand_kwargs(mgr, options.subcmd, options)
logger.debug('Calling %s with %s' % (subcmd, subcmd_kwargs))
result = subcmd(**subcmd_kwargs)
except (HttpError, ClientException, CommandError, Exists, NotFound) as e:
printo(text_type(e), std_type='stderr')
exit(1)
except KeyboardInterrupt:
pass
except EOFError:
pass
else:
if result:
printo(result)
def main():
argv = sys.argv[1:]
# early setup for logging
if '-d' in argv or '--debug' in argv:
logging.basicConfig(level=logging.DEBUG)
if '--logging-conf' in argv:
try:
path = argv[argv.index('--logging-conf') + 1]
logging.config.fileConfig(path)
except IndexError:
pass
parser = argparse.ArgumentParser()
parser.add_argument('--host',
'-H',
default=os.environ.get('CONTRAIL_API_HOST',
'localhost'),
type=str,
help="host to connect to (default='%(default)s')")
parser.add_argument('--port',
'-p',
default=os.environ.get('CONTRAIL_API_PORT', 8082),
type=int,
help="port to connect to (default='%(default)s')")
parser.add_argument('--protocol',
type=str,
default=os.environ.get('CONTRAIL_API_PROTOCOL',
'http'),
help="protocol used (default=%(default)s)")
parser.add_argument('--debug', '-d', action="store_true", default=False)
parser.add_argument(
'--schema-version',
default=os.environ.get('CONTRAIL_API_VERSION', None),
choices=list_available_schema_version(),
help="schema version used by contrail-api server (default=%(default)s)"
)
parser.add_argument('--logging-conf',
help="python logging configuration file")
ksession.Session.register_cli_options(parser)
# Default auth plugin will be http unless OS_AUTH_PLUGIN envvar is set
auth.register_argparse_arguments(parser, argv, default="http")
# Add commands to the parser given the namespaces list
mgr = CommandManager.register_argparse_commands(parser, argv)
options = parser.parse_args()
if not os.path.exists(CONFIG_DIR):
os.makedirs(CONFIG_DIR)
ContrailAPISession.make(**vars(options))
if options.schema_version:
Context().schema = create_schema_from_version(options.schema_version)
else:
Context().schema = DummySchema()
try:
subcmd, subcmd_kwargs = get_subcommand_kwargs(mgr, options.subcmd,
options)
logger.debug('Calling %s with %s' % (subcmd, subcmd_kwargs))
result = subcmd(**subcmd_kwargs)
except (HttpError, ClientException, CommandError, Exists, NotFound) as e:
printo(text_type(e), std_type='stderr')
exit(1)
except KeyboardInterrupt:
pass
except EOFError:
pass
else:
if result:
printo(result)
def main():
argv = sys.argv[1:]
parser = argparse.ArgumentParser()
parser.add_argument("--host", default="localhost:8082", help="host:port to connect to (default='%(default)s')")
parser.add_argument("--ssl", action="store_true", default=False, help="connect with SSL (default=%(default)s)")
session.Session.register_cli_options(parser)
# Default auth plugin will be http unless OS_AUTH_PLUGIN envvar is set
auth.register_argparse_arguments(parser, argv, default="http")
options = parser.parse_args()
if options.ssl:
APIClient.PROTOCOL = "https"
if options.host:
APIClient.HOST = options.host
auth_plugin = auth.load_from_argparse_arguments(options)
APIClient.SESSION = session.Session.load_from_cli_options(options, auth=auth_plugin)
try:
for p in APIClient().list(ShellContext.current_path):
ShellContext.completion_queue.put(p)
except ClientException as e:
print(e)
sys.exit(1)
while True:
try:
action = prompt(
get_prompt_tokens=get_prompt_tokens, history=history, completer=completer, style=PromptStyle
)
except (EOFError, KeyboardInterrupt):
break
try:
action_list = action.split()
cmd = getattr(commands, action_list[0])
args = action_list[1:]
except IndexError:
continue
except AttributeError:
print("Command not found. Type help for all commands.")
continue
try:
result = cmd.parse_and_call(*args)
except (HttpError, ClientException, commands.CommandError) as e:
print(e)
continue
except KeyboardInterrupt:
continue
except EOFError:
break
else:
if result is None:
continue
elif type(result) == list:
output_paths = []
for p in result:
output_paths.append(str(p.relative_to(ShellContext.current_path)))
ShellContext.completion_queue.put(p)
print("\n".join(output_paths))
elif type(result) == dict:
print(pprint.pformat(result, indent=2))
else:
print(result)
