raise ValueError("no node found")
if fast_mode:
preload_msgs.setdefault(node, []).append(content)
else:
tree.add(node, content)
except ValueError, ex:
raise ValueError("%s (\"%s\")" % (ex, linestripped))
if fast_mode:
# Messages per node have been aggregated, now add to tree one
# full msg per node
for key, wholemsg in preload_msgs.iteritems():
tree.add(key, '\n'.join(wholemsg))
if options.debug:
STD_GROUP_RESOLVER.set_verbosity(1)
print >> sys.stderr, "clubak: line_mode=%s gather=%s tree_depth=%d" % \
(bool(options.line_mode), bool(options.gather), tree._depth())
# Display results
disp = Display(options)
display(tree, disp, options.gather or disp.regroup, options.trace_mode)
def main():
"""main script function"""
try:
clubak()
except GENERIC_ERRORS, ex:
sys.exit(handle_generic_error(ex))
except ValueError, ex:
print >> sys.stderr, "%s:" % sys.argv[0], ex
def nodeset():
"""script subroutine"""
class_set = NodeSet
usage = "%prog [COMMAND] [OPTIONS] [ns1 [-ixX] ns2|...]"
parser = OptionParser(usage)
parser.install_nodeset_commands()
parser.install_nodeset_operations()
parser.install_nodeset_options()
(options, args) = parser.parse_args()
if options.debug:
STD_GROUP_RESOLVER.set_verbosity(1)
# Check for command presence
cmdcount = int(options.count) + int(options.expand) + \
int(options.fold) + int(bool(options.list)) + \
int(options.regroup) + int(options.groupsources)
if not cmdcount:
parser.error("No command specified.")
elif cmdcount > 1:
parser.error("Multiple commands not allowed.")
if options.rangeset:
class_set = RangeSet
if options.all or options.regroup:
assert class_set == NodeSet, "-a/-r only supported in NodeSet mode"
if options.groupsource and not options.quiet and \
(class_set == RangeSet or options.groupsources):
print >> sys.stderr, "WARNING: option group source \"%s\" ignored" \
% options.groupsource
# The list command doesn't need any NodeSet, check for it first.
if options.list > 0:
list_level = options.list
for group in grouplist(options.groupsource):
if options.groupsource and not options.groupbase:
nsgroup = "@%s:%s" % (options.groupsource, group)
else:
nsgroup = "@%s" % group
if list_level == 1:
print nsgroup
else:
nodes = NodeSet(nsgroup)
if list_level == 2: # -ll ?
print "%s %s" % (nsgroup, nodes)
else: # -lll ?
print "%s %s %d" % (nsgroup, nodes, len(nodes))
return
# Also, the groupsources command simply lists group sources.
elif options.groupsources:
if options.quiet:
dispdefault = "" # don't show (default) if quiet is set
else:
dispdefault = " (default)"
for src in STD_GROUP_RESOLVER.sources():
print "%s%s" % (src, dispdefault)
dispdefault = ""
return
# We want -s <groupsource> to act as a substition of default groupsource
# (ie. it's not necessary to prefix group names by this group source).
if options.groupsource:
STD_GROUP_RESOLVER.default_sourcename = options.groupsource
# Instantiate RangeSet or NodeSet object
xset = class_set(autostep=options.autostep)
if options.all:
# Include all nodes from external node groups support.
xset.update(NodeSet.fromall()) # uses default_sourcename
elif not args:
# No need to specify '-' to read stdin if no argument at all.
process_stdin(xset.update, xset.__class__, options.autostep)
# Apply first operations (before first non-option)
for nodes in options.and_nodes:
if nodes == '-':
process_stdin(xset.intersection_update, xset.__class__,
options.autostep)
else:
xset.intersection_update(class_set(nodes,
autostep=options.autostep))
for nodes in options.sub_nodes:
if nodes == '-':
process_stdin(xset.difference_update, xset.__class__,
options.autostep)
else:
xset.difference_update(class_set(nodes, autostep=options.autostep))
for nodes in options.xor_nodes:
if nodes == '-':
process_stdin(xset.symmetric_difference_update, xset.__class__,
options.autostep)
else:
xset.symmetric_difference_update(class_set(nodes, \
autostep=options.autostep))
# Finish xset computing from args
compute_nodeset(xset, args, options.autostep)
# Interprate special characters (may raise SyntaxError)
separator = eval('\'%s\'' % options.separator, {"__builtins__":None}, {})
if options.slice_rangeset:
_xset = class_set()
for sli in RangeSet(options.slice_rangeset).slices(False):
_xset.update(xset[sli])
xset = _xset
# Display result according to command choice
if options.expand:
xsubres = separator.join
elif options.fold:
xsubres = lambda x: x
elif options.regroup:
xsubres = lambda x: x.regroup(options.groupsource, \
noprefix=options.groupbase)
else:
xsubres = len
if not xset or options.maxsplit <= 1:
print xsubres(xset)
else:
for xsubset in xset.split(options.maxsplit):
print xsubres(xsubset)
def main(args=sys.argv):
"""clush script entry point"""
sys.excepthook = clush_excepthook
# Default values
nodeset_base, nodeset_exclude = NodeSet(), NodeSet()
#
# Argument management
#
usage = "%prog [options] command"
parser = OptionParser(usage)
parser.add_option("--nostdin", action="store_true", dest="nostdin",
help="don't watch for possible input from stdin")
parser.install_nodes_options()
parser.install_display_options(verbose_options=True)
parser.install_filecopy_options()
parser.install_ssh_options()
(options, args) = parser.parse_args(args[1:])
#
# Load config file and apply overrides
#
config = ClushConfig(options)
# Should we use ANSI colors for nodes?
if config.color == "auto":
color = sys.stdout.isatty() and (options.gatherall or \
sys.stderr.isatty())
else:
color = config.color == "always"
# Create and configure display object.
display = Display(options, config, color)
#
# Compute the nodeset
#
if options.nodes:
nodeset_base = NodeSet.fromlist(options.nodes)
if options.exclude:
nodeset_exclude = NodeSet.fromlist(options.exclude)
if options.groupsource:
# Be sure -a/g -s source work as espected.
STD_GROUP_RESOLVER.default_sourcename = options.groupsource
# FIXME: add public API to enforce engine
Task._std_default['engine'] = options.engine
# Do we have nodes group?
task = task_self()
task.set_info("debug", config.verbosity > 1)
if config.verbosity == VERB_DEBUG:
STD_GROUP_RESOLVER.set_verbosity(1)
if options.nodes_all:
all_nodeset = NodeSet.fromall()
display.vprint(VERB_DEBUG, "Adding nodes from option -a: %s" % \
all_nodeset)
nodeset_base.add(all_nodeset)
if options.group:
grp_nodeset = NodeSet.fromlist(options.group,
resolver=NOGROUP_RESOLVER)
for grp in grp_nodeset:
addingrp = NodeSet("@" + grp)
display.vprint(VERB_DEBUG, \
"Adding nodes from option -g %s: %s" % (grp, addingrp))
nodeset_base.update(addingrp)
if options.exgroup:
grp_nodeset = NodeSet.fromlist(options.exgroup,
resolver=NOGROUP_RESOLVER)
for grp in grp_nodeset:
removingrp = NodeSet("@" + grp)
display.vprint(VERB_DEBUG, \
"Excluding nodes from option -X %s: %s" % (grp, removingrp))
nodeset_exclude.update(removingrp)
# Do we have an exclude list? (-x ...)
nodeset_base.difference_update(nodeset_exclude)
if len(nodeset_base) < 1:
parser.error('No node to run on.')
# Set open files limit.
set_fdlimit(config.fd_max, display)
#
# Task management
#
# check for clush interactive mode
interactive = not len(args) and \
not (options.copy or options.rcopy)
# check for foreground ttys presence (input)
stdin_isafgtty = sys.stdin.isatty() and \
os.tcgetpgrp(sys.stdin.fileno()) == os.getpgrp()
# check for special condition (empty command and stdin not a tty)
if interactive and not stdin_isafgtty:
# looks like interactive but stdin is not a tty:
# switch to non-interactive + disable ssh pseudo-tty
interactive = False
# SSH: disable pseudo-tty allocation (-T)
ssh_options = config.ssh_options or ''
ssh_options += ' -T'
config._set_main("ssh_options", ssh_options)
if options.nostdin and interactive:
parser.error("illegal option `--nostdin' in that case")
user_interaction = False
if not options.nostdin:
# Try user interaction: check for foreground ttys presence (ouput)
stdout_isafgtty = sys.stdout.isatty() and \
os.tcgetpgrp(sys.stdout.fileno()) == os.getpgrp()
user_interaction = stdin_isafgtty and stdout_isafgtty
display.vprint(VERB_DEBUG, "User interaction: %s" % user_interaction)
if user_interaction:
# Standard input is a terminal and we want to perform some user
# interactions in the main thread (using blocking calls), so
# we run cluster commands in a new ClusterShell Task (a new
# thread is created).
task = Task()
# else: perform everything in the main thread
# Handle special signal only when user_interaction is set
task.set_default("USER_handle_SIGUSR1", user_interaction)
task.excepthook = sys.excepthook
task.set_default("USER_stdin_worker", not (sys.stdin.isatty() or \
options.nostdin))
display.vprint(VERB_DEBUG, "Create STDIN worker: %s" % \
task.default("USER_stdin_worker"))
task.set_info("debug", config.verbosity >= VERB_DEBUG)
task.set_info("fanout", config.fanout)
if config.ssh_user:
task.set_info("ssh_user", config.ssh_user)
if config.ssh_path:
task.set_info("ssh_path", config.ssh_path)
if config.ssh_options:
task.set_info("ssh_options", config.ssh_options)
# Set detailed timeout values
task.set_info("connect_timeout", config.connect_timeout)
command_timeout = config.command_timeout
task.set_info("command_timeout", command_timeout)
# Enable stdout/stderr separation
task.set_default("stderr", not options.gatherall)
# Disable MsgTree buffering if not gathering outputs
task.set_default("stdout_msgtree", display.gather or display.line_mode)
# Always disable stderr MsgTree buffering
task.set_default("stderr_msgtree", False)
# Set timeout at worker level when command_timeout is defined.
if command_timeout > 0:
timeout = command_timeout
else:
timeout = -1
# Configure task custom status
task.set_default("USER_interactive", interactive)
task.set_default("USER_running", False)
if (options.copy or options.rcopy) and not args:
parser.error("--[r]copy option requires at least one argument")
if options.copy:
if not options.dest_path:
options.dest_path = os.path.dirname(args[0])
op = "copy sources=%s dest=%s" % (args, options.dest_path)
elif options.rcopy:
if not options.dest_path:
options.dest_path = os.path.dirname(args[0])
op = "rcopy sources=%s dest=%s" % (args, options.dest_path)
else:
op = "command=\"%s\"" % ' '.join(args)
# print debug values (fanout value is get from the config object
# and not task itself as set_info() is an asynchronous call.
display.vprint(VERB_DEBUG, "clush: nodeset=%s fanout=%d [timeout " \
"conn=%.1f cmd=%.1f] %s" % (nodeset_base, config.fanout,
task.info("connect_timeout"),
task.info("command_timeout"),
op))
if not task.default("USER_interactive"):
if options.copy:
run_copy(task, args, options.dest_path, nodeset_base, 0,
options.preserve_flag, display)
elif options.rcopy:
run_rcopy(task, args, options.dest_path, nodeset_base, 0,
options.preserve_flag, display)
else:
run_command(task, ' '.join(args), nodeset_base, timeout, display)
if user_interaction:
ttyloop(task, nodeset_base, timeout, display)
elif task.default("USER_interactive"):
display.vprint_err(VERB_QUIET, \
"ERROR: interactive mode requires a tty")
clush_exit(1)
rc = 0
if options.maxrc:
# Instead of clush return code, return commands retcode
rc = task.max_retcode()
if task.num_timeout() > 0:
rc = 255
clush_exit(rc)
