def list(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") configuration = configurations[e_host][Role.EXPORTD] export_l = {} list_l = [] for vid, volume in configuration.volumes.items(): volume_l = [] if volume.layout is not None: volume_l.append({'LAYOUT' : volume.layout }) else: volume_l.append({'LAYOUT' : configuration.layout }) for cid, cluster in volume.clusters.items(): cluster_l = [] for sid, storage in cluster.storages.items(): cluster_l.append({'STORAGE ' + str(sid): storage}) volume_l.append({'CLUSTER ' + str(cid): cluster_l}) list_l.append({'VOLUME ' + str(vid): volume_l}) export_l.update({'EXPORTD on ' + str(e_host): list_l}) ordered_puts(export_l)
def get(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") configuration = configurations[e_host][Role.EXPORTD] get_l = [] for vid in args.vid: if vid not in configuration.volumes: raise Exception("Unknown volume with vid=%d." % vid) vconfig = configuration.volumes[vid] vstat = configuration.stats.vstats[vid] volume_l = [] volume_l.append({'bsize': vstat.bsize}) volume_l.append({'bfree': vstat.bfree}) volume_l.append({'blocks': vstat.blocks}) for cid, cstat in vstat.cstats.items(): cluster_l = [] cluster_l.append({'size': cstat.size}) cluster_l.append({'free': cstat.free}) for sid, sstat in cstat.sstats.items(): storage_l = [] storage_l.append({'host': sstat.host}) storage_l.append({'size': sstat.size}) storage_l.append({'free': sstat.free}) cluster_l.append({'STORAGE ' + str(sid): storage_l}) volume_l.append({'CLUSTER ' + str(cid): cluster_l}) get_l.append({'VOLUME ' + str(vid): volume_l}) ordered_puts({'' + str(e_host): get_l})
def get(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) configuration = configurations[e_host][Role.EXPORTD] # Check exception if isinstance(configuration, Exception): raise type(configuration)(str(configuration)) eids_l = [] if not args.eids: eids_l = configuration.exports.keys() else: eids_l = args.eids list_l = {} exports_l = [] for eid in eids_l: if eid not in configuration.exports: raise Exception("Unknown export with eid=%d." % eid) econfig = configuration.exports[eid] export_l = [] export_l.append({'vid':econfig.vid}) export_l.append({'root':econfig.root}) export_l.append({'md5':econfig.md5}) export_l.append({'squota':econfig.squota}) export_l.append({'hquota':econfig.hquota}) exports_l.append({'EXPORT '+ str(eid):export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def get(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) configuration = configurations[e_host][Role.EXPORTD] # Check exception if isinstance(configuration, Exception): raise type(configuration)(str(configuration)) eids_l = [] if not args.eids: eids_l = configuration.exports.keys() else: eids_l = args.eids list_l = {} exports_l = [] for eid in eids_l: if eid not in configuration.exports: raise Exception("Unknown export with eid=%d." % eid) econfig = configuration.exports[eid] export_l = [] export_l.append({'vid': econfig.vid}) export_l.append({'root': econfig.root}) export_l.append({'md5': econfig.md5}) export_l.append({'squota': econfig.squota}) export_l.append({'hquota': econfig.hquota}) exports_l.append({'EXPORT ' + str(eid): export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def list(platform, args): list_l = {} for h, r in platform.list_nodes(__args_to_roles(args)).items(): role_l = [] role_l.append(__roles_to_strings(r)) list_l.update({h: role_l}) ordered_puts(list_l)
def list(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") configuration = configurations[e_host][Role.EXPORTD] export_l = {} list_l = [] for vid, volume in configuration.volumes.items(): volume_l = [] if volume.layout is not None: volume_l.append({'LAYOUT': volume.layout}) else: volume_l.append({'LAYOUT': configuration.layout}) for cid, cluster in volume.clusters.items(): cluster_l = [] for sid, storage in cluster.storages.items(): cluster_l.append({'STORAGE ' + str(sid): storage}) volume_l.append({'CLUSTER ' + str(cid): cluster_l}) list_l.append({'VOLUME ' + str(vid): volume_l}) export_l.update({'EXPORTD on ' + str(e_host): list_l}) ordered_puts(export_l)
def option_list(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) config = configurations[e_host][Role.EXPORTD] export_l = {} errors_l = {} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict export_l.update({e_host: err_str}) # Update errors dict errors_l.update({e_host: err_str}) else: options_l = [] options_l.append({'nbcores': config.nbcores}) export_l.update({e_host: {'OPTIONS': options_l}}) ordered_puts(export_l) if errors_l: raise MultipleError(errors_l)
def option_list(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) config = configurations[e_host][Role.EXPORTD] export_l={} errors_l={} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict export_l.update({e_host: err_str}) # Update errors dict errors_l.update({e_host : err_str}) else: options_l = [] options_l.append({'nbcores' : config.nbcores}) export_l.update( {e_host :{'OPTIONS':options_l}}) ordered_puts(export_l) if errors_l: raise MultipleError(errors_l)
def layout_get(platform, args): layout = platform.get_layout() ordered_puts({platform._active_export_host : {'layout '+str(layout): OrderedDict([ ("inverse", LAYOUT_VALUES[layout][0]), ("forward", LAYOUT_VALUES[layout][1]), ("safe", LAYOUT_VALUES[layout][2]) ])}})
def option_get(platform, args): # Check given option valid_opts = [NBCORES] if args.option not in valid_opts: raise Exception('invalid option: \'%s\' (valid value: %s).' % (args.option, ', '.join(valid_opts))) e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) config = configurations[e_host][Role.EXPORTD] export_l={} errors_l={} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict export_l.update({e_host: err_str}) # Update errors dict errors_l.update({e_host : err_str}) else: options_l = [] if args.option == NBCORES: options_l.append({'nbcores' : config.nbcores}) export_l.update( {e_host :{'OPTIONS':options_l}}) ordered_puts(export_l) if errors_l: raise MultipleError(errors_l)
def get(platform, args): layout = platform. get_layout() ordered_puts({'layout '+str(layout): OrderedDict([ ("inverse", LAYOUT_VALUES[layout][0]), ("forward", LAYOUT_VALUES[layout][1]), ("safe", LAYOUT_VALUES[layout][2]) ])})
def get(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") configuration = configurations[e_host][Role.EXPORTD] list_l = {} exports_l = [] for eid in args.eids: if eid not in configuration.exports: raise Exception("Unknown export with eid=%d." % eid) econfig = configuration.exports[eid] export_l = [] export_l.append({'vid':econfig.vid}) export_l.append({'root':econfig.root}) export_l.append({'md5':econfig.md5}) export_l.append({'squota':econfig.squota}) export_l.append({'hquota':econfig.hquota}) exports_l.append({'EXPORT '+ str(eid):export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def get(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") configuration = configurations[e_host][Role.EXPORTD] list_l = {} exports_l = [] for eid in args.eids: if eid not in configuration.exports: raise Exception("Unknown export with eid=%d." % eid) econfig = configuration.exports[eid] export_l = [] export_l.append({'vid': econfig.vid}) export_l.append({'root': econfig.root}) export_l.append({'md5': econfig.md5}) export_l.append({'squota': econfig.squota}) export_l.append({'hquota': econfig.hquota}) exports_l.append({'EXPORT ' + str(eid): export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def option_get(platform, args): # Check given option valid_opts = [NBCORES] if args.option not in valid_opts: raise Exception('invalid option: \'%s\' (valid value: %s).' % (args.option, ', '.join(valid_opts))) e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) config = configurations[e_host][Role.EXPORTD] export_l = {} errors_l = {} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict export_l.update({e_host: err_str}) # Update errors dict errors_l.update({e_host: err_str}) else: options_l = [] if args.option == NBCORES: options_l.append({'nbcores': config.nbcores}) export_l.update({e_host: {'OPTIONS': options_l}}) ordered_puts(export_l) if errors_l: raise MultipleError(errors_l)
def remove(platform, args): for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(args.exportd)[host].get_configurations(Role.STORAGED) configuration = configurations[Role.STORAGED] check = True for listener in configuration.listens: if args.interface == listener.addr: if args.port == listener.port: configuration.listens.remove(listener) check = False if check: raise Exception('entry %s:%s does not exist.' % (args.interface, args.port)) sid_l={} sid_l[host]=[] lid_l={} configurations[Role.STORAGED] = configuration platform._get_nodes(args.exportd)[host].set_configurations(configurations) for lconfig in configuration.listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l)
def get(platform, args): layout = platform.get_layout() ordered_puts({ 'layout ' + str(layout): OrderedDict([("inverse", LAYOUT_VALUES[layout][0]), ("forward", LAYOUT_VALUES[layout][1]), ("safe", LAYOUT_VALUES[layout][2])]) })
def option_set(platform, args): e_host = platform._active_export_host if args.nodes is not None: for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) if args.option not in [SELF_HEALING]: raise Exception('%s: invalid option.' % args.option) sid_l = {} errors_l = {} for host, configuration in platform.get_configurations( args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host: err_str}) continue if args.option == SELF_HEALING: if int(args.value) < 1: raise Exception( 'invalid value: \'%s\' (The lowest possible value is 1).' % args.value) config.self_healing = args.value # TO DO: not send value option if it's not necessary configuration[Role.STORAGED] = config try: platform._get_nodes(e_host)[host].set_configurations(configuration) except Exception as e: err = type(e).__name__ + ' (' + str(e) + ')' sid_l.update({host: err}) continue sid_l[host].append({args.option: args.value}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def layout_get(platform, args): layout = platform.get_layout() ordered_puts({ platform._active_export_host: { 'layout ' + str(layout): OrderedDict([("inverse", LAYOUT_VALUES[layout][0]), ("forward", LAYOUT_VALUES[layout][1]), ("safe", LAYOUT_VALUES[layout][2])]) } })
def stat(platform, args): e_host = platform._active_export_host # Get configuration configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") # Get statuses from storaged nodes statuses = {} for h, n in platform._nodes.items(): if n.has_one_of_roles(Role.STORAGED): statuses[h] = n.get_statuses(Role.STORAGED) # Check if all storaged nodes running for host, status in statuses.items(): try: if not status: print 'WARNING: %s is not reachable' % str(host) continue if not status[Role.STORAGED]: print 'WARNING: storaged is not running on ' + str(host) except KeyError: raise Exception("storaged node is off line.") # configuration of exportd node configuration = configurations[e_host][Role.EXPORTD] if configuration.stats is None: ordered_puts({'EXPORTD on ' + str(args.exportd): "not running"}) return export_l = {} stat_l = [] for vid, vstat in configuration.stats.vstats.items(): volume_l = [] if configuration.volumes[vid].layout is not None: volume_l.append({'layout': configuration.volumes[vid].layout}) else: volume_l.append({'layout': configuration.layout}) volume_l.append({'bsize': vstat.bsize}) volume_l.append({'bfree': vstat.bfree}) volume_l.append({'blocks': vstat.blocks}) for cid, cstat in vstat.cstats.items(): cluster_l = [] cluster_l.append({'size': cstat.size}) cluster_l.append({'free': cstat.free}) for sid, sstat in cstat.sstats.items(): storage_l = [] storage_l.append({'host': sstat.host}) storage_l.append({'size': sstat.size}) storage_l.append({'free': sstat.free}) cluster_l.append({'STORAGE ' + str(sid): storage_l}) volume_l.append({'CLUSTER ' + str(cid): cluster_l}) stat_l.append({'VOLUME ' + str(vid): volume_l}) export_l.update({'EXPORTD on ' + str(e_host): stat_l}) ordered_puts(export_l)
def stat(platform, args): e_host = platform._active_export_host # Get configuration configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("exportd node is off line.") # Get statuses from storaged nodes statuses = {} for h, n in platform._nodes.items(): if n.has_one_of_roles(Role.STORAGED): statuses[h] = n.get_statuses(Role.STORAGED) # Check if all storaged nodes running for host, status in statuses.items(): try: if not status: print 'WARNING: %s is not reachable' % str(host) continue if not status[Role.STORAGED]: print 'WARNING: storaged is not running on ' + str(host) except KeyError: raise Exception("storaged node is off line.") # configuration of exportd node configuration = configurations[e_host][Role.EXPORTD] if configuration.stats is None: ordered_puts({'EXPORTD on ' + str(args.exportd): "not running"}) return export_l = {} stat_l = [] for vid, vstat in configuration.stats.vstats.items(): volume_l = [] if configuration.volumes[vid].layout is not None: volume_l.append({'layout' : configuration.volumes[vid].layout }) else: volume_l.append({'layout' : configuration.layout }) volume_l.append({'bsize': vstat.bsize}) volume_l.append({'bfree': vstat.bfree}) volume_l.append({'blocks': vstat.blocks}) for cid, cstat in vstat.cstats.items(): cluster_l = [] cluster_l.append({'size': cstat.size}) cluster_l.append({'free': cstat.free}) for sid, sstat in cstat.sstats.items(): storage_l = [] storage_l.append({'host': sstat.host}) storage_l.append({'size': sstat.size}) storage_l.append({'free': sstat.free}) cluster_l.append({'STORAGE ' + str(sid): storage_l}) volume_l.append({'CLUSTER ' + str(cid): cluster_l}) stat_l.append({'VOLUME ' + str(vid): volume_l}) export_l.update({'EXPORTD on ' + str(e_host): stat_l}) ordered_puts(export_l)
def option_set(platform, args): e_host = platform._active_export_host if args.nodes is not None: for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) if args.option not in [SELF_HEALING]: raise Exception('%s: invalid option.' % args.option) sid_l = {} errors_l = {} for host, configuration in platform.get_configurations(args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host: err_str}) continue if args.option == SELF_HEALING: if int(args.value) < 1: raise Exception('invalid value: \'%s\' (The lowest possible value is 1).' % args.value) config.self_healing = args.value # TO DO: not send value option if it's not necessary configuration[Role.STORAGED] = config try: platform._get_nodes(e_host)[host].set_configurations(configuration) except Exception as e: err = type(e).__name__ + ' (' + str(e) + ')' sid_l.update({host: err}) continue sid_l[host].append({args.option: args.value}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def option_list(platform, args): if args.nodes is not None: for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) sid_l = {} errors_l = {} for host, configuration in platform.get_configurations( args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host: err_str}) continue options_l = [] if config.nbcores is not None: options_l.append({'nbcores': config.nbcores}) if config.threads is not None: options_l.append({'threads': config.threads}) if config.storio is not None: options_l.append({'storio': config.storio}) if config.self_healing is not None: options_l.append({'self-healing': config.self_healing}) if config.export_hosts is not None: options_l.append({'export-hosts': config.export_hosts}) options_l.append({'crc32c_check': bool(config.crc32c_check)}) options_l.append({'crc32c_generate': bool(config.crc32c_generate)}) options_l.append({'crc32c_hw_forced': bool(config.crc32c_hw_forced)}) sid_l[host].append({'OPTIONS': options_l}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def option_list(platform, args): if args.nodes is not None: for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) sid_l={} errors_l = {} for host, configuration in platform.get_configurations(args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host : err_str}) continue options_l = [] if config.nbcores is not None: options_l.append({'nbcores' : config.nbcores}) if config.threads is not None: options_l.append({'threads' : config.threads}) if config.storio is not None: options_l.append({'storio' : config.storio}) if config.self_healing is not None: options_l.append({'self-healing' : config.self_healing}) if config.export_hosts is not None: options_l.append({'export-hosts' : config.export_hosts}) options_l.append({'crc32c_check' : bool(config.crc32c_check)}) options_l.append({'crc32c_generate' : bool(config.crc32c_generate)}) options_l.append({'crc32c_hw_forced' : bool(config.crc32c_hw_forced)}) sid_l[host].append({'OPTIONS':options_l}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def status(platform, args): statuses = platform.get_statuses(args.nodes, __args_to_roles(args)) if statuses is None: ordered_puts(OrderedDict({h:'down'})) else: status_l = {} for h, s in statuses.items(): role_l = [] for role, status in s.items(): if status: role_l.append({ROLES_STR[role]: 'running'}) else: role_l.append({ROLES_STR[role]: 'not running'}) status_l.update({h:role_l}) ordered_puts(status_l)
def status(platform, args): statuses = platform.get_statuses(args.nodes, __args_to_roles(args)) if statuses is None: ordered_puts(OrderedDict({h:'down'})) else: status_l = {} for h, s in statuses.items(): role_l = [] for role, status in s.items(): if status: role_l.append({ROLES_STR[role]: 'running'}) else: role_l.append({ROLES_STR[role]: 'not running'}) if role_l: status_l.update({h:role_l}) ordered_puts(status_l)
def option_get(platform, args): if args.nodes is not None: for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) # Check given option valid_opts = [SELF_HEALING, EXPORT_HOSTS] if args.option not in valid_opts: raise Exception('invalid option: \'%s\' (valid values: %s).' % (args.option, ', '.join(valid_opts))) sid_l = {} errors_l = {} for host, configuration in platform.get_configurations( args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host: err_str}) continue if args.option == SELF_HEALING: sid_l[host].append({SELF_HEALING: config.self_healing}) if args.option == EXPORT_HOSTS: sid_l[host].append({EXPORT_HOSTS: config.export_hosts}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def status(platform, args): statuses = platform.get_statuses(args.nodes, __args_to_roles(args)) status_l = {} errors_l = {} for h, s in statuses.items(): role_l = [] role_err_l = [] for role, status in s.items(): # Check exception if isinstance(status, Exception): # Update standard output dict err_str = type(status).__name__ + ' (' + str(status) + ')' role_l.append({ROLES_STR[role]: err_str}) # Update errors dict role_err_l.append({ROLES_STR[role]: err_str}) errors_l.update({'NODE: ' + str(h): role_err_l}) continue if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): mount_l = [] if not status: role_l.append( {ROLES_STR[role]: 'no mountpoint configured'}) else: for m, s in status.items(): mount_l.append({m: 'mounted' if s else 'unmounted'}) role_l.append({ROLES_STR[role]: mount_l}) else: if status: role_l.append({ROLES_STR[role]: 'running'}) else: role_l.append({ROLES_STR[role]: 'not running'}) if role_l: status_l.update({h: role_l}) # Display output ordered_puts(status_l) # Check errors if errors_l: raise MultipleError(errors_l)
def option_get(platform, args): if args.nodes is not None: for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) # Check given option valid_opts = [SELF_HEALING, EXPORT_HOSTS] if args.option not in valid_opts: raise Exception('invalid option: \'%s\' (valid values: %s).' % (args.option, ', '.join(valid_opts))) sid_l = {} errors_l = {} for host, configuration in platform.get_configurations(args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host: err_str}) continue if args.option == SELF_HEALING: sid_l[host].append({SELF_HEALING: config.self_healing}) if args.option == EXPORT_HOSTS: sid_l[host].append({EXPORT_HOSTS: config.export_hosts}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def list(platform, args): configurations = platform.get_configurations([args.exportd], Role.EXPORTD) if configurations[args.exportd] is None: raise Exception("exportd node is off line.") configuration = configurations[args.exportd][Role.EXPORTD] export_l = {} list_l = [] for vid, volume in configuration.volumes.items(): volume_l = [] for cid, cluster in volume.clusters.items(): cluster_l = [] for sid, storage in cluster.storages.items(): cluster_l.append({'STORAGE ' + str(sid): storage}) volume_l.append({'CLUSTER ' + str(cid): cluster_l}) list_l.append({'VOLUME ' + str(vid): volume_l}) export_l.update({'EXPORTD on ' + str(args.exportd): list_l}) ordered_puts(export_l)
def start(platform, args): changes = platform.start(args.nodes, __args_to_roles(args)) status_l = {} errors_l = {} for h, s in changes.items(): role_l = [] role_err_l = [] for role, change in s.items(): # Check exception if isinstance(change, Exception): # Update standard output dict err_str = type(change).__name__ + ' (' + str(change) + ')' role_l.append({ROLES_STR[role]: 'failed, ' + err_str}) # Update errors dict role_err_l.append({ROLES_STR[role]: err_str}) errors_l.update({'NODE: ' + str(h) : role_err_l}) continue if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): mount_l = [] for m, s in change.items(): mount_l.append({m : 'mounted' if s else 'already mounted'}) role_l.append({ROLES_STR[role]: mount_l}) else: if change: role_l.append({ROLES_STR[role]: 'started'}) else: role_l.append({ROLES_STR[role]: 'already started'}) if role_l: status_l.update({h:role_l}) # Display output ordered_puts(status_l) # Check errors if errors_l: raise MultipleError(errors_l)
def start(platform, args): changes = platform.start(args.nodes, __args_to_roles(args)) status_l = {} errors_l = {} for h, s in changes.items(): role_l = [] role_err_l = [] for role, change in s.items(): # Check exception if isinstance(change, Exception): # Update standard output dict err_str = type(change).__name__ + ' (' + str(change) + ')' role_l.append({ROLES_STR[role]: 'failed, ' + err_str}) # Update errors dict role_err_l.append({ROLES_STR[role]: err_str}) errors_l.update({'NODE: ' + str(h): role_err_l}) continue if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): mount_l = [] for m, s in change.items(): mount_l.append({m: 'mounted' if s else 'already mounted'}) role_l.append({ROLES_STR[role]: mount_l}) else: if change: role_l.append({ROLES_STR[role]: 'started'}) else: role_l.append({ROLES_STR[role]: 'already started'}) if role_l: status_l.update({h: role_l}) # Display output ordered_puts(status_l) # Check errors if errors_l: raise MultipleError(errors_l)
def remove(platform, args): e_host = platform._active_export_host for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(e_host)[host].get_configurations(Role.STORAGED) configuration = configurations[Role.STORAGED] check = True for listener in configuration.listens: if args.interface == listener.addr: if args.port == listener.port: # listen entry is found check = False # Check if it's the last listen entry # Replaced by default address if len(configuration.listens) == 1: listener.addr = "*" listener.port = 41001 else: configuration.listens.remove(listener) if check: raise Exception('entry %s:%s does not exist.' % (args.interface, args.port)) sid_l={} sid_l[host]=[] lid_l={} configurations[Role.STORAGED] = configuration platform._get_nodes(e_host)[host].set_configurations(configurations) for lconfig in configuration.listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l)
def list(platform, args): configurations = platform.get_configurations([args.exportd], Role.EXPORTD) if configurations[args.exportd] is None: raise Exception("exportd node is off line.") configuration = configurations[args.exportd][Role.EXPORTD] list_l = {} exports_l = [] for eid, econfig in configuration.exports.items(): export_l = [] export_l.append({'vid':econfig.vid}) export_l.append({'root':econfig.root}) export_l.append({'md5':econfig.md5}) export_l.append({'squota':econfig.squota}) export_l.append({'hquota':econfig.hquota}) exports_l.append({'EXPORT '+ str(eid):export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def list(platform, args): configurations = {} for h, n in platform._nodes.items(): if n.has_one_of_roles(Role.STORAGED): configurations[h] = n.get_configurations(Role.STORAGED) sid_l={} for stor in configurations: sid_l[stor] = [] lid_l={} for lconfig in configurations[stor][Role.STORAGED].listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[stor].append(lid_l) ordered_puts(sid_l)
def get(platform, args): for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) sid_l={} for host, configuration in platform.get_configurations(args.nodes, Role.STORAGED).items(): sid_l[host]=[] lid_l={} for lconfig in configuration[Role.STORAGED].listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l)
def listen_get(platform, args): if args.nodes is not None: for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) errors_l = {} sid_l={} for host, configuration in platform.get_configurations(args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host]=[] lid_l={} config = configuration[Role.STORAGED] if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host : err_str}) continue for lconfig in configuration[Role.STORAGED].listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def remove(platform, args): for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(args.exportd)[host].get_configurations(Role.STORAGED) configuration = configurations[Role.STORAGED] check = True for listener in configuration.listens: if args.interface == listener.addr: if args.port == listener.port: # listen entry is found check = False # Check if it's the last listen entry # Replaced by default address if len(configuration.listens) == 1: listener.addr = "*" listener.port = 41001 else: configuration.listens.remove(listener) if check: raise Exception('entry %s:%s does not exist.' % (args.interface, args.port)) sid_l={} sid_l[host]=[] lid_l={} configurations[Role.STORAGED] = configuration platform._get_nodes(args.exportd)[host].set_configurations(configurations) for lconfig in configuration.listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l)
def list(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("%s is not reachable" % e_host) configuration = configurations[e_host][Role.EXPORTD] list_l = {} exports_l = [] for eid, econfig in configuration.exports.items(): export_l = [] export_l.append({'vid':econfig.vid}) export_l.append({'root':econfig.root}) export_l.append({'md5':econfig.md5}) export_l.append({'squota':econfig.squota}) export_l.append({'hquota':econfig.hquota}) exports_l.append({'EXPORT '+ str(eid):export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def list(platform, args): e_host = platform._active_export_host configurations = platform.get_configurations([e_host], Role.EXPORTD) if configurations[e_host] is None: raise Exception("%s is not reachable" % e_host) configuration = configurations[e_host][Role.EXPORTD] list_l = {} exports_l = [] for eid, econfig in configuration.exports.items(): export_l = [] export_l.append({'vid': econfig.vid}) export_l.append({'root': econfig.root}) export_l.append({'md5': econfig.md5}) export_l.append({'squota': econfig.squota}) export_l.append({'hquota': econfig.hquota}) exports_l.append({'EXPORT ' + str(eid): export_l}) list_l.update({'EXPORTS': exports_l}) ordered_puts(list_l)
def listen_get(platform, args): if args.nodes is not None: for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) errors_l = {} sid_l = {} for host, configuration in platform.get_configurations( args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] lid_l = {} config = configuration[Role.STORAGED] if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host: err_str}) continue for lconfig in configuration[Role.STORAGED].listens: lid_l = OrderedDict([('addr', lconfig.addr), ('port', lconfig.port)]) sid_l[host].append(lid_l) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def add(platform, args): e_host = platform._active_export_host for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(e_host)[host].get_configurations(Role.STORAGED) configuration = configurations[Role.STORAGED] for listener in configuration.listens: # if given interface is '*', remove existing interfaces if args.interface == "*": configuration.listens = [] continue elif args.interface == listener.addr: if args.port == listener.port: raise Exception('entry %s:%s already exists.' % (args.interface, args.port)) if listener.addr == '*': configuration.listens = [] sid_l={} sid_l[host]=[] lid_l={} lconfig = ListenConfig(args.interface, args.port) configuration.listens.append(lconfig) configurations[Role.STORAGED] = configuration platform._get_nodes(e_host)[host].set_configurations(configurations) for lconfig in configuration.listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l)
def add(platform, args): for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(args.exportd)[host].get_configurations(Role.STORAGED) configuration = configurations[Role.STORAGED] for listener in configuration.listens: # if given interface is '*', remove existing interfaces if args.interface == "*": configuration.listens = [] continue elif args.interface == listener.addr: if args.port == listener.port: raise Exception('entry %s:%s already exists.' % (args.interface, args.port)) if listener.addr == '*': configuration.listens = [] sid_l={} sid_l[host]=[] lid_l={} lconfig = ListenConfig(args.interface, args.port) configuration.listens.append(lconfig) configurations[Role.STORAGED] = configuration platform._get_nodes(args.exportd)[host].set_configurations(configurations) for lconfig in configuration.listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l)
def option_get(platform, args): if args.nodes is not None: for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) # Check given option valid_opts = [THREADS, NBCORES, STORIO, CRC32C_CHECK, CRC32C_GENERATE, CRC32C_HW_FORCED, SELF_HEALING, EXPORT_HOSTS] if args.option not in valid_opts: raise Exception('invalid option: \'%s\' (valid values: %s).' % (args.option, ', '.join(valid_opts))) sid_l={} errors_l = {} for host, configuration in platform.get_configurations(args.nodes, Role.STORAGED).items(): # Node without storaged role if not configuration: continue sid_l[host] = [] config = configuration[Role.STORAGED] # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) # Update errors dict errors_l.update({host : err_str}) continue if args.option == THREADS: sid_l[host].append({THREADS : config.threads}) if args.option == NBCORES: sid_l[host].append({NBCORES : config.nbcores}) if args.option == STORIO: sid_l[host].append({STORIO : config.storio}) if args.option == SELF_HEALING: sid_l[host].append({SELF_HEALING : config.self_healing}) if args.option == EXPORT_HOSTS: sid_l[host].append({EXPORT_HOSTS : config.export_hosts}) if args.option == CRC32C_CHECK: sid_l[host].append({CRC32C_CHECK : bool(config.crc32c_check)}) if args.option == CRC32C_GENERATE: sid_l[host].append({CRC32C_GENERATE : bool(config.crc32c_generate)}) if args.option == CRC32C_HW_FORCED: sid_l[host].append({CRC32C_HW_FORCED : bool(config.crc32c_hw_forced)}) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def config(platform, args): if not args.roles: args.roles = [EXPORTD_MANAGER, STORAGED_MANAGER, ROZOFSMOUNT_MANAGER] configurations = platform.get_configurations(args.nodes, __args_to_roles(args)) host_l = {} for h, c in configurations.items(): if c is not None and not c: return if c is None: raise Exception ('%s is down.' % h) role_l=[] for role, config in c.items(): if (role & Role.EXPORTD == Role.EXPORTD): exportd_l = [] volume_l = [] for v in config.volumes.values(): cluster_l = [] for cluster in v.clusters.values(): s_l = [] for s, hhh in cluster.storages.items(): s_l.append({'sid ' + str(s): hhh}) cluster_l.append({'cluster ' + str(cluster.cid): s_l}) volume_l.append({'volume ' + str(v.vid): cluster_l}) exportd_l.append({'VOLUME':volume_l}) if len(config.exports) != 0: for e in config.exports.values(): export_l = OrderedDict([ ('vid', e.vid), ('root', e.root), ('md5', e.md5), ('squota', e.squota), ('hquota', e.hquota)]) exportd_l.append({'EXPORT':export_l}) role_l.append({'EXPORTD':exportd_l}) if (role & Role.STORAGED == Role.STORAGED): storage_l = [] interface_l = [] for lconfig in config.listens: interface_l.append({lconfig.addr : lconfig.port}) storage_l.append({'INTERFACE':interface_l}) keylist = config.storages.keys() keylist.sort() st_l = [] for key in keylist: st = config.storages[key] st_l.append({'cid ' + str(st.cid) + ', sid '+ str(st.sid) : st.root}) storage_l.append({'STORAGE': st_l}) role_l.append({'STORAGED': storage_l}) if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): exp_l = [] for c in config: exp_l.append({'node ' + str(c.export_host) : c.export_path}) role_l.append({'ROZOFSMOUNT': exp_l}) host_l.update({'NODE: ' + str(h) : role_l}) ordered_puts(host_l)
def config(platform, args): if not args.roles: args.roles = [EXPORTD_MANAGER, STORAGED_MANAGER, ROZOFSMOUNT_MANAGER] configurations = platform.get_configurations(args.nodes, __args_to_roles(args)) host_l = {} for h, c in configurations.items(): # Why? #if c is not None and not c: # return if c is None: host_l.update({'NODE: ' + str(h): "not reachable"}) continue role_l = [] for role, config in c.items(): if (role & Role.EXPORTD == Role.EXPORTD): exportd_l = [] volume_l = [] for v in config.volumes.values(): cluster_l = [] for cluster in v.clusters.values(): s_l = [] for s, hhh in cluster.storages.items(): s_l.append({'sid ' + str(s): hhh}) cluster_l.append({'cluster ' + str(cluster.cid): s_l}) volume_l.append({'volume ' + str(v.vid): cluster_l}) exportd_l.append({'VOLUME': volume_l}) if len(config.exports) != 0: for e in config.exports.values(): export_l = OrderedDict([('vid', e.vid), ('root', e.root), ('md5', e.md5), ('squota', e.squota), ('hquota', e.hquota)]) exportd_l.append({'EXPORT': export_l}) role_l.append({'EXPORTD': exportd_l}) if (role & Role.STORAGED == Role.STORAGED): storage_l = [] interface_l = [] for lconfig in config.listens: interface_l.append({lconfig.addr: lconfig.port}) storage_l.append({'INTERFACE': interface_l}) keylist = config.storages.keys() keylist.sort() st_l = [] for key in keylist: st = config.storages[key] st_l.append({ 'cid ' + str(st.cid) + ', sid ' + str(st.sid): st.root }) storage_l.append({'STORAGE': st_l}) role_l.append({'STORAGED': storage_l}) if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): exp_l = [] for c in config: exp_l.append({'node ' + str(c.export_host): c.export_path}) role_l.append({'ROZOFSMOUNT': exp_l}) host_l.update({'NODE: ' + str(h): role_l}) ordered_puts(host_l)
def config(platform, args): if not args.roles: args.roles = [EXPORTD_MANAGER, STORAGED_MANAGER, ROZOFSMOUNT_MANAGER] configurations = platform.get_configurations(args.nodes, __args_to_roles(args)) errors_l = {} host_l = {} for h, c in configurations.items(): # Is-it necessary ? if c is None: host_l.update({'NODE: ' + str(h) : "not reachable"}) continue role_l=[] role_err_l = [] for role, config in c.items(): # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict role_l.append({ROLES_STR[role]: err_str}) host_l.update({'NODE: ' + str(h) : role_l}) # Update errors dict role_err_l.append({ROLES_STR[role]: err_str}) errors_l.update({'NODE: ' + str(h) : role_err_l}) continue if (role & Role.EXPORTD == Role.EXPORTD): exportd_l = [] volume_l = [] for v in config.volumes.values(): cluster_l = [] for cluster in v.clusters.values(): s_l = [] for s, hhh in cluster.storages.items(): s_l.append({'sid ' + str(s): hhh}) cluster_l.append({'cluster ' + str(cluster.cid): s_l}) volume_l.append({'volume ' + str(v.vid): cluster_l}) exportd_l.append({'VOLUME':volume_l}) if len(config.exports) != 0: for e in config.exports.values(): export_l = OrderedDict([ ('vid', e.vid), ('root', e.root), ('md5', e.md5), ('squota', e.squota), ('hquota', e.hquota)]) exportd_l.append({'EXPORT':export_l}) role_l.append({'EXPORTD':exportd_l}) if (role & Role.STORAGED == Role.STORAGED): options_l = [] interface_l = [] storage_l = [] if config.nbcores is not None: options_l.append({'nbcores' : config.nbcores}) if config.threads is not None: options_l.append({'threads' : config.threads}) if config.storio is not None: options_l.append({'storio' : config.storio}) if config.self_healing is not None: options_l.append({'self-healing' : config.self_healing}) if config.export_hosts is not None: options_l.append({'export-hosts' : config.export_hosts}) options_l.append({'crc32c_check' : bool(config.crc32c_check)}) options_l.append({'crc32c_generate' : bool(config.crc32c_generate)}) options_l.append({'crc32c_hw_forced' : bool(config.crc32c_hw_forced)}) storage_l.append({'OPTIONS':options_l}) for lconfig in config.listens: interface_l.append({lconfig.addr : lconfig.port}) storage_l.append({'INTERFACE':interface_l}) keylist = config.storages.keys() keylist.sort() st_l = [] for key in keylist: st = config.storages[key] stor_l = OrderedDict([ ('root', st.root), ('device-total', st.device_t), ('device-mapper', st.device_m), ('device-redundancy', st.device_r)]) st_l.append({'cid ' + str(st.cid) + ', sid '+ str(st.sid) : stor_l}) storage_l.append({'STORAGE': st_l}) role_l.append({'STORAGED': storage_l}) if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): exp_l = [] if config: for c in config: mountdict = {} mountdict["mountpoint"] = c.mountpoint mountdict["export host"] = c.export_host mountdict["export path"] = c.export_path exp_l.append(mountdict) role_l.append({'ROZOFSMOUNT': exp_l}) host_l.update({'NODE: ' + str(h) : role_l}) ordered_puts(host_l) if errors_l: raise MultipleError(errors_l)
def listen_add(platform, args): e_host = platform._active_export_host for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(e_host)[host].get_configurations( Role.STORAGED) config = configurations[Role.STORAGED] errors_l = {} sid_l = {} sid_l[host] = [] lid_l = {} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) ordered_puts(sid_l) # Update errors dict errors_l.update({host: err_str}) continue for listener in config.listens: # if given interface is '*', remove existing interfaces if args.interface == "*": config.listens = [] continue elif args.interface == listener.addr: if args.port == listener.port: raise Exception('entry %s:%s already exists.' % (args.interface, args.port)) if listener.addr == '*': config.listens = [] lconfig = ListenConfig(args.interface, args.port) config.listens.append(lconfig) configurations[Role.STORAGED] = config try: platform._get_nodes(e_host)[host].set_configurations( configurations) except Exception as e: err = type(e).__name__ + ' (' + str(e) + ')' sid_l.update({host: err}) ordered_puts(sid_l) continue for lconfig in config.listens: lid_l = OrderedDict([('addr', lconfig.addr), ('port', lconfig.port)]) sid_l[host].append(lid_l) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def listen_remove(platform, args): e_host = platform._active_export_host for host in args.nodes: if host not in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(e_host)[host].get_configurations( Role.STORAGED) config = configurations[Role.STORAGED] check = True sid_l = {} sid_l[host] = [] lid_l = {} errors_l = {} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) ordered_puts(sid_l) # Update errors dict errors_l.update({host: err_str}) continue for listener in config.listens: if args.interface == listener.addr: if args.port == listener.port: # listen entry is found check = False # Check if it's the last listen entry # Replaced by default address if len(config.listens) == 1: listener.addr = "*" listener.port = 41001 else: config.listens.remove(listener) if check: raise Exception('entry %s:%s does not exist.' % (args.interface, args.port)) configurations[Role.STORAGED] = config try: platform._get_nodes(e_host)[host].set_configurations( configurations) except Exception as e: err = type(e).__name__ + ' (' + str(e) + ')' sid_l.update({host: err}) ordered_puts(sid_l) continue for lconfig in config.listens: lid_l = OrderedDict([('addr', lconfig.addr), ('port', lconfig.port)]) sid_l[host].append(lid_l) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def config(platform, args): if not args.roles: args.roles = [EXPORTD_MANAGER, STORAGED_MANAGER, ROZOFSMOUNT_MANAGER] configurations = platform.get_configurations( args.nodes, __args_to_roles(args)) errors_l = {} host_l = {} for h, c in configurations.items(): # Is-it necessary ? if c is None: host_l.update({'NODE: ' + str(h): "not reachable"}) continue role_l = [] role_err_l = [] for role, config in c.items(): # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict role_l.append({ROLES_STR[role]: err_str}) host_l.update({'NODE: ' + str(h): role_l}) # Update errors dict role_err_l.append({ROLES_STR[role]: err_str}) errors_l.update({'NODE: ' + str(h): role_err_l}) continue if (role & Role.EXPORTD == Role.EXPORTD): exportd_l = [] volume_l = [] for v in config.volumes.values(): cluster_l = [] for cluster in v.clusters.values(): s_l = [] for s, hhh in cluster.storages.items(): s_l.append({'sid ' + str(s): hhh}) cluster_l.append({'cluster ' + str(cluster.cid): s_l}) volume_l.append({'volume ' + str(v.vid): cluster_l}) exportd_l.append({'VOLUME': volume_l}) if len(config.exports) != 0: for e in config.exports.values(): # export_l = OrderedDict([ # ('vid', e.vid), # ('root', e.root), # ('md5', e.md5), # ('squota', e.squota), # ('hquota', e.hquota)]) export_l = OrderedDict() export_l['vid'] = e.vid export_l['root'] = e.root if e.md5 != '': export_l['md5'] = e.md5 export_l['squota'] = e.squota export_l['hquota'] = e.hquota exportd_l.append({'EXPORT': export_l}) role_l.append({'EXPORTD': exportd_l}) if (role & Role.STORAGED == Role.STORAGED): options_l = [] interface_l = [] storage_l = [] if config.self_healing is not None: options_l.append({'self-healing': config.self_healing}) if config.export_hosts is not None: options_l.append({'export-hosts': config.export_hosts}) if options_l: storage_l.append({'OPTIONS': options_l}) for lconfig in config.listens: interface_l.append({lconfig.addr: lconfig.port}) storage_l.append({'INTERFACE': interface_l}) keylist = config.storages.keys() keylist.sort() st_l = [] for key in keylist: st = config.storages[key] stor_l = OrderedDict([ ('root', st.root), ('device-total', st.device_t), ('device-mapper', st.device_m), ('device-redundancy', st.device_r)]) st_l.append({'cid ' + str(st.cid) + ', sid ' + str(st.sid): stor_l}) storage_l.append({'STORAGE': st_l}) role_l.append({'STORAGED': storage_l}) if (role & Role.ROZOFSMOUNT == Role.ROZOFSMOUNT): exp_l = [] if config: for c in config: mountdict = {} mountdict["mountpoint"] = c.mountpoint mountdict["export host"] = c.export_host mountdict["export path"] = c.export_path exp_l.append(mountdict) role_l.append({'ROZOFSMOUNT': exp_l}) host_l.update({'NODE: ' + str(h): role_l}) ordered_puts(host_l) if errors_l: raise MultipleError(errors_l)
def status(args): (pid, listeners) = AgentServer().status() if not pid: raise Exception("no agent is running.") ordered_puts(OrderedDict([("pid", int(pid)), ("listeners", listeners)]))
def listen_remove(platform, args): e_host = platform._active_export_host for host in args.nodes: if not host in platform.list_nodes(Role.STORAGED): raise Exception('%s: invalid storaged server.' % host) for host in args.nodes: configurations = platform._get_nodes(e_host)[host].get_configurations(Role.STORAGED) config = configurations[Role.STORAGED] check = True sid_l={} sid_l[host]=[] lid_l={} errors_l = {} # Check exception if isinstance(config, Exception): # Get error msg err_str = type(config).__name__ + ' (' + str(config) + ')' # Update standard output dict sid_l.update({host: err_str}) ordered_puts(sid_l) # Update errors dict errors_l.update({host : err_str}) continue for listener in config.listens: if args.interface == listener.addr: if args.port == listener.port: # listen entry is found check = False # Check if it's the last listen entry # Replaced by default address if len(config.listens) == 1: listener.addr = "*" listener.port = 41001 else: config.listens.remove(listener) if check: raise Exception('entry %s:%s does not exist.' % (args.interface, args.port)) configurations[Role.STORAGED] = config try: platform._get_nodes(e_host)[host].set_configurations(configurations) except Exception as e: err = type(e).__name__ + ' (' + str(e) + ')' sid_l.update({host: err}) ordered_puts(sid_l) continue for lconfig in config.listens: lid_l = OrderedDict([ ('addr', lconfig.addr), ('port', lconfig.port) ]) sid_l[host].append(lid_l) ordered_puts(sid_l) if errors_l: raise MultipleError(errors_l)
def create(platform, args): if not args.eids: args.eids = None statuses = platform.mount_export(args.eids, args.exports, args.nodes, args.mountpoints, args.options) host_statuses_l = {} host_errors_l = {} for h, s in statuses.items(): # Check exception if isinstance(s, Exception): # Update standard output dict err_str = type(s).__name__ + ' (' + str(s) + ')' host_statuses_l.update({str(h): err_str}) host_errors_l.update({str(h): err_str}) continue mount_statuses_l = [] mount_errors_l = [] for mountpoint, status in s.items(): mountpoint_status = {} mountpoint_error = {} # Check config status if status['config'] is True: mountpoint_status.update({'configuration': 'added'}) elif status['config'] is None: mountpoint_status.update({'configuration': 'already present'}) else: # Check exception if isinstance(status['config'], Exception): # Update standard output dict err_str = type(status['config']).__name__ + ' (' + str( status['config']) + ')' mountpoint_status.update( {'configuration': 'failed, ' + err_str}) # Update errors dict mountpoint_error.update( {'configuration': 'failed, ' + err_str}) # Check service status if status['service'] is True: mountpoint_status.update({'status': 'mounted'}) elif status['service'] is False: mountpoint_status.update({'status': 'unmounted'}) elif status['service'] is None: mountpoint_status.update({'status': 'already mounted'}) else: # Check exception if isinstance(status['service'], Exception): # Update standard output dict err_str = type(status['service']).__name__ + ' (' + str( status['service']) + ')' mountpoint_status.update({'status': 'failed, ' + err_str}) # Update errors dict mountpoint_error.update({'status': 'failed, ' + err_str}) # Update list of mountpoint statuses export_name = os.path.basename(status['export_root']) mnt_config = { "export " + export_name + ' (eid=' + str(status['eid']) + ') on ' + mountpoint: mountpoint_status } mount_statuses_l.append(mnt_config) if mountpoint_error: mnt_config_err = { "export " + export_name + ' (eid=' + str(status['eid']) + ') on ' + mountpoint: mountpoint_error } mount_errors_l.append(mnt_config_err) # Update host host_statuses_l.update({str(h): mount_statuses_l}) if mount_errors_l: host_errors_l.update({str(h): mount_errors_l}) # Display output ordered_puts(host_statuses_l) # Check errors if host_errors_l: raise MultipleError(host_errors_l)