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 session(self):
if not self._session:
auth_plugin = ksc_auth.load_from_argparse_arguments(self.args)
try:
if not auth_plugin.auth_url:
logging.error("OS_AUTH_URL not set. Aborting.")
sys.exit(-1)
except AttributeError:
pass
self._session = ksc_session.Session.load_from_cli_options(self.args, auth=auth_plugin)
return self._session
def session_factory(resolver):
parser = resolver.resolve(argparse.ArgumentParser)
args = parser.parse_args()
auth_plugin = ksc_auth.load_from_argparse_arguments(args)
try:
if not auth_plugin.auth_url:
logging.error('OS_AUTH_URL not set. Aborting.')
sys.exit(-1)
except AttributeError:
pass
session = ksc_session.Session.load_from_cli_options(args, auth=auth_plugin)
return session
def session(self):
if not self._session:
auth_plugin = ksc_auth.load_from_argparse_arguments(self.args)
try:
if not auth_plugin.auth_url:
logging.error('OS_AUTH_URL not set. Aborting.')
sys.exit(-1)
except AttributeError:
pass
self._session = ksc_session.Session.load_from_cli_options(
self.args, auth=auth_plugin)
return self._session
def session_factory(resolver):
parser = resolver.resolve(argparse.ArgumentParser)
args = parser.parse_args()
auth_plugin = ksc_auth.load_from_argparse_arguments(args)
try:
if not auth_plugin.auth_url:
logging.error('OS_AUTH_URL not set. Aborting.')
sys.exit(-1)
except AttributeError:
pass
session = ksc_session.Session.load_from_cli_options(
args, auth=auth_plugin)
return session
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 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:]
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)
