3 # vim: ts=4 sw=4 smarttab expandtab
5 # Processed in Makefile to add python #! line and version variable
11 ceph.in becomes ceph, the command-line management tool for Ceph clusters.
12 This is a replacement for tools/ceph.cc and tools/common.cc.
14 Copyright (C) 2013 Inktank Storage, Inc.
16 This is free software; you can redistribute it and/or
17 modify it under the terms of the GNU General Public
18 License version 2, as published by the Free Software
19 Foundation. See file COPYING.
22 from __future__ import print_function
23 from time import sleep
37 CEPH_GIT_VER = "@CEPH_GIT_VER@"
38 CEPH_GIT_NICE_VER = "@CEPH_GIT_NICE_VER@"
39 CEPH_RELEASE = "@CEPH_RELEASE@"
40 CEPH_RELEASE_NAME = "@CEPH_RELEASE_NAME@"
41 CEPH_RELEASE_TYPE = "@CEPH_RELEASE_TYPE@"
43 # priorities from src/common/perf_counters.h
47 PRIO_UNINTERESTING = 2
50 PRIO_DEFAULT = PRIO_INTERESTING
52 # Make life easier on developers:
53 # If our parent dir contains CMakeCache.txt and bin/init-ceph,
54 # assume we're running from a build dir (i.e. src/build/bin/ceph)
55 # and tweak sys.path and LD_LIBRARY_PATH to use built files.
56 # Since this involves re-execing, if CEPH_DBG is set in the environment
57 # re-exec with -mpdb. Also, if CEPH_DEV is in the env, suppress
58 # the warning message about the DEVELOPER MODE.
60 MYPATH = os.path.abspath(__file__)
61 MYDIR = os.path.dirname(MYPATH)
62 MYPDIR = os.path.dirname(MYDIR)
63 DEVMODEMSG = '*** DEVELOPER MODE: setting PATH, PYTHONPATH and LD_LIBRARY_PATH ***'
66 def respawn_in_path(lib_path, pybind_path, pythonlib_path, asan_lib_path):
68 if 'CEPH_DBG' in os.environ:
69 execv_cmd += ['@PYTHON_EXECUTABLE@', '-mpdb']
71 if platform.system() == "Darwin":
72 lib_path_var = "DYLD_LIBRARY_PATH"
74 lib_path_var = "LD_LIBRARY_PATH"
78 os.environ['LD_PRELOAD'] = asan_lib_path
79 if lib_path_var in os.environ:
80 if lib_path not in os.environ[lib_path_var]:
81 os.environ[lib_path_var] += ':' + lib_path
82 if "CEPH_DEV" not in os.environ:
83 print(DEVMODEMSG, file=sys.stderr)
84 os.execvp(execv_cmd[0], execv_cmd)
86 os.environ[lib_path_var] = lib_path
87 if "CEPH_DEV" not in os.environ:
88 print(DEVMODEMSG, file=sys.stderr)
89 os.execvp(execv_cmd[0], execv_cmd)
90 sys.path.insert(0, os.path.join(MYDIR, pybind_path))
91 sys.path.insert(0, os.path.join(MYDIR, pythonlib_path))
94 def get_pythonlib_dir():
95 """Returns the name of a distutils build directory"""
96 return "lib.{version[0]}".format(version=sys.version_info)
99 def get_cmake_variables(*names):
100 vars = dict((name, None) for name in names)
101 for line in open(os.path.join(MYPDIR, "CMakeCache.txt")):
102 # parse lines like "WITH_ASAN:BOOL=ON"
104 if line.startswith("{}:".format(name)):
105 type_value = line.split(":")[1].strip()
106 t, v = type_value.split("=")
108 v = v.upper() in ('TRUE', '1', 'Y', 'YES', 'ON')
111 if all(vars.values()):
113 return [vars[name] for name in names]
116 if os.path.exists(os.path.join(MYPDIR, "CMakeCache.txt")) \
117 and os.path.exists(os.path.join(MYPDIR, "bin/init-ceph")):
118 src_path, with_asan, asan_lib_path = \
119 get_cmake_variables("ceph_SOURCE_DIR", "WITH_ASAN", "ASAN_LIBRARY")
121 # Huh, maybe we're not really in a cmake environment?
124 # Developer mode, but in a cmake build dir instead of the src dir
125 lib_path = os.path.join(MYPDIR, "lib")
126 bin_path = os.path.join(MYPDIR, "bin")
127 pybind_path = os.path.join(src_path, "src", "pybind")
128 pythonlib_path = os.path.join(lib_path,
131 respawn_in_path(lib_path, pybind_path, pythonlib_path,
132 asan_lib_path if with_asan else None)
134 if 'PATH' in os.environ and bin_path not in os.environ['PATH']:
135 os.environ['PATH'] = os.pathsep.join([bin_path, os.environ['PATH']])
146 from ceph_argparse import \
147 concise_sig, descsort_key, parse_json_funcsigs, \
148 validate_command, find_cmd_target, \
149 json_command, run_in_thread, Flag
151 from ceph_daemon import admin_socket, DaemonWatcher, Termsize
153 # just a couple of globals
156 cluster_handle = None
158 # Always use Unicode (UTF-8) for stdout
159 if sys.version_info[0] >= 3:
160 raw_stdout = sys.stdout.buffer
161 raw_stderr = sys.stderr.buffer
163 raw_stdout = sys.__stdout__
164 raw_stderr = sys.__stderr__
165 sys.stdout = codecs.getwriter('utf-8')(raw_stdout)
166 sys.stderr = codecs.getwriter('utf-8')(raw_stderr)
171 raw_stdout.write(rados.cstr(buf, ''))
175 ret, outbuf, outs = json_command(cluster_handle, prefix='osd ls')
177 raise RuntimeError('Can\'t contact mon for osd list')
178 return [line.decode('utf-8') for line in outbuf.split(b'\n') if line]
182 ret, outbuf, outs = json_command(cluster_handle, prefix='mon dump',
183 argdict={'format': 'json'})
185 raise RuntimeError('Can\'t contact mon for mon list')
186 d = json.loads(outbuf.decode('utf-8'))
187 return [m['name'] for m in d['mons']]
191 ret, outbuf, outs = json_command(cluster_handle, prefix='fs dump',
192 argdict={'format': 'json'})
194 raise RuntimeError('Can\'t contact mon for mds list')
195 d = json.loads(outbuf.decode('utf-8'))
197 for info in d['standbys']:
198 l.append(info['name'])
199 for fs in d['filesystems']:
200 for info in fs['mdsmap']['info'].values():
201 l.append(info['name'])
206 ret, outbuf, outs = json_command(cluster_handle, prefix='mgr dump',
207 argdict={'format': 'json'})
209 raise RuntimeError('Can\'t contact mon for mgr list')
211 d = json.loads(outbuf.decode('utf-8'))
213 l.append(d['active_name'])
214 for i in d['standbys']:
219 def ids_by_service(service):
220 ids = {"mon": monids,
224 return ids[service]()
227 def validate_target(target):
229 this function will return true iff target is a correct
230 target, such as mon.a/osd.2/mds.a/mgr.
232 target: array, likes ['osd', '2']
233 return: bool, or raise RuntimeError
237 # for case "service.id"
238 service_name, service_id = target[0], target[1]
240 exist_ids = ids_by_service(service_name)
242 print('WARN: {0} is not a legal service name, should be one of mon/osd/mds/mgr'.format(service_name),
246 if service_id in exist_ids or len(exist_ids) > 0 and service_id == '*':
249 print('WARN: the service id you provided does not exist. service id should '
250 'be one of {0}.'.format('/'.join(exist_ids)), file=sys.stderr)
253 elif len(target) == 1 and target[0] in ['mgr', 'mon']:
256 print('WARN: \"{0}\" is not a legal target. it should be one of mon.<id>/osd.<int>/mds.<id>/mgr'.format('.'.join(target)), file=sys.stderr)
260 # these args must be passed to all child programs
263 'client_name': '--name',
264 'cluster': '--cluster',
265 'cephconf': '--conf',
269 def parse_cmdargs(args=None, target=''):
271 Consume generic arguments from the start of the ``args``
272 list. Call this first to handle arguments that are not
273 handled by a command description provided by the server.
275 :returns: three tuple of ArgumentParser instance, Namespace instance
276 containing parsed values, and list of un-handled arguments
278 # alias: let the line-wrapping be sane
279 AP = argparse.ArgumentParser
281 # format our own help
282 parser = AP(description='Ceph administration tool', add_help=False)
284 parser.add_argument('--completion', action='store_true',
285 help=argparse.SUPPRESS)
287 parser.add_argument('-h', '--help', help='request mon help',
290 parser.add_argument('-c', '--conf', dest='cephconf',
291 help='ceph configuration file')
292 parser.add_argument('-i', '--in-file', dest='input_file',
293 help='input file, or "-" for stdin')
294 parser.add_argument('-o', '--out-file', dest='output_file',
295 help='output file, or "-" for stdout')
296 parser.add_argument('--setuser', dest='setuser',
297 help='set user file permission')
298 parser.add_argument('--setgroup', dest='setgroup',
299 help='set group file permission')
300 parser.add_argument('--id', '--user', dest='client_id',
301 help='client id for authentication')
302 parser.add_argument('--name', '-n', dest='client_name',
303 help='client name for authentication')
304 parser.add_argument('--cluster', help='cluster name')
306 parser.add_argument('--admin-daemon', dest='admin_socket',
307 help='submit admin-socket commands (\"help\" for help')
309 parser.add_argument('-s', '--status', action='store_true',
310 help='show cluster status')
312 parser.add_argument('-w', '--watch', action='store_true',
313 help='watch live cluster changes')
314 parser.add_argument('--watch-debug', action='store_true',
315 help='watch debug events')
316 parser.add_argument('--watch-info', action='store_true',
317 help='watch info events')
318 parser.add_argument('--watch-sec', action='store_true',
319 help='watch security events')
320 parser.add_argument('--watch-warn', action='store_true',
321 help='watch warn events')
322 parser.add_argument('--watch-error', action='store_true',
323 help='watch error events')
325 parser.add_argument('--watch-channel', dest="watch_channel",
326 choices=['cluster', 'audit', '*'],
327 help="which log channel to follow " \
328 "when using -w/--watch. One of ['cluster', 'audit', '*']",
331 parser.add_argument('--version', '-v', action="store_true", help="display version")
332 parser.add_argument('--verbose', action="store_true", help="make verbose")
333 parser.add_argument('--concise', dest='verbose', action="store_false",
334 help="make less verbose")
336 parser.add_argument('-f', '--format', choices=['json', 'json-pretty',
337 'xml', 'xml-pretty', 'plain'], dest='output_format')
339 parser.add_argument('--connect-timeout', dest='cluster_timeout',
341 help='set a timeout for connecting to the cluster')
343 parser.add_argument('--block', action='store_true',
344 help='block until completion (scrub and deep-scrub only)')
345 parser.add_argument('--period', '-p', default=1, type=float,
346 help='polling period, default 1.0 second (for ' \
347 'polling commands only)')
349 # returns a Namespace with the parsed args, and a list of all extras
350 parsed_args, extras = parser.parse_known_args(args)
352 return parser, parsed_args, extras
356 print('\n', s, '\n', '=' * len(s))
359 def do_basic_help(parser, args):
361 Print basic parser help
362 If the cluster is available, get and print monitor help
364 hdr('General usage:')
366 print_locally_handled_command_help()
369 def print_locally_handled_command_help():
370 hdr("Local commands:")
372 ping <mon.id> Send simple presence/life test to a mon
373 <mon.id> may be 'mon.*' for all mons
374 daemon {type.id|path} <cmd>
375 Same as --admin-daemon, but auto-find admin socket
376 daemonperf {type.id | path} [stat-pats] [priority] [<interval>] [<count>]
377 daemonperf {type.id | path} list|ls [stat-pats] [priority]
378 Get selected perf stats from daemon/admin socket
379 Optional shell-glob comma-delim match string stat-pats
380 Optional selection priority (can abbreviate name):
381 critical, interesting, useful, noninteresting, debug
382 List shows a table of all available stats
383 Run <count> times (default forever),
384 once per <interval> seconds (default 1)
385 """, file=sys.stdout)
388 def do_extended_help(parser, args, target, partial):
389 def help_for_sigs(sigs, partial=None):
390 sys.stdout.write(format_help(parse_json_funcsigs(sigs, 'cli'),
393 def help_for_target(target, partial=None):
394 # wait for osdmap because we know this is sent after the mgrmap
395 # and monmap (it's alphabetical).
396 cluster_handle.wait_for_latest_osdmap()
397 ret, outbuf, outs = json_command(cluster_handle, target=target,
398 prefix='get_command_descriptions',
401 if ret == -errno.EPERM and target[0] in ('osd', 'mds'):
402 print("Permission denied. Check that your user has 'allow *' "
403 "capabilities for the target daemon type.", file=sys.stderr)
404 elif ret == -errno.EPERM:
405 print("Permission denied. Check your user has proper "
406 "capabilities configured", file=sys.stderr)
408 print("couldn't get command descriptions for {0}: {1} ({2})".
409 format(target, outs, ret), file=sys.stderr)
412 return help_for_sigs(outbuf.decode('utf-8'), partial)
414 assert(cluster_handle.state == "connected")
415 return help_for_target(target, partial)
417 DONTSPLIT = string.ascii_letters + '{[<>]}'
420 def wrap(s, width, indent):
422 generator to transform s into a sequence of strings width or shorter,
423 for wrapping text to a specific column width.
424 Attempt to break on anything but DONTSPLIT characters.
425 indent is amount to indent 2nd-through-nth lines.
427 so "long string long string long string" width=11 indent=1 becomes
428 'long string', ' long string', ' long string' so that it can be printed
441 # no splitting; just possibly indent
448 while (splitpos > 0) and (s[splitpos-1] in DONTSPLIT):
455 # prior result means we're mid-iteration, indent
458 # first time, set leader and width for next
459 leader = ' ' * indent
460 width -= 1 # for subsequent space additions
462 # remove any leading spaces in this chunk of s
463 result += s[:splitpos].lstrip()
469 def format_help(cmddict, partial=None):
471 Formats all the cmdsigs and helptexts from cmddict into a sorted-by-
472 cmdsig 2-column display, with each column wrapped and indented to
473 fit into (terminal_width / 2) characters.
477 for cmd in sorted(cmddict.values(), key=descsort_key):
481 flags = cmd.get('flags', 0)
482 if flags & (Flag.OBSOLETE | Flag.DEPRECATED | Flag.HIDDEN):
484 concise = concise_sig(cmd['sig'])
485 if partial and not concise.startswith(partial):
487 width = Termsize().cols - 1 # 1 for the line between sig and help
488 sig_width = int(width / 2)
489 # make sure width == sig_width + help_width, even (width % 2 > 0)
490 help_width = int(width / 2) + (width % 2)
491 siglines = [l for l in wrap(concise, sig_width, 1)]
492 helplines = [l for l in wrap(cmd['help'], help_width, 1)]
494 # make lists the same length
495 maxlen = max(len(siglines), len(helplines))
496 siglines.extend([''] * (maxlen - len(siglines)))
497 helplines.extend([''] * (maxlen - len(helplines)))
499 # so we can zip them for output
500 for s, h in zip(siglines, helplines):
501 fullusage += '{s:{w}s} {h}\n'.format(s=s, h=h, w=sig_width)
506 def ceph_conf(parsed_args, field, name):
510 args.extend(['--name', name])
512 # add any args in GLOBAL_ARGS
513 for key, val in GLOBAL_ARGS.items():
514 # ignore name in favor of argument name, if any
515 if name and key == 'client_name':
517 if getattr(parsed_args, key):
518 args.extend([val, getattr(parsed_args, key)])
520 args.extend(['--show-config-value', field])
521 p = subprocess.Popen(
523 stdout=subprocess.PIPE,
524 stderr=subprocess.PIPE)
525 outdata, errdata = p.communicate()
527 raise RuntimeError('unable to get conf option %s for %s: %s' % (field, name, errdata))
528 return outdata.rstrip()
532 if sys.stdin.isatty():
535 line = input(PROMPT).rstrip()
536 if line in ['q', 'quit', 'Q', 'exit']:
543 line = sys.stdin.readline()
551 def do_command(parsed_args, target, cmdargs, sigdict, inbuf, verbose):
552 ''' Validate a command, and handle the polling flag '''
554 valid_dict = validate_command(sigdict, cmdargs, verbose)
555 # Validate input args against list of sigs
557 if parsed_args.output_format:
558 valid_dict['format'] = parsed_args.output_format
560 print("Submitting command: ", valid_dict, file=sys.stderr)
562 return -errno.EINVAL, '', 'invalid command'
564 next_header_print = 0
565 # Set extra options for polling commands only:
566 if valid_dict.get('poll', False):
567 valid_dict['width'] = Termsize().cols
570 # Only print the header for polling commands
571 if next_header_print == 0 and valid_dict.get('poll', False):
572 valid_dict['print_header'] = True
573 next_header_print = Termsize().rows - 3
574 next_header_print -= 1
575 ret, outbuf, outs = json_command(cluster_handle, target=target,
576 argdict=valid_dict, inbuf=inbuf)
577 if valid_dict.get('poll', False):
578 valid_dict['print_header'] = False
579 if not valid_dict.get('poll', False):
580 # Don't print here if it's not a polling command
584 print('Error: {0} {1}'.format(ret, errno.errorcode.get(ret, 'Unknown')),
588 print(outbuf.decode('utf-8'))
590 print(outs, file=sys.stderr)
591 if parsed_args.period <= 0:
593 sleep(parsed_args.period)
594 except KeyboardInterrupt:
597 if ret == errno.ETIMEDOUT:
600 outs = ("Connection timed out. Please check the client's " +
601 "permission and connection.")
602 return ret, outbuf, outs
605 def new_style_command(parsed_args, cmdargs, target, sigdict, inbuf, verbose):
607 Do new-style command dance.
608 target: daemon to receive command: mon (any) or osd.N
609 sigdict - the parsed output from the new monitor describing commands
610 inbuf - any -i input file data
614 for cmdtag in sorted(sigdict.keys()):
615 cmd = sigdict[cmdtag]
617 print('{0}: {1}'.format(cmdtag, concise_sig(sig)))
621 # Non interactive mode
622 ret, outbuf, outs = do_command(parsed_args, target, cmdargs, sigdict, inbuf, verbose)
624 # Interactive mode (ceph cli)
625 if sys.stdin.isatty():
626 # do the command-interpreter looping
627 # for input to do readline cmd editing
628 import readline # noqa
632 interactive_input = read_input()
634 # leave user an uncluttered prompt
636 if interactive_input is None:
638 cmdargs = parse_cmdargs(shlex.split(interactive_input))[2]
640 target = find_cmd_target(cmdargs)
641 except Exception as e:
642 print('error handling command target: {0}'.format(e),
645 if len(cmdargs) and cmdargs[0] == 'tell':
646 print('Can not use \'tell\' in interactive mode.',
649 ret, outbuf, outs = do_command(parsed_args, target, cmdargs,
650 sigdict, inbuf, verbose)
653 errstr = errno.errorcode.get(ret, 'Unknown')
654 print(u'Error {0}: {1}'.format(errstr, outs), file=sys.stderr)
657 print(outs, file=sys.stderr)
661 return ret, outbuf, outs
664 def complete(sigdict, args, target):
666 Command completion. Match as much of [args] as possible,
667 and print every possible match separated by newlines.
670 # XXX this looks a lot like the front of validate_command(). Refactor?
672 # Repulsive hack to handle tell: lop off 'tell' and target
673 # and validate the rest of the command. 'target' is already
674 # determined in our callers, so it's ok to remove it here.
675 if len(args) and args[0] == 'tell':
677 # look for best match, accumulate possibles in bestcmds
678 # (so we can maybe give a more-useful error message)
682 for cmdtag, cmd in sigdict.items():
685 # iterate over all arguments, except last one
686 for arg in args[0:-1]:
688 # an out of argument definitions
690 found_match = arg in sig[j].complete(arg)
691 if not found_match and sig[j].req:
692 # no elements that match
697 # successfully matched all - except last one - arguments
698 if j < len(sig) and len(args) > 0:
699 comps += sig[j].complete(args[-1])
704 if match_count == 1 and len(comps) == 0:
705 # only one command matched and no hints yet => add help
706 comps = comps + [' ', '#'+match_cmd['help']]
707 print('\n'.join(sorted(set(comps))))
711 def ping_monitor(cluster_handle, name, timeout):
712 if 'mon.' not in name:
713 print('"ping" expects a monitor to ping; try "ping mon.<id>"', file=sys.stderr)
716 mon_id = name[len('mon.'):]
718 run_in_thread(cluster_handle.connect, timeout=timeout)
720 s = run_in_thread(cluster_handle.ping_monitor, m)
722 print("mon.{0}".format(m) + '\n' + "Error connecting to monitor.")
724 print("mon.{0}".format(m) + '\n' + s)
726 s = run_in_thread(cluster_handle.ping_monitor, mon_id)
731 def maybe_daemon_command(parsed_args, childargs):
733 Check if --admin-socket, daemon, or daemonperf command
734 if it is, returns (boolean handled, return code if handled == True)
739 if parsed_args.admin_socket:
740 sockpath = parsed_args.admin_socket
741 elif len(childargs) > 0 and childargs[0] in ["daemon", "daemonperf"]:
742 daemon_perf = (childargs[0] == "daemonperf")
743 # Treat "daemon <path>" or "daemon <name>" like --admin_daemon <path>
744 # Handle "daemonperf <path>" the same but requires no trailing args
745 require_args = 2 if daemon_perf else 3
746 if len(childargs) >= require_args:
747 if childargs[1].find('/') >= 0:
748 sockpath = childargs[1]
750 # try resolve daemon name
752 sockpath = ceph_conf(parsed_args, 'admin_socket',
754 except Exception as e:
755 print('Can\'t get admin socket path: ' + str(e), file=sys.stderr)
756 return True, errno.EINVAL
758 childargs = childargs[2:]
760 print('{0} requires at least {1} arguments'.format(childargs[0], require_args),
762 return True, errno.EINVAL
764 if sockpath and daemon_perf:
765 return True, daemonperf(childargs, sockpath)
768 raw_write(admin_socket(sockpath, childargs, parsed_args.output_format))
769 except Exception as e:
770 print('admin_socket: {0}'.format(e), file=sys.stderr)
771 return True, errno.EINVAL
785 def daemonperf(childargs, sockpath):
787 Handle daemonperf command; returns errno or 0
789 daemonperf <daemon> [priority string] [statpats] [interval] [count]
790 daemonperf <daemon> list|ls [statpats]
799 def prio_from_name(arg):
802 'critical': PRIO_CRITICAL,
803 'interesting': PRIO_INTERESTING,
804 'useful': PRIO_USEFUL,
805 'uninteresting': PRIO_UNINTERESTING,
806 'debugonly': PRIO_DEBUGONLY,
812 for name, val in PRIOMAP.items():
813 if name.startswith(arg):
817 # consume and analyze non-numeric args
818 while len(childargs) and not isnum(childargs[0]):
819 arg = childargs.pop(0)
821 if arg in ['list', 'ls']:
825 prio = prio_from_name(arg)
830 statpats = arg.split(',')
833 priority = PRIO_DEFAULT
835 if len(childargs) > 0:
837 interval = float(childargs.pop(0))
841 print('daemonperf: interval should be a positive number', file=sys.stderr)
844 if len(childargs) > 0:
845 arg = childargs.pop(0)
846 if (not isnum(arg)) or (int(arg) < 0):
847 print('daemonperf: count should be a positive integer', file=sys.stderr)
851 watcher = DaemonWatcher(sockpath, statpats, priority)
855 watcher.run(interval, count)
859 def get_scrub_timestamps(childargs):
860 last_scrub_stamp = "last_" + childargs[1].replace('-', '_') + "_stamp"
863 if childargs[2] in ['all', 'any', '*']:
865 devnull = open(os.devnull, 'w')
866 out = subprocess.check_output(['ceph', 'pg', 'dump', '--format=json-pretty'],
869 pgstats = json.loads(out)['pg_map']['pg_stats']
871 pgstats = json.loads(out)['pg_stats']
873 if scruball or stat['up_primary'] == int(childargs[2]):
874 scrub_tuple = (stat['up_primary'], stat[last_scrub_stamp])
875 results[stat['pgid']] = scrub_tuple
878 def check_scrub_stamps(waitdata, currdata):
879 for pg in waitdata.keys():
880 # Try to handle the case where a pg may not exist in current results
881 if pg in currdata and waitdata[pg][1] == currdata[pg][1]:
885 def waitscrub(childargs, waitdata):
886 print(u'Waiting for {0} to complete...'.format(childargs[1]), file=sys.stdout)
887 currdata = get_scrub_timestamps(childargs)
888 while not check_scrub_stamps(waitdata, currdata):
890 currdata = get_scrub_timestamps(childargs)
891 print(u'{0} completed'.format(childargs[1]), file=sys.stdout)
893 def wait(childargs, waitdata):
894 if childargs[1] in ['scrub', 'deep-scrub']:
895 waitscrub(childargs, waitdata)
899 ceph_args = os.environ.get('CEPH_ARGS')
901 if "injectargs" in sys.argv:
902 i = sys.argv.index("injectargs")
903 sys.argv = sys.argv[:i] + ceph_args.split() + sys.argv[i:]
905 sys.argv.extend([arg for arg in ceph_args.split()
906 if '--admin-socket' not in arg])
907 parser, parsed_args, childargs = parse_cmdargs()
909 if parsed_args.version:
910 print('ceph version {0} ({1}) {2} ({3})'.format(
914 CEPH_RELEASE_TYPE)) # noqa
918 verbose = parsed_args.verbose
921 print("parsed_args: {0}, childargs: {1}".format(parsed_args, childargs), file=sys.stderr)
923 # pass on --id, --name, --conf
924 name = 'client.admin'
925 if parsed_args.client_id:
926 name = 'client.' + parsed_args.client_id
927 if parsed_args.client_name:
928 name = parsed_args.client_name
930 # default '' means default conf search
932 if parsed_args.cephconf:
933 conffile = parsed_args.cephconf
934 # For now, --admin-daemon is handled as usual. Try it
935 # first in case we can't connect() to the cluster
937 done, ret = maybe_daemon_command(parsed_args, childargs)
942 if parsed_args.cluster_timeout:
943 timeout = parsed_args.cluster_timeout
947 do_basic_help(parser, childargs)
949 # handle any 'generic' ceph arguments that we didn't parse here
950 global cluster_handle
952 # rados.Rados() will call rados_create2, and then read the conf file,
953 # and then set the keys from the dict. So we must do these
954 # "pre-file defaults" first (see common_preinit in librados)
956 'log_to_stderr': 'true',
957 'err_to_stderr': 'true',
958 'log_flush_on_exit': 'true',
961 if 'injectargs' in childargs:
962 position = childargs.index('injectargs')
963 injectargs = childargs[position:]
964 childargs = childargs[:position]
966 print('Separate childargs {0} from injectargs {1}'.format(childargs, injectargs),
972 if parsed_args.cluster:
973 clustername = parsed_args.cluster
976 cluster_handle = run_in_thread(rados.Rados,
977 name=name, clustername=clustername,
978 conf_defaults=conf_defaults,
980 retargs = run_in_thread(cluster_handle.conf_parse_argv, childargs)
981 except rados.Error as e:
982 print('Error initializing cluster client: {0!r}'.format(e), file=sys.stderr)
989 # -- means "stop parsing args", but we don't want to see it either
990 if '--' in childargs:
991 childargs.remove('--')
992 if injectargs and '--' in injectargs:
993 injectargs.remove('--')
995 # special deprecation warning for 'ceph <type> tell'
996 # someday 'mds' will be here too
997 if (len(childargs) >= 2 and
998 childargs[0] in ['mon', 'osd'] and
999 childargs[1] == 'tell'):
1000 print('"{0} tell" is deprecated; try "tell {0}.<id> <command> [options...]" instead (id can be "*") '.format(childargs[0]),
1006 if parsed_args.block:
1007 if (len(childargs) >= 2 and
1008 childargs[0] == 'osd' and
1009 childargs[1] in ['deep-scrub', 'scrub']):
1011 waitdata = get_scrub_timestamps(childargs)
1013 if parsed_args.help:
1014 # short default timeout for -h
1018 if childargs and childargs[0] == 'ping' and not parsed_args.help:
1019 if len(childargs) < 2:
1020 print('"ping" requires a monitor name as argument: "ping mon.<id>"', file=sys.stderr)
1022 if parsed_args.completion:
1023 # for completion let timeout be really small
1026 if childargs and childargs[0] == 'ping' and not parsed_args.help:
1027 return ping_monitor(cluster_handle, childargs[1], timeout)
1028 result = run_in_thread(cluster_handle.connect, timeout=timeout)
1029 if type(result) is tuple and result[0] == -errno.EINTR:
1030 print('Cluster connection interrupted or timed out', file=sys.stderr)
1032 except KeyboardInterrupt:
1033 print('Cluster connection aborted', file=sys.stderr)
1035 except rados.PermissionDeniedError as e:
1036 print(str(e), file=sys.stderr)
1038 except Exception as e:
1039 print(str(e), file=sys.stderr)
1042 if parsed_args.help:
1043 hdr('Monitor commands:')
1045 print('[Contacting monitor, timeout after %d seconds]' % timeout)
1047 return do_extended_help(parser, childargs, ('mon', ''), ' '.join(childargs))
1049 # implement "tell service.id help"
1050 if len(childargs) >= 3 and childargs[0] == 'tell' and childargs[2] == 'help':
1051 target = childargs[1].split('.')
1052 if validate_target(target):
1053 return do_extended_help(parser, childargs, target, None)
1055 print('target {0} doesn\'t exists, please pass correct target to tell command, such as mon.a/'
1056 'osd.1/mds.a/mgr'.format(childargs[1]), file=sys.stderr)
1058 # implement -w/--watch_*
1059 # This is ugly, but Namespace() isn't quite rich enough.
1061 for k, v in parsed_args._get_kwargs():
1062 if k.startswith('watch') and v:
1065 elif k != "watch_channel":
1066 level = k.replace('watch_', '')
1068 # an awfully simple callback
1069 def watch_cb(arg, line, channel, name, who, stamp_sec, stamp_nsec, seq, level, msg):
1071 if sys.version_info[0] >= 3:
1072 channel = channel.decode('utf-8')
1073 if (channel == parsed_args.watch_channel or \
1074 parsed_args.watch_channel == "*"):
1075 print(line.decode('utf-8'))
1078 # first do a ceph status
1079 ret, outbuf, outs = json_command(cluster_handle, prefix='status')
1081 print("status query failed: ", outs, file=sys.stderr)
1083 print(outbuf.decode('utf-8'))
1085 # this instance keeps the watch connection alive, but is
1087 run_in_thread(cluster_handle.monitor_log2, level, watch_cb, 0)
1089 # loop forever letting watch_cb print lines
1092 except KeyboardInterrupt:
1093 # or until ^C, at least
1096 # read input file, if any
1098 if parsed_args.input_file:
1100 if parsed_args.input_file == '-':
1101 inbuf = sys.stdin.read()
1103 with open(parsed_args.input_file, 'rb') as f:
1105 except Exception as e:
1106 print('Can\'t open input file {0}: {1}'.format(parsed_args.input_file, e), file=sys.stderr)
1109 # prepare output file, if any
1110 if parsed_args.output_file:
1112 if parsed_args.output_file == '-':
1115 outf = open(parsed_args.output_file, 'wb')
1116 except Exception as e:
1117 print('Can\'t open output file {0}: {1}'.format(parsed_args.output_file, e), file=sys.stderr)
1119 if parsed_args.setuser:
1121 ownerid = pwd.getpwnam(parsed_args.setuser).pw_uid
1122 os.fchown(outf.fileno(), ownerid, -1)
1123 except OSError as e:
1124 print('Failed to change user ownership of {0} to {1}: {2}'.format(outf, parsed_args.setuser, e))
1126 if parsed_args.setgroup:
1128 groupid = grp.getgrnam(parsed_args.setgroup).gr_gid
1129 os.fchown(outf.fileno(), -1, groupid)
1130 except OSError as e:
1131 print('Failed to change group ownership of {0} to {1}: {2}'.format(outf, parsed_args.setgroup, e))
1134 # -s behaves like a command (ceph status).
1135 if parsed_args.status:
1136 childargs.insert(0, 'status')
1139 target = find_cmd_target(childargs)
1140 except Exception as e:
1141 print('error handling command target: {0}'.format(e), file=sys.stderr)
1144 # Repulsive hack to handle tell: lop off 'tell' and target
1145 # and validate the rest of the command. 'target' is already
1146 # determined in our callers, so it's ok to remove it here.
1148 if len(childargs) and childargs[0] == 'tell':
1149 childargs = childargs[2:]
1154 childargs = injectargs
1155 if not len(childargs):
1156 print('"{0} tell" requires additional arguments.'.format(sys.argv[0]),
1157 'Try "{0} tell <name> <command> [options...]" instead.'.format(sys.argv[0]),
1161 # fetch JSON sigs from command
1162 # each line contains one command signature (a placeholder name
1163 # of the form 'cmdNNN' followed by an array of argument descriptors)
1164 # as part of the validated argument JSON object
1166 if target[1] == '*':
1168 targets = [(service, o) for o in ids_by_service(service)]
1173 for target in targets:
1174 # prettify? prefix output with target, if there was a wildcard used
1177 if not parsed_args.output_file and len(targets) > 1:
1178 prefix = '{0}.{1}: '.format(*target)
1181 ret, outbuf, outs = json_command(cluster_handle, target=target,
1182 prefix='get_command_descriptions')
1184 where = '{0}.{1}'.format(*target)
1186 raise RuntimeError('Unexpected return code from {0}: {1}'.
1188 outs = 'problem getting command descriptions from {0}'.format(where)
1190 sigdict = parse_json_funcsigs(outbuf.decode('utf-8'), 'cli')
1192 if parsed_args.completion:
1193 return complete(sigdict, childargs, target)
1195 ret, outbuf, outs = new_style_command(parsed_args, childargs,
1196 target, sigdict, inbuf,
1199 # debug tool: send any successful command *again* to
1200 # verify that it is idempotent.
1201 if not ret and 'CEPH_CLI_TEST_DUP_COMMAND' in os.environ:
1202 ret, outbuf, outs = new_style_command(parsed_args, childargs,
1203 target, sigdict, inbuf,
1208 'Second attempt of previously successful command '
1209 'failed with {0}: {1}'.format(
1210 errno.errorcode.get(ret, 'Unknown'), outs),
1215 errstr = errno.errorcode.get(ret, 'Unknown')
1216 print(u'Error {0}: {1}'.format(errstr, outs), file=sys.stderr)
1217 if len(targets) > 1:
1223 print(prefix + outs, file=sys.stderr)
1227 if parsed_args.output_file:
1230 # hack: old code printed status line before many json outputs
1231 # (osd dump, etc.) that consumers know to ignore. Add blank line
1232 # to satisfy consumers that skip the first line, but not annoy
1233 # consumers that don't.
1234 if parsed_args.output_format and \
1235 parsed_args.output_format.startswith('json'):
1238 # if we are prettifying things, normalize newlines. sigh.
1240 outbuf = outbuf.rstrip()
1243 print(prefix, end='')
1244 # Write directly to binary stdout
1246 print(suffix, end='')
1247 except IOError as e:
1248 if e.errno != errno.EPIPE:
1253 # Block until command completion (currently scrub and deep_scrub only)
1255 wait(childargs, waitdata)
1257 if parsed_args.output_file and parsed_args.output_file != '-':
1265 if __name__ == '__main__':
1267 # shutdown explicitly; Rados() does not
1269 run_in_thread(cluster_handle.shutdown)