Python gpparseopts.OptParser类代码示例

def parseargs():
    parser = OptParser(option_class=OptChecker)
    parser.remove_option('-h')
    parser.add_option('-h', '-?', '--help',  action='store_true')
    parser.add_option('-f', '--fromthreads', type='int')
    parser.add_option('-t', '--tothreads',   type='int')
    parser.add_option('-d', '--database',    type='string')
    (options, args) = parser.parse_args()
    if options.help:
        print """
Script generates a big CPU workload on the cluster within configured diapason of
thread number to check the elasicity of cluster CPU resources
Usage:
python cpu_stresstest.py -f fromthreads -t tothreads -d database
    -t | --fromthreads - Lower bound of thread number to start
    -t | --tothreads   - Upper bound of thread number to start
    -d | --database    - Database to run the test on
"""
        sys.exit(0)
    if not options.fromthreads:
        raise_err('You must specify the lower bound of thread number with -f parameter')
    if not options.tothreads:
        raise_err('You must specify the upper bound of thread number with -t parameter')
    if not options.database:
        raise_err('You must specify the database name with -d parameter')
    return options

    def createParser():
        parser = OptParser(
            option_class=OptChecker,
            description="Gets status from segments on a single host " "using a transition message.  Internal-use only.",
            version="%prog version $Revision: #1 $",
        )
        parser.setHelp([])

        addStandardLoggingAndHelpOptions(parser, True)

        addTo = parser
        addTo.add_option(
            "-s",
            None,
            type="string",
            dest="statusQueryRequests",
            metavar="<statusQueryRequests>",
            help="Status Query Message",
        )
        addTo.add_option(
            "-D", "--dblist", type="string", action="append", dest="dirList", metavar="<dirList>", help="Directory List"
        )

        parser.set_defaults()
        return parser

    def create_parser():
        parser = OptParser(option_class=OptChecker,
            description="Greenplum Package Manager",
            version='%prog version $Revision: #1 $')
        parser.setHelp([])

        addStandardLoggingAndHelpOptions(parser, includeNonInteractiveOption=True)

        parser.remove_option('-q')
        parser.remove_option('-l')
        
        add_to = OptionGroup(parser, 'General Options')
        parser.add_option_group(add_to)

        addMasterDirectoryOptionForSingleClusterProgram(add_to)

        # TODO: AK: Eventually, these options may need to be flexible enough to accept mutiple packages
        # in one invocation. If so, the structure of this parser may need to change.
        add_to.add_option('-i', '--install', help='install the given gppkg', metavar='<package>')
        add_to.add_option('-u', '--update', help='update the given gppkg', metavar='<package>')
        add_to.add_option('-r', '--remove', help='remove the given gppkg', metavar='<name>-<version>')
        add_to.add_option('-q', '--query', help='query the gppkg database or a particular gppkg', action='store_true')
        add_to.add_option('-b', '--build', help='build a gppkg', metavar='<directory>')
        add_to.add_option('-c', '--clean', help='clean the cluster of the given gppkg', action='store_true')
        add_to.add_option('--migrate', help='migrate gppkgs from a separate $GPHOME', metavar='<from_gphome> <to_gphome>', action='store_true', default=False)

        add_to = OptionGroup(parser, 'Query Options')
        parser.add_option_group(add_to)
        add_to.add_option('--info', action='store_true', help='print information about the gppkg including name, version, description')
        add_to.add_option('--list', action='store_true', help='print all the files present in the gppkg')
        add_to.add_option('--all', action='store_true', help='print all the gppkgs installed by gppkg')

        return parser

    def createParser():

        description = ("Add mirrors to a system")
        help = [""]

        parser = OptParser(option_class=OptChecker,
                           description=' '.join(description.split()),
                           version='%prog version $Revision$')
        parser.setHelp(help)

        addStandardLoggingAndHelpOptions(parser, True)

        addTo = OptionGroup(parser, "Connection Options")
        parser.add_option_group(addTo)
        addMasterDirectoryOptionForSingleClusterProgram(addTo)

        addTo = OptionGroup(parser, "Mirroring Options")
        parser.add_option_group(addTo)
        addTo.add_option("-i", None, type="string",
                         dest="mirrorConfigFile",
                         metavar="<configFile>",
                         help="Mirroring configuration file")

        addTo.add_option("-o", None,
                         dest="outputSampleConfigFile",
                         metavar="<configFile>", type="string",
                         help="Sample configuration file name to output; "
                         "this file can be passed to a subsequent call using -i option")
        
        addTo.add_option("-m", None, type="string",
                         dest="mirrorDataDirConfigFile",
                         metavar="<dataDirConfigFile>",
                         help="Mirroring data directory configuration file")

        addTo.add_option('-s', default=False, action='store_true',
                         dest="spreadMirroring" ,
                         help="use spread mirroring for placing mirrors on hosts")

        addTo.add_option("-p", None, type="int", default=1000,
                         dest="mirrorOffset",
                         metavar="<mirrorOffset>",
                         help="Mirror port offset.  The mirror port offset will be used multiple times "
                         "to derive three sets of ports [default: %default]")

        addTo.add_option("-B", None, type="int", default=16,
                         dest="parallelDegree",
                         metavar="<parallelDegree>",
                         help="Max # of workers to use for building recovery segments.  [default: %default]")

        parser.set_defaults()
        return parser

    def createParser():

        description = ("""
        Clean segment directories.
        """)

        help = ["""
          To be used internally only.
        """]

        parser = OptParser(option_class=OptChecker,
                    description=' '.join(description.split()),
                    version='%prog version $Revision: #1 $')
        parser.setHelp(help)

        addStandardLoggingAndHelpOptions(parser, True)

        addTo = OptionGroup(parser, "Clean Segment Options")
        parser.add_option_group(addTo)
        addTo.add_option('-p', None, dest="pickledArguments",
                         type='string', default=None, metavar="<pickledArguments>",
                       help="The arguments passed from the original script")

        parser.set_defaults()
        return parser

def create_parser():
    parser = OptParser(option_class=OptChecker, 
                       version='%prog version $Revision: #1 $',
                       description='Persistent tables backp and restore')

    addStandardLoggingAndHelpOptions(parser, includeNonInteractiveOption=True)

    addTo = OptionGroup(parser, 'Connection opts')
    parser.add_option_group(addTo)
    addMasterDirectoryOptionForSingleClusterProgram(addTo)

    addTo = OptionGroup(parser, 'Persistent tables backup and restore options')
    addTo.add_option('--backup', metavar="<pickled dbid info>", type="string",
                     help="A list of dbid info where backups need to be done in pickled format")
    addTo.add_option('--restore', metavar="<pickled dbid info>", type="string",
                     help="A list of dbid info where restore needs to be done in pickled format")
    addTo.add_option('--validate-backups', metavar="<pickled dbid info>", type="string",
                     help="A list of dbid info where validation needs to be done in pickled format")
    addTo.add_option('--validate-backup-dir', metavar="<pickled dbid info>", type="string",
                     help="A list of dbid info where validation needs to be done in pickled format")
    addTo.add_option('--timestamp', metavar="<timestamp of backup>", type="string",
                     help="A timestamp for the backup that needs to be validated") 
    addTo.add_option('--batch-size', metavar="<batch size for the worker pool>", type="int",
                      help="Batch size for parallelism in worker pool")
    addTo.add_option('--backup-dir', metavar="<backup directory>", type="string",
                      help="Backup directory for persistent tables and transaction logs")
    addTo.add_option('--perdbpt', metavar="<per database pt filename>", type="string",  
                      help="Filenames for per database persistent files")
    addTo.add_option('--globalpt', metavar="<global pt filenames>", type="string",
                      help="Filenames for global persistent files")
    addTo.add_option('--validate-source-file-only', action='store_true', default=False,
                      help="validate that required source files existed for backup and restore")

    parser.setHelp([
    """
    This tool is used to backup persistent table files.
    """
    ])

    return parser

def parseargs():
    global allocation_rate, memory_split, cpu_split
    parser = OptParser(option_class=OptChecker)
    parser.remove_option('-h')    
    parser.add_option('-h', '-?', '--help', action='store_true')
    parser.add_option('-f', '--force',      action='store_true')
    parser.add_option('-s', '--memsplit',   type='float')
    parser.add_option('-a', '--allocrate',  type='float')
    parser.add_option('-c', '--cpusplit',   type='float')
    (options, args) = parser.parse_args()
    if options.help:
        print """
Script configures memory and CPU allocation for GPText and GPDB. GPDB should be running when
the script is started. The script should work on master server. Local GPDB connection under
gpadmin to template1 database should be passwordless.
Usage:
python gptext_tune_settings.py [-s memory_split] [-a allocation_rate] [-c cpu_split] [-f | --force]
    memory_split    - [0.1 .. 0.9] - split of the memory between GPText and GPDB. Greater value - more memory for GPText
    allocation_rate - [0.1 .. 0.9] - part of the system memory available to GPText and GPDB
    cpu_split       - [0.3 .. 2.0] - part of the CPU dedicated to GPDB. Over utilization is allowed
    force           - do not ask for confirmation of changing the memory settings
"""
        sys.exit(0)        
    if options.allocrate:
        if not (options.allocrate >= 0.1 and options.allocrate <= 0.9):
            logger.error('Correct values for --allocrate are [0.1 .. 0.9]')
            sys.exit(3)
        allocation_rate = options.allocrate
    if options.memsplit:
        if not (options.memsplit >= 0.1 and options.memsplit <= 0.9):
            logger.error('Correct values for --memsplit are [0.1 .. 0.9]')
            sys.exit(3)
        memory_split = options.memsplit
    if options.cpusplit:
        if not (options.cpusplit >= 0.3 and options.cpusplit <= 2.0):
            logger.error('Correct values for --cpusplit are [0.3 .. 2.0]')
            sys.exit(3)
        cpu_split = options.cpusplit
    return options

def parseargs():
    parser = OptParser(option_class=OptChecker)
    parser.remove_option('-h')
    parser.add_option('-h', '-?', '--help', action='store_true')
    parser.add_option('-d', '--dbname',   type='string')
    parser.add_option('-p', '--password', type='string')
    parser.add_option('-n', '--nthreads', type='int')
    (options, args) = parser.parse_args()
    if options.help or (not options.dbname and not options.filename):
        print """Script performs parallel analyze of all tables
Usage:
./parallel_analyze.py -n thread_number -d dbname [-p gpadmin_password]
Parameters:
    thread_number    - number of parallel threads to run
    dbname           - name of the database
    gpadmin_password - password of the gpadmin user"""
        sys.exit(0)
    if not options.dbname:
        logger.error('Failed to start utility. Please, specify database name with "-d" key')
        sys.exit(1)
    if not options.nthreads:
        logger.error('Failed to start utility. Please, specify number of threads with "-n" key')
        sys.exit(1)
    return options

    def create_parser():
        parser = OptParser(
            option_class=OptChecker, description="Greenplum Package Manager", version="%prog version $Revision: #1 $"
        )
        parser.setHelp([])

        addStandardLoggingAndHelpOptions(parser, includeNonInteractiveOption=True)

        parser.remove_option("-q")
        parser.remove_option("-l")

        add_to = OptionGroup(parser, "General Options")
        parser.add_option_group(add_to)

        addMasterDirectoryOptionForSingleClusterProgram(add_to)

        # TODO: AK: Eventually, these options may need to be flexible enough to accept mutiple packages
        # in one invocation. If so, the structure of this parser may need to change.
        add_to.add_option("-i", "--install", help="install the given gppkg", metavar="<package>")
        add_to.add_option("-u", "--update", help="update the given gppkg", metavar="<package>")
        add_to.add_option("-r", "--remove", help="remove the given gppkg", metavar="<name>-<version>")
        add_to.add_option("-q", "--query", help="query the gppkg database or a particular gppkg", action="store_true")
        add_to.add_option("-b", "--build", help="build a gppkg", metavar="<directory>")
        add_to.add_option("-c", "--clean", help="clean the cluster of the given gppkg", action="store_true")
        add_to.add_option(
            "--migrate",
            help="migrate gppkgs from a separate $GPHOME",
            metavar="<from_gphome> <to_gphome>",
            action="store_true",
            default=False,
        )

        add_to = OptionGroup(parser, "Query Options")
        parser.add_option_group(add_to)
        add_to.add_option(
            "--info", action="store_true", help="print information about the gppkg including name, version, description"
        )
        add_to.add_option("--list", action="store_true", help="print all the files present in the gppkg")
        add_to.add_option("--all", action="store_true", help="print all the gppkgs installed by gppkg")

        return parser

    def createParser():
        """
        Constructs and returns an option parser.

        Called by simple_main()
        """
        parser = OptParser(option_class=OptChecker, version="%prog version $Revision: $")
        parser.setHelp(__help__)

        addStandardLoggingAndHelpOptions(parser, False)

        opts = OptionGroup(parser, "Required Options")
        opts.add_option("-d", "--directory", type="string")
        opts.add_option("-i", "--dbid", type="int")
        parser.add_option_group(opts)

        parser.set_defaults()
        return parser

def parseargs():
    parser = OptParser(option_class=OptChecker)
    parser.remove_option('-h')
    parser.add_option('-h', '-?', '--help', action='store_true')
    parser.add_option('-i', '--index',      type='string')
    (options, args) = parser.parse_args()
    if options.help:
        print """
Script is calling Solr commit with the expungeDeletes flag to cause
all the index segments with deletes in them to clean up their segments
from the deleted records
Usage:
python gptext_expunge_deletes.py -i index_name
    -i | --index - Name of the index to expunge
Examples:
    python gptext_expunge_deletes.py -i test.public.test_table
"""
        sys.exit(0)
    if not options.index:
        logger.error('You must specify index name with -i or --index key')
        sys.exit(3)
    return options

    def create_parser():
        """Create the command line parser object for gpkill"""

        help = []
        parser = OptParser(option_class=OptChecker,
                    description='Check or Terminate a Greenplum Database process.',
                    version='%prog version $Revision: #1 $')
        parser.setHelp(help)

        addStandardLoggingAndHelpOptions(parser, True)

        parser.remove_option('-l')
        parser.remove_option('-a')
 
        addTo = OptionGroup(parser, 'Check Options') 
        parser.add_option_group(addTo)
        addTo.add_option('--check', metavar='pid', help='Only returns status 0 if pid may be killed without gpkill, status 1 otherwise.', action='store_true')
        
        return parser

def get_schema_level_restore_list(schema_level_restore_file=None):
    """
    Note: white space in schema and table name is supported now, don't do strip on them
    """
    if not os.path.exists(schema_level_restore_file):
        raise Exception("schema level restore file path %s does not exist" % schema_level_restore_file)
    schema_level_restore_list = []
    with open(schema_level_restore_file) as fr:
        schema_entries = fr.read()
        schema_level_restore_list = schema_entries.splitlines()
    return schema_level_restore_list


if __name__ == "__main__":
    parser = OptParser(option_class=OptChecker)
    parser.remove_option("-h")
    parser.add_option("-h", "-?", "--help", action="store_true")
    parser.add_option("-t", "--tablefile", type="string", default=None)
    parser.add_option("-c", "--change-schema-file", type="string", default=None)
    parser.add_option("-s", "--schema-level-file", type="string", default=None)
    (options, args) = parser.parse_args()
    if not (options.tablefile or options.schema_level_file):
        raise Exception("-t table file name or -s schema level file name must be specified")
    elif options.schema_level_file and options.change_schema_file:
        raise Exception("-s schema level file option can not be specified with -c change schema file option")

    schemas, tables = None, None
    if options.tablefile:
        (schemas, tables) = get_table_schema_set(options.tablefile)

    def createParser():
        description = ("""
        This utility is NOT SUPPORTED and is for internal-use only.

        Used to inject faults into the file replication code.
        """)

        help = ["""

        Return codes:
          0 - Fault injected
          non-zero: Error or invalid options
        """]

        parser = OptParser(option_class=OptChecker,
                    description='  '.join(description.split()),
                    version='%prog version $Revision$')
        parser.setHelp(help)

        addStandardLoggingAndHelpOptions(parser, False)

        # these options are used to determine the target segments
        addTo = OptionGroup(parser, 'Target Segment Options: ')
        parser.add_option_group(addTo)
        addTo.add_option('-r', '--role', dest="targetRole", type='string', metavar="<role>",
                         help="Role of segments to target: primary, mirror, or primary_mirror")
        addTo.add_option("-s", "--seg_dbid", dest="targetDbId", type="string", metavar="<dbid>",
                         help="The segment  dbid on which fault should be set and triggered.")
        addTo.add_option("-H", "--host", dest="targetHost", type="string", metavar="<host>",
                         help="The hostname on which fault should be set and triggered; pass ALL to target all hosts")

        addTo = OptionGroup(parser, 'Master Connection Options')
        parser.add_option_group(addTo)

        addMasterDirectoryOptionForSingleClusterProgram(addTo)
        addTo.add_option("-p", "--master_port", dest="masterPort",  type="int", default=None,
                         metavar="<masterPort>",
                         help="DEPRECATED, use MASTER_DATA_DIRECTORY environment variable or -d option.  " \
                         "The port number of the master database on localhost, " \
                         "used to fetch the segment configuration.")

        addTo = OptionGroup(parser, 'Client Polling Options: ')
        parser.add_option_group(addTo)
        addTo.add_option('-m', '--mode', dest="syncMode", type='string', default="async",
                         metavar="<syncMode>",
                         help="Synchronization mode : sync (client waits for fault to occur)" \
                         " or async (client only sets fault request on server)")

        # these options are used to build the message for the segments
        addTo = OptionGroup(parser, 'Fault Options: ')
        parser.add_option_group(addTo)
        # NB: This list needs to be kept in sync with:
        # - FaultInjectorTypeEnumToString
        # - FaultInjectorType_e
        addTo.add_option('-y','--type', dest="type", type='string', metavar="<type>",
                         help="fault type: sleep (insert sleep), fault (report fault to postmaster and fts prober), " \
			      "fatal (inject FATAL error), panic (inject PANIC error), error (inject ERROR), " \
			      "infinite_loop, data_curruption (corrupt data in memory and persistent media), " \
			      "suspend (suspend execution), resume (resume execution that was suspended), " \
			      "skip (inject skip i.e. skip checkpoint), " \
			      "memory_full (all memory is consumed when injected), " \
			      "reset (remove fault injection), status (report fault injection status), " \
			      "segv (inject a SEGV), " \
			      "interrupt (inject an Interrupt), " \
			      "finish_pending (set QueryFinishPending to true), " \
			      "checkpoint_and_panic (inject a panic following checkpoint) ")
        addTo.add_option("-z", "--sleep_time_s", dest="sleepTimeSeconds", type="int", default="10" ,
                            metavar="<sleepTime>",
                            help="For 'sleep' faults, the amount of time for the sleep.  Defaults to %default." \
				 "Min Max Range is [0, 7200 sec] ")
        addTo.add_option('-f','--fault_name', dest="faultName", type='string', metavar="<name>",
                         help="fault name: " \
			      "postmaster (inject fault when new connection is accepted in postmaster), " \
			      "pg_control (inject fault when global/pg_control file is written), " \
			      "pg_xlog (inject fault when files in pg_xlog directory are written), " \
			      "start_prepare (inject fault during start prepare transaction), " \
			      "filerep_consumer (inject fault before data are processed, i.e. if mirror " \
			      "then before file operation is issued to file system, if primary " \
			      "then before mirror file operation is acknowledged to backend processes), " \
			      "filerep_consumer_verificaton (inject fault before ack verification data are processed on primary), " \
			      "filerep_change_tracking_compacting (inject fault when compacting change tracking log files), " \
			      "filerep_sender (inject fault before data are sent to network), " \
			      "filerep_receiver (inject fault after data are received from network), " \
			      "filerep_flush (inject fault before fsync is issued to file system), " \
			      "filerep_resync (inject fault while in resync when first relation is ready to be resynchronized), " \
			      "filerep_resync_in_progress (inject fault while resync is in progress), " \
			      "filerep_resync_worker (inject fault after write to mirror), " \
			      "filerep_resync_worker_read (inject fault before read required for resync), " \
			      "filerep_transition_to_resync (inject fault during transition to InResync before mirror re-create), " \
			      "filerep_transition_to_resync_mark_recreate (inject fault during transition to InResync before marking re-created), " \
			      "filerep_transition_to_resync_mark_completed (inject fault during transition to InResync before marking completed), " \
			      "filerep_transition_to_sync_begin (inject fault before transition to InSync begin), " \
			      "filerep_transition_to_sync (inject fault during transition to InSync), " \
			      "filerep_transition_to_sync_before_checkpoint (inject fault during transition to InSync before checkpoint is created), " \
			      "filerep_transition_to_sync_mark_completed (inject fault during transition to InSync before marking completed), " \
			      "filerep_transition_to_change_tracking (inject fault during transition to InChangeTracking), " \
                              "fileRep_is_operation_completed (inject fault in FileRep Is Operation completed function just for ResyncWorker Threads), "\
                              "filerep_immediate_shutdown_request (inject fault just before sending the shutdown SIGQUIT to child processes), "\
			      "checkpoint (inject fault before checkpoint is taken), " \
			      "change_tracking_compacting_report (report if compacting is in progress), " \
#.........这里部分代码省略.........

def parseargs():
    parser = OptParser(option_class=OptChecker)
    parser.remove_option("-h")
    parser.add_option("-h", "-?", "--help", action="store_true")
    parser.add_option("-d", "--dbname", type="string")
    parser.add_option("-p", "--password", type="string")
    parser.add_option("-n", "--nthreads", type="int")
    (options, args) = parser.parse_args()
    if options.help or (not options.dbname and not options.filename):
        print """Script performs serial restore of the backup files in case
of the cluster topology change.
Usage:
./parallel_analyze.py -n thread_number -d dbname [-p gpadmin_password]
Parameters:
    thread_number    - number of parallel threads to run
    dbname           - name of the database
    gpadmin_password - password of the gpadmin user"""
        sys.exit(0)
    if not options.dbname:
        logger.error('Failed to start utility. Please, specify database name with "-d" key')
        sys.exit(1)
    if not options.nthreads:
        logger.error('Failed to start utility. Please, specify number of threads with "-n" key')
        sys.exit(1)
    return options