def main():
"""
setres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[cb_debug, ()]
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
whoami = client_utils.getuid()
parser.parse_it() # parse the command line
validate_args(parser)
opt = parser.options
args = parser.args
if opt.down:
delta = client_utils.component_call(SYSMGR, False, 'nodes_down',
(args, whoami))
client_utils.logger.info("nodes marked down:")
for d in delta:
client_utils.logger.info(" %s" % d)
client_utils.logger.info("")
client_utils.logger.info("unknown nodes:")
for a in args:
if a not in delta:
client_utils.logger.info(" %s" % a)
elif opt.up:
delta = client_utils.component_call(SYSMGR, False, 'nodes_up',
(args, whoami))
client_utils.logger.info("nodes marked up:")
for d in delta:
client_utils.logger.info(" %s" % d)
client_utils.logger.info('')
client_utils.logger.info("nodes that weren't in the down list:")
for a in args:
if a not in delta:
client_utils.logger.info(" %s" % a)
elif opt.list_nstates:
header, output = client_utils.cluster_display_node_info()
client_utils.printTabular(header + output)
elif opt.queue:
data = client_utils.component_call(SYSMGR, False,
'set_queue_assignments',
(opt.queue, args, whoami))
client_utils.logger.info(data)
def main():
"""
qdel main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_debug , () ] ]
# Get the version information
opt_def = __doc__.replace('__revision__',__revision__)
opt_def = opt_def.replace('__version__',__version__)
parser = ArgParse(opt_def,callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
jobids = client_utils.validate_jobid_args(parser)
jobs = [{'tag':'job', 'user':user, 'jobid':jobid} for jobid in jobids]
deleted_jobs = client_utils.component_call(QUEMGR, True, 'del_jobs', (jobs, False, user))
time.sleep(1)
if deleted_jobs:
data = [('JobID','User')] + [(job.get('jobid'), job.get('user')) for job in deleted_jobs]
client_utils.logger.info(" Deleted Jobs")
client_utils.print_tabular(data)
def main():
"""
setres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_debug , () ] ]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
whoami = client_utils.getuid()
parser.parse_it() # parse the command line
validate_args(parser)
opt = parser.options
args = parser.args
if opt.down:
delta = client_utils.component_call(SYSMGR, False, 'nodes_down', (args, whoami))
client_utils.logger.info("nodes marked down:")
for d in delta:
client_utils.logger.info(" %s" % d)
client_utils.logger.info("")
client_utils.logger.info("unknown nodes:")
for a in args:
if a not in delta:
client_utils.logger.info(" %s" % a)
elif opt.up:
delta = client_utils.component_call(SYSMGR, False, 'nodes_up', (args, whoami))
client_utils.logger.info("nodes marked up:")
for d in delta:
client_utils.logger.info(" %s" % d)
client_utils.logger.info('')
client_utils.logger.info("nodes that weren't in the down list:")
for a in args:
if a not in delta:
client_utils.logger.info(" %s" %a)
elif opt.list_nstates:
header, output = client_utils.cluster_display_node_info()
client_utils.printTabular(header + output)
elif opt.queue:
data = client_utils.component_call(SYSMGR, False, 'set_queue_assignments', (opt.queue, args, whoami))
client_utils.logger.info(data)
def main():
"""
userres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [( cb_debug, ())]
# Get the version information
opt_def = __doc__.replace('__revision__',__revision__)
opt_def = opt_def.replace('__version__',__version__)
parser = ArgParse(opt_def,callbacks)
parser.parse_it() # parse the command line
args = parser.args
if parser.no_args():
client_utils.print_usage(parser)
sys.exit(1)
# Check if reservation exists
spec = [{'name': rname, 'users':"*", 'start':'*', 'cycle':'*', 'duration':'*'} for rname in args]
result = client_utils.component_call(SCHMGR, False, 'get_reservations', (spec,))
if len(result) and len(result) != len(args):
client_utils.logger.error("Reservation subset matched")
elif not result:
client_utils.logger.error("No Reservations matched")
sys.exit(1)
user_name = client_utils.getuid()
for spec in result:
if not spec['users'] or user_name not in spec['users'].split(":"):
client_utils.logger.error("You are not a user of reservation '%s' and so cannot alter it.", spec['name'])
continue
if spec['cycle']:
updates = update_start_time(spec, user_name)
else:
client_utils.component_call(SCHMGR, False, 'del_reservations', ([{'name':spec['name']}], user_name))
client_utils.logger.info("Releasing reservation '%s'", spec['name'])
def main():
"""
qmove main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[cb_debug, ()]
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
queue, jobs = validate_args(parser, user)
filters = client_utils.get_filters()
jobdata = client_utils.component_call(QUEMGR, False, 'get_jobs', (jobs, ))
response = []
# move jobs to queue
for job in jobdata:
orig_job = job.copy()
job.update({'queue': queue})
client_utils.process_filters(filters, job)
[j] = client_utils.component_call(QUEMGR, False, 'set_jobs',
([orig_job], job, user))
response.append("moved job %d to queue '%s'" %
(j.get('jobid'), j.get('queue')))
if not response:
client_utils.logger.error("Failed to match any jobs or queues")
else:
for line in response:
client_utils.logger.info(line)
def main():
"""
setres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[cb_time, (False, True, True)], # no delta time, Seconds, return int
[cb_date, (True, )], # Allow to set the date to 'now'
[cb_passthrough, ()],
[cb_debug, ()],
[cb_res_users, ()]
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
parser.parse_it() # parse the command line
opt_count = client_utils.get_options(spec, opts, opt2spec, parser)
# if continue to process options then
if validate_args(parser, spec, opt_count):
# modify an existing reservation
if parser.options.modify_res != None:
modify_reservation(parser)
# add new reservation
else:
add_reservation(parser, spec, user)
def main():
"""
qmove main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_debug , () ] ]
# Get the version information
opt_def = __doc__.replace('__revision__',__revision__)
opt_def = opt_def.replace('__version__',__version__)
parser = ArgParse(opt_def,callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
queue,jobs = validate_args(parser,user)
filters = client_utils.get_filters()
jobdata = client_utils.component_call(QUEMGR, False, 'get_jobs', (jobs,))
response = []
# move jobs to queue
for job in jobdata:
orig_job = job.copy()
job.update({'queue':queue})
client_utils.process_filters(filters,job)
[j] = client_utils.component_call(QUEMGR, False, 'set_jobs', ([orig_job],job,user))
response.append("moved job %d to queue '%s'" % (j.get('jobid'), j.get('queue')))
if not response:
client_utils.logger.error("Failed to match any jobs or queues")
else:
for line in response:
client_utils.logger.info(line)
def main():
"""
setres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_time , (False, True, True) ], # no delta time, Seconds, return int
[ cb_date , (True,) ], # Allow to set the date to 'now'
[ cb_passthrough , () ],
[ cb_debug , () ],
[ cb_res_users , () ]]
# Get the version information
opt_def = __doc__.replace('__revision__',__revision__)
opt_def = opt_def.replace('__version__',__version__)
parser = ArgParse(opt_def,callbacks)
user = client_utils.getuid()
parser.parse_it() # parse the command line
opt_count = client_utils.get_options(spec, opts, opt2spec, parser)
# if continue to process options then
if validate_args(parser,spec,opt_count):
# modify an existing reservation
if parser.options.modify_res != None:
modify_reservation(parser)
# add new reservation
else:
add_reservation(parser,spec,user)
def main():
"""
releaseres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [(cb_debug, ())]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
parser.parse_it() # parse the command line
args = parser.args
if parser.no_args():
client_utils.print_usage(parser)
sys.exit(1)
# Check if reservation exists
spec = [{'name': arg, 'partitions': '*'} for arg in args]
result = client_utils.component_call(SCHMGR, False, 'get_reservations',
(spec, ))
if len(result) and len(result) != len(args):
client_utils.logger.error("Reservation subset matched")
elif not result:
client_utils.logger.error("No Reservations matched")
sys.exit(1)
result = client_utils.component_call(SCHMGR, False, 'release_reservations',
(spec, client_utils.getuid()))
for resinfo in result:
partitions = resinfo['partitions'].split(':')
client_utils.logger.info(
"Released reservation '%s' for partitions: %s", resinfo['name'],
str(partitions))
def main():
"""
cqadm main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
(cb_debug, ()),
(cb_gtzero, (True, )), # return int
(cb_time, (False, False,
False)), # no delta time, minutes, return string
(cb_path, (opts, False)), # do not use CWD
(cb_setqueues, ()),
(cb_hold, ())
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
opt_count = client_utils.get_options(spec, opts, opt2spec, parser)
jobs = validate_args(parser, spec, opt_count)
process_cqadm_options(jobs, parser, spec, user)
def main():
"""
cqadm main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
(cb_debug, ()),
(cb_gtzero, (True,)), # return int
(cb_time, (False, False, False)), # no delta time, minutes, return string
(cb_path, (opts, False)), # do not use CWD
(cb_setqueues, ()),
(cb_hold, ()),
]
# Get the version information
opt_def = __doc__.replace("__revision__", __revision__)
opt_def = opt_def.replace("__version__", __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
opt_count = client_utils.get_options(spec, opts, opt2spec, parser)
jobs = validate_args(parser, spec, opt_count)
process_cqadm_options(jobs, parser, spec, user)
def main():
"""
qdel main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[cb_debug, ()]
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
jobids = client_utils.validate_jobid_args(parser)
jobs = [{'tag': 'job', 'user': user, 'jobid': jobid} for jobid in jobids]
deleted_jobs = client_utils.component_call(QUEMGR, True, 'del_jobs',
(jobs, False, user))
time.sleep(1)
if deleted_jobs:
data = [('JobID', 'User')] + [(job.get('jobid'), job.get('user'))
for job in deleted_jobs]
client_utils.logger.info(" Deleted Jobs")
client_utils.print_tabular(data)
def main():
"""
get-bootable-blocks main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[cb_debug, ()],
[cb_gtzero, (True, )]
] # return int
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
parser.parse_it() # parse the command line
opts = parser.options
if not parser.no_args():
client_utils.logger.info('No arguments needed')
if opts.free and opts.reboot:
client_utils.logger.error(
"ERROR: --free may not be specified with --reboot.")
sys.exit(BAD_OPTION_FAIL)
block = opts.block
if block == None:
try:
block = os.environ['COBALT_PARTNAME']
except KeyError:
pass
try:
block = os.environ['COBALT_BLOCKNAME']
except KeyError:
pass
if block == None:
client_utils.logger.error(
"ERROR: block not specified as option or in environment.")
sys.exit(BAD_OPTION_FAIL)
jobid = opts.jobid
if jobid == None:
try:
jobid = int(os.environ['COBALT_JOBID'])
except KeyError:
client_utils.logger.error(
"ERROR: Cobalt jobid not specified as option or in environment."
)
sys.exit(BAD_OPTION_FAIL)
if opts.reboot or opts.free:
#Start the free on the block
#poke cobalt to kill all jobs on the resource as well.
success = client_utils.component_call(SYSMGR, False,
'initiate_proxy_free',
(block, user, jobid))
client_utils.logger.info("Block free on %s initiated." % (block, ))
if not success:
client_utils.logger.error(
"Free request for block %s failed authorization." % (block, ))
sys.exit(AUTH_FAIL)
while (True):
#wait for free. If the user still has jobs running, this won't complete.
#the proxy free should take care of this, though.
if client_utils.component_call(SYSMGR, False,
'get_block_bgsched_status',
(block, )) == 'Free':
client_utils.logger.info("Block %s successfully freed." %
(block, ))
break
if not opts.free:
#This returns important error codes. Pass this back up through main.
return client_utils.boot_block(block, user, jobid)
def main():
"""
qsub main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
def_spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
( cb_debug , () ),
( cb_interactive , () ),
( cb_env , (opts,) ),
( cb_nodes , (False,) ), # return string
( cb_gtzero , (False,) ), # return string
( cb_time , (False, False, False) ), # no delta time, minutes, return string
( cb_umask , () ),
( cb_path , (opts, True) ), # use CWD
( cb_dep , () ),
( cb_attrs , () ),
( cb_mode , () ),
( cb_user_list , (opts,) ),
( cb_geometry , (opts,) )]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
user = client_utils.getuid()
def_spec['tag'] = 'job'
def_spec['user'] = user
def_spec['outputdir'] = client_utils.CWD_TAG
def_spec['jobid'] = '*'
def_spec['path'] = client_utils.getpath()
def_spec['mode'] = False
def_spec['cwd'] = client_utils.getcwd()
def_spec['kernel'] = CN_DEFAULT_KERNEL
def_spec['ion_kernel'] = ION_DEFAULT_KERNEL
def_spec['queue'] = 'default'
def_spec['umask'] = 022
def_spec['run_project'] = False
def_spec['user_list'] = [user]
def_spec['procs'] = False
def_spec['script_preboot'] = True
parser = ArgParse(opt_def, callbacks)
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
reparse = validate_args(parser, spec)
if reparse:
# re-parse with new sys.argv
# note: the first parse is necessary to make sure that
# the env syntax is correct for every --env option provided
# If not parsed prior to the union then the union could result
# in a valid syntax, but it would not be what the user would want.
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
client_utils.setumask(spec['umask'])
validate_options(parser, opt_count)
update_outputprefix(parser, spec)
update_paths(spec)
check_inputfile(parser, spec)
not_exit_on_interrupt()
opts['qsub_host'] = socket.gethostname()
opts = client_utils.component_call(SYSMGR, False, 'validate_job',(opts,))
impl = client_utils.component_call(SYSMGR, False, 'get_implementation',())
exit_on_interrupt()
if impl in ['alps_system']:
# If we're interactive, remote and go.
if opts['mode'] == 'interactive':
if opts.get('ssh_host', None) is not None:
if opts['qsub_host'] != opts['ssh_host']:
#remote execute qsub on the ssh_host
client_utils.logger.info('Connecting to %s for interactive qsub...', opts['ssh_host'])
sys.exit(qsub_remote_host(opts['ssh_host'])) # return status from qsub-ssh
filters = client_utils.get_filters()
client_utils.process_filters(filters, spec)
# Attrs needs special handling filter won't set otherwise
if spec.get('attrs', None) is not None:
opts['attrs'].update(ast.literal_eval(str(spec['attrs'])))
update_spec(parser, opts, spec, opt2spec)
run_job(parser, user, spec, opts)
def main():
"""
qsub main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
def_spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
(cb_debug, ()),
(cb_env, (opts, )),
(cb_nodes, (False, )), # return string
(cb_gtzero, (False, )), # return string
(cb_time, (False, False,
False)), # no delta time, minutes, return string
(cb_umask, ()),
(cb_path, (opts, True)), # use CWD
(cb_dep, ()),
(cb_attrs, ()),
(cb_mode, ()),
(cb_user_list, (opts, )),
(cb_geometry, (opts, ))
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
user = client_utils.getuid()
def_spec['tag'] = 'job'
def_spec['user'] = user
def_spec['outputdir'] = client_utils.CWD_TAG
def_spec['jobid'] = '*'
def_spec['path'] = client_utils.getpath()
def_spec['mode'] = False
def_spec['cwd'] = client_utils.getcwd()
def_spec['kernel'] = CN_DEFAULT_KERNEL
def_spec['ion_kernel'] = ION_DEFAULT_KERNEL
def_spec['queue'] = 'default'
def_spec['umask'] = 022
def_spec['run_project'] = False
def_spec['user_list'] = [user]
def_spec['procs'] = False
def_spec['script_preboot'] = True
parser = ArgParse(opt_def, callbacks)
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
reparse = validate_args(parser, spec)
if reparse:
# re-parse with new sys.argv
# note: the first parse is necessary to make sure that
# the env syntax is correct for every --env option provided
# If not parsed prior to the union then the union could result
# in a valid syntax, but it would not be what the user would want.
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
client_utils.setumask(spec['umask'])
validate_options(parser, opt_count)
update_outputprefix(parser, spec)
update_paths(spec)
check_inputfile(parser, spec)
opts = client_utils.component_call(SYSMGR, False, 'validate_job', (opts, ))
filters = client_utils.get_filters()
client_utils.process_filters(filters, spec)
update_spec(opts, spec, opt2spec)
get_interactive_command(parser, spec, opts, opt2spec, def_spec)
jobs = client_utils.component_call(QUEMGR, False, 'add_jobs', ([spec], ))
def on_interrupt(sig, func=None):
'''Handler to cleanup the queued 'dummy' job if the user interrupts
qsub -I forcibly
'''
try:
spec = [{'tag': 'job', 'jobid': jobs[0]['jobid'], 'user': user}]
except NameError:
sys.exit(1)
except:
raise
client_utils.logger.info("Deleting job %d", (jobs[0]['jobid']))
del_jobs = client_utils.component_call(QUEMGR, False, 'del_jobs',
(spec, False, user))
client_utils.logger.info("%s", del_jobs)
sys.exit(1)
#reset sigint and sigterm interrupt handlers to deal with interactive failures
signal.signal(signal.SIGINT, on_interrupt)
signal.signal(signal.SIGTERM, on_interrupt)
if parser.options.envs:
client_utils.logger.debug("Environment Vars: %s", parser.options.envs)
logjob(jobs[0], spec)
# If this is an interactive job, wait for it to start, then ssh in
if parser.options.interactive:
headnode = ""
query = [{
'tag': 'job',
'jobid': jobs[0]['jobid'],
'location': '*',
'state': "*"
}]
while True:
response = client_utils.component_call(QUEMGR, False, 'get_jobs',
(query, ))
state = response[0]['state']
location = response[0]['location']
if state == 'running' and location:
headnode = location[0]
client_utils.logger.info("Opening ssh session to %s", headnode)
break
elif state != 'running' and state != 'queued' and state != 'starting':
client_utils.logger.error(
"ERROR: Something went wrong with job submission, did not expect job to reach %s state.",
response[0]['state'])
break
else:
#using Cobalt Utils sleep here
sleep(2)
if not headnode:
client_utils.logger.error(
"Unable to determine head node for job %d", (jobs[0]['jobid']))
else:
try:
os.putenv("COBALT_NODEFILE",
"/var/tmp/cobalt.%s" % (response[0]['jobid']))
os.putenv("COBALT_JOBID", "%s" % (response[0]['jobid']))
os.system(
"/usr/bin/ssh -o \"SendEnv COBALT_NODEFILE COBALT_JOBID\" %s"
% (headnode))
except:
client_utils.logger.error(
'Exception occurred during execution ssh session. Job Terminated.'
)
spec = [{'tag': 'job', 'jobid': jobs[0]['jobid'], 'user': user}]
jobs = client_utils.component_call(QUEMGR, False, 'del_jobs',
(spec, False, user))
def main():
"""
qsub main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
def_spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
( cb_debug , () ),
( cb_env , (opts,) ),
( cb_nodes , (False,) ), # return string
( cb_gtzero , (False,) ), # return string
( cb_time , (False, False, False) ), # no delta time, minutes, return string
( cb_umask , () ),
( cb_path , (opts, True) ), # use CWD
( cb_dep , () ),
( cb_attrs , () ),
( cb_mode , () ),
( cb_user_list , (opts,) ),
( cb_geometry , (opts,) )]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
user = client_utils.getuid()
def_spec['tag'] = 'job'
def_spec['user'] = user
def_spec['outputdir'] = client_utils.CWD_TAG
def_spec['jobid'] = '*'
def_spec['path'] = client_utils.getpath()
def_spec['mode'] = False
def_spec['cwd'] = client_utils.getcwd()
def_spec['kernel'] = CN_DEFAULT_KERNEL
def_spec['ion_kernel'] = ION_DEFAULT_KERNEL
def_spec['queue'] = 'default'
def_spec['umask'] = 022
def_spec['run_project'] = False
def_spec['user_list'] = [user]
def_spec['procs'] = False
def_spec['script_preboot'] = True
parser = ArgParse(opt_def, callbacks)
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
reparse = validate_args(parser, spec)
if reparse:
# re-parse with new sys.argv
# note: the first parse is necessary to make sure that
# the env syntax is correct for every --env option provided
# If not parsed prior to the union then the union could result
# in a valid syntax, but it would not be what the user would want.
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
client_utils.setumask(spec['umask'])
validate_options(parser, opt_count)
update_outputprefix(parser, spec)
update_paths(spec)
check_inputfile(parser, spec)
opts = client_utils.component_call(SYSMGR, False, 'validate_job',(opts,))
filters = client_utils.get_filters()
client_utils.process_filters(filters, spec)
update_spec(opts, spec, opt2spec)
get_interactive_command(parser, spec, opts, opt2spec, def_spec)
jobs = client_utils.component_call(QUEMGR, False, 'add_jobs',([spec],))
def on_interrupt(sig, func=None):
'''Handler to cleanup the queued 'dummy' job if the user interrupts
qsub -I forcibly
'''
try:
spec = [{'tag':'job', 'jobid':jobs[0]['jobid'], 'user':user}]
except NameError:
sys.exit(1)
except:
raise
client_utils.logger.info("Deleting job %d", (jobs[0]['jobid']))
del_jobs = client_utils.component_call(QUEMGR, False, 'del_jobs', (spec, False, user))
client_utils.logger.info("%s", del_jobs)
sys.exit(1)
#reset sigint and sigterm interrupt handlers to deal with interactive failures
signal.signal(signal.SIGINT, on_interrupt)
signal.signal(signal.SIGTERM, on_interrupt)
if parser.options.envs:
client_utils.logger.debug("Environment Vars: %s", parser.options.envs)
logjob(jobs[0], spec)
# If this is an interactive job, wait for it to start, then ssh in
if parser.options.interactive:
headnode = ""
query = [{'tag':'job', 'jobid':jobs[0]['jobid'], 'location':'*', 'state':"*"}]
while True:
response = client_utils.component_call(QUEMGR, False, 'get_jobs', (query, ))
state = response[0]['state']
location = response[0]['location']
if state == 'running' and location:
headnode = location[0]
client_utils.logger.info("Opening ssh session to %s", headnode)
break
elif state != 'running' and state != 'queued' and state != 'starting':
client_utils.logger.error("ERROR: Something went wrong with job submission, did not expect job to reach %s state.",
response[0]['state'])
break
else:
#using Cobalt Utils sleep here
sleep(2)
if not headnode:
client_utils.logger.error("Unable to determine head node for job %d", (jobs[0]['jobid']))
else:
try:
os.putenv("COBALT_NODEFILE", "/var/tmp/cobalt.%s" % (response[0]['jobid']))
os.putenv("COBALT_JOBID", "%s" % (response[0]['jobid']))
os.system("/usr/bin/ssh -o \"SendEnv COBALT_NODEFILE COBALT_JOBID\" %s" % (headnode))
except:
client_utils.logger.error('Exception occurred during execution ssh session. Job Terminated.')
spec = [{'tag':'job', 'jobid':jobs[0]['jobid'], 'user':user}]
jobs = client_utils.component_call(QUEMGR, False, 'del_jobs', (spec, False, user))
def modify_reservation(parser):
"""
this will handle reservation modifications
"""
query = [{
'name': parser.options.name,
'start': '*',
'cycle': '*',
'duration': '*'
}]
res_list = client_utils.component_call(SCHMGR, False, 'get_reservations',
(query, ))
if not res_list:
client_utils.logger.error("cannot find reservation named '%s'" %
parser.options.name)
sys.exit(1)
updates = {} # updates to reservation
if parser.options.defer != None:
res = res_list[0]
if not res['cycle']:
client_utils.logger.error(
"Cannot use -D on a non-cyclic reservation")
sys.exit(1)
start = res['start']
duration = res['duration']
cycle = float(res['cycle'])
now = time.time()
periods = math.floor((now - start) / cycle)
if (periods < 0):
start += cycle
elif (now - start) % cycle < duration:
start += (periods + 1) * cycle
else:
start += (periods + 2) * cycle
newstart = time.strftime("%c", time.localtime(start))
client_utils.logger.info(
"Setting new start time for for reservation '%s': %s" %
(res['name'], newstart))
updates['start'] = start
#add a field to updates to indicate we're deferring:
updates['defer'] = True
else:
if parser.options.start != None:
updates['start'] = parser.options.start
if parser.options.duration != None:
updates['duration'] = parser.options.duration
if parser.options.users != None:
updates[
'users'] = None if parser.options.users == "*" else parser.options.users
if parser.options.project != None:
updates['project'] = parser.options.project
if parser.options.cycle != None:
updates['cycle'] = parser.options.cycle
if not parser.no_args():
updates['partitions'] = ":".join(parser.args)
if parser.options.block_passthrough != None:
updates['block_passthrough'] = parser.options.block_passthrough
comp_args = ([{
'name': parser.options.name
}], updates, client_utils.getuid())
client_utils.component_call(SCHMGR, False, 'set_reservations', comp_args)
reservations = client_utils.component_call(SCHMGR, False,
'get_reservations',
([{
'name': parser.options.name,
'users': '*',
'start': '*',
'duration': '*',
'partitions': '*',
'cycle': '*',
'res_id': '*',
'project': '*',
'block_passthrough': '*'
}], ))
client_utils.logger.info(reservations)
client_utils.logger.info(
client_utils.component_call(SCHMGR, False, 'check_reservations', ()))
def main():
"""
partadm main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# get the system info
sysinfo = client_utils.system_info()
sys_type = sysinfo[0]
print_block = print_block_bgp
if sys_type == 'bgq':
print_block = print_block_bgq
use_cwd = False
options = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
[cb_debug, ()],
[cb_path, (options, use_cwd)]
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
# Set required default values: None
parser.parse_it() # parse the command line
args = parser.args
opts = parser.options
whoami = client_utils.getuid()
validate_args(parser)
parts = []
if parser.options.recursive:
parts = recursive(args)
else:
parts = args
parts = handle_mux_options(opts, parts, whoami, sys_type)
# make sure parts is an a list even if it is an empty list
if parts is None:
parts = []
if opts.pg_list:
print_pg_info(None)
sys.exit(0)
if opts.blockinfo:
handle_blockinfo_option(parts, sys_type, print_block)
if opts.clean_block:
handle_clean_block_option(parts, whoami, sys_type)
if opts.list_blocks:
handle_list_blocks_option(parts, sys_type)
elif opts.boot_start or opts.boot_stop or opts.list_io:
pass
else:
client_utils.logger.info(parts)
if opts.list_io:
handle_list_io_option(sys_type)
def main():
"""
qsub main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
def_spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
(cb_debug, ()),
(cb_interactive, ()),
(cb_env, (opts, )),
(cb_nodes, (False, )), # return string
(cb_gtzero, (False, )), # return string
(cb_time, (False, False,
False)), # no delta time, minutes, return string
(cb_umask, ()),
(cb_path, (opts, True)), # use CWD
(cb_dep, ()),
(cb_attrs, ()),
(cb_mode, ()),
(cb_user_list, (opts, )),
(cb_geometry, (opts, ))
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
user = client_utils.getuid()
def_spec['tag'] = 'job'
def_spec['user'] = user
def_spec['outputdir'] = client_utils.CWD_TAG
def_spec['jobid'] = '*'
def_spec['path'] = client_utils.getpath()
def_spec['mode'] = False
def_spec['cwd'] = client_utils.getcwd()
def_spec['kernel'] = CN_DEFAULT_KERNEL
def_spec['ion_kernel'] = ION_DEFAULT_KERNEL
def_spec['queue'] = 'default'
def_spec['umask'] = 022
def_spec['run_project'] = False
def_spec['user_list'] = [user]
def_spec['procs'] = False
def_spec['script_preboot'] = True
parser = ArgParse(opt_def, callbacks)
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
reparse = validate_args(parser, spec)
if reparse:
# re-parse with new sys.argv
# note: the first parse is necessary to make sure that
# the env syntax is correct for every --env option provided
# If not parsed prior to the union then the union could result
# in a valid syntax, but it would not be what the user would want.
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
client_utils.setumask(spec['umask'])
validate_options(parser, opt_count)
update_outputprefix(parser, spec)
update_paths(spec)
check_inputfile(parser, spec)
not_exit_on_interrupt()
opts = client_utils.component_call(SYSMGR, False, 'validate_job', (opts, ))
exit_on_interrupt()
filters = client_utils.get_filters()
client_utils.process_filters(filters, spec)
update_spec(parser, opts, spec, opt2spec)
run_job(parser, user, spec, opts)
def main():
"""
releaseres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [(cb_debug, ())]
# Get the version information
opt_def = __doc__.replace("__revision__", __revision__)
opt_def = opt_def.replace("__version__", __version__)
parser = ArgParse(opt_def, callbacks)
parser.parse_it() # parse the command line
args = parser.args
if parser.no_args():
client_utils.print_usage(parser)
sys.exit(1)
# Check if reservation exists
spec = [{"name": arg, "partitions": "*"} for arg in args]
result = client_utils.component_call(SCHMGR, False, "get_reservations", (spec,))
if len(result) and len(result) != len(args):
client_utils.logger.error("Reservation subset matched")
elif not result:
client_utils.logger.error("No Reservations matched")
sys.exit(1)
result = client_utils.component_call(SCHMGR, False, "release_reservations", (spec, client_utils.getuid()))
for resinfo in result:
partitions = resinfo["partitions"].split(":")
client_utils.logger.info("Released reservation '%s' for partitions: %s", resinfo["name"], str(partitions))
def modify_reservation(parser):
"""
this will handle reservation modifications
"""
query = [{'name':parser.options.name, 'start':'*', 'cycle':'*', 'duration':'*'}]
res_list = client_utils.component_call(SCHMGR, False, 'get_reservations', (query,))
if not res_list:
client_utils.logger.error("cannot find reservation named '%s'" % parser.options.name)
sys.exit(1)
updates = {} # updates to reservation
if parser.options.defer != None:
res = res_list[0]
if not res['cycle']:
client_utils.logger.error("Cannot use -D on a non-cyclic reservation")
sys.exit(1)
start = res['start']
duration = res['duration']
cycle = float(res['cycle'])
now = time.time()
periods = math.floor((now - start)/cycle)
if(periods < 0):
start += cycle
elif(now - start) % cycle < duration:
start += (periods + 1) * cycle
else:
start += (periods + 2) * cycle
newstart = time.strftime("%c", time.localtime(start))
client_utils.logger.info("Setting new start time for for reservation '%s': %s" % (res['name'], newstart))
updates['start'] = start
#add a field to updates to indicate we're deferring:
updates['defer'] = True
else:
if parser.options.start != None:
updates['start'] = parser.options.start
if parser.options.duration != None:
updates['duration'] = parser.options.duration
if parser.options.users != None:
updates['users'] = None if parser.options.users == "*" else parser.options.users
if parser.options.project != None:
updates['project'] = parser.options.project
if parser.options.cycle != None:
updates['cycle'] = parser.options.cycle
if not parser.no_args():
updates['partitions'] = ":".join(parser.args)
if parser.options.block_passthrough != None:
updates['block_passthrough'] = parser.options.block_passthrough
comp_args = ([{'name':parser.options.name}], updates, client_utils.getuid())
client_utils.component_call(SCHMGR, False, 'set_reservations', comp_args)
reservations = client_utils.component_call(SCHMGR, False, 'get_reservations',
([{'name':parser.options.name, 'users':'*','start':'*', 'duration':'*', 'partitions':'*',
'cycle': '*', 'res_id': '*', 'project':'*', 'block_passthrough':'*'}], ))
client_utils.logger.info(reservations)
client_utils.logger.info(client_utils.component_call(SCHMGR, False, 'check_reservations', ()))
def main():
"""
partadm main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# get the system info
sysinfo = client_utils.system_info()
sys_type = sysinfo[0]
print_block = print_block_bgp
if sys_type == 'bgq':
print_block = print_block_bgq
use_cwd = False
options = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
[ cb_debug , () ],
[ cb_path , (options, use_cwd) ] ]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
# Set required default values: None
parser.parse_it() # parse the command line
args = parser.args
opts = parser.options
whoami = client_utils.getuid()
validate_args(parser)
parts = []
if parser.options.recursive:
parts = recursive(args)
else:
parts = args
parts = handle_mux_options(opts, parts, whoami, sys_type)
# make sure parts is an a list even if it is an empty list
if parts is None:
parts = []
if opts.pg_list:
print_pg_info(None)
sys.exit(0)
if opts.blockinfo:
handle_blockinfo_option(parts, sys_type, print_block)
if opts.clean_block:
handle_clean_block_option(parts, whoami, sys_type)
if opts.list_blocks:
handle_list_blocks_option(parts, sys_type)
elif opts.boot_start or opts.boot_stop or opts.list_io:
pass
else:
client_utils.logger.info(parts)
if opts.list_io:
handle_list_io_option(sys_type)
def main():
"""
qsub main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
def_spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
( cb_debug , () ),
( cb_interactive , () ),
( cb_env , (opts,) ),
( cb_nodes , (False,) ), # return string
( cb_gtzero , (False,) ), # return string
( cb_time , (False, False, False) ), # no delta time, minutes, return string
( cb_umask , () ),
( cb_path , (opts, True) ), # use CWD
( cb_dep , () ),
( cb_attrs , () ),
( cb_mode , () ),
( cb_user_list , (opts,) ),
( cb_geometry , (opts,) )]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
user = client_utils.getuid()
def_spec['tag'] = 'job'
def_spec['user'] = user
def_spec['outputdir'] = client_utils.CWD_TAG
def_spec['jobid'] = '*'
def_spec['path'] = client_utils.getpath()
def_spec['mode'] = False
def_spec['cwd'] = client_utils.getcwd()
def_spec['kernel'] = CN_DEFAULT_KERNEL
def_spec['ion_kernel'] = ION_DEFAULT_KERNEL
def_spec['queue'] = 'default'
def_spec['umask'] = 022
def_spec['run_project'] = False
def_spec['user_list'] = [user]
def_spec['procs'] = False
def_spec['script_preboot'] = True
parser = ArgParse(opt_def, callbacks)
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
reparse = validate_args(parser, spec)
if reparse:
# re-parse with new sys.argv
# note: the first parse is necessary to make sure that
# the env syntax is correct for every --env option provided
# If not parsed prior to the union then the union could result
# in a valid syntax, but it would not be what the user would want.
opt_count = parse_options(parser, spec, opts, opt2spec, def_spec)
client_utils.setumask(spec['umask'])
validate_options(parser, opt_count)
update_outputprefix(parser, spec)
update_paths(spec)
check_inputfile(parser, spec)
not_exit_on_interrupt()
opts = client_utils.component_call(SYSMGR, False, 'validate_job',(opts,))
exit_on_interrupt()
filters = client_utils.get_filters()
client_utils.process_filters(filters, spec)
update_spec(parser, opts, spec, opt2spec)
run_job(parser, user, spec, opts)
def main():
"""
get-bootable-blocks main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_debug , () ],
[ cb_gtzero , (True,) ] ] # return int
# Get the version information
opt_def = __doc__.replace('__revision__',__revision__)
opt_def = opt_def.replace('__version__',__version__)
parser = ArgParse(opt_def,callbacks)
user = client_utils.getuid()
parser.parse_it() # parse the command line
opts = parser.options
if not parser.no_args():
client_utils.logger.info('No arguments needed')
if opts.free and opts.reboot:
client_utils.logger.error("ERROR: --free may not be specified with --reboot.")
sys.exit(BAD_OPTION_FAIL)
block = opts.block
if block == None:
try:
block = os.environ['COBALT_PARTNAME']
except KeyError:
pass
try:
block = os.environ['COBALT_BLOCKNAME']
except KeyError:
pass
if block == None:
client_utils.logger.error("ERROR: block not specified as option or in environment.")
sys.exit(BAD_OPTION_FAIL)
jobid = opts.jobid
if jobid == None:
try:
jobid = int(os.environ['COBALT_JOBID'])
except KeyError:
client_utils.logger.error("ERROR: Cobalt jobid not specified as option or in environment.")
sys.exit(BAD_OPTION_FAIL)
if opts.reboot or opts.free:
#Start the free on the block
#poke cobalt to kill all jobs on the resource as well.
success = client_utils.component_call(SYSMGR, False, 'initiate_proxy_free', (block, user, jobid))
client_utils.logger.info("Block free on %s initiated." % (block,))
if not success:
client_utils.logger.error("Free request for block %s failed authorization." % (block, ))
sys.exit(AUTH_FAIL)
while (True):
#wait for free. If the user still has jobs running, this won't complete.
#the proxy free should take care of this, though.
if client_utils.component_call(SYSMGR, False, 'get_block_bgsched_status', (block,)) == 'Free':
client_utils.logger.info("Block %s successfully freed." % (block,))
break
if not opts.free:
#This returns important error codes. Pass this back up through main.
return client_utils.boot_block(block, user, jobid)
def main():
"""
qalter main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
spec = {} # map of destination option strings and parsed values
opts = {} # old map
opt2spec = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_debug , () ],
[ cb_gtzero , (True,) ], # return int
[ cb_nodes , (True,) ], # return int
[ cb_time , (True, False, False) ], # delta time allowed, return minutes, return string
[ cb_upd_dep , () ],
[ cb_attrs , () ],
[ cb_user_list , (opts,) ],
[ cb_geometry , (opts,) ],
[ cb_mode , () ]]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
user = client_utils.getuid()
# Set required default values: None
parser.parse_it() # parse the command line
opt_count = client_utils.get_options(spec, opts, opt2spec, parser)
# if run_project set then set run users to current user
if parser.options.run_project != None:
spec['user_list'] = [user]
jobids = validate_args(parser, opt_count)
filters = client_utils.get_filters()
jobdata = get_jobdata(jobids, parser, user)
if parser.options.defer != None:
client_utils.set_scores(0, jobids, user)
if opt_count == 1:
return
response = []
# for every job go update the spec info
for job in jobdata:
# append the parsed spec to the updates list
new_spec = spec.copy()
new_spec['jobid'] = job['jobid']
if parser.options.walltime is not None:
update_time(job, new_spec, parser)
if parser.options.nodes is not None or parser.options.mode is not None:
if parser.options.nodes is None:
new_spec['nodes'] = job['nodes']
if parser.options.mode is None:
new_spec['mode'] = job['mode']
update_procs(new_spec, parser)
if parser.options.geometry is not None:
client_utils.validate_geometry(opts['geometry'], job['nodes'])
del job['is_active']
orig_job = job.copy()
job.update(new_spec)
client_utils.process_filters(filters, job)
response = client_utils.component_call(QUEMGR, False, 'set_jobs', ([orig_job], job, user))
do_some_logging(job, orig_job, parser)
if not response:
client_utils.logger.error("Failed to match any jobs or queues")
else:
client_utils.logger.debug(response)
def main():
"""
schedctl main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
use_cwd = False
options = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
[ cb_debug , () ],
[ cb_score , () ],
[ cb_path , (options, use_cwd) ] ]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
# Set required default values: None
parser.parse_it() # parse the command line
args = parser.args
opt = parser.options
whoami = client_utils.getuid()
validate_args(parser, args)
if opt.stop != None:
client_utils.component_call(SCHMGR, False, 'disable', (whoami,))
client_utils.logger.info("Job Scheduling: DISABLED")
sys.exit(0)
elif opt.start != None:
client_utils.component_call(SCHMGR, False, 'enable', (whoami,))
client_utils.logger.info("Job Scheduling: ENABLED")
sys.exit(0)
elif opt.stat != None:
if client_utils.component_call(SCHMGR, False, 'sched_status', ()):
client_utils.logger.info("Job Scheduling: ENABLED")
else:
client_utils.logger.info("Job Scheduling: DISABLED")
sys.exit(0)
elif opt.reread != None:
client_utils.logger.info("Attempting to reread utility functions.")
client_utils.component_call(QUEMGR, False, 'define_user_utility_functions', (whoami,))
sys.exit(0)
elif opt.savestate != None:
response = client_utils.component_call(SCHMGR, False, 'save', (opt.savestate,))
client_utils.logger.info(response)
sys.exit(0)
if opt.adjust != None:
client_utils.set_scores(opt.adjust, args, whoami)
if opt.dep_frac != None:
specs = [{'jobid':jobid} for jobid in args]
response = client_utils.component_call(QUEMGR, False, 'set_jobs', (specs, {"dep_frac": opt.dep_frac}, whoami))
if not response:
client_utils.logger.info("no jobs matched")
else:
dumb = [str(r["jobid"]) for r in response]
client_utils.logger.info("updating inheritance fraction for jobs: %s" % ", ".join(dumb))
def main():
"""
setres main
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
# list of callback with its arguments
callbacks = [
# <cb function> <cb args>
[ cb_debug , () ] ]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
whoami = client_utils.getuid()
parser.parse_it() # parse the command line
validate_args(parser)
opt = parser.options
args = parser.args
#get type of system, Cray systems handled differently
impl = client_utils.component_call(SYSMGR, False, 'get_implementation', ())
if impl in ['alps_system']:
updates = {}
if opt.list_nstates:
client_utils.print_node_list()
return
if opt.list_details:
# list details and bail
# get list from arguments. Currently assuing a comma separated,
# hyphen-condensed nodelist
client_utils.print_node_details(args)
return
update_type = 'ERROR'
if opt.down:
update_type = 'node down'
updates['down'] = True
elif opt.up:
update_type = 'node up'
updates['up'] = True
elif opt.queue:
update_type = 'queue'
updates['queues'] = opt.queue
mod_nodes = client_utils.component_call(SYSMGR, False, 'update_nodes',
(updates, client_utils.expand_node_args(args), whoami))
client_utils.logger.info('Update %s applied to nodes %s', update_type,
compact_num_list(mod_nodes))
else:
if opt.down:
delta = client_utils.component_call(SYSMGR, False, 'nodes_down', (args, whoami))
client_utils.logger.info("nodes marked down:")
for d in delta:
client_utils.logger.info(" %s" % d)
client_utils.logger.info("")
client_utils.logger.info("unknown nodes:")
for a in args:
if a not in delta:
client_utils.logger.info(" %s" % a)
elif opt.up:
delta = client_utils.component_call(SYSMGR, False, 'nodes_up', (args, whoami))
client_utils.logger.info("nodes marked up:")
for d in delta:
client_utils.logger.info(" %s" % d)
client_utils.logger.info('')
client_utils.logger.info("nodes that weren't in the down list:")
for a in args:
if a not in delta:
client_utils.logger.info(" %s" %a)
elif opt.list_nstates:
header, output = client_utils.cluster_display_node_info()
client_utils.printTabular(header + output)
elif opt.queue:
data = client_utils.component_call(SYSMGR, False, 'set_queue_assignments', (opt.queue, args, whoami))
client_utils.logger.info(data)
def main():
"""
schedctl main function.
"""
# setup logging for client. The clients should call this before doing anything else.
client_utils.setup_logging(logging.INFO)
use_cwd = False
options = {}
# list of callback with its arguments
callbacks = [
# <cb function> <cb args (tuple) >
[cb_debug, ()],
[cb_score, ()],
[cb_path, (options, use_cwd)]
]
# Get the version information
opt_def = __doc__.replace('__revision__', __revision__)
opt_def = opt_def.replace('__version__', __version__)
parser = ArgParse(opt_def, callbacks)
# Set required default values: None
parser.parse_it() # parse the command line
args = parser.args
opt = parser.options
whoami = client_utils.getuid()
validate_args(parser, args)
if opt.stop != None:
client_utils.component_call(SCHMGR, False, 'disable', (whoami, ))
client_utils.logger.info("Job Scheduling: DISABLED")
sys.exit(0)
elif opt.start != None:
client_utils.component_call(SCHMGR, False, 'enable', (whoami, ))
client_utils.logger.info("Job Scheduling: ENABLED")
sys.exit(0)
elif opt.stat != None:
if client_utils.component_call(SCHMGR, False, 'sched_status', ()):
client_utils.logger.info("Job Scheduling: ENABLED")
else:
client_utils.logger.info("Job Scheduling: DISABLED")
sys.exit(0)
elif opt.reread != None:
client_utils.logger.info("Attempting to reread utility functions.")
client_utils.component_call(QUEMGR, False,
'define_user_utility_functions',
(whoami, ))
sys.exit(0)
elif opt.savestate != None:
response = client_utils.component_call(SCHMGR, False, 'save',
(opt.savestate, ))
client_utils.logger.info(response)
sys.exit(0)
if opt.adjust != None:
client_utils.set_scores(opt.adjust, args, whoami)
if opt.dep_frac != None:
specs = [{'jobid': jobid} for jobid in args]
response = client_utils.component_call(QUEMGR, False, 'set_jobs',
(specs, {
"dep_frac": opt.dep_frac
}, whoami))
if not response:
client_utils.logger.info("no jobs matched")
else:
dumb = [str(r["jobid"]) for r in response]
client_utils.logger.info(
"updating inheritance fraction for jobs: %s" % ", ".join(dumb))