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 handle_list_io_option(sys_type): """ handles list io option """ if sys_type != 'bgq': client_utils.logger.error( "WARNING: IO Block information only exists on BG/Q-type systems.") #fetch and print bulk IO Block data if sys_type == 'bgq': args = ([{ 'name': '*', 'size': '*', 'status': '*', 'state': '*', 'block_computes_for_reboot': '*', 'autoreboot': '*', 'current_kernel': '*', 'current_kernel_options': '*' }], ) io_block_info = client_utils.component_call(SYSMGR, False, 'get_io_blocks', args) data = [[ 'Name', 'Size', 'State', 'CS Status', 'BlockComputes', 'Autoreboot' ]] for io_block in io_block_info: data.append([ io_block['name'], io_block['size'], io_block['state'], io_block['status'], 'x' if io_block['block_computes_for_reboot'] else '-', 'x' if io_block['autoreboot'] else '-' ]) client_utils.printTabular(data, centered=[4])
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(): """ 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) # Set required default values: None parser.parse_it() # parse the command line if not parser.no_args(): client_utils.logger.error("No arguments needed") impl = client_utils.component_call(SYSMGR, False, 'get_implementation', ()) # make sure we're on a cluster-system or orcm-system if ("cluster_system" != impl) and ("orcm_system" != impl): client_utils.logger.error("nodelist is only supported on cluster and orcm systems. Try partlist instead.") sys.exit(0) status = client_utils.component_call(SYSMGR, False, 'get_node_status', ()) queue_data = client_utils.component_call(SYSMGR, False, 'get_queue_assignments', ()) header = [['Host', 'Queue', 'State']] #build output list output = [] for t in status: host_name = t[0] status = t[1] queues = [] for q in queue_data: if host_name in queue_data[q]: queues.append(q) output.append([host_name, ":".join(queues), status]) client_utils.printTabular(header + output)
def 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) # Set required default values: None parser.parse_it() # parse the command line opt = parser.options args = parser.args #if not parser.no_args(): # client_utils.logger.error("No arguments needed") impl = client_utils.component_call(SYSMGR, False, 'get_implementation', ()) # make sure we're on a cluster-system if impl not in ['cluster_system', 'alps_system']: client_utils.logger.error("nodelist is only supported on cluster systems. Try partlist instead.") sys.exit(0) if impl == 'alps_system': if opt.list_details: # get list from arguments. Currently assuing a comma separated, # hyphen-condensed nodelist client_utils.print_node_details(args) else: client_utils.print_node_list() return header, output = client_utils.cluster_display_node_info() if parser.options.noheader is not None: client_utils.printTabular(header + output, with_header_info=False) else: client_utils.printTabular(header + output)
def handle_list_io_option(sys_type): """ handles list io option """ if sys_type != 'bgq': client_utils.logger.error("WARNING: IO Block information only exists on BG/Q-type systems.") #fetch and print bulk IO Block data if sys_type == 'bgq': args = ([{'name':'*', 'size':'*', 'status':'*', 'state':'*', 'block_computes_for_reboot':'*', 'autoreboot':'*', 'current_kernel':'*', 'current_kernel_options':'*'}],) io_block_info = client_utils.component_call(SYSMGR, False, 'get_io_blocks', args) data = [['Name', 'Size', 'State', 'CS Status', 'BlockComputes', 'Autoreboot']] for io_block in io_block_info: data.append([io_block['name'], io_block['size'], io_block['state'], io_block['status'], 'x' if io_block['block_computes_for_reboot'] else '-', 'x' if io_block['autoreboot'] else '-']) client_utils.printTabular(data, centered=[4])
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) # Set required default values: None parser.parse_it() # parse the command line if not parser.no_args(): client_utils.logger.error("No arguments needed") impl = client_utils.component_call(SYSMGR, False, 'get_implementation', ()) # make sure we're on a cluster-system if "cluster_system" != impl: client_utils.logger.error("nodelist is only supported on cluster systems. Try partlist instead.") sys.exit(0) header, output = client_utils.cluster_display_node_info() if parser.options.noheader is not None: client_utils.printTabular(header + output, with_header_info=False) else: client_utils.printTabular(header + output)
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) # Set required default values: None parser.parse_it() # parse the command line if not parser.no_args(): client_utils.logger.error("No arguments needed") impl = client_utils.component_call(SYSMGR, False, "get_implementation", ()) # make sure we're on a cluster-system if "cluster_system" != impl: client_utils.logger.error("nodelist is only supported on cluster systems. Try partlist instead.") sys.exit(0) header, output = client_utils.cluster_display_node_info() if parser.options.noheader is not None: client_utils.printTabular(header + output, with_header_info=False) else: client_utils.printTabular(header + output)
def main(): """ partlist 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) parser.parse_it() # parse the command line if not parser.no_args(): client_utils.logger.error("No arguments required") sys.exit(1) sys_info = client_utils.system_info() sys_type = sys_info[0] if sys_type == 'bgq': spec = [{ 'tag': 'partition', 'name': '*', 'queue': '*', 'state': '*', 'size': '*', 'functional': '*', 'scheduled': '*', 'children': '*', 'backfill_time': "*", 'draining': "*", 'node_geometry': "*" }] else: spec = [{ 'tag': 'partition', 'name': '*', 'queue': '*', 'state': '*', 'size': '*', 'functional': '*', 'scheduled': '*', 'children': '*', 'backfill_time': "*", 'draining': "*" }] parts = client_utils.component_call(SYSMGR, True, 'get_partitions', (spec, )) reservations = client_utils.component_call(SCHMGR, False, 'get_reservations', ([{ 'queue': '*', 'partitions': '*', 'active': True }], )) expanded_parts = {} for res in reservations: for res_part in res['partitions'].split(':'): for p in parts: if p['name'] == res_part: if expanded_parts.has_key(res['queue']): expanded_parts[res['queue']].update(p['children']) else: expanded_parts[res['queue']] = set(p['children']) expanded_parts[res['queue']].add(p['name']) for res in reservations: for p in parts: if p['name'] in expanded_parts.get(res['queue'], []): p['queue'] += ":%s" % res['queue'] def my_cmp(left, right): val = -cmp(int(left['size']), int(right['size'])) if val == 0: return cmp(left['name'], right['name']) else: return val parts.sort(my_cmp) now = time.time() for part in parts: if part['draining'] and part['state'] == "idle": # remove a little extra, to make sure that users can just type the number # that is output by partlist to get their job to backfill remaining = max(0, part['backfill_time'] - now - 90) hours, seconds = divmod(remaining, 3600.0) minutes = seconds / 60.0 part['backfill'] = "%d:%0.2d" % (int(hours), int(minutes)) else: part['backfill'] = "-" if sys_type == 'bgq': header = [['Name', 'Queue', 'State', 'Backfill', 'node_geometry']] #build output list, adding output = [[part.get(x) for x in [y.lower() for y in header[0]]] for part in parts if part['functional'] and part['scheduled']] #Hack to make the display cleaner. header[0][4] = 'Geometry' for o in output: if o[4] != None: o[4] = 'x'.join([str(i) for i in o[4]]) else: header = [['Name', 'Queue', 'State', 'Backfill']] #build output list, adding output = [[part.get(x) for x in [y.lower() for y in header[0]]] for part in parts if part['functional'] and part['scheduled']] client_utils.printTabular(header + output)
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(): """ partlist 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) parser.parse_it() # parse the command line if not parser.no_args(): client_utils.logger.error("No arguments required") sys.exit(1) sys_info = client_utils.system_info() sys_type = sys_info[0] if sys_type == 'bgq': spec = [{'tag':'partition', 'name':'*', 'queue':'*', 'state':'*', 'size':'*', 'functional':'*', 'scheduled':'*', 'children':'*', 'backfill_time':"*", 'draining':"*",'node_geometry':"*"}] else: spec = [{'tag':'partition', 'name':'*', 'queue':'*', 'state':'*', 'size':'*', 'functional':'*', 'scheduled':'*', 'children':'*', 'backfill_time':"*", 'draining':"*"}] parts = client_utils.component_call(SYSMGR, True, 'get_partitions', (spec,)) reservations = client_utils.component_call(SCHMGR, False, 'get_reservations', ([{'queue':'*','partitions':'*','active':True}],)) expanded_parts = {} for res in reservations: for res_part in res['partitions'].split(':'): for p in parts: if p['name'] == res_part: if expanded_parts.has_key(res['queue']): expanded_parts[res['queue']].update(p['children']) else: expanded_parts[res['queue']] = set( p['children'] ) expanded_parts[res['queue']].add(p['name']) for res in reservations: for p in parts: if p['name'] in expanded_parts.get(res['queue'], []): p['queue'] += ":%s" % res['queue'] def my_cmp(left, right): val = -cmp(int(left['size']), int(right['size'])) if val == 0: return cmp(left['name'], right['name']) else: return val parts.sort(my_cmp) now = time.time() for part in parts: if part['draining'] and part['state'] == "idle": # remove a little extra, to make sure that users can just type the number # that is output by partlist to get their job to backfill remaining = max(0, part['backfill_time'] - now - 90) hours, seconds = divmod(remaining, 3600.0) minutes = seconds/60.0 part['backfill'] = "%d:%0.2d" % (int(hours), int(minutes)) else: part['backfill'] = "-" if sys_type == 'bgq': header = [['Name', 'Queue', 'State', 'Backfill', 'node_geometry']] #build output list, adding output = [[part.get(x) for x in [y.lower() for y in header[0]]] for part in parts if part['functional'] and part['scheduled']] #Hack to make the display cleaner. header[0][4] = 'Geometry' for o in output: if o[4] != None: o[4] = 'x'.join([str(i) for i in o[4]]) else: header = [['Name', 'Queue', 'State', 'Backfill']] #build output list, adding output = [[part.get(x) for x in [y.lower() for y in header[0]]] for part in parts if part['functional'] and part['scheduled']] client_utils.printTabular(header + output)
def handle_list_blocks_option(parts, sys_type): """ function to handle the list io option """ # need to cascade up busy and non-functional flags if sys_type == 'bgq': query = [{ 'queue': "*", 'partitions': "*", 'active': True, 'block_passthrough': '*' }] elif sys_type == 'bgp': query = [{'queue': "*", 'partitions': "*", 'active': True}] try: reservations = client_utils.component_call(SCHMGR, False, 'get_reservations', (query, ), exit_on_error=False) except ComponentLookupError: client_utils.logger.error( "Failed to connect to scheduler; no reservations data available") reservations = [] expanded_parts = {} for res in reservations: for res_part in res['partitions'].split(":"): for part in parts: if part['name'] == res_part: if expanded_parts.has_key(res['queue']): if sys_type == 'bgq': expanded_parts[res['queue']].update( part['relatives']) if res['block_passthrough']: expanded_parts[res['queue']].update( part['passthrough_blocks']) elif sys_type == 'bgp': expanded_parts[res['queue']].update( part['parents']) expanded_parts[res['queue']].update( part['children']) else: if sys_type == 'bgq': expanded_parts[res['queue']] = set( part['relatives']) if res['block_passthrough']: expanded_parts[res['queue']].update( part['passthrough_blocks']) elif sys_type == 'bgp': expanded_parts[res['queue']] = set(part['parents']) expanded_parts[res['queue']].update( part['children']) expanded_parts[res['queue']].add(part['name']) for res in reservations: for part in parts: if part['name'] in expanded_parts[res['queue']]: part['queue'] += ":%s" % res['queue'] def my_cmp(left, right): '''Comparator for partition sorting. Size has priority followed by names in lexical order. ''' val = -cmp(int(left['size']), int(right['size'])) if val == 0: return cmp(left['name'], right['name']) else: return val parts.sort(my_cmp) offline = [part['name'] for part in parts if not part['functional']] if sys_type == 'bgq': forced = [part for part in parts \ if [down for down in offline \ if down in part['relatives']]] for part in forced: part.__setitem__('functional', '-') data = [[ 'Name', 'Queue', 'Size', 'Geometry', 'Functional', 'Scheduled', 'State', 'Dependencies' ]] for part in parts: if not part['node_geometry']: part['node_geometry'] = [] data += [[ part['name'], part['queue'], part['size'], "x".join([str(i) for i in part['node_geometry']]), part['functional'], part['scheduled'], part['state'], ','.join([]) ] for part in parts] client_utils.printTabular(data, centered=[4, 5]) elif sys_type == 'bgp': forced = [part for part in parts \ if [down for down in offline \ if (down in part['parents'] or down in part['children']) ]] for part in forced: part.__setitem__('functional', '-') data = [[ 'Name', 'Queue', 'Size', 'Functional', 'Scheduled', 'State', 'Dependencies' ]] data += [[ part['name'], part['queue'], part['size'], part['functional'], part['scheduled'], part['state'], ','.join([]) ] for part in parts] client_utils.printTabular(data, centered=[3, 4])
def handle_list_blocks_option(parts, sys_type): """ function to handle the list io option """ # need to cascade up busy and non-functional flags if sys_type == 'bgq': query = [{'queue':"*", 'partitions':"*", 'active':True, 'block_passthrough':'*'}] elif sys_type == 'bgp': query = [{'queue':"*", 'partitions':"*", 'active':True}] try: reservations = client_utils.component_call(SCHMGR, False, 'get_reservations', (query,), exit_on_error = False) except ComponentLookupError: client_utils.logger.error("Failed to connect to scheduler; no reservations data available") reservations = [] expanded_parts = {} for res in reservations: for res_part in res['partitions'].split(":"): for part in parts: if part['name'] == res_part: if expanded_parts.has_key(res['queue']): if sys_type == 'bgq': expanded_parts[res['queue']].update(part['relatives']) if res['block_passthrough']: expanded_parts[res['queue']].update(part['passthrough_blocks']) elif sys_type == 'bgp': expanded_parts[res['queue']].update(part['parents']) expanded_parts[res['queue']].update(part['children']) else: if sys_type == 'bgq': expanded_parts[res['queue']] = set( part['relatives'] ) if res['block_passthrough']: expanded_parts[res['queue']].update(part['passthrough_blocks']) elif sys_type == 'bgp': expanded_parts[res['queue']] = set( part['parents'] ) expanded_parts[res['queue']].update(part['children']) expanded_parts[res['queue']].add(part['name']) for res in reservations: for part in parts: if part['name'] in expanded_parts[res['queue']]: part['queue'] += ":%s" % res['queue'] def my_cmp(left, right): '''Comparator for partition sorting. Size has priority followed by names in lexical order. ''' val = -cmp(int(left['size']), int(right['size'])) if val == 0: return cmp(left['name'], right['name']) else: return val parts.sort(my_cmp) offline = [part['name'] for part in parts if not part['functional']] if sys_type == 'bgq': forced = [part for part in parts \ if [down for down in offline \ if down in part['relatives']]] for part in forced: part.__setitem__('functional', '-') data = [['Name', 'Queue', 'Size', 'Geometry', 'Functional', 'Scheduled', 'State', 'Dependencies']] for part in parts: if not part['node_geometry']: part['node_geometry'] = [] data += [[part['name'], part['queue'], part['size'], "x".join([str(i) for i in part['node_geometry']]), part['functional'], part['scheduled'], part['state'], ','.join([])] for part in parts] client_utils.printTabular(data, centered=[4, 5]) elif sys_type == 'bgp': forced = [part for part in parts \ if [down for down in offline \ if (down in part['parents'] or down in part['children']) ]] for part in forced: part.__setitem__('functional', '-') data = [['Name', 'Queue', 'Size', 'Functional', 'Scheduled', 'State', 'Dependencies']] data += [[part['name'], part['queue'], part['size'], part['functional'], part['scheduled'], part['state'], ','.join([])] for part in parts] client_utils.printTabular(data, centered=[3, 4])