def _main():
signal.signal(signal.SIGINT, signal_handler)
if not _is_valid_configuration():
return 1
args = docopt.docopt(
__doc__,
version='dcos version {}'.format(dcoscli.version),
options_first=True)
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
if not _config_log_level_environ(args['--log-level']):
return 1
err = util.configure_logger_from_environ()
if err is not None:
emitter.publish(err)
return 1
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
executable = subcommand.command_executables(command, util.dcos_path())
subproc = Popen([executable, command] + args['<args>'],
stderr=PIPE)
return analytics.wait_and_track(subproc)
def _main():
signal.signal(signal.SIGINT, signal_handler)
http.silence_requests_warnings()
config = util.get_config()
set_ssl_info_env_vars(config)
args = docopt.docopt(default_doc("dcos"), options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['--version']:
return _get_versions(config.get("core.dcos_url"))
command = args['<command>']
if not command:
command = "help"
if command in subcommand.default_subcommands():
sc = SubcommandMain(command, args['<args>'])
else:
executable = subcommand.command_executables(command)
sc = subcommand.SubcommandProcess(
executable, command, args['<args>'])
exitcode, _ = sc.run_and_capture()
return exitcode
def _main(argv):
args = docopt.docopt(default_doc("experimental"),
argv=argv,
version='dcos-experimental version {}'.format(
dcoscli.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def get_resource(name):
"""
:param name: optional filename or http(s) url
for the application or group resource
:type name: str | None
:returns: resource
:rtype: dict
"""
if name is not None:
if os.path.isfile(name):
with util.open_file(name) as resource_file:
return util.load_json(resource_file)
else:
try:
http.silence_requests_warnings()
req = http.get(name)
if req.status_code == 200:
data = b''
for chunk in req.iter_content(1024):
data += chunk
return util.load_jsons(data.decode('utf-8'))
else:
raise Exception
except Exception:
logger.exception('Cannot read from resource %s', name)
raise DCOSException(
"Can't read from resource: {0}.\n"
"Please check that it exists.".format(name))
example = "E.g.: dcos marathon app add < app_resource.json"
ResourceReader._assert_no_tty(example)
return util.load_json(sys.stdin)
def _main():
signal.signal(signal.SIGINT, signal_handler)
args = docopt.docopt(
__doc__,
version='dcos version {}'.format(dcoscli.version),
options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
executable = subcommand.command_executables(command)
subproc = Popen([executable, command] + args['<args>'],
stderr=PIPE)
if dcoscli.version != 'SNAPSHOT':
return analytics.wait_and_track(subproc)
else:
return analytics.wait_and_capture(subproc)[0]
def get_resource(resource):
"""
:param resource: optional filename or http(s) url
for the application or group resource
:type resource: str
:returns: resource
:rtype: dict
"""
if resource is not None:
if os.path.isfile(resource):
with util.open_file(resource) as resource_file:
return util.load_json(resource_file)
else:
try:
http.silence_requests_warnings()
req = http.get(resource)
if req.status_code == 200:
data = b''
for chunk in req.iter_content(1024):
data += chunk
return util.load_jsons(data.decode('utf-8'))
else:
raise Exception
except Exception:
raise DCOSException(
"Can't read from resource: {0}.\n"
"Please check that it exists.".format(resource))
def get_resource(name):
"""
:param name: optional filename or http(s) url
for the application or group resource
:type name: str | None
:returns: resource
:rtype: dict
"""
if name is not None:
if os.path.isfile(name):
with util.open_file(name) as resource_file:
return util.load_json(resource_file)
else:
try:
http.silence_requests_warnings()
req = http.get(name)
if req.status_code == 200:
data = b''
for chunk in req.iter_content(1024):
data += chunk
return util.load_jsons(data.decode('utf-8'))
else:
raise Exception
except Exception:
logger.exception('Cannot read from resource %s', name)
raise DCOSException(
"Can't read from resource: {0}.\n"
"Please check that it exists.".format(name))
example = "E.g.: dcos marathon app add < app_resource.json"
ResourceReader._assert_no_tty(example)
return util.load_json(sys.stdin)
def _main():
signal.signal(signal.SIGINT, signal_handler)
args = docopt.docopt(__doc__,
version='dcos version {}'.format(dcoscli.version),
options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
executable = subcommand.command_executables(command)
subproc = Popen([executable, command] + args['<args>'], stderr=PIPE)
if dcoscli.version != 'SNAPSHOT':
return analytics.wait_and_track(subproc)
else:
return analytics.wait_and_capture(subproc)[0]
def _main(argv):
args = docopt.docopt(
default_doc("experimental"),
argv=argv,
version='dcos-experimental version {}'.format(dcoscli.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def _main():
util.configure_process_from_environ()
args = docopt.docopt(_doc(),
version='dcos-package version {}'.format(
dcoscli.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def _main():
util.configure_process_from_environ()
args = docopt.docopt(
_doc(),
version='dcos-package version {}'.format(dcoscli.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def _main():
util.configure_process_from_environ()
args = docopt.docopt(__doc__,
version='dcos-management version {}'.format(
constants.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def _main():
util.configure_logger_from_environ()
args = docopt.docopt(__doc__,
version='myriad cli version {}'.format(
constants.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def _main():
util.configure_logger_from_environ()
args = docopt.docopt(
__doc__,
version='myriad cli version {}'.format(constants.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(), args)
def _main():
signal.signal(signal.SIGINT, signal_handler)
args = docopt.docopt(
_doc(),
version='dcos version {}'.format(dcoscli.version),
options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
config = util.get_config()
set_ssl_info_env_vars(config)
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
executable = subcommand.command_executables(command)
cluster_id = None
if dcoscli.version != 'SNAPSHOT' and command and \
command not in ["config", "help"]:
try:
cluster_id = mesos.DCOSClient().metadata().get('CLUSTER_ID')
except DCOSAuthenticationException:
raise
except:
msg = 'Unable to get the cluster_id of the cluster.'
logger.exception(msg)
# the call to retrieve cluster_id must happen before we run the subcommand
# so that if you have auth enabled we don't ask for user/pass multiple
# times (with the text being out of order) before we can cache the auth
# token
subproc = Popen([executable, command] + args['<args>'],
stderr=PIPE)
if dcoscli.version != 'SNAPSHOT':
return analytics.wait_and_track(subproc, cluster_id)
else:
return analytics.wait_and_capture(subproc)[0]
def _main():
signal.signal(signal.SIGINT, signal_handler)
args = docopt.docopt(_doc(),
version='dcos version {}'.format(dcoscli.version),
options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
config = util.get_config()
set_ssl_info_env_vars(config)
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
executable = subcommand.command_executables(command)
cluster_id = None
if dcoscli.version != 'SNAPSHOT' and command and \
command not in ["config", "help"]:
try:
cluster_id = mesos.DCOSClient().metadata().get('CLUSTER_ID')
except DCOSAuthenticationException:
raise
except:
msg = 'Unable to get the cluster_id of the cluster.'
logger.exception(msg)
# the call to retrieve cluster_id must happen before we run the subcommand
# so that if you have auth enabled we don't ask for user/pass multiple
# times (with the text being out of order) before we can cache the auth
# token
subproc = Popen([executable, command] + args['<args>'], stderr=PIPE)
if dcoscli.version != 'SNAPSHOT':
return analytics.wait_and_track(subproc, cluster_id)
else:
return analytics.wait_and_capture(subproc)[0]
def _main():
signal.signal(signal.SIGINT, signal_handler)
http.silence_requests_warnings()
args = docopt.docopt(default_doc("dcos"), options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['--version']:
return _get_versions()
command = args['<command>']
if not command:
return dcos_help()
if config.uses_deprecated_config():
if constants.DCOS_CONFIG_ENV in os.environ:
msg = ('{} is deprecated, please consider using '
'`dcos cluster setup <dcos_url>`.')
err = errors.DefaultError(msg.format(constants.DCOS_CONFIG_ENV))
emitter.publish(err)
cluster.move_to_cluster_config()
if command in subcommand.default_subcommands():
sc = SubcommandMain(command, args['<args>'])
else:
executable = subcommand.command_executables(command)
sc = subcommand.SubcommandProcess(executable, command, args['<args>'])
exitcode, _ = sc.run_and_capture()
return exitcode
def _main(argv):
doc_name = 'cluster'
# If a cluster is attached and the cluster linker API is reachable,
# use cluster_ee.txt.
dcos_url = config.get_config_val('core.dcos_url')
if dcos_url:
try:
cluster.get_cluster_links(dcos_url)
doc_name = 'cluster_ee'
except Exception:
pass
args = docopt.docopt(
default_doc(doc_name),
argv=argv,
version='dcos-cluster version {}'.format(dcoscli.version))
http.silence_requests_warnings()
return cmds.execute(_cmds(doc_name), args)
def _get_resource(resource):
"""
:param resource: optional filename or http(s) url
for the application or group resource
:type resource: str
:returns: resource
:rtype: dict
"""
if resource is not None:
if os.path.isfile(resource):
with util.open_file(resource) as resource_file:
return util.load_json(resource_file)
else:
try:
http.silence_requests_warnings()
req = http.get(resource)
if req.status_code == 200:
data = b''
for chunk in req.iter_content(1024):
data += chunk
return util.load_jsons(data.decode('utf-8'))
else:
raise DCOSHTTPException("HTTP error code: {}"
.format(req.status_code))
except Exception:
logger.exception('Cannot read from resource %s', resource)
raise DCOSException(
"Can't read from resource: {0}.\n"
"Please check that it exists.".format(resource))
# Check that stdin is not tty
if sys.stdin.isatty():
# We don't support TTY right now. In the future we will start an
# editor
raise DCOSException(
"We currently don't support reading from the TTY. Please "
"specify an application JSON.\n"
"E.g.: dcos job add < app_resource.json")
return util.load_json(sys.stdin)
def _get_resource(resource):
"""
:param resource: optional filename or http(s) url
for the application or group resource
:type resource: str
:returns: resource
:rtype: dict
"""
if resource is not None:
if os.path.isfile(resource):
with util.open_file(resource) as resource_file:
return util.load_json(resource_file)
else:
try:
http.silence_requests_warnings()
req = http.get(resource)
if req.status_code == 200:
data = b''
for chunk in req.iter_content(1024):
data += chunk
return util.load_jsons(data.decode('utf-8'))
else:
raise DCOSHTTPException("HTTP error code: {}"
.format(req.status_code))
except Exception:
logger.exception('Cannot read from resource %s', resource)
raise DCOSException(
"Can't read from resource: {0}.\n"
"Please check that it exists.".format(resource))
# Check that stdin is not tty
if sys.stdin.isatty():
# We don't support TTY right now. In the future we will start an
# editor
raise DCOSException(
"We currently don't support reading from the TTY. Please "
"specify an application JSON.\n"
"E.g.: dcos job add < app_resource.json")
return util.load_json(sys.stdin)
def _main():
signal.signal(signal.SIGINT, signal_handler)
args = docopt.docopt(
default_doc("dcos"),
version='dcos version {}'.format(dcoscli.version),
options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
config = util.get_config()
set_ssl_info_env_vars(config)
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
cluster_id = None
if dcoscli.version != 'SNAPSHOT' and command and \
command not in ["config", "help"]:
try:
cluster_id = mesos.DCOSClient().metadata().get('CLUSTER_ID')
except DCOSAuthenticationException:
raise
except:
msg = 'Unable to get the cluster_id of the cluster.'
logger.exception(msg)
# send args call to segment.io
with ThreadPoolExecutor(max_workers=2) as reporting_executor:
analytics.segment_track_cli(reporting_executor, config, cluster_id)
# the call to retrieve cluster_id must happen before we run the
# subcommand so that if you have auth enabled we don't ask for
# user/pass multiple times (with the text being out of order)
# before we can cache the auth token
if command in subcommand.default_subcommands():
sc = SubcommandMain(command, args['<args>'])
else:
executable = subcommand.command_executables(command)
sc = subcommand.SubcommandProcess(
executable, command, args['<args>'])
exitcode, err = sc.run_and_capture()
if err:
analytics.track_err(
reporting_executor, exitcode, err, config, cluster_id)
return exitcode
def _main():
signal.signal(signal.SIGINT, signal_handler)
args = docopt.docopt(default_doc("dcos"),
version='dcos version {}'.format(dcoscli.version),
options_first=True)
log_level = args['--log-level']
if log_level and not _config_log_level_environ(log_level):
return 1
if args['--debug']:
os.environ[constants.DCOS_DEBUG_ENV] = 'true'
util.configure_process_from_environ()
if args['<command>'] != 'config' and \
not auth.check_if_user_authenticated():
auth.force_auth()
config = util.get_config()
set_ssl_info_env_vars(config)
command = args['<command>']
http.silence_requests_warnings()
if not command:
command = "help"
cluster_id = None
if dcoscli.version != 'SNAPSHOT' and command and \
command not in ["config", "help"]:
try:
cluster_id = mesos.DCOSClient().metadata().get('CLUSTER_ID')
except DCOSAuthenticationException:
raise
except:
msg = 'Unable to get the cluster_id of the cluster.'
logger.exception(msg)
# send args call to segment.io
with ThreadPoolExecutor(max_workers=2) as reporting_executor:
analytics.segment_track_cli(reporting_executor, config, cluster_id)
# the call to retrieve cluster_id must happen before we run the
# subcommand so that if you have auth enabled we don't ask for
# user/pass multiple times (with the text being out of order)
# before we can cache the auth token
if command in subcommand.default_subcommands():
sc = SubcommandMain(command, args['<args>'])
else:
executable = subcommand.command_executables(command)
sc = subcommand.SubcommandProcess(executable, command,
args['<args>'])
exitcode, err = sc.run_and_capture()
if err:
analytics.track_err(reporting_executor, exitcode, err, config,
cluster_id)
return exitcode