Exemplo n.º 1
0
	def list_all_users(self):
		table = [("Username","Status","2fa")]
		for (user, status, two_factor) in c.execute("SELECT username, inactive, two_factor FROM users ORDER BY inactive, username"):
			if status == 0:
				table.append((user,"Active",two_factor))
			else:
				table.append((user,"Inactive",two_factor))
		Helpers.print_table(table)
 def __init__(self, rdmcObj):
     RdmcCommandBase.__init__(self, \
         name='showbackupdevices', \
         usage='showbackupdevices\n\n\tDisplay the devices supported for use '\
         'as Scalable Persistent Memory\n\tbackup storage.\n\n\texample: '\
         'showbackupdevices', \
         summary='Display backup storage devices.', \
         aliases=['spmem-showdrives', 'spmemsd', 'showscalablepmemdrives'], \
         optparser=OptionParser())
     self._rdmc = rdmcObj
     self._helpers = Helpers()
     self._chif_lib = self._helpers.gethprestchifhandle()
 def __init__(self, rdmcObj):
     RdmcCommandBase.__init__(self, \
         name='enablescalablepmem', \
         usage='enablescalablepmem [OPTIONS]\n\n' \
             '\tEnables or disables the Scalable Persistent Memory feature.\n'\
             '\n\texample: enablescalablepmem', \
         summary='Enable or disable the Scalable Persistent Memory feature.', \
         aliases=['spmem-enable', 'spmemen'], \
         optparser=OptionParser())
     self.definearguments(self.parser)
     self._rdmc = rdmcObj
     self._helpers = Helpers()
     self._restHelpers = RestHelpers(self._rdmc)
     self._chif_lib = self._helpers.gethprestchifhandle()
 def __init__(self, rdmcObj):
     RdmcCommandBase.__init__(self, \
         name='removelogicalnvdimm', \
         usage='removelogicalnvdimm (--processor=NUMBER --index=INDEX | '\
         '--pair=PAIR)\n\n\tRemove a logical NVDIMM. All data will be lost.\n'\
         '\n\texample: removelogicalnvdimm --processor=1 --index=1'\
         '\n\texample: removelogicalnvdimm --processors=1,2', \
         summary='Remove an existing logical NVDIMM.', \
         aliases=['lnvdimm-remove', 'lnr'], \
         optparser=OptionParser())
     self.definearguments(self.parser)
     self._rdmc = rdmcObj
     self._helpers = Helpers()
     self._restHelpers = RestHelpers(self._rdmc)
     self._chif_lib = self._helpers.gethprestchifhandle()
Exemplo n.º 5
0
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
            name='revertscalablepmemconfig', \
            usage='revertscalablepmemconfig\n\n'\
                '\tDiscards any pending Scalable Persistent Memory configuration '\
                'changes.\n\n\texample: revertscalablepmemconfig', \
            summary='Discard pending Scalable Persistent Memory configuration changes.',\
            aliases=['spmem-revertcfg', 'spmem-undocfg', 'spmemrc'], \
            optparser=OptionParser())

        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._restHelpers = RestHelpers(self._rdmc)
        self._validator = LogicalNvdimmValidator()
        self._chif_lib = self._helpers.gethprestchifhandle()
Exemplo n.º 6
0
 def __init__(self, rdmcObj):
     RdmcCommandBase.__init__(self,\
         name='showscalablepmemconfig', \
         usage='showscalablepmemconfig [OPTIONS]\n\n'\
             '\tDisplay the Scalable Persistent Memory configuration.\n'\
             '\tIf system is configured, reports the estimated time to complete a backup boot.\n\n'\
             '\texample: showscalablepmemconfig', \
         summary='Display the Scalable Persistent Memory configuration.', \
         aliases=['spmem-showcfg', 'spmemsc'], \
         optparser=OptionParser())
     self.definearguments(self.parser)
     self._rdmc = rdmcObj
     self._helpers = Helpers()
     self._chif_lib = self._helpers.gethprestchifhandle()
     self._restHelpers = RestHelpers(rdmcObject=self._rdmc)
     self._options = None
Exemplo n.º 7
0
 def __init__(self, rdmcObj):
     RdmcCommandBase.__init__(self, \
         name='setbackupdevices', \
         usage='setbackupdevices (--device=ID... | --remove-all)\n\n'\
             '\tSelect the devices to use for Scalable Persistent Memory '\
             'backup storage.\n\n\texample: setbackupdevices --device=1@1 '\
             '--device=1@2', \
         summary='Set backup storage devices.', \
         aliases=['spmem-setdrives', 'spmsetd', 'setbackupdrives'], \
         optparser=OptionParser())
     self.definearguments(self.parser)
     self._rdmc = rdmcObj
     self._helpers = Helpers()
     self._restHelpers = RestHelpers(self._rdmc)
     self._validator = LogicalNvdimmValidator()
     self._chif_lib = self._helpers.gethprestchifhandle()
Exemplo n.º 8
0
 def __init__(self, rdmcObj):
     RdmcCommandBase.__init__(self,\
         name='autoselectbackupdevices', \
         usage='autoselectbackupdevices --size=SIZE [--confirm]\n\n'\
         '\tAutomatically select the devices for use as Scalable '\
         'Persistent Memory backup storage.\n\n'\
         "\tDevices selected for backup storage will be initialized.\n"\
         "\tBack up all data first.\n" \
         '\n\texample: autoselectbackupdevices --size=1024 --confirm\n', \
         summary='Automatically select backup storage devices.', \
         aliases=['spmem-autosetd', 'spmemautosetd'],\
         optparser=OptionParser())
     self.definearguments(self.parser)
     self._rdmc = rdmcObj
     self._helpers = Helpers()
     self._restHelpers = RestHelpers(self._rdmc)
     self._validator = LogicalNvdimmValidator()
     self._chif_lib = self._helpers.gethprestchifhandle()
Exemplo n.º 9
0
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
        name='replacebackupdevice', \
        usage="replacebackupdevice OLD-ID NEW-ID\n"\
            "\n\tReplace a Scalable Persistent Memory backup storage device.\n"\
            "\tSpecify devices by ID, e.g. '1@1' from the show backup device command.\n"\
            "\n\tThis operation initializes all backup storage devices."\
            "\n\tData on any existing logical NVDIMMs will be lost. Back up all data first.\n"\
            "\n\texample: replacebackupdevice 1@1 2@1", \
        summary='Replace a backup storage device.', \
        aliases=['spmem-replaced', 'spmreplaced'], \
        optparser=OptionParser())

        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._rest_helpers = RestHelpers(self._rdmc)
        self._validator = LogicalNvdimmValidator()
        self._chif_lib = self._helpers.gethprestchifhandle()
Exemplo n.º 10
0
	def get_user_networks(self, user):
		self._ad_bind()
		ad_obj = self._ad_lookup(user)
		ret = list()
		for network_data in ad_obj["msRADIUSFramedRoute"]:
			network, _ = network_data.split(" ", 1)
			net, cidr = network.split("/",1)
			netmask = Helpers.netmask_from_cidr(cidr)
			ret.append((net, netmask))
		return ret
Exemplo n.º 11
0
	def _client_connect(self):
		networks = db.get_user_networks(os.environ["username"])
		if networks:
			if os.geteuid() == 0 and os.path.isfile("/sbin/iptables"):
				firewall = IpTables
			elif os.geteuid() == 0 and os.path.isfile("/sbin/pfctl"):
				firewall = PacketFilter
			else:
				firewall = DummyFirewall
			fw = firewall(os.environ["ifconfig_pool_remote_ip"])
			c_conf=open(sys.argv[1], "a+")
			for (network, netmask) in networks:
				try:
					c_conf.write("push \"route %s %s\"\n" % (network, netmask))
					fw.add_rule(os.environ["ifconfig_pool_remote_ip"], "%s/%s" %
						(network, Helpers.cidr_from_netmask(netmask)))
				except ValueError:
					continue
			fw.commit()
		sys.exit(0)
    def showDriveData(self):
        """ Main showlogicalnvdimmdrives command worker function

        :param options: command options
        :type options: options.
        """

        helpers = Helpers()
        restHelpers = RestHelpers(self._rdmc)
        validator = LogicalNvdimmValidator()

        scalable_pmem_config = ScalablePersistentMemoryConfig(restHelpers, \
                                                    validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateFeatureIsSupported(scalable_pmem_config)

        helpers.writeHeader2(
            u"Scalable Persistent Memory Backup Storage Devices")
        helpers.displayDrivesConfiguration(scalable_pmem_config)
        sys.stdout.write(u"\n")
class RemoveLogicalNVDIMMRegionCommand(RdmcCommandBase):
    """ Main removelogicalnvdimm command class """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
            name='removelogicalnvdimm', \
            usage='removelogicalnvdimm (--processor=NUMBER --index=INDEX | '\
            '--pair=PAIR)\n\n\tRemove a logical NVDIMM. All data will be lost.\n'\
            '\n\texample: removelogicalnvdimm --processor=1 --index=1'\
            '\n\texample: removelogicalnvdimm --processors=1,2', \
            summary='Remove an existing logical NVDIMM.', \
            aliases=['lnvdimm-remove', 'lnr'], \
            optparser=OptionParser())
        self.definearguments(self.parser)
        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._restHelpers = RestHelpers(self._rdmc)
        self._chif_lib = self._helpers.gethprestchifhandle()

    def removeRegion(self, options):
        """ Removes the Logical NVDIMM specified

        :param socketIdx: the socket of the NUMA region, or None for Non-NUMA
        :type socketIdx: string or int

        :param regionIdx: the index of the region
        :type regionIdx: string or int
        """

        validator = LogicalNvdimmValidator()

        scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
                                                     validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateAllConfigurationPolicies(scalable_pmem_config)

        matchingRegion = None
        if options.processorPair:
            matchingPair = next((p for _, p in scalable_pmem_config.regions.\
                                 socketPairs.items() if p.labelString == options.\
                                                            processorPair), None)
            if matchingPair:
                matchingRegion = matchingPair.nonNumaRegion
        else:
            matchingSocket = next((s for _, s in scalable_pmem_config.regions.\
                                   sockets.items() if s.labelString == options.\
                                                        processorNumber), None)
            if matchingSocket:
                matchingRegion = matchingSocket.numaRegions.get(options.index)

        if matchingRegion and matchingRegion.isConfigured:
            if self._rdmc.interactive:
                if matchingRegion.isActivelyConfigured:
                    self._helpers.confirmBeforeConfigCausesDataLoss(scalable_pmem_config)

            patchAttributes = {
                matchingRegion.settingName : 0
            }
            _ = self._restHelpers.patchScalablePmemSettingAttributes(patchAttributes)
        else:
            self._helpers.displayRegionConfiguration(scalable_pmem_config)
            raise InvalidCommandLineError(u"Unable to identify an existing logical NVDIMM")

        # display the new state
        scalable_pmem_config.refresh()
        self._helpers.displayRegionConfiguration(scalable_pmem_config)
        sys.stdout.write(u"\n")



    def run(self, line):
        """ Wrapper function for the Remove logical NVDIMM command

        :param line: command line input
        :type line: string.
        """
        LOGGER.info("Scalable PMEM: {}".format(self.name))
        try:
            (options, _) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        LOGGER.info("Options: {}".format(options))

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        if not options.processorNumber and not options.processorPair:
            self.parser.print_help()
            raise InvalidCommandLineError(u"One of --processor or --processors"\
                                                                " is required")

        if options.processorNumber and options.processorPair:
            self.parser.print_help()
            raise InvalidCommandLineError(u"--processor and --processors may not"\
                                                        " be used at the same time")

        if options.processorNumber:
            if options.index is None:
                self.parser.print_help()
                raise InvalidCommandLineError(u"--index must be specified with "\
                                                                    "--processor")
            self.removeRegion(options)

        if options.processorPair:
            if not options.index is None:
                self.parser.print_help()
                raise InvalidCommandLineError(u"--index is not a valid option to"\
                                                        " use with --processors")
            self.removeRegion(options)

        #Return code
        return ReturnCodes.SUCCESS

    def definearguments(self, customparser):
        """ Define the arguments in the remove region function

        :param customparser: command line input
        :type customparser: parser.
        """

        groupDanger = OptionGroup(customparser, "Dangerous Options", \
            "Use of these options will alter the backup storage devices configured\n" \
            "for use with Scalable Persistent Memory and could cause data loss.  "\
            "Back up all\ndata first.")

        groupDanger.add_option(
            '--proc',
            '--processor',
            action="store",
            type="string",
            default=None,
            dest="processorNumber",
            metavar="NUMBER",
            help="Specify the processor number of the logical NVDIMM to remove (1, 2)."
        )

        groupDanger.add_option(
            '-i',
            '--index',
            type="int",
            default=None,
            dest="index",
            help="Specify the index of the logical NVDIMM to remove (use with --processor).")

        groupDanger.add_option(
            '--pair',
            '--processors',
            action="store",
            type="string",
            default=None,
            dest="processorPair",
            metavar="PAIR",
            help="Specify the pair of processors of the spanned logical NVDIMM to remove (1,2)."
            )

        customparser.add_option_group(groupDanger)
Exemplo n.º 14
0
class AutoSelectBackupDevicesCommand(RdmcCommandBase):
    """ Main autoselectbackupdevices command class """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self,\
            name='autoselectbackupdevices', \
            usage='autoselectbackupdevices --size=SIZE [--confirm]\n\n'\
            '\tAutomatically select the devices for use as Scalable '\
            'Persistent Memory backup storage.\n\n'\
            "\tDevices selected for backup storage will be initialized.\n"\
            "\tBack up all data first.\n" \
            '\n\texample: autoselectbackupdevices --size=1024 --confirm\n', \
            summary='Automatically select backup storage devices.', \
            aliases=['spmem-autosetd', 'spmemautosetd'],\
            optparser=OptionParser())
        self.definearguments(self.parser)
        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._restHelpers = RestHelpers(self._rdmc)
        self._validator = LogicalNvdimmValidator()
        self._chif_lib = self._helpers.gethprestchifhandle()

    def autoselectdrives(self, pmem_size_GiB, confirm):
        """ function to perform the automatic selection of backup drives

        :param pmem_size_GiB: requested scalable persistent memory size
        :type pmem_size_GiB: int

        :param confirm: whether or not to automatically confirm the selected drives
        :type confirm: Boolean
        """

        scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
                                             self._validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateAllConfigurationPolicies(scalable_pmem_config)

        # make sure this is an un-configured system
        if scalable_pmem_config.isConfiguredSystem:
            raise InvalidCommandLineError(u"This operation is not supported on "\
                                                        "a configured system")

        # get policies
        policies = resolve_pointer(scalable_pmem_config.config_resource, \
                                                    "/Attributes/Policy", None)
        sameModel = False
        sameSize = False
        if policies:
            sameModel = policies.get("SameModelNVMe", False)
            sameSize = policies.get("SameSizeNVMe", False)

        # separate the supported drives into supported groups, based on model or size
        # if same model or size, then order doesn't matter; else the
        # drives should be sorted largest to smallest
        supported_drives_groups = self.sort_drives(sameModel, sameSize, \
                                    scalable_pmem_config.drives.supportedDrives)

        # loop through the group until a valid config is found or all drives
        # have been tested
        isValid = False
        i = 0
        num_groups = len(supported_drives_groups)
        while not isValid and i < num_groups:
            drive_group = supported_drives_groups[i]
            drivesToUse = []
            for drive in drive_group:
                drivesToUse.append(drive)
                # calculate the maximum supported by the new configuration,
                # which may be different from the requested capacity
                max_pmem_supported = self._validator.calculateMaxPmemGiB(\
                        self._chif_lib, scalable_pmem_config.config_resource, \
                        drivesToUse)
                if max_pmem_supported >= pmem_size_GiB:
                    # check drive policies
                    (isValidDrivePolicies, _) = self._validator.\
                            checkLogicalNvdimmDrivePolicies(scalable_pmem_config.\
                            config_resource, drivesToUse)
                    if isValidDrivePolicies:
                        isValid = True
                        break
            i += 1

        if not isValid:
            # TODO: more info? maybe build a list of reasons why certain drives will not work
            raise InvalidCommandLineError(u"Requested size of {} GiB is not "\
                                          "supported by the installed backup "\
                                          "devices".format(pmem_size_GiB))

        # get a list of the drives to show to the user
        summary_drive_list = ["{:15} ({} GB)".format(d.formattedLocation, \
                                                d.sizeGB) for d in drivesToUse]

        # Make sure the user confirms the changes
        sys.stdout.write(u"\nThe following backup devices have been "\
                                "automatically selected for Scalable PMEM:\n")
        self._helpers.printLimitedMessageList(summary_drive_list, 99)
        sys.stdout.write(u"\n")

        if not confirm:
            if self._rdmc.interactive:
                # TODO: timeout
                s = raw_input(
                    u"\nConfirm changes? Y(y) to confirm. N(n) to cancel: ")
                if s == 'y' or s == 'Y':
                    confirm = True
                else:
                    raise NoChangesFoundOrMadeError(
                        u"No changes have been made")
            else:
                raise NoChangesFoundOrMadeError(u"No changes have been made.  "\
                                    "To confirm the changes, specify --confirm")

        if confirm:
            # if all is valid, configure the related BIOS setting
            self._restHelpers.setDrives(new_drives=drivesToUse)
            #self._restHelpers.enableConfiguration()
            scalable_pmem_config.refresh()
            self._helpers.displayDrivesConfiguration(scalable_pmem_config)

    def sort_drives(self, sameModel, sameSize, supported_drives):
        """ sort drives into separate groups based on model or size.
        if same model or size, then order doesn't matter
        else the drives are sorted largest to smallest size

        :param sameModel: specifies if drives need to be the same model
        :type sameModel: Boolean

        :param sameSize: specifies is drives need to be the same size, model takes precedence
        :type sameSize: Boolean

        :param supported_drives: list of all supported drives
        :type supported_drives: list of Drives

        :returns: 2D list of supported drives, where a row is a group of """\
        """drives based on model or size
        :rtype: 2D list of Drive
        """
        supported_drives_groups = []  # 2D Array, row=model or size
        if sameModel:
            # separate drives by model
            # for each model, build a list of drives
            models = set([drive.model for drive in supported_drives])
            for model_to_find in models:
                drive_model_group = [drive for drive in supported_drives if \
                                                    drive.model == model_to_find]
                supported_drives_groups.append(drive_model_group)

        elif sameSize:
            # separate drives by size
            sizes = set([drive.sizeMB for drive in supported_drives])
            for size_to_find in sizes:
                drive_size_group = [drive for drive in supported_drives if \
                                                    drive.sizeMB == size_to_find]
                supported_drives_groups.append(drive_size_group)
        else:
            # contains one list of all supported drives, regardless of size or model
            # sort by the size, descending from largest to smallest
            sorted_supported_drives = sorted(supported_drives, key=lambda d: d.sizeMB,\
                                                                 reverse=True)
            supported_drives_groups.append(sorted_supported_drives)

        return supported_drives_groups

    def run(self, line):
        """ Wrapper function for new command main function

        :param line: command line input
        :type line: string.
        """
        LOGGER.info("Scalable PMEM: {}".format(self.name))
        try:
            (options, _) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        LOGGER.info("Options: {}".format(options))

        if options.size <= 0:
            self.parser.print_help()
            raise InvalidCommandLineError("Invalid value for --size")

        self.autoselectdrives(options.size, options.confirm)

        #Return code
        return ReturnCodes.SUCCESS

    def definearguments(self, customparser):
        """ Wrapper function for new command main function

        :param customparser: command line input
        :type customparser: parser.
        """

        customparser.add_option(
            '--size',
            '-s',
            dest='size',
            default=-1,
            action="store",
            help="Amount (in GiB) of Scalable Persistent Memory to be supported"\
                            " by the new backup storage device configuration.",
            type="int"
        )

        groupDanger = OptionGroup(customparser, "Dangerous Options", \
            "Use of these options will alter the Scalable Persistent Memory " \
            "configuration\nand will cause data loss.  Back up all data first.")

        groupDanger.add_option(
            '--confirm',
            action="store_true",
            default=False,
            dest="confirm",
            help="Confirm the configuration of the automatically selected backup"\
                            " devices. If not specified, no changes will occur."
        )

        customparser.add_option_group(groupDanger)
class ShowLogicalNVDIMMDrivesCommand(RdmcCommandBase):
    """ Main showbackupdevices command class """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
            name='showbackupdevices', \
            usage='showbackupdevices\n\n\tDisplay the devices supported for use '\
            'as Scalable Persistent Memory\n\tbackup storage.\n\n\texample: '\
            'showbackupdevices', \
            summary='Display backup storage devices.', \
            aliases=['spmem-showdrives', 'spmemsd', 'showscalablepmemdrives'], \
            optparser=OptionParser())
        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._chif_lib = self._helpers.gethprestchifhandle()

    def showDriveData(self):
        """ Main showlogicalnvdimmdrives command worker function

        :param options: command options
        :type options: options.
        """

        helpers = Helpers()
        restHelpers = RestHelpers(self._rdmc)
        validator = LogicalNvdimmValidator()

        scalable_pmem_config = ScalablePersistentMemoryConfig(restHelpers, \
                                                    validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateFeatureIsSupported(scalable_pmem_config)

        helpers.writeHeader2(
            u"Scalable Persistent Memory Backup Storage Devices")
        helpers.displayDrivesConfiguration(scalable_pmem_config)
        sys.stdout.write(u"\n")

    def run(self, line):
        """ Wrapper function for showlogicalnvdimmdrives command main function

        :param line: command line input
        :type line: string.
        """
        LOGGER.info("Scalable PMEM: {}".format(self.name))
        try:
            (options, args) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        if args:
            raise InvalidCommandLineError("No argument is required.")

        LOGGER.info("Options: {}".format(options))

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        self.showDriveData()

        #Return code
        return ReturnCodes.SUCCESS
Exemplo n.º 16
0
def get_parameters():
	parameters=dict()

	parameters['script_path'] = Helpers.input("Installation path", os.path.dirname(os.path.realpath(__file__)))
	parameters['vpn_server_host'] = Helpers.input("Domain or IP for vpn server", socket_gethostname())
	parameters['vpn_server_port'] = Helpers.input("Port for the vpn server", 1194)
	parameters['client_network_address'] = Helpers.input("Network address for client network", '10.31.8.0')
	parameters['client_network_netmask'] = Helpers.input("Netmask for client network", '255.255.255.0')
	parameters['cipher'] = Helpers.input("Encryption cipher for the vpn", 'AES-256-CBC')

	parameters['ca_certificate'] = open(Helpers.input("Filename for CA-certificate", "%s.crt" % parameters['vpn_server_host'])).read().strip()
	parameters['server_certificate'] =  open(Helpers.input("Filename for server certificate", parameters['ca_certificate'])).read().strip()
	parameters['server_key'] = open(Helpers.input("Filename for server certificate key file", "%s.key" % parameters['vpn_server_host'])).read().strip()
	parameters['ta_key'] = open(Helpers.input("Filename for tls-auth key", "ta.key")).read().strip()
	parameters['dhparam'] = open(Helpers.input("Filename for Diffie-Hellman key", "dh2048.pem")).read().strip()

	return parameters
Exemplo n.º 17
0
	def __init__(self):
		import argparse
		parser = argparse.ArgumentParser(description='Manage the sqlite3 user/access-db for openvpn')
		mode = parser.add_mutually_exclusive_group()
		mode.add_argument('-a', '--add', action='store_true')
		mode.add_argument('-r', '--remove', action='store_true')
		mode.add_argument('-l', '--list', action='store_true')
		mode.add_argument('-e', '--enable', action='store_true')
		mode.add_argument('-d', '--disable', action='store_true')
		parser.add_argument('-m', '--map', action='store_true')
		parser.add_argument('--chpass', action='store_true')
		parser.add_argument('--initdb', action='store_true')
		parser.add_argument('-u', '--user', nargs='?', const=False)
		parser.add_argument('-n', '--network', nargs='?', const=False)
		parser.add_argument('-t', '--totp-secret', nargs='?', const=False)
		args = parser.parse_args()

		if len(sys.argv) < 2:
			parser.print_help()
			sys.exit(1)

		if args.initdb:
			if Helpers.input("Really initialize db and remove all in it?", "y/N").lower() != 'y':
				sys.exit(1)
			else:
				print "OK, initializing DB"
				self.init_db()
				sys.exit(0)
		elif args.user:
			user = User(args.user)
			if args.add and not args.map and args.totp_secret == None:
				if user.exists():
					print "User %s already exist" % user.username
					sys.exit(1)
				user.create()
				user.set_password()
			else:
				if not user.exists():
					print "User %s doesn't exist" % user.username
					sys.exit(1)
				elif args.chpass:
					user.set_password()
				elif args.enable:
					user.enable()
				elif args.disable:
					user.disable()
				elif args.map:
					if args.list:
						for (network,) in user.get_maps():
							print network
					elif args.network and args.add:
						user.add_network(args.network)
					elif args.network and args.remove:
						user.remove_network(args.network)
					else:
						print "Don't know what to map"
						sys.exit(1)
				elif args.totp_secret:
					if args.list:
						for (secret,) in user.get_totp_secrets():
							print secret
					elif args.add:
						user.add_totp_secret(args.totp_secret)
					elif args.remove:
						user.remove_totp_secret(args.totp_secret)
					else:
						print "Dont know what to do here"
						sys.exit(1)
				elif args.remove: # and not args.map:
					user.remove()
				else:
					raise Exception("Should not happen (%s)", args)
		elif args.network:
			network = Network(args.network)
			if args.add and not args.map:
				if network.exists():
					print "Network %s already exist" % network.network
					sys.exit(1)
				network.create()
			else:
				if not network.exists():
					print "Network %s doesn't exist" % network.network
					sys.exit(1)
				elif args.map:
					if args.list:
						for (user,) in network.get_maps():
							print user
					else:
						print "Missing user argument, don't know how to map"
						sys.exit(1)
				elif args.remove: # and not args.map:
					network.remove()
				else:
					raise Exception("Should not happen (%s)", args)
		elif args.list:
			if args.user == False and args.network != False:
				self.list_all_users()
			elif args.user != False and args.network == False:
				self.list_all_networks()
			elif args.map:
				self.list_all_maps()
			else:
				print "List what?"
				sys.exit(1)
		else:
			raise Exception("Should not happen (%s)", args)
		sys.exit(0)
Exemplo n.º 18
0
			if status == 0:
				table.append((user,"Active",two_factor))
			else:
				table.append((user,"Inactive",two_factor))
		Helpers.print_table(table)

	def list_all_networks(self):
		table = [("Network", "Description")]
		for (network, description) in c.execute("SELECT network, description FROM networks"):
			table.append((network, description))
		Helpers.print_table(table)

	def list_all_maps(self):
		table = [("Username", "Network")]
		for (username, network) in c.execute("SELECT username, network FROM network_map ORDER BY username, network"):
			table.append((username, network))
		Helpers.print_table(table)

	def init_db(self):
		c.execute("CREATE TABLE IF NOT EXISTS users (username TEXT PRIMARY KEY, password TEXT, two_factor INTEGER DEFAULT 0, inactive INTEGER DEFAULT 0)")
		c.execute("CREATE TABLE IF NOT EXISTS networks (network TEXT PRIMARY KEY CHECK ( LIKE('%/%', network) ), description TEXT)")
		c.execute("CREATE TABLE IF NOT EXISTS network_map (username TEXT REFERENCES users(username), network TEXT REFERENCES networks(network), CONSTRAINT pk PRIMARY KEY (username, network))")
		c.execute("CREATE TABLE IF NOT EXISTS totp_secrets (totp_secret TEXT, username TEXT REFERENCES users(username), CONSTRAINT pk PRIMARY KEY (totp_secret, username))")
		conn.commit()


if __name__ == "__main__":
	Helpers.connect_db(db_file)

	Manage()
Exemplo n.º 19
0
class ReplaceBackupDeviceCommand(RdmcCommandBase):
    """ Main replacebackupdevice command class """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
        name='replacebackupdevice', \
        usage="replacebackupdevice OLD-ID NEW-ID\n"\
            "\n\tReplace a Scalable Persistent Memory backup storage device.\n"\
            "\tSpecify devices by ID, e.g. '1@1' from the show backup device command.\n"\
            "\n\tThis operation initializes all backup storage devices."\
            "\n\tData on any existing logical NVDIMMs will be lost. Back up all data first.\n"\
            "\n\texample: replacebackupdevice 1@1 2@1", \
        summary='Replace a backup storage device.', \
        aliases=['spmem-replaced', 'spmreplaced'], \
        optparser=OptionParser())

        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._rest_helpers = RestHelpers(self._rdmc)
        self._validator = LogicalNvdimmValidator()
        self._chif_lib = self._helpers.gethprestchifhandle()

    def run(self, line):
        """ Runs the command.

        :param line: command line input
        :type line: string
        """
        try:
            (_, args) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        if not args or len(args) != 2:
            self.print_help()
            sys.stdout.write("\n")
            raise InvalidCommandLineError(u"OLD-ID and NEW-ID must be specified")

        if len(args) != len(set(args)):
            raise InvalidCommandLineError(u"Duplicate device IDs specified")

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        scalable_pmem_config = ScalablePersistentMemoryConfig(self._rest_helpers,\
                                                 self._validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateFeatureIsSupported(scalable_pmem_config)
        self._helpers.validateFeatureEnabledByUser(scalable_pmem_config)

        try:
            old_drive, new_drive = scalable_pmem_config.drives.findDrives(args)
        except ValueError as excp:
            raise InvalidCommandLineError(u"Invalid device ID: {}".format(excp))

        self.replace_drive(scalable_pmem_config, old_drive, new_drive)

        scalable_pmem_config.refresh()
        self._helpers.displayDrivesConfiguration(scalable_pmem_config)

        return ReturnCodes.SUCCESS

    def replace_drive(self, scalable_pmem_config, old_drive, new_drive):
        """ Replaces a backup storage drive.

        :param scalable_pmem_config: the Scalable Persistent Memory configuration
        :param old_drive: the drive to be replaced
        :param new_drive: the replacement drive
        """
        backup_drives = scalable_pmem_config.drives.selectedDrives

        if old_drive not in backup_drives:
            raise NoChangesFoundOrMadeError(u"Device {} is not configured "\
                            "for backup storage".format(old_drive.generatedId))

        if new_drive in backup_drives:
            raise NoChangesFoundOrMadeError(u"Device {} is already configured " \
                            "for backup storage".format(new_drive.generatedId))

        backup_drives.remove(old_drive)
        backup_drives.append(new_drive)

        config_data = scalable_pmem_config.config_resource

        # new backup storage drives must adhere to the drive policy requirements
        is_valid, error_msg = self._validator.checkLogicalNvdimmDrivePolicies(\
                                                    config_data, backup_drives)
        if not is_valid:
            raise NoChangesFoundOrMadeError(error_msg)

        # new backup storage drives must support the current logical NVDIMM configuration
        max_pmem = self._validator.calculateMaxPmemGiB(self._chif_lib, \
                                                    config_data, backup_drives)
        allocated_pmem = scalable_pmem_config.regions.totalSizeGiB

        if allocated_pmem > max_pmem:
            raise NoChangesFoundOrMadeError(u"The new backup storage devices must support "
                                            u"the current logical NVDIMM configuration.")

        if old_drive.currentMode == Drive.MODE_NVDIMM and scalable_pmem_config.\
                                                    hasActiveConfiguredRegions:
            # actual drive replacement occurring with data at risk
            if self._rdmc.interactive:
                sys.stdout.write(u"\nAll backup storage devices will be initialized upon restart."
                                 u"\nData on any existing logical NVDIMMs will be lost.\n")

                uinput = raw_input(u"\nConfirm changes [y/N]? ")
                if uinput.lower() != 'y':
                    raise NoChangesFoundOrMadeError(u"No changes have been made")

        self._rest_helpers.setDrives(new_drives=[new_drive], old_drives=[old_drive])
Exemplo n.º 20
0
class RevertScalablePmemConfigurationCommand(RdmcCommandBase):
    """ Main revertscalablepmemconfig command class """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
            name='revertscalablepmemconfig', \
            usage='revertscalablepmemconfig\n\n'\
                '\tDiscards any pending Scalable Persistent Memory configuration '\
                'changes.\n\n\texample: revertscalablepmemconfig', \
            summary='Discard pending Scalable Persistent Memory configuration changes.',\
            aliases=['spmem-revertcfg', 'spmem-undocfg', 'spmemrc'], \
            optparser=OptionParser())

        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._restHelpers = RestHelpers(self._rdmc)
        self._validator = LogicalNvdimmValidator()
        self._chif_lib = self._helpers.gethprestchifhandle()

    def revertPendingChanges(self):
        """ Reverts any pending changes """

        scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
                                             self._validator, self._chif_lib)
        scalable_pmem_config.refresh()

        self._restHelpers.revertSettings()

        scalable_pmem_config.refresh()

        self._helpers.writeHeader2(u"Logical NVDIMMs")
        self._helpers.displayRegionConfiguration(scalable_pmem_config)
        self._helpers.writeHeader2(
            u"Scalable Persistent Memory Backup Storage Devices")
        self._helpers.displayDrivesConfiguration(scalable_pmem_config)

        sys.stdout.write("\n\n")

    def run(self, line):
        """ Wrapper function for the revert configuration command

        :param line: command line input
        :type line: string.
        """
        LOGGER.info("Scalable PMEM: {}".format(self.name))
        try:
            (options, _) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        LOGGER.info("Options: {}".format(options))

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        self.revertPendingChanges()

        #Return code
        return ReturnCodes.SUCCESS
Exemplo n.º 21
0
	def list_all_networks(self):
		table = [("Network", "Description")]
		for (network, description) in c.execute("SELECT network, description FROM networks"):
			table.append((network, description))
		Helpers.print_table(table)
Exemplo n.º 22
0
class SetLogicalNVDIMMDrivesCommand(RdmcCommandBase):
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
            name='setbackupdevices', \
            usage='setbackupdevices (--device=ID... | --remove-all)\n\n'\
                '\tSelect the devices to use for Scalable Persistent Memory '\
                'backup storage.\n\n\texample: setbackupdevices --device=1@1 '\
                '--device=1@2', \
            summary='Set backup storage devices.', \
            aliases=['spmem-setdrives', 'spmsetd', 'setbackupdrives'], \
            optparser=OptionParser())
        self.definearguments(self.parser)
        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._restHelpers = RestHelpers(self._rdmc)
        self._validator = LogicalNvdimmValidator()
        self._chif_lib = self._helpers.gethprestchifhandle()

    def common_setup(self):
        """ function to get the config setup """
        scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers, \
                                                 self._validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateAllConfigurationPolicies(scalable_pmem_config)

        return scalable_pmem_config

    def removeAllDrives(self):
        """ setlogicalnvdimmdrives command worker function """

        scalable_pmem_config = self.common_setup()

        if scalable_pmem_config.hasConfiguredRegions:
            raise NoChangesFoundOrMadeError(u"Backup drives cannot be removed "\
                                        "while logical NVDIMMs are configured")

        self._restHelpers.setDrives(
            old_drives=scalable_pmem_config.drives.selectedDrives)
        #self._restHelpers.enableConfiguration()

        scalable_pmem_config.refresh()
        self._helpers.displayDrivesConfiguration(scalable_pmem_config)

        return ReturnCodes.SUCCESS

    def setDrives(self, options=None):
        """ Main setlogicalnvdimmdrives command worker function

        :param options: command options
        :type options: options.
        """

        drivesToUse = []

        if not options.driveId:
            raise InvalidCommandLineError(u"No device IDs specified")

        if len(options.driveId) > len(set(options.driveId)):
            raise InvalidCommandLineError(u"Duplicate device IDs specified")

        scalable_pmem_config = self.common_setup()

        for userProvidedId in options.driveId:
            matchingDrive = scalable_pmem_config.drives.findDrive(
                userProvidedId)
            if not matchingDrive:
                raise InvalidCommandLineError(
                    u"Invalid device ID: {}".format(userProvidedId))
            drivesToUse.append(matchingDrive)

        if scalable_pmem_config.hasConfiguredRegions:
            # allow drives to be added but not removed
            if not set(scalable_pmem_config.drives.selectedDrives).issubset(
                    drivesToUse):
                raise NoChangesFoundOrMadeError(u"Backup devices cannot be "\
                                "removed while logical NVDIMMs are configured")

        # check the configuration policies
        (isValidDrivePolicies, drivePoliciesMessage) = self._validator.\
                checkLogicalNvdimmDrivePolicies(scalable_pmem_config.config_resource,\
                                                                    drivesToUse)
        if not isValidDrivePolicies:
            sys.stdout.write(
                u"\nThe set of devices specified is not a valid configuration:\n"
            )
            sys.stdout.write(drivePoliciesMessage)
            sys.stdout.write(u"\n\n")
            raise NoChangesFoundOrMadeError(u"Unable to continue")

        # calculate maximum persistent memory supported
        maxPmem = self._validator.calculateMaxPmemGiB(self._chif_lib, scalable_pmem_config.\
                                                      config_resource, drivesToUse)
        # compare this to the TOTAL of the pmem regions in the current/pending settings
        totalPmemAllocated = scalable_pmem_config.regions.totalSizeGiB
        if totalPmemAllocated != 0 and maxPmem < totalPmemAllocated:
            sys.stdout.write(
                u"\nThe set of devices specified is not a valid configuration:\n"
            )
            sys.stdout.write(
                u"\nScalable Persistent Memory supported by requested configuration: {} GiB" \
                            u"\nAllocated Scalable Persistent Memory: {} GiB.".\
                                            format(maxPmem, totalPmemAllocated))
            sys.stdout.write(u"\n\n")
            raise NoChangesFoundOrMadeError(u"Unable to continue")

        # if all is valid, configure the related BIOS setting
        if self._rdmc.interactive:
            self._helpers.confirmBeforeConfigCausesDataLoss(
                scalable_pmem_config)

        self._restHelpers.setDrives(new_drives=drivesToUse, old_drives=scalable_pmem_config.\
                                                            drives.selectedDrives)

        scalable_pmem_config.refresh()
        self._helpers.displayDrivesConfiguration(scalable_pmem_config)

        return ReturnCodes.SUCCESS

    def run(self, line):
        """ Wrapper function for setbackupdrives command main function

        :param line: command line input
        :type line: string.
        """
        LOGGER.info("Scalable PMEM: {}".format(self.name))
        try:
            (options, _) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        LOGGER.info("Options: {}".format(options))

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        if options.removeAll and options.driveId:
            raise InvalidCommandLineError(u"--device and --remove-all may not "\
                                                        "be used at the same time")
        if options.removeAll:
            return self.removeAllDrives()
        else:
            return self.setDrives(options)

    def definearguments(self, customparser):
        """ Define arguments for the command

        :param customparser: command line input
        :type customparser: parser.
        """

        groupDanger = OptionGroup(customparser, "Dangerous Options", \
            "Use of these options will alter the backup storage devices configured\n" \
            "for use with Scalable Persistent Memory and could cause data loss. " \
            " Back up all\ndata first.")

        groupDanger.add_option(
            '--device',
            '--drive',
            action="append",
            dest="driveId",
            metavar="ID",
            help="ID of the backup device to set, e.g. '1@1'")

        groupDanger.add_option(
            '--remove-all',
            action="store_true",
            dest="removeAll",
            help="Remove all currently-configured backup devices")

        customparser.add_option_group(groupDanger)
Exemplo n.º 23
0
	def list_all_maps(self):
		table = [("Username", "Network")]
		for (username, network) in c.execute("SELECT username, network FROM network_map ORDER BY username, network"):
			table.append((username, network))
		Helpers.print_table(table)
class EnableScalablePmemCommand(RdmcCommandBase):
    """ Enable Scalable Pmem command """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self, \
            name='enablescalablepmem', \
            usage='enablescalablepmem [OPTIONS]\n\n' \
                '\tEnables or disables the Scalable Persistent Memory feature.\n'\
                '\n\texample: enablescalablepmem', \
            summary='Enable or disable the Scalable Persistent Memory feature.', \
            aliases=['spmem-enable', 'spmemen'], \
            optparser=OptionParser())
        self.definearguments(self.parser)
        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._restHelpers = RestHelpers(self._rdmc)
        self._chif_lib = self._helpers.gethprestchifhandle()

    def enableOrDisableFeature(self, enable):
        """ Enables or disables the feature

        :param enable: a flag whether to enable or disable the feature
        :type enable: boolean
        """

        validator = LogicalNvdimmValidator()

        scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
                                                     validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # pre-validation
        self._helpers.validateFeatureIsSupported(scalable_pmem_config)
        self._helpers.validateFunctionalityIsEnabled(scalable_pmem_config)

        if enable is False:
            # If user disables Scalable PMEM, revert any pending changes to
            # prevent data or configuration loss
            if self._rdmc.interactive:
                message = u"Warning: disabling Scalable Persistent Memory will "\
                                    "revert any pending configuration changes.\n"
                self._helpers.confirmChanges(message=message)
            self._restHelpers.revertSettings()

        patchAttributes = {
            "FeatureEnabled" : enable
        }
        _ = self._restHelpers.patchScalablePmemSettingAttributes(patchAttributes)

        sys.stdout.write(u"\nThe Scalable Persistent Memory feature has been "\
                    "set to: {}\n".format("Enabled" if enable else "Disabled"))

        self._helpers.noticeRestartRequired(scalable_pmem_config)

        sys.stdout.write("\n\n")

    def run(self, line):
        """ Wrapper function for the Remove logical NVDIMM command

        :param line: command line input
        :type line: string.
        """
        LOGGER.info("Scalable PMEM: {}".format(self.name))
        try:
            (options, _) = self._parse_arglist(line)
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        if len(args):
            InvalidCommandLineError("This command takes no parameters.")

        LOGGER.info("Options: {}".format(options))

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        enable = True
        if options.enableFeature is False:
            enable = False

        self.enableOrDisableFeature(enable)

        #Return code
        return ReturnCodes.SUCCESS

    def definearguments(self, customparser):
        """ Define arguments for the command

        :param customparser: command line input
        :type customparser: parser.
        """

        customparser.add_option(
            '--disable',
            action="store_false",
            dest="enableFeature",
            help="Disable the Scalable Persistent Memory feature. Warning: "\
                                "any pending configuration changes will be lost."
        )
Exemplo n.º 25
0
class ShowLogicalNVDIMMConfigurationCommand(RdmcCommandBase):
    """ Main showscalablepmemconfig command class """
    def __init__(self, rdmcObj):
        RdmcCommandBase.__init__(self,\
            name='showscalablepmemconfig', \
            usage='showscalablepmemconfig [OPTIONS]\n\n'\
                '\tDisplay the Scalable Persistent Memory configuration.\n'\
                '\tIf system is configured, reports the estimated time to complete a backup boot.\n\n'\
                '\texample: showscalablepmemconfig', \
            summary='Display the Scalable Persistent Memory configuration.', \
            aliases=['spmem-showcfg', 'spmemsc'], \
            optparser=OptionParser())
        self.definearguments(self.parser)
        self._rdmc = rdmcObj
        self._helpers = Helpers()
        self._chif_lib = self._helpers.gethprestchifhandle()
        self._restHelpers = RestHelpers(rdmcObject=self._rdmc)
        self._options = None

    def showLogicalNvdimmConfig(self, options):
        """ Main showlogicalnvdimmconfig command worker function

        :param options: command options
        :type options: options.
        """

        if self._rdmc.app.config._ac__format.lower() == 'json':
            options.json = True         #pragma: no cover

        validator = LogicalNvdimmValidator()

        scalable_pmem_config = ScalablePersistentMemoryConfig(self._restHelpers,\
                                                     validator, self._chif_lib)
        scalable_pmem_config.refresh()

        # overall config status
        self._helpers.validateAllConfigurationPolicies(scalable_pmem_config, \
                                                    output_as_json=options.json)

        if options.available:
            if not options.json:
                self._helpers.writeHeader2(u"Available Scalable Persistent Memory")
                sys.stdout.write("Available capacity to create logical NVDIMMs "\
                                 "is constrained by the system\n hardware, including"\
                                 " the number of backup storage devices selected.\n")

            self._helpers.displayAvailableCapacity(scalable_pmem_config, \
                                                   output_as_json=options.json)
        else:
            if not options.json:
                # overall config enabled and capacity graph
                self._helpers.writeHeader2(u"Overall Allocated Scalable Persistent Memory")
                sys.stdout.write(u"\n")
                self._helpers.displayOverallCapacityBarGraph(scalable_pmem_config, 60)
                self._helpers.printBackupBootTimeMessage(scalable_pmem_config)
                if len(scalable_pmem_config.drives.selectedDrives) == 0:
                    sys.stdout.write("* No backup storage devices have been selected")
                sys.stdout.write(u"\n")
                # allocated logical nvdimms
                self._helpers.writeHeader2(u"Logical NVDIMMs")
            self._helpers.displayRegionConfiguration(scalable_pmem_config, \
                                                     output_as_json=options.json, \
                                                     print_backup_time_message=False)

        sys.stdout.write(u"\n\n")



    def run(self, line):
        """ Wrapper function for showlogicalnvdimmconfiguration command main function

        :param line: command line input
        :type line: string.
        """

        LOGGER.info("Scalable PMEM: {}".format(self.name))

        try:
            (options, args) = self._parse_arglist(line)
            if options:
                self._options = options
        except:
            if ("-h" in line) or ("--help" in line):
                return ReturnCodes.SUCCESS
            else:
                raise InvalidCommandLineErrorOPTS("")

        if len(args):
            InvalidCommandLineError("This command takes no parameters.")

        LOGGER.info("Options: {}".format(options))

        if not self._chif_lib:
            self._helpers.failNoChifLibrary()

        self.showLogicalNvdimmConfig(options)

        #Return code
        return ReturnCodes.SUCCESS


    def definearguments(self, customparser):
        """ Defines argument for the command

        :param customparser: command line input
        :type customparser: parser.
        """

        customparser.add_option(
            '-a',
            '--available',
            action="store_true",
            dest="available",
            help="Show the available capacity per processor or processor pair."
        )

        customparser.add_option(
            '-j',
            '--json',
            action="store_true",
            dest="json",
            help="Optionally include this flag to change the output to JSON format.",
            default=False
        )