def get_parser(self, prog_name):
parser = super(CreateAddressScope, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar="<name>",
help=_("New address scope name")
)
parser.add_argument(
'--ip-version',
type=int,
default=4,
choices=[4, 6],
help=_("IP version (default is 4)")
)
parser.add_argument(
'--project',
metavar="<project>",
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
share_group = parser.add_mutually_exclusive_group()
share_group.add_argument(
'--share',
action='store_true',
help=_('Share the address scope between projects')
)
share_group.add_argument(
'--no-share',
action='store_true',
help=_('Do not share the address scope between projects (default)')
)
return parser
def get_parser(self, prog_name):
parser = super(ListPort, self).get_parser(prog_name)
parser.add_argument(
'--device-owner',
metavar='<device-owner>',
help=_("List only ports with the specified device owner. "
"This is the entity that uses the port (for example, "
"network:dhcp).")
)
parser.add_argument(
'--network',
metavar='<network>',
help=_("List only ports connected to this network (name or ID)"))
device_group = parser.add_mutually_exclusive_group()
device_group.add_argument(
'--router',
metavar='<router>',
dest='router',
help=_("List only ports attached to this router (name or ID)")
)
device_group.add_argument(
'--server',
metavar='<server>',
help=_("List only ports attached to this server (name or ID)"),
)
device_group.add_argument(
'--device-id',
metavar='<device-id>',
help=_("List only ports with the specified device ID")
)
parser.add_argument(
'--mac-address',
metavar='<mac-address>',
help=_("List only ports with this MAC address")
)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_("List additional fields in output")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("List ports according to their project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--fixed-ip',
metavar=('subnet=<subnet>,ip-address=<ip-address>,'
'ip-substring=<ip-substring>'),
action=parseractions.MultiKeyValueAction,
optional_keys=['subnet', 'ip-address', 'ip-substring'],
help=_("Desired IP and/or subnet for filtering ports "
"(name or ID): subnet=<subnet>,ip-address=<ip-address>,"
"ip-substring=<ip-substring> "
"(repeat option to set multiple fixed IP addresses)"),
)
_tag.add_tag_filtering_option_to_parser(parser, _('ports'))
return parser
def get_parser(self, prog_name):
parser = super(CreateNetworkQosPolicy, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_("Name of QoS policy to create")
)
parser.add_argument(
'--description',
metavar='<description>',
help=_("Description of the QoS policy")
)
share_group = parser.add_mutually_exclusive_group()
share_group.add_argument(
'--share',
action='store_true',
default=None,
help=_("Make the QoS policy accessible by other projects")
)
share_group.add_argument(
'--no-share',
action='store_true',
help=_("Make the QoS policy not accessible by other projects "
"(default)")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListEndpoint, self).get_parser(prog_name)
parser.add_argument(
'--service',
metavar='<service>',
help=_('Filter by service (type, name or ID)'),
)
parser.add_argument(
'--interface',
metavar='<interface>',
choices=['admin', 'public', 'internal'],
help=_('Filter by interface type (admin, public or internal)'),
)
parser.add_argument(
'--region',
metavar='<region-id>',
help=_('Filter by region ID'),
)
list_group = parser.add_mutually_exclusive_group()
list_group.add_argument(
'--endpoint',
metavar='<endpoint-group>',
help=_('Endpoint to list filters'),
)
list_group.add_argument(
'--project',
metavar='<project>',
help=_('Project to list filters (name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(SetVolumeType, self).get_parser(prog_name)
parser.add_argument(
'volume_type',
metavar='<volume-type>',
help='Volume type to modify (name or ID)',
)
parser.add_argument(
'--name',
metavar='<name>',
help='Set volume type name',
)
parser.add_argument(
'--description',
metavar='<name>',
help='Set volume type description',
)
parser.add_argument(
'--property',
metavar='<key=value>',
action=parseractions.KeyValueAction,
help='Set a property on this volume type '
'(repeat option to set multiple properties)',
)
parser.add_argument(
'--project',
metavar='<project>',
help='Set volume type access to project (name or ID) (admin only)',
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateRouter, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help="New router name",
)
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
dest='admin_state_up',
action='store_true',
default=True,
help="Enable router (default)",
)
admin_group.add_argument(
'--disable',
dest='admin_state_up',
action='store_false',
help="Disable router",
)
parser.add_argument(
'--distributed',
dest='distributed',
action='store_true',
default=False,
help="Create a distributed router",
)
parser.add_argument(
'--project',
metavar='<poroject>',
help="Owner's project (name or ID)",
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def update_parser_network(self, parser):
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
dest='admin_state',
action='store_true',
default=True,
help='Enable network (default)',
)
admin_group.add_argument(
'--disable',
dest='admin_state',
action='store_false',
help='Disable network',
)
parser.add_argument(
'--project',
metavar='<project>',
help="Owner's project (name or ID)"
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--availability-zone-hint',
action='append',
dest='availability_zone_hints',
metavar='<availability-zone>',
help='Availability Zone in which to create this network '
'(requires the Network Availability Zone extension, '
'this option can be repeated).',
)
return parser
def update_parser_network(self, parser):
direction_group = parser.add_mutually_exclusive_group()
direction_group.add_argument(
'--ingress',
action='store_true',
help='Rule applies to incoming network traffic (default)',
)
direction_group.add_argument(
'--egress',
action='store_true',
help='Rule applies to outgoing network traffic',
)
parser.add_argument(
'--ethertype',
metavar='<ethertype>',
choices=['IPv4', 'IPv6'],
help='Ethertype of network traffic '
'(IPv4, IPv6; default: IPv4)',
)
parser.add_argument(
'--project',
metavar='<project>',
help="Owner's project (name or ID)"
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateSubnetPool, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_("Name of the new subnet pool")
)
_add_prefix_options(parser, for_create=True)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--address-scope',
metavar='<address-scope>',
help=_("Set address scope associated with the subnet pool "
"(name or ID), prefixes must be unique across address "
"scopes")
)
_add_default_options(parser)
shared_group = parser.add_mutually_exclusive_group()
shared_group.add_argument(
'--share',
action='store_true',
help=_("Set this subnet pool as shared"),
)
shared_group.add_argument(
'--no-share',
action='store_true',
help=_("Set this subnet pool as not shared"),
)
return parser
def get_parser(self, prog_name):
parser = super(CreateMeter, self).get_parser(prog_name)
parser.add_argument(
'--description',
metavar='<description>',
help=_("Create description for meter")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
share_group = parser.add_mutually_exclusive_group()
share_group.add_argument(
'--share',
action='store_true',
default=None,
help=_("Share meter between projects")
)
share_group.add_argument(
'--no-share',
action='store_true',
help=_("Do not share meter between projects")
)
parser.add_argument(
'name',
metavar='<name>',
help=_('Name of meter'),
)
return parser
def get_parser(self, prog_name):
parser = super(ProjectPurge, self).get_parser(prog_name)
parser.add_argument(
'--dry-run',
action='store_true',
help=_("List a project's resources"),
)
parser.add_argument(
'--keep-project',
action='store_true',
help=_("Clean project resources, but don't delete the project"),
)
project_group = parser.add_mutually_exclusive_group(required=True)
project_group.add_argument(
'--auth-project',
action='store_true',
help=_('Delete resources of the project used to authenticate'),
)
project_group.add_argument(
'--project',
metavar='<project>',
help=_('Project to clean (name or ID)'),
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListRouter, self).get_parser(prog_name)
parser.add_argument(
'--name',
metavar='<name>',
help=_("List routers according to their name")
)
admin_state_group = parser.add_mutually_exclusive_group()
admin_state_group.add_argument(
'--enable',
action='store_true',
help=_("List enabled routers")
)
admin_state_group.add_argument(
'--disable',
action='store_true',
help=_("List disabled routers")
)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_("List additional fields in output")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("List routers according to their project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def _add_identity_and_resource_options_to_parser(parser):
domain_or_project = parser.add_mutually_exclusive_group()
domain_or_project.add_argument(
'--domain',
metavar='<domain>',
help='Include <domain> (name or ID)',
)
domain_or_project.add_argument(
'--project',
metavar='<project>',
help='Include `<project>` (name or ID)',
)
user_or_group = parser.add_mutually_exclusive_group()
user_or_group.add_argument(
'--user',
metavar='<user>',
help='Include <user> (name or ID)',
)
user_or_group.add_argument(
'--group',
metavar='<group>',
help='Include <group> (name or ID)',
)
common.add_group_domain_option_to_parser(parser)
common.add_project_domain_option_to_parser(parser)
common.add_user_domain_option_to_parser(parser)
common.add_inherited_option_to_parser(parser)
def get_parser(self, prog_name):
parser = super(ListRoleAssignment, self).get_parser(prog_name)
parser.add_argument(
'--effective',
action="store_true",
default=False,
help=_('Returns only effective role assignments'),
)
parser.add_argument(
'--role',
metavar='<role>',
help=_('Role to filter (name or ID)'),
)
common.add_role_domain_option_to_parser(parser)
parser.add_argument(
'--names',
action="store_true",
help=_('Display names instead of IDs'),
)
user_or_group = parser.add_mutually_exclusive_group()
user_or_group.add_argument(
'--user',
metavar='<user>',
help=_('User to filter (name or ID)'),
)
common.add_user_domain_option_to_parser(parser)
user_or_group.add_argument(
'--group',
metavar='<group>',
help=_('Group to filter (name or ID)'),
)
common.add_group_domain_option_to_parser(parser)
domain_or_project = parser.add_mutually_exclusive_group()
domain_or_project.add_argument(
'--domain',
metavar='<domain>',
help=_('Domain to filter (name or ID)'),
)
domain_or_project.add_argument(
'--project',
metavar='<project>',
help=_('Project to filter (name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
common.add_inherited_option_to_parser(parser)
parser.add_argument(
'--auth-user',
action="store_true",
dest='authuser',
help='Only list assignments for the authenticated user',
)
parser.add_argument(
'--auth-project',
action="store_true",
dest='authproject',
help='Only list assignments for the project to which the '
'authenticated user\'s token is scoped',
)
return parser
def update_parser_network(self, parser):
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreatePort, self).get_parser(prog_name)
parser.add_argument(
'--network',
metavar='<network>',
required=True,
help=_("Network this port belongs to (name or ID)")
)
_add_updatable_args(parser)
parser.add_argument(
'--fixed-ip',
metavar='subnet=<subnet>,ip-address=<ip-address>',
action=parseractions.MultiKeyValueAction,
optional_keys=['subnet', 'ip-address'],
help=_("Desired IP and/or subnet (name or ID) for this port: "
"subnet=<subnet>,ip-address=<ip-address> "
"(repeat option to set multiple fixed IP addresses)")
)
parser.add_argument(
'--binding-profile',
metavar='<binding-profile>',
action=JSONKeyValueAction,
help=_("Custom data to be passed as binding:profile. Data may "
"be passed as <key>=<value> or JSON. "
"(repeat option to set multiple binding:profile data)")
)
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
action='store_true',
default=True,
help=_("Enable port (default)")
)
admin_group.add_argument(
'--disable',
action='store_true',
help=_("Disable port")
)
parser.add_argument(
'--mac-address',
metavar='<mac-address>',
help=_("MAC address of this port")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'name',
metavar='<name>',
help=_("Name of this port")
)
# TODO(singhj): Add support for extended options:
# qos,security groups,dhcp, address pairs
return parser
def get_parser(self, prog_name):
parser = super(SetUser, self).get_parser(prog_name)
parser.add_argument(
'user',
metavar='<user>',
help=_('User to modify (name or ID)'),
)
parser.add_argument(
'--name',
metavar='<name>',
help=_('Set user name'),
)
parser.add_argument(
'--domain',
metavar='<domain>',
help=_('Domain the user belongs to (name or ID). This can be '
'used in case collisions between user names exist.'),
)
parser.add_argument(
'--project',
metavar='<project>',
help=_('Set default project (name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--password',
metavar='<password>',
help=_('Set user password'),
)
parser.add_argument(
'--password-prompt',
dest="password_prompt",
action="store_true",
help=_('Prompt interactively for password'),
)
parser.add_argument(
'--email',
metavar='<email-address>',
help=_('Set user email address'),
)
parser.add_argument(
'--description',
metavar='<description>',
help=_('Set user description'),
)
enable_group = parser.add_mutually_exclusive_group()
enable_group.add_argument(
'--enable',
action='store_true',
help=_('Enable user (default)'),
)
enable_group.add_argument(
'--disable',
action='store_true',
help=_('Disable user'),
)
return parser
def update_parser_network(self, parser):
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
_tag.add_tag_option_to_parser_for_create(parser, _('security group'))
return parser
def get_parser(self, prog_name):
parser = super(ListImageProjects, self).get_parser(prog_name)
parser.add_argument(
"image",
metavar="<image>",
help=_("Image (name or ID)"),
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateUser, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_('New user name'),
)
parser.add_argument(
'--domain',
metavar='<domain>',
help=_('Default domain (name or ID)'),
)
parser.add_argument(
'--project',
metavar='<project>',
help=_('Default project (name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--password',
metavar='<password>',
help=_('Set user password'),
)
parser.add_argument(
'--password-prompt',
dest="password_prompt",
action="store_true",
help=_('Prompt interactively for password'),
)
parser.add_argument(
'--email',
metavar='<email-address>',
help=_('Set user email address'),
)
parser.add_argument(
'--description',
metavar='<description>',
help=_('User description'),
)
enable_group = parser.add_mutually_exclusive_group()
enable_group.add_argument(
'--enable',
action='store_true',
help=_('Enable user (default)'),
)
enable_group.add_argument(
'--disable',
action='store_true',
help=_('Disable user'),
)
parser.add_argument(
'--or-show',
action='store_true',
help=_('Return existing user'),
)
return parser
def update_parser_network(self, parser):
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
action='store_true',
default=True,
help=_("Enable network (default)")
)
admin_group.add_argument(
'--disable',
action='store_true',
help=_("Disable network")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--availability-zone-hint',
action='append',
dest='availability_zone_hints',
metavar='<availability-zone>',
help=_("Availability Zone in which to create this network "
"(Network Availability Zone extension required, "
"repeat option to set multiple availability zones)")
)
external_router_grp = parser.add_mutually_exclusive_group()
external_router_grp.add_argument(
'--external',
action='store_true',
help=_("Set this network as an external network "
"(external-net extension required)")
)
external_router_grp.add_argument(
'--internal',
action='store_true',
help=_("Set this network as an internal network (default)")
)
default_router_grp = parser.add_mutually_exclusive_group()
default_router_grp.add_argument(
'--default',
action='store_true',
help=_("Specify if this network should be used as "
"the default external network")
)
default_router_grp.add_argument(
'--no-default',
action='store_true',
help=_("Do not use the network as the default external network "
"(default)")
)
_add_additional_network_options(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListServer, self).get_parser(prog_name)
parser.add_argument(
"--reservation-id", metavar="<reservation-id>", help=_("Only return instances that match the reservation")
)
parser.add_argument("--ip", metavar="<ip-address-regex>", help=_("Regular expression to match IP addresses"))
parser.add_argument("--ip6", metavar="<ip-address-regex>", help=_("Regular expression to match IPv6 addresses"))
parser.add_argument("--name", metavar="<name-regex>", help=_("Regular expression to match names"))
parser.add_argument(
"--instance-name", metavar="<server-name>", help=_("Regular expression to match instance name (admin only)")
)
parser.add_argument(
"--status",
metavar="<status>",
# FIXME(dhellmann): Add choices?
help=_("Search by server status"),
)
parser.add_argument("--flavor", metavar="<flavor>", help=_("Search by flavor (name or ID)"))
parser.add_argument("--image", metavar="<image>", help=_("Search by image (name or ID)"))
parser.add_argument("--host", metavar="<hostname>", help=_("Search by hostname"))
parser.add_argument(
"--all-projects",
action="store_true",
default=bool(int(os.environ.get("ALL_PROJECTS", 0))),
help=_("Include all projects (admin only)"),
)
parser.add_argument("--project", metavar="<project>", help="Search by project (admin only) (name or ID)")
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument("--user", metavar="<user>", help=_("Search by user (admin only) (name or ID)"))
identity_common.add_user_domain_option_to_parser(parser)
parser.add_argument("--long", action="store_true", default=False, help=_("List additional fields in output"))
parser.add_argument(
"--marker",
metavar="<marker>",
default=None,
help=(
"The last server (name or ID) of the previous page. Display"
" list of servers after marker. Display all servers if not"
" specified."
),
)
parser.add_argument(
"--limit",
metavar="<limit>",
type=int,
default=None,
help=(
"Maximum number of servers to display. If limit equals -1,"
" all servers will be displayed. If limit is greater than"
" 'osapi_max_limit' option of Nova API,"
" 'osapi_max_limit' will be used instead."
),
)
return parser
def get_parser(self, prog_name):
parser = super(ListVolumeSnapshot, self).get_parser(prog_name)
parser.add_argument(
'--all-projects',
action='store_true',
default=False,
help=_('Include all projects (admin only)'),
)
parser.add_argument(
'--project',
metavar='<project>',
help=_('Filter results by project (name or ID) (admin only)')
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_('List additional fields in output'),
)
parser.add_argument(
'--marker',
metavar='<volume-snapshot>',
help=_('The last snapshot ID of the previous page'),
)
parser.add_argument(
'--limit',
type=int,
action=parseractions.NonNegativeAction,
metavar='<num-snapshots>',
help=_('Maximum number of snapshots to display'),
)
parser.add_argument(
'--name',
metavar='<name>',
default=None,
help=_('Filters results by a name.')
)
parser.add_argument(
'--status',
metavar='<status>',
choices=['available', 'error', 'creating', 'deleting',
'error-deleting'],
help=_("Filters results by a status. "
"('available', 'error', 'creating', 'deleting'"
" or 'error-deleting')")
)
parser.add_argument(
'--volume',
metavar='<volume>',
default=None,
help=_('Filters results by a volume (name or ID).')
)
return parser
def _add_identity_and_resource_options_to_parser(parser):
domain_or_project = parser.add_mutually_exclusive_group()
domain_or_project.add_argument("--domain", metavar="<domain>", help="Include <domain> (name or ID)")
domain_or_project.add_argument("--project", metavar="<project>", help="Include <project> (name or ID)")
user_or_group = parser.add_mutually_exclusive_group()
user_or_group.add_argument("--user", metavar="<user>", help="Include <user> (name or ID)")
user_or_group.add_argument("--group", metavar="<group>", help="Include <group> (name or ID)")
common.add_group_domain_option_to_parser(parser)
common.add_project_domain_option_to_parser(parser)
common.add_user_domain_option_to_parser(parser)
common.add_inherited_option_to_parser(parser)
def get_parser(self, prog_name):
parser = super(CreateTrust, self).get_parser(prog_name)
parser.add_argument(
'trustor',
metavar='<trustor-user>',
help='User that is delegating authorization (name or ID)',
)
parser.add_argument(
'trustee',
metavar='<trustee-user>',
help='User that is assuming authorization (name or ID)',
)
parser.add_argument(
'--project',
metavar='<project>',
required=True,
help='Project being delegated (name or ID) (required)',
)
parser.add_argument(
'--role',
metavar='<role>',
action='append',
default=[],
help='Roles to authorize (name or ID) '
'(repeat to set multiple values) (required)',
required=True
)
parser.add_argument(
'--impersonate',
dest='impersonate',
action='store_true',
default=False,
help='Tokens generated from the trust will represent <trustor>'
' (defaults to False)',
)
parser.add_argument(
'--expiration',
metavar='<expiration>',
help='Sets an expiration date for the trust'
' (format of YYYY-mm-ddTHH:MM:SS)',
)
common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--trustor-domain',
metavar='<trustor-domain>',
help='Domain that contains <trustor> (name or ID)',
)
parser.add_argument(
'--trustee-domain',
metavar='<trustee-domain>',
help='Domain that contains <trustee> (name or ID)',
)
return parser
def get_parser(self, prog_name):
parser = super(CreateRouter, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_("New router name")
)
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
action='store_true',
default=True,
help=_("Enable router (default)")
)
admin_group.add_argument(
'--disable',
action='store_true',
help=_("Disable router")
)
parser.add_argument(
'--distributed',
dest='distributed',
action='store_true',
default=False,
help=_("Create a distributed router")
)
parser.add_argument(
'--ha',
action='store_true',
help=_("Create a highly available router")
)
parser.add_argument(
'--description',
metavar='<description>',
help=_("Set router description")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--availability-zone-hint',
metavar='<availability-zone>',
action='append',
dest='availability_zone_hints',
help=_("Availability Zone in which to create this router "
"(Router Availability Zone extension required, "
"repeat option to set multiple availability zones)")
)
return parser
def get_parser(self, prog_name):
parser = super(CreateNetwork, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help='New network name',
)
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
dest='admin_state',
action='store_true',
default=True,
help='Enable network (default)',
)
admin_group.add_argument(
'--disable',
dest='admin_state',
action='store_false',
help='Disable network',
)
share_group = parser.add_mutually_exclusive_group()
share_group.add_argument(
'--share',
dest='shared',
action='store_true',
default=None,
help='Share the network between projects',
)
share_group.add_argument(
'--no-share',
dest='shared',
action='store_false',
help='Do not share the network between projects',
)
parser.add_argument(
'--project',
metavar='<project>',
help="Owner's project (name or ID)"
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--availability-zone-hint',
action='append',
dest='availability_zone_hints',
metavar='<availability-zone>',
help='Availability Zone in which to create this network '
'(requires the Network Availability Zone extension, '
'this option can be repeated).',
)
return parser
def get_parser(self, prog_name):
parser = super(SetUser, self).get_parser(prog_name)
parser.add_argument(
'user',
metavar='<user>',
help='User to change (name or ID)',
)
parser.add_argument(
'--name',
metavar='<name>',
help='Set user name',
)
parser.add_argument(
'--project',
metavar='<project>',
help='Set default project (name or ID)',
)
common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--password',
metavar='<password>',
help='Set user password',
)
parser.add_argument(
'--password-prompt',
dest="password_prompt",
action="store_true",
help='Prompt interactively for password',
)
parser.add_argument(
'--email',
metavar='<email-address>',
help='Set user email address',
)
parser.add_argument(
'--description',
metavar='<description>',
help='Set user description',
)
enable_group = parser.add_mutually_exclusive_group()
enable_group.add_argument(
'--enable',
action='store_true',
help='Enable user (default)',
)
enable_group.add_argument(
'--disable',
action='store_true',
help='Disable user',
)
return parser
def get_parser(self, prog_name):
parser = super(ListPort, self).get_parser(prog_name)
parser.add_argument(
'--device-owner',
metavar='<device-owner>',
help=_("List only ports with the specified device owner. "
"This is the entity that uses the port (for example, "
"network:dhcp)."))
parser.add_argument(
'--network',
metavar='<network>',
help=_("List only ports connected to this network (name or ID)"))
device_group = parser.add_mutually_exclusive_group()
device_group.add_argument(
'--router',
metavar='<router>',
dest='router',
help=_("List only ports attached to this router (name or ID)"))
device_group.add_argument(
'--server',
metavar='<server>',
help=_("List only ports attached to this server (name or ID)"),
)
device_group.add_argument(
'--device-id',
metavar='<device-id>',
help=_("List only ports with the specified device ID"))
parser.add_argument('--mac-address',
metavar='<mac-address>',
help=_("List only ports with this MAC address"))
parser.add_argument('--long',
action='store_true',
default=False,
help=_("List additional fields in output"))
parser.add_argument(
'--project',
metavar='<project>',
help=_("List ports according to their project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--fixed-ip',
metavar='subnet=<subnet>,ip-address=<ip-address>',
action=parseractions.MultiKeyValueAction,
optional_keys=['subnet', 'ip-address'],
help=_("Desired IP and/or subnet for filtering ports "
"(name or ID): subnet=<subnet>,ip-address=<ip-address> "
"(repeat option to set multiple fixed IP addresses)"),
)
_tag.add_tag_filtering_option_to_parser(parser, _('ports'))
return parser
def get_parser(self, prog_name):
parser = super(RemoveProjectImage, self).get_parser(prog_name)
parser.add_argument(
"image",
metavar="<image>",
help=_("Image to unshare (name or ID)"),
)
parser.add_argument(
"project",
metavar="<project>",
help=_("Project to disassociate with image (name or ID)"),
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListSubnetPool, self).get_parser(prog_name)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_("List additional fields in output")
)
shared_group = parser.add_mutually_exclusive_group()
shared_group.add_argument(
'--share',
action='store_true',
help=_("List subnet pools shared between projects"),
)
shared_group.add_argument(
'--no-share',
action='store_true',
help=_("List subnet pools not shared between projects"),
)
default_group = parser.add_mutually_exclusive_group()
default_group.add_argument(
'--default',
action='store_true',
help=_("List subnet pools used as the default external "
"subnet pool"),
)
default_group.add_argument(
'--no-default',
action='store_true',
help=_("List subnet pools not used as the default external "
"subnet pool")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("List subnet pools according to their project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--name',
metavar='<name>',
help=_("List only subnet pools of given name in output")
)
parser.add_argument(
'--address-scope',
metavar='<address-scope>',
help=_("List only subnet pools of given address scope "
"(name or ID) in output")
)
return parser
def get_parser(self, prog_name):
parser = super(AddProjectToImage, self).get_parser(prog_name)
parser.add_argument(
"image",
metavar="<image>",
help="Image to share (name or ID)",
)
parser.add_argument(
"project",
metavar="<project>",
help="Project to associate with image (name or ID)",
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListVolumeSnapshot, self).get_parser(prog_name)
parser.add_argument(
'--all-projects',
action='store_true',
default=False,
help=_('Include all projects (admin only)'),
)
parser.add_argument(
'--project',
metavar='<project>',
help=_('Filter results by project (name or ID) (admin only)'))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_('List additional fields in output'),
)
parser.add_argument(
'--marker',
metavar='<volume-snapshot>',
help=_('The last snapshot ID of the previous page'),
)
parser.add_argument(
'--limit',
type=int,
action=parseractions.NonNegativeAction,
metavar='<num-snapshots>',
help=_('Maximum number of snapshots to display'),
)
parser.add_argument('--name',
metavar='<name>',
default=None,
help=_('Filters results by a name.'))
parser.add_argument(
'--status',
metavar='<status>',
choices=[
'available', 'error', 'creating', 'deleting', 'error_deleting'
],
help=_("Filters results by a status. "
"('available', 'error', 'creating', 'deleting'"
" or 'error_deleting')"))
parser.add_argument(
'--volume',
metavar='<volume>',
default=None,
help=_('Filters results by a volume (name or ID).'))
return parser
def get_parser(self, prog_name):
parser = super(CreateMeterRule, self).get_parser(prog_name)
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
exclude_group = parser.add_mutually_exclusive_group()
exclude_group.add_argument(
'--exclude',
action='store_true',
help=_("Exclude remote IP prefix from traffic count"))
exclude_group.add_argument(
'--include',
action='store_true',
help=_("Include remote IP prefix from traffic count (default)"))
direction_group = parser.add_mutually_exclusive_group()
direction_group.add_argument(
'--ingress',
action='store_true',
help=_("Apply rule to incoming network traffic (default)"))
direction_group.add_argument(
'--egress',
action='store_true',
help=_('Apply rule to outgoing network traffic'))
parser.add_argument(
'--remote-ip-prefix',
metavar='<remote-ip-prefix>',
required=False,
help=_('The remote IP prefix to associate with this rule'),
)
parser.add_argument(
'--source-ip-prefix',
metavar='<remote-ip-prefix>',
required=False,
help=_('The source IP prefix to associate with this rule'),
)
parser.add_argument(
'--destination-ip-prefix',
metavar='<remote-ip-prefix>',
required=False,
help=_('The destination IP prefix to associate with this rule'),
)
parser.add_argument(
'meter',
metavar='<meter>',
help=_('Label to associate with this metering rule (name or ID)'),
)
return parser
def get_parser(self, prog_name):
parser = super(CreateBgpvpn, self).get_parser(prog_name)
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
_add_create_update_common_arguments(parser)
parser.add_argument(
'--type',
default='l3',
choices=['l2', 'l3'],
help=_('BGP VPN type selection between IP VPN (l3) and Ethernet '
'VPN (l2) (default:%(default)s)'))
return parser
def get_parser(self, prog_name):
parser = super(RemoveProjectImage, self).get_parser(prog_name)
parser.add_argument(
"image",
metavar="<image>",
help="Image to unshare (name or ID)",
)
parser.add_argument(
"project",
metavar="<project>",
help="Project to disassociate with image (name or ID)",
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListBgpvpn, self).get_parser(prog_name)
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--property',
metavar='<key=value>',
default=dict(),
help=_('Filter property to apply on returned BGP VPNs (repeat to '
'filter on multiple properties)'),
action=KeyValueAction)
return parser
def get_parser(self, prog_name):
parser = super(AddProjectToImage, self).get_parser(prog_name)
parser.add_argument(
"image",
metavar="<image>",
help=_("Image to share (name or ID)"),
)
parser.add_argument(
"project",
metavar="<project>",
help=_("Project to associate with image (ID)"),
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateNetworkRBAC, self).get_parser(prog_name)
parser.add_argument(
'rbac_object',
metavar="<rbac-object>",
help=_(
"The object to which this RBAC policy affects (name or ID)"))
parser.add_argument(
'--type',
metavar="<type>",
required=True,
choices=[
'address_group', 'address_scope', 'bgpvpn', 'security_group',
'subnetpool', 'qos_policy', 'network'
],
help=_('Type of the object that RBAC policy '
'affects ("address_group", "address_scope", "bgpvpn" '
'"security_group", "subnetpool", "qos_policy" or '
'"network")'))
parser.add_argument(
'--action',
metavar="<action>",
required=True,
choices=['access_as_external', 'access_as_shared'],
help=_('Action for the RBAC policy '
'("access_as_external" or "access_as_shared")'))
target_project_group = parser.add_mutually_exclusive_group(
required=True)
target_project_group.add_argument(
'--target-project',
metavar="<target-project>",
help=_('The project to which the RBAC policy '
'will be enforced (name or ID)'))
target_project_group.add_argument(
'--target-all-projects',
action='store_true',
help=_('Allow creating RBAC policy for all projects.'))
parser.add_argument(
'--target-project-domain',
metavar='<target-project-domain>',
help=_('Domain the target project belongs to (name or ID). '
'This can be used in case collisions between project names '
'exist.'),
)
parser.add_argument('--project',
metavar="<project>",
help=_('The owner project (name or ID)'))
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListVolume, self).get_parser(prog_name)
parser.add_argument(
'--project',
metavar='<project>',
help=_('Filter results by project (name or ID) (admin only)')
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--user',
metavar='<user>',
help=_('Filter results by user (name or ID) (admin only)')
)
identity_common.add_user_domain_option_to_parser(parser)
parser.add_argument(
'--name',
metavar='<name>',
help=_('Filter results by volume name'),
)
parser.add_argument(
'--status',
metavar='<status>',
help=_('Filter results by status'),
)
parser.add_argument(
'--all-projects',
action='store_true',
default=False,
help=_('Include all projects (admin only)'),
)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_('List additional fields in output'),
)
parser.add_argument(
'--marker',
metavar='<volume>',
help=_('The last volume ID of the previous page'),
)
parser.add_argument(
'--limit',
type=int,
action=parseractions.NonNegativeAction,
metavar='<num-volumes>',
help=_('Maximum number of volumes to display'),
)
return parser
def get_parser(self, prog_name):
parser = super(ShareGroupTypeAccessAllow, self).get_parser(prog_name)
parser.add_argument(
'share_group_type',
metavar="<share-group-type>",
help=_("Share group type name or ID to allow access to.")
)
parser.add_argument(
'projects',
metavar="<project>",
nargs="+",
help=_("Project Name or ID to add share group type access for.")
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(
AddProjectToEndpointGroup, self).get_parser(prog_name)
parser.add_argument(
'endpointgroup',
metavar='<endpoint-group>',
help=_('Endpoint group (name or ID)'),
)
parser.add_argument(
'project',
metavar='<project>',
help=_('Project to associate (name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
return parser
def update_parser_network(self, parser):
parser.add_argument(
'--network',
metavar='<network>',
help=_("List floating IP(s) according to "
"given network (name or ID)")
)
parser.add_argument(
'--port',
metavar='<port>',
help=_("List floating IP(s) according to "
"given port (name or ID)")
)
parser.add_argument(
'--fixed-ip-address',
metavar='<ip-address>',
help=_("List floating IP(s) according to "
"given fixed IP address")
)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_("List additional fields in output")
)
parser.add_argument(
'--status',
metavar='<status>',
choices=['ACTIVE', 'DOWN'],
help=_("List floating IP(s) according to "
"given status ('ACTIVE', 'DOWN')")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("List floating IP(s) according to "
"given project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--router',
metavar='<router>',
help=_("List floating IP(s) according to "
"given router (name or ID)")
)
_tag.add_tag_filtering_option_to_parser(parser, _('floating IP'))
return parser
def update_parser_network(self, parser):
# Maintain and hide the argument for backwards compatibility.
# Network will always return all projects for an admin.
parser.add_argument(
'--all-projects',
action='store_true',
default=False,
help=argparse.SUPPRESS,
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("List security groups according to the project "
"(name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(AddProjectToEndpoint, self).get_parser(prog_name)
parser.add_argument(
'endpoint',
metavar='<endpoint>',
help=_('Endpoint to associate with '
'specified project (name or ID)'),
)
parser.add_argument(
'project',
metavar='<project>',
help=_('Project to associate with '
'specified endpoint name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateSubnetPool, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_("Name of the new subnet pool")
)
_add_prefix_options(parser, for_create=True)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--address-scope',
metavar='<address-scope>',
help=_("Set address scope associated with the subnet pool "
"(name or ID), prefixes must be unique across address "
"scopes")
)
_add_default_options(parser)
shared_group = parser.add_mutually_exclusive_group()
shared_group.add_argument(
'--share',
action='store_true',
help=_("Set this subnet pool as shared"),
)
shared_group.add_argument(
'--no-share',
action='store_true',
help=_("Set this subnet pool as not shared"),
)
parser.add_argument(
'--description',
metavar='<description>',
help=_("Set subnet pool description")
)
parser.add_argument(
'--default-quota',
type=int,
metavar='<num-ip-addresses>',
help=_("Set default per-project quota for this subnet pool "
"as the number of IP addresses that can be allocated "
"from the subnet pool")),
_tag.add_tag_option_to_parser_for_create(parser, _('subnet pool'))
return parser
def get_parser(self, prog_name):
parser = super(CreateSubnetPool, self).get_parser(prog_name)
parser.add_argument('name',
metavar='<name>',
help=_("Name of the new subnet pool"))
_add_prefix_options(parser)
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--address-scope',
metavar='<address-scope>',
help=_("Set address scope associated with the subnet pool "
"(name or ID), prefixes must be unique across address "
"scopes"))
return parser
def get_parser(self, prog_name):
parser = super(ListIPAvailability, self).get_parser(prog_name)
parser.add_argument(
'--ip-version',
type=int,
choices=[4, 6],
metavar='<ip-version>',
dest='ip_version',
help=_("List IP availability of given IP version networks"),
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("List IP availability of given project"),
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateEC2Creds, self).get_parser(prog_name)
parser.add_argument(
'--project',
metavar='<project>',
help=_('Create credentials in project '
'(name or ID; default: current authenticated project)'),
)
parser.add_argument(
'--user',
metavar='<user>',
help=_('Create credentials for user '
'(name or ID; default: current authenticated user)'),
)
common.add_user_domain_option_to_parser(parser)
common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListAddressGroup, self).get_parser(prog_name)
parser.add_argument(
'--name',
metavar='<name>',
help=_("List only address groups of given name in output")
)
parser.add_argument(
'--project',
metavar="<project>",
help=_("List address groups according to their project "
"(name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreatePort, self).get_parser(prog_name)
parser.add_argument(
'--network',
metavar='<network>',
required=True,
help=_("Network this port belongs to (name or ID)"))
_add_updatable_args(parser)
parser.add_argument(
'--fixed-ip',
metavar='subnet=<subnet>,ip-address=<ip-address>',
action=parseractions.MultiKeyValueAction,
optional_keys=['subnet', 'ip-address'],
help=_("Desired IP and/or subnet (name or ID) for this port: "
"subnet=<subnet>,ip-address=<ip-address> "
"(repeat option to set multiple fixed IP addresses)"))
parser.add_argument(
'--binding-profile',
metavar='<binding-profile>',
action=parseractions.KeyValueAction,
help=_("Custom data to be passed as binding:profile: "
"<key>=<value> "
"(repeat option to set multiple binding:profile data)"))
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument('--enable',
action='store_true',
default=True,
help=_("Enable port (default)"))
admin_group.add_argument('--disable',
action='store_true',
help=_("Disable port"))
parser.add_argument('--mac-address',
metavar='<mac-address>',
help=_("MAC address of this port"))
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument('name',
metavar='<name>',
help=_("Name of this port"))
# TODO(singhj): Add support for extended options:
# qos,security groups,dhcp, address pairs
return parser
def get_parser(self, prog_name):
parser = super(CreateNetworkTrunk, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_("Name of the trunk to create")
)
parser.add_argument(
'--description',
metavar='<description>',
help=_("A description of the trunk")
)
parser.add_argument(
'--parent-port',
metavar='<parent-port>',
required=True,
help=_("Parent port belonging to this trunk (name or ID)")
)
parser.add_argument(
'--subport',
metavar='<port=,segmentation-type=,segmentation-id=>',
action=parseractions.MultiKeyValueAction, dest='add_subports',
help=_("Subport to add. Subport is of form "
"\'port=<name or ID>,segmentation-type=,segmentation-ID=\' "
"(--subport) option can be repeated")
)
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
action='store_true',
default=True,
help=_("Enable trunk (default)")
)
admin_group.add_argument(
'--disable',
action='store_true',
help=_("Disable trunk")
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListRoleAssignment, self).get_parser(prog_name)
parser.add_argument(
'--effective',
action="store_true",
default=False,
help=_('Returns only effective role assignments'),
)
parser.add_argument(
'--role',
metavar='<role>',
help=_('Role to filter (name or ID)'),
)
parser.add_argument(
'--names',
action="store_true",
help=_('Display names instead of IDs'),
)
user_or_group = parser.add_mutually_exclusive_group()
user_or_group.add_argument(
'--user',
metavar='<user>',
help=_('User to filter (name or ID)'),
)
common.add_user_domain_option_to_parser(parser)
user_or_group.add_argument(
'--group',
metavar='<group>',
help=_('Group to filter (name or ID)'),
)
common.add_group_domain_option_to_parser(parser)
domain_or_project = parser.add_mutually_exclusive_group()
domain_or_project.add_argument(
'--domain',
metavar='<domain>',
help=_('Domain to filter (name or ID)'),
)
domain_or_project.add_argument(
'--project',
metavar='<project>',
help=_('Project to filter (name or ID)'),
)
common.add_project_domain_option_to_parser(parser)
common.add_inherited_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(CreateRouter, self).get_parser(prog_name)
parser.add_argument('name',
metavar='<name>',
help=_("New router name"))
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument('--enable',
action='store_true',
default=True,
help=_("Enable router (default)"))
admin_group.add_argument('--disable',
action='store_true',
help=_("Disable router"))
distribute_group = parser.add_mutually_exclusive_group()
distribute_group.add_argument('--distributed',
action='store_true',
help=_("Create a distributed router"))
distribute_group.add_argument('--centralized',
action='store_true',
help=_("Create a centralized router"))
ha_group = parser.add_mutually_exclusive_group()
ha_group.add_argument('--ha',
action='store_true',
help=_("Create a highly available router"))
ha_group.add_argument('--no-ha',
action='store_true',
help=_("Create a legacy router"))
parser.add_argument('--description',
metavar='<description>',
help=_("Set router description"))
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--availability-zone-hint',
metavar='<availability-zone>',
action='append',
dest='availability_zone_hints',
help=_("Availability Zone in which to create this router "
"(Router Availability Zone extension required, "
"repeat option to set multiple availability zones)"))
_tag.add_tag_option_to_parser_for_create(parser, _('router'))
return parser
def get_parser(self, prog_name):
parser = super(CreateRouter, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help="New router name",
)
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument(
'--enable',
dest='admin_state_up',
action='store_true',
default=True,
help="Enable router (default)",
)
admin_group.add_argument(
'--disable',
dest='admin_state_up',
action='store_false',
help="Disable router",
)
parser.add_argument(
'--distributed',
dest='distributed',
action='store_true',
default=False,
help="Create a distributed router",
)
parser.add_argument(
'--project',
metavar='<project>',
help="Owner's project (name or ID)",
)
parser.add_argument(
'--availability-zone-hint',
metavar='<availability-zone>',
action='append',
dest='availability_zone_hints',
help='Availability Zone in which to create this router '
'(requires the Router Availability Zone extension, '
'this option can be repeated).',
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super().get_parser(prog_name)
parser.add_argument(
'local_ip',
metavar='<local-ip>',
help=_("Local IP that the port association belongs to "
"(IP address or ID)"))
parser.add_argument(
'fixed_port',
metavar='<fixed_port>',
help=_("The ID or Name of Port to allocate Local IP Association"))
parser.add_argument('--fixed-ip',
metavar='<fixed_ip>',
help=_("Fixed IP for Local IP Association"))
identity_common.add_project_domain_option_to_parser(parser)
return parser
def get_parser(self, prog_name):
parser = super(ListNetworkQosPolicy, self).get_parser(prog_name)
parser.add_argument(
'--project',
metavar='<project>',
help=_(
"List qos policies according to their project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
shared_group = parser.add_mutually_exclusive_group()
shared_group.add_argument(
'--share',
action='store_true',
help=_("List qos policies shared between projects"))
shared_group.add_argument(
'--no-share',
action='store_true',
help=_("List qos policies not shared between projects"))
return parser
def update_parser_network(self, parser):
admin_group = parser.add_mutually_exclusive_group()
admin_group.add_argument('--enable',
action='store_true',
default=True,
help=_("Enable network (default)"))
admin_group.add_argument('--disable',
action='store_true',
help=_("Disable network"))
parser.add_argument('--project',
metavar='<project>',
help=_("Owner's project (name or ID)"))
identity_common.add_project_domain_option_to_parser(parser)
parser.add_argument(
'--availability-zone-hint',
action='append',
dest='availability_zone_hints',
metavar='<availability-zone>',
help=_("Availability Zone in which to create this network "
"(Network Availability Zone extension required, "
"repeat option to set multiple availability zones)"))
external_router_grp = parser.add_mutually_exclusive_group()
external_router_grp.add_argument(
'--external',
action='store_true',
help=_("Set this network as an external network "
"(external-net extension required)"))
external_router_grp.add_argument(
'--internal',
action='store_true',
help=_("Set this network as an internal network (default)"))
default_router_grp = parser.add_mutually_exclusive_group()
default_router_grp.add_argument(
'--default',
action='store_true',
help=_("Specify if this network should be used as "
"the default external network"))
default_router_grp.add_argument(
'--no-default',
action='store_true',
help=_("Do not use the network as the default external network "
"(default)"))
_add_additional_network_options(parser)
return parser
def update_parser_network(self, parser):
parser.add_argument(
'--subnet',
metavar='<subnet>',
help=_("Subnet on which you want to create the floating IP "
"(name or ID)")
)
parser.add_argument(
'--port',
metavar='<port>',
help=_("Port to be associated with the floating IP "
"(name or ID)")
)
parser.add_argument(
'--floating-ip-address',
metavar='<ip-address>',
dest='floating_ip_address',
help=_("Floating IP address")
)
parser.add_argument(
'--fixed-ip-address',
metavar='<ip-address>',
dest='fixed_ip_address',
help=_("Fixed IP address mapped to the floating IP")
)
parser.add_argument(
'--qos-policy',
metavar='<qos-policy>',
help=_("Attach QoS policy to the floating IP (name or ID)")
)
parser.add_argument(
'--description',
metavar='<description>',
help=_('Set floating IP description')
)
parser.add_argument(
'--project',
metavar='<project>',
help=_("Owner's project (name or ID)")
)
identity_common.add_project_domain_option_to_parser(parser)
_tag.add_tag_option_to_parser_for_create(parser, _('floating IP'))
return parser
def get_parser(self, prog_name):
parser = super().get_parser(prog_name)
user_group = parser.add_mutually_exclusive_group()
user_group.add_argument(
'--user',
metavar='<user>',
help=_('Show keypairs for another user (admin only) (name or ID). '
'Requires ``--os-compute-api-version`` 2.10 or greater.'),
)
identity_common.add_user_domain_option_to_parser(parser)
user_group.add_argument(
'--project',
metavar='<project>',
help=_('Show keypairs for all users associated with project '
'(admin only) (name or ID). '
'Requires ``--os-compute-api-version`` 2.10 or greater.'),
)
identity_common.add_project_domain_option_to_parser(parser)
return parser
