def get_parser(self, prog_name):
     parser = super(CreateDatabaseUser, self).get_parser(prog_name)
     parser.add_argument(
         'instance',
         metavar='<instance>',
         help=_('ID or name of the instance.')
     )
     parser.add_argument(
         'name',
         metavar='<name>',
         help=_('Name of user.')
     )
     parser.add_argument(
         'password',
         metavar='<password>',
         help=_('Password of user.')
     )
     parser.add_argument(
         '--host',
         metavar='<host>',
         help=_('Optional host of user.')
     )
     parser.add_argument(
         '--databases',
         metavar='<databases>',
         nargs='+',
         default=[],
         help=_('Optional list of databases.')
     )
     return parser

 def get_parser(self, prog_name):
     parser = super(ListDatabaseInstances, self).get_parser(prog_name)
     parser.add_argument(
         '--limit',
         dest='limit',
         metavar='<limit>',
         default=None,
         help=_('Limit the number of results displayed.')
     )
     parser.add_argument(
         '--marker',
         dest='marker',
         metavar='<ID>',
         type=str,
         default=None,
         help=_('Begin displaying the results for IDs greater than the'
                'specified marker. When used with :option:`--limit,` set'
                'this to the last ID displayed in the previous run.')
     )
     parser.add_argument(
         '--include_clustered', '--include-clustered',
         dest='include_clustered',
         action="store_true",
         default=False,
         help=_("Include instances that are part of a cluster "
                "(default %(default)s).  --include-clustered may be "
                "deprecated in the future, retaining just "
                "--include_clustered.")
     )
     return parser

 def get_parser(self, prog_name):
     parser = super(CreateDatabaseBackup, self).get_parser(prog_name)
     parser.add_argument(
         'instance',
         metavar='<instance>',
         help=_('ID or name of the instance.')
     )
     parser.add_argument(
         'name',
         metavar='<name>',
         help=_('Name of the backup.')
     )
     parser.add_argument(
         '--description',
         metavar='<description>',
         default=None,
         help=_('An optional description for the backup.')
     )
     parser.add_argument(
         '--parent',
         metavar='<parent>',
         default=None,
         help=_('Optional ID of the parent backup to perform an'
                ' incremental backup from.')
     )
     parser.add_argument(
         '--incremental',
         action='store_true',
         default=False,
         help=_('Create an incremental backup based on the last'
                ' full or incremental backup. It will create a'
                ' full backup if no existing backup found.')
     )
     return parser

 def get_parser(self, prog_name):
     parser = super(UpgradeDatabaseCluster, self).get_parser(prog_name)
     parser.add_argument(
         'cluster',
         metavar='<cluster>',
         help=_('ID or name of the cluster.'),
     )
     parser.add_argument(
         'datastore_version',
         metavar='<datastore_version>',
         help=_('A datastore version name or ID.'),
     )
     return parser

 def get_parser(self, prog_name):
     parser = super(DeleteDatabase, self).get_parser(prog_name)
     parser.add_argument(
         dest='instance',
         metavar='<instance>',
         help=_('ID or name of the instance.')
     )
     parser.add_argument(
         dest='database',
         metavar='<database>',
         help=_('Name of the database.')
     )
     return parser

    def get_parser(self, prog_name):
        parser = super(EnableDatabaseRoot, self).get_parser(prog_name)
        parser.add_argument(
            'instance_or_cluster',
            metavar='<instance_or_cluster>',
            help=_('ID or name of the instance or cluster.'),
        )
        parser.add_argument(
            '--root_password',
            metavar='<root_password>',
            default=None,
            help=_('Root password to set.'))

        return parser

 def get_parser(self, prog_name):
     parser = super(ListDatabaseFlavors, self).get_parser(prog_name)
     parser.add_argument(
         '--datastore-type',
         dest='datastore_type',
         metavar='<datastore-type>',
         help=_('Type of the datastore. For eg: mysql.')
     )
     parser.add_argument(
         '--datastore-version-id',
         dest='datastore_version_id',
         metavar='<datastore-version-id>',
         help=_('ID of the datastore version.')
     )
     return parser

 def get_parser(self, prog_name):
     parser = super(ShowDatastoreVersion, self).get_parser(prog_name)
     parser.add_argument(
         'datastore_version',
         metavar='<datastore_version>',
         help=_('ID or name of the datastore version.'),
     )
     parser.add_argument(
         '--datastore',
         metavar='<datastore>',
         default=None,
         help=_('ID or name of the datastore. Optional if the ID of'
                'the datastore_version is provided.'),
     )
     return parser

def main():
    try:
        if sys.version_info >= (3, 0):
            OpenStackTroveShell().main(sys.argv[1:])
        else:
            OpenStackTroveShell().main(map(encodeutils.safe_decode,
                                           sys.argv[1:]))
    except KeyboardInterrupt:
        print(_("... terminating trove client"), file=sys.stderr)
        sys.exit(130)
    except Exception as e:
        logger.debug(e, exc_info=1)
        message = six.text_type(e)
        if not isinstance(message, six.string_types):
            message = str(message)
        print(_("ERROR: %s") % encodeutils.safe_encode(message),
              file=sys.stderr)
        sys.exit(1)