def args2body(self, parsed_args):
_policy_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), "firewall_policy", parsed_args.firewall_policy_id
)
body = {self.resource: {"firewall_policy_id": _policy_id, "admin_state_up": parsed_args.admin_state}}
neutronv20.update_dict(parsed_args, body[self.resource], ["name", "description", "shared", "tenant_id"])
return body
def args2body(self, parsed_args, body=None):
"""Add in conditional args and then return all conn info."""
if body is None:
body = {}
if parsed_args.dpd:
vpn_utils.validate_dpd_dict(parsed_args.dpd)
body['dpd'] = parsed_args.dpd
if parsed_args.local_ep_group:
_local_epg = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'endpoint_group',
parsed_args.local_ep_group)
body['local_ep_group_id'] = _local_epg
if parsed_args.peer_ep_group:
_peer_epg = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'endpoint_group',
parsed_args.peer_ep_group)
body['peer_ep_group_id'] = _peer_epg
if hasattr(parsed_args, 'mtu') and int(parsed_args.mtu) < 68:
message = _("Invalid MTU value: MTU must be "
"greater than or equal to 68.")
raise exceptions.CommandError(message)
# ToDo (Reedip) : Remove below check when peer-cidr is removed
if parsed_args.peer_cidrs and parsed_args.local_ep_group:
message = _("You cannot specify both endpoint groups and peer "
"CIDR(s).")
raise exceptions.CommandError(message)
neutronv20.update_dict(parsed_args, body,
['peer_id', 'mtu', 'initiator', 'psk',
'peer_address', 'name', 'description',
'peer_cidrs'])
return {self.resource: body}
def args2body(self, parsed_args):
body = {}
client = self.get_client()
if parsed_args.logical_source_port:
body["logical_source_port"] = pp.get_port_id(client, parsed_args.logical_source_port)
if parsed_args.logical_destination_port:
body["logical_destination_port"] = pp.get_port_id(client, parsed_args.logical_destination_port)
if parsed_args.source_port:
self._fill_protocol_port_info(body, "source", parsed_args.source_port)
if parsed_args.destination_port:
self._fill_protocol_port_info(body, "destination", parsed_args.destination_port)
neutronv20.update_dict(
parsed_args,
body,
[
"name",
"description",
"protocol",
"source_ip_prefix",
"destination_ip_prefix",
"ethertype",
"l7_parameters",
],
)
return {self.resource: body}
def _parse_common_args(body, parsed_args, client):
neutronV20.update_dict(parsed_args, body,
['name', 'description', 'connection_limit'])
if parsed_args.default_pool:
default_pool_id = _get_pool_id(
client, parsed_args.default_pool)
body['default_pool_id'] = default_pool_id
def args2body(self, parsed_args):
body = {'admin_state_up': parsed_args.admin_state}
neutronV20.update_dict(parsed_args, body,
['name', 'tenant_id', 'distributed', 'ha',
'description'])
availability_zone.args2body_az_hint(parsed_args, body)
return {self.resource: body}
def args2body(self, parsed_args):
if parsed_args.loadbalancer:
parsed_args.loadbalancer = _get_loadbalancer_id(self.get_client(), parsed_args.loadbalancer)
body = {
self.resource: {
"loadbalancer_id": parsed_args.loadbalancer,
"protocol": parsed_args.protocol,
"protocol_port": parsed_args.protocol_port,
"admin_state_up": parsed_args.admin_state,
}
}
neutronV20.update_dict(
parsed_args,
body[self.resource],
[
"connection-limit",
"description",
"loadbalancer_id",
"name",
"default_tls_container_id",
"sni_container_ids",
"tenant_id",
],
)
return body
def comman_args2body(parsed_args):
body = {'ovsvapp_cluster': {
'vcenter_id': parsed_args.vcenter_id,
'clusters': parsed_args.clusters}, }
neutronV20.update_dict(parsed_args, body['ovsvapp_cluster'],
['vcenter_id', 'clusters'])
return body
def _common_args2body(client, parsed_args, is_create=True):
if parsed_args.redirect_url:
if parsed_args.action != 'REDIRECT_TO_URL':
raise exceptions.CommandError(_('Action must be REDIRECT_TO_URL'))
if parsed_args.redirect_pool:
if parsed_args.action != 'REDIRECT_TO_POOL':
raise exceptions.CommandError(_('Action must be REDIRECT_TO_POOL'))
parsed_args.redirect_pool_id = _get_pool_id(
client, parsed_args.redirect_pool)
if (parsed_args.action == 'REDIRECT_TO_URL' and
not parsed_args.redirect_url):
raise exceptions.CommandError(_('Redirect URL must be specified'))
if (parsed_args.action == 'REDIRECT_TO_POOL' and
not parsed_args.redirect_pool):
raise exceptions.CommandError(_('Redirect pool must be specified'))
attributes = ['name', 'description',
'action', 'redirect_pool_id', 'redirect_url',
'position', 'admin_state_up']
if is_create:
parsed_args.listener_id = _get_listener_id(
client, parsed_args.listener)
attributes.extend(['listener_id', 'tenant_id'])
body = {}
neutronV20.update_dict(parsed_args, body, attributes)
return {'l7policy': body}
def args2body(self, parsed_args):
body = {'name': parsed_args.name}
neutronV20.update_dict(parsed_args, body,
['segment_type', 'sub_type', 'segment_range',
'physical_network', 'multicast_ip_range',
'add_tenants'])
return {'network_profile': body}
def args2body(self, parsed_args):
body = {'network': {
'name': parsed_args.name,
'admin_state_up': parsed_args.admin_state}, }
neutronV20.update_dict(parsed_args, body['network'],
['shared', 'tenant_id'])
return body
def args2body(self, parsed_args):
body = {'name': parsed_args.name,
'ip_version': parsed_args.ip_version}
if parsed_args.shared:
body['shared'] = True
neutronV20.update_dict(parsed_args, body, ['tenant_id'])
return {self.resource: body}
def args2body(self, parsed_args):
body = {
self.resource: {}
}
neutronV20.update_dict(parsed_args, body[self.resource],
['key','value'])
return body
def updatable_args2body(parsed_args, body, for_create=True, ip_version=None):
if parsed_args.disable_dhcp and parsed_args.enable_dhcp:
raise exceptions.CommandError(_(
"You cannot enable and disable DHCP at the same time."))
neutronV20.update_dict(parsed_args, body,
['name', 'allocation_pools',
'host_routes', 'dns_nameservers',
'description'])
if parsed_args.no_gateway:
body['gateway_ip'] = None
elif parsed_args.gateway:
body['gateway_ip'] = parsed_args.gateway
if parsed_args.disable_dhcp:
body['enable_dhcp'] = False
if parsed_args.enable_dhcp:
body['enable_dhcp'] = True
if for_create and parsed_args.ipv6_ra_mode:
if ip_version == 4:
raise exceptions.CommandError(_("--ipv6-ra-mode is invalid "
"when --ip-version is 4"))
body['ipv6_ra_mode'] = parsed_args.ipv6_ra_mode
if for_create and parsed_args.ipv6_address_mode:
if ip_version == 4:
raise exceptions.CommandError(_("--ipv6-address-mode is "
"invalid when --ip-version "
"is 4"))
body['ipv6_address_mode'] = parsed_args.ipv6_address_mode
def args2body(self, parsed_args):
_subnet_id = neutronV20.find_resourceid_by_name_or_id(self.get_client(), "subnet", parsed_args.subnet_id)
body = {"admin_state_up": parsed_args.admin_state, "subnet_id": _subnet_id}
neutronV20.update_dict(
parsed_args, body, ["description", "lb_method", "name", "protocol", "tenant_id", "provider"]
)
return {self.resource: body}
def args2body(self, parsed_args):
body = {
self.resource: {}
}
neutronV20.update_dict(parsed_args, body[self.resource],
['name','description','certificate_content','private_key'])
return body
def args2body(self, parsed_args):
body = {
self.resource: {
'admin_state_up': parsed_args.admin_state, }, }
neutronV20.update_dict(parsed_args, body[self.resource],
['description'])
return body
def args2body(self, parsed_args):
body = {}
validate_peer_attributes(parsed_args)
neutronv20.update_dict(parsed_args, body,
['name', 'peer_ip',
'remote_as', 'auth_type', 'password'])
return {self.resource: body}
def args2body(self, parsed_args):
body = {}
if hasattr(parsed_args, 'admin_state'):
body['admin_state_up'] = parsed_args.admin_state
neutronV20.update_dict(parsed_args, body,
['name', 'distributed'])
return {self.resource: body}
def args2body(self, parsed_args):
body = {self.resource: {}, }
neutronV20.update_dict(parsed_args, body[self.resource],
['name', 'description', 'shared', 'vendor',
'insertion_mode', 'service_type',
'service_flavor'])
return body
def args2body(self, parsed_args):
body = {self.resource: {}}
neutronV20.update_dict(
parsed_args,
body[self.resource],
["name", "description", "shared", "vendor", "insertion_mode", "service_type", "service_flavor"],
)
return body
def args2body(self, args):
body = {}
attributes = ['name', 'type', 'management_ip',
'management_port', 'management_protocol',
'resource_id', 'tenant_id', 'tunnel_ips']
gw_deviceV20.update_dict(args, body, attributes)
return {'gateway_device': body}
def args2body(self, parsed_args):
body = {
self.resource: {
},
}
neutronV20.update_dict(parsed_args, body[self.resource],
['name','securitygroup_id', 'description'])
return body
def args2body(self, parsed_args):
self.parent_id = _get_pool_id(self.get_client(), parsed_args.pool)
body = {
self.resource: {}
}
neutronV20.update_dict(parsed_args, body[self.resource],
['admin_state_up', 'weight'])
return body
def update_bandwidth_limit_args2body(parsed_args, body):
max_kbps = parsed_args.max_kbps
max_burst_kbps = parsed_args.max_burst_kbps
if not (max_kbps or max_burst_kbps):
raise exceptions.CommandError(_("Must provide max_kbps"
" or max_burst_kbps option."))
neutronv20.update_dict(parsed_args, body,
['max_kbps', 'max_burst_kbps', 'tenant_id'])
def _common_args2body(client, parsed_args, is_create=True):
attributes = ['type', 'compare_type',
'invert', 'key', 'value', 'admin_state_up']
if is_create:
attributes.append('tenant_id')
body = {}
neutronV20.update_dict(parsed_args, body, attributes)
return {'rule': body}
def args2body(self, parsed_args):
body = _parse_common_args(parsed_args)
if parsed_args.no_session_persistence:
body['session_persistence'] = None
elif parsed_args.session_persistence:
body['session_persistence'] = parsed_args.session_persistence
neutronV20.update_dict(parsed_args, body,
['admin_state_up'])
return {self.resource: body}
def args2body(self, parsed_args):
_rule = ''
if parsed_args.firewall_rule_id:
_rule = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'firewall_rule',
parsed_args.firewall_rule_id)
body = {'firewall_rule_id': _rule}
neutronv20.update_dict(parsed_args, body, [])
return body
def args2body(self, parsed_args):
body = {}
client = self.get_client()
if parsed_args.port_pair_groups:
body["port_pair_groups"] = [ppg.get_port_pair_group_id(client, p) for p in parsed_args.port_pair_groups]
if parsed_args.flow_classifiers:
body["flow_classifiers"] = [fc.get_flowclassifier_id(client, f) for f in parsed_args.flow_classifiers]
neutronv20.update_dict(parsed_args, body, ["name", "description", "chain_parameters"])
return {self.resource: body}
def args2body(self, parsed_args):
body = {}
if parsed_args.flow_classifiers:
client = self.get_client()
body["flow_classifiers"] = [fc.get_flowclassifier_id(client, f) for f in parsed_args.flow_classifiers]
elif parsed_args.no_flow_classifier:
body["flow_classifiers"] = []
neutronv20.update_dict(parsed_args, body, ["name", "description"])
return {self.resource: body}
def take_action(self, parsed_args):
neutron_client = self.get_client()
update_dict = {}
neutronV20.update_dict(parsed_args, update_dict,
['port_id', 'fixed_ip_address'])
neutron_client.update_floatingip(parsed_args.floatingip_id,
{'floatingip': update_dict})
print(_('Associated floating IP %s') % parsed_args.floatingip_id,
file=self.app.stdout)
def args2body(self, parsed_args):
_subnet_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'subnet', parsed_args.vip_subnet)
body = {
'vip_subnet_id': _subnet_id,
'admin_state_up': parsed_args.admin_state
}
if parsed_args.flavor:
_flavor_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'flavor', parsed_args.flavor)
body['flavor_id'] = _flavor_id
neutronV20.update_dict(parsed_args, body,
['provider', 'vip_address', 'tenant_id'])
_parse_common_args(body, parsed_args)
return {self.resource: body}
def args2body(self, parsed_args):
if parsed_args.loadbalancer:
parsed_args.loadbalancer = _get_loadbalancer_id(
self.get_client(), parsed_args.loadbalancer)
body = {
'loadbalancer_id': parsed_args.loadbalancer,
'protocol': parsed_args.protocol,
'protocol_port': parsed_args.protocol_port,
'admin_state_up': parsed_args.admin_state
}
neutronV20.update_dict(parsed_args, body, [
'connection_limit', 'description', 'loadbalancer_id', 'name',
'default_tls_container_ref', 'sni_container_refs', 'tenant_id'
])
return {self.resource: body}
def args2body(self, parsed_args):
body = {}
client = self.get_client()
if parsed_args.port_pair_groups:
body['port_pair_groups'] = [
ppg.get_port_pair_group_id(client, p)
for p in parsed_args.port_pair_groups
]
if parsed_args.flow_classifiers:
body['flow_classifiers'] = [
fc.get_flowclassifier_id(client, f)
for f in parsed_args.flow_classifiers
]
neutronv20.update_dict(parsed_args, body,
['name', 'description', 'chain_parameters'])
return {self.resource: body}
def args2body(self, parsed_args):
_pool_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'pool', parsed_args.pool_id)
_subnet_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'subnet', parsed_args.subnet_id)
body = {
self.resource: {
'pool_id': _pool_id,
'admin_state_up': parsed_args.admin_state,
'subnet_id': _subnet_id,
},
}
neutronV20.update_dict(parsed_args, body[self.resource], [
'address', 'connection_limit', 'description', 'name',
'protocol_port', 'protocol', 'tenant_id'
])
return body
def args2body(self, parsed_args):
if parsed_args.session_persistence:
parsed_args.session_persistence = utils.str2dict(
parsed_args.session_persistence)
_listener_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'listener', parsed_args.listener)
body = {
self.resource: {
'admin_state_up': parsed_args.admin_state,
'protocol': parsed_args.protocol,
'lb_algorithm': parsed_args.lb_algorithm,
'listener_id': _listener_id,
},
}
neutronV20.update_dict(parsed_args, body[self.resource],
['description', 'name', 'session_persistence'])
return body
def args2body(self, parsed_args):
client = self.get_client()
_template_id = neutronV20.find_resourceid_by_name_or_id(
client, 'hosting_device_template', parsed_args.template_id)
body = {self.resource: {
'name': parsed_args.name, 'template_id': _template_id,
'admin_state_up': True}}
_updatable_args2body(parsed_args, body)
neutronV20.update_dict(parsed_args, body[self.resource],
['id', 'tenant_id', 'management_port_id',
'cfg_agent_id'])
if (hasattr(parsed_args, 'management_port') and
parsed_args.management_port):
_port_id = neutronV20.find_resourceid_by_name_or_id(
client, 'port', parsed_args.management_port)
body[self.resource]['management_port_id'] = _port_id
return body
def args2body(self, parsed_args):
if parsed_args.session_persistence:
parsed_args.session_persistence = _parse_persistence(parsed_args)
if parsed_args.healthmonitor:
parsed_args.healthmonitor = _parse_healthmonitor(parsed_args)
body = {
self.resource: {
'protocol': parsed_args.protocol,
'network_id': parsed_args.network_id,
'lb_algorithm': parsed_args.lb_algorithm,
'admin_state_up': parsed_args.admin_state,
},
}
neutronV20.update_dict(parsed_args, body[self.resource],
['healthmonitor', 'session_persistence',
'name', 'tenant_id','subnet_id','description'])
return body
def args2body(self, parsed_args):
if not parsed_args.listener and not parsed_args.loadbalancer:
message = _('At least one of --listener or --loadbalancer must be '
'specified.')
raise exceptions.CommandError(message)
body = _parse_common_args(parsed_args)
if parsed_args.listener:
listener_id = _get_listener_id(self.get_client(),
parsed_args.listener)
body['listener_id'] = listener_id
if parsed_args.loadbalancer:
loadbalancer_id = _get_loadbalancer_id(self.get_client(),
parsed_args.loadbalancer)
body['loadbalancer_id'] = loadbalancer_id
body['admin_state_up'] = parsed_args.admin_state
neutronV20.update_dict(parsed_args, body, ['tenant_id', 'protocol'])
return {self.resource: body}
def parse_common_args(client, parsed_args):
body = {}
if parsed_args.policy:
body['firewall_policy_id'] = neutronv20.find_resourceid_by_name_or_id(
client, 'firewall_policy',
parsed_args.policy)
if parsed_args.routers:
body['router_ids'] = [
neutronv20.find_resourceid_by_name_or_id(client, 'router', r)
for r in parsed_args.routers]
elif parsed_args.no_routers:
body['router_ids'] = []
neutronv20.update_dict(parsed_args, body,
['name', 'description'])
return body
def args2body(self, parsed_args):
if parsed_args.subnet:
_subnet_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'subnet', parsed_args.subnet)
else:
_subnet_id = None
_router_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'router', parsed_args.router)
body = {
'subnet_id': _subnet_id,
'router_id': _router_id,
'admin_state_up': parsed_args.admin_state
}
neutronv20.update_dict(parsed_args, body, ['tenant_id'])
common_args2body(parsed_args, body)
return {self.resource: body}
def args2body(self, parsed_args):
if parsed_args.loadbalancer:
parsed_args.loadbalancer = _get_loadbalancer_id(
self.get_client(), parsed_args.loadbalancer)
body = {
self.resource: {
'loadbalancer_id': parsed_args.loadbalancer,
'protocol': parsed_args.protocol,
'protocol_port': parsed_args.protocol_port,
'admin_state_up': parsed_args.admin_state,
},
}
neutronV20.update_dict(
parsed_args, body[self.resource],
['connection-limit', 'description', 'loadbalancer_id', 'name'])
return body
def args2body(self, parsed_args):
if parsed_args.firewall_rules:
_firewall_rules = []
for f in parsed_args.firewall_rules:
_firewall_rules.append(
neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'firewall_rule', f))
body = {self.resource: {
'firewall_rules': _firewall_rules,
},
}
else:
body = {self.resource: {}}
neutronv20.update_dict(parsed_args, body[self.resource],
['name', 'description', 'shared',
'audited', 'tenant_id'])
return body
def args2body(self, parsed_args):
_security_group_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'security_group', parsed_args.security_group_id)
body = {'security_group_id': _security_group_id,
'direction': parsed_args.direction,
'ethertype': parsed_args.ethertype or
generate_default_ethertype(parsed_args.protocol)}
neutronV20.update_dict(parsed_args, body,
['protocol', 'port_range_min', 'port_range_max',
'remote_ip_prefix', 'tenant_id',
'description'])
if parsed_args.remote_group_id:
_remote_group_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'security_group',
parsed_args.remote_group_id)
body['remote_group_id'] = _remote_group_id
return {'security_group_rule': body}
def args2body(self, parsed_args):
client = self.get_client()
_policy_id = neutronv20.find_resourceid_by_name_or_id(
client, 'firewall_policy',
parsed_args.firewall_policy_id)
body = {
self.resource: {
'firewall_policy_id': _policy_id,
'admin_state_up': parsed_args.admin_state, }, }
if parsed_args.routers:
body[self.resource]['router_ids'] = [
neutronv20.find_resourceid_by_name_or_id(client, 'router', r)
for r in parsed_args.routers]
neutronv20.update_dict(parsed_args, body[self.resource],
['name', 'description', 'shared',
'tenant_id'])
return body
def args2body(self, parsed_args):
_subnet_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'subnet', parsed_args.subnet)
_router_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'router', parsed_args.router)
body = {
self.resource: {
'subnet_id': _subnet_id,
'router_id': _router_id,
'admin_state_up': parsed_args.admin_state
},
}
neutronv20.update_dict(parsed_args, body[self.resource],
['name', 'description', 'tenant_id'])
return body
def _updatable_args2body(parsed_args, body, client):
neutronV20.update_dict(
parsed_args, body,
['device_id', 'device_owner', 'name', 'description'])
if parsed_args.wrs_vif_model:
body['wrs-binding:vif_model'] = parsed_args.wrs_vif_model
ips = []
if parsed_args.fixed_ip:
for ip_spec in parsed_args.fixed_ip:
if 'subnet_id' in ip_spec:
subnet_name_id = ip_spec['subnet_id']
_subnet_id = neutronV20.find_resourceid_by_name_or_id(
client, 'subnet', subnet_name_id)
ip_spec['subnet_id'] = _subnet_id
ips.append(ip_spec)
if ips:
body['fixed_ips'] = ips
def args2body(self, parsed_args):
_vpnservice_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'vpnservice',
parsed_args.vpnservice_id)
_ikepolicy_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'ikepolicy',
parsed_args.ikepolicy_id)
_ipsecpolicy_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'ipsecpolicy',
parsed_args.ipsecpolicy_id)
if int(parsed_args.mtu) < 68:
message = _("Invalid MTU value: MTU must be "
"greater than or equal to 68")
raise exceptions.CommandError(message)
if (bool(parsed_args.local_ep_group) !=
bool(parsed_args.peer_ep_group)):
message = _("You must specify both local and peer endpoint "
"groups.")
raise exceptions.CommandError(message)
if parsed_args.peer_cidrs and parsed_args.local_ep_group:
message = _("You cannot specify both endpoint groups and peer "
"CIDR(s).")
raise exceptions.CommandError(message)
if not parsed_args.peer_cidrs and not parsed_args.local_ep_group:
message = _("You must specify endpoint groups or peer CIDR(s).")
raise exceptions.CommandError(message)
body = {
'vpnservice_id': _vpnservice_id,
'ikepolicy_id': _ikepolicy_id,
'ipsecpolicy_id': _ipsecpolicy_id,
'admin_state_up': parsed_args.admin_state_down,
}
neutronv20.update_dict(parsed_args, body,
['peer_id', 'mtu', 'initiator', 'psk',
'peer_address'])
if parsed_args.name:
body['name'] = parsed_args.name
if parsed_args.description:
body['description'] = parsed_args.description
if parsed_args.tenant_id:
body['tenant_id'] = parsed_args.tenant_id
if parsed_args.peer_cidrs:
body['peer_cidrs'] = parsed_args.peer_cidrs
return super(CreateIPsecSiteConnection, self).args2body(parsed_args,
body)
def args2body(self, parsed_args):
client = self.get_client()
_template_id = neutronV20.find_resourceid_by_name_or_id(
client, 'hosting_device_template', parsed_args.template_id)
body = {
self.resource: {
'template_id': _template_id,
'scheduler': parsed_args.scheduler,
'driver': parsed_args.driver,
'cfg_agent_service_helper':
parsed_args.cfg_agent_service_helper,
'cfg_agent_driver': parsed_args.cfg_agent_driver
}
}
_updatable_args2body(parsed_args, body)
neutronV20.update_dict(parsed_args, body[self.resource],
['id', 'tenant_id'])
return body
def args2body(self, parsed_args):
body = {
self.resource: {},
}
if parsed_args.template_file:
if os.path.isfile(parsed_args.template_file):
tpl_files, template = template_utils.get_template_contents(
parsed_args.template_file)
parsed_args.config = json.dumps(template)
else:
raise exc.NeutronClientException("File %s does not exist. "
"Please check the path" %
parsed_args.template_file)
neutronV20.update_dict(parsed_args, body[self.resource], [
'name', 'service_type', 'config', 'tenant_id', 'param_names',
'description'
])
return body
def args2body(self, parsed_args):
pool_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(),
'pool',
parsed_args.pool,
cmd_resource='lbaas_pool')
body = {
'admin_state_up': parsed_args.admin_state,
'delay': parsed_args.delay,
'max_retries': parsed_args.max_retries,
'timeout': parsed_args.timeout,
'type': parsed_args.type,
'pool_id': pool_id
}
neutronV20.update_dict(
parsed_args, body,
['expected_codes', 'http_method', 'url_path', 'tenant_id'])
return {self.resource: body}
def args2body(self, parsed_args):
self.validate_fields(parsed_args)
_network_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'network', parsed_args.network)
body = {'network_id': _network_id,
'admin_state_up': parsed_args.admin_state}
if parsed_args.in_port:
_port_id = neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'port', parsed_args.in_port)
body['in_port'] = _port_id
neutronV20.update_dict(
parsed_args, body,
['action', 'priority', 'name',
'eth_type', 'protocol', 'src_mac', 'dst_mac',
'src_cidr', 'dst_cidr', 'src_port', 'dst_port'])
return {self.resource: body}
def args2body(self, parsed_args):
body = {
self.resource: {
'devices': parsed_args.devices,
# 'service_type_id': parsed_args.service_type_id,
}
}
if parsed_args.attribute:
body[self.resource]['attributes'] = dict(parsed_args.attribute)
if parsed_args.service_table_id:
body[self.
resource]['service_table_id'] = parsed_args.service_table_id
#if parsed_args.managed_by_user:
# body[self.resource]['managed_by_user'] = parsed_args.managed_by_user
neutronv20.update_dict(parsed_args, body[self.resource], [
'tenant_id', 'name', 'managed_by_user', 'mgmt_driver', 'mgmt_url',
'service_type_id'
])
return body
def args2body(self, parsed_args):
body = {}
client = self.get_client()
if parsed_args.logical_source_port:
body['logical_source_port'] = pp.get_port_id(
client, parsed_args.logical_source_port)
if parsed_args.logical_destination_port:
body['logical_destination_port'] = pp.get_port_id(
client, parsed_args.logical_destination_port)
if parsed_args.source_port:
self._fill_protocol_port_info(body, 'source',
parsed_args.source_port)
if parsed_args.destination_port:
self._fill_protocol_port_info(body, 'destination',
parsed_args.destination_port)
neutronv20.update_dict(parsed_args, body, [
'name', 'description', 'protocol', 'source_ip_prefix',
'destination_ip_prefix', 'ethertype', 'l7_parameters'
])
return {self.resource: body}
def args2body(self, parsed_args):
body = {
self.resource: {
'template_id': parsed_args.device_template_id,
}
}
if parsed_args.attributes:
try:
attributes = dict(
key_value.split('=', 1)
for key_value in parsed_args.attributes)
except ValueError:
msg = (_('invalid argument for --attributes %s') %
parsed_args.attributes)
raise exceptions.TackerCLIError(msg)
if attributes:
body[self.resource]['attributes'] = attributes
neutronv20.update_dict(parsed_args, body[self.resource], ['tenant_id'])
return body
def args2body(self, parsed_args):
_policy_id = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'firewall_policy',
parsed_args.firewall_policy_id)
_router_ids = []
if parsed_args.router:
for r in parsed_args.router:
_router_ids.append(
neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'router', r))
body = {
self.resource: {
'firewall_policy_id': _policy_id,
'admin_state_up': parsed_args.admin_state,
'router_ids': _router_ids
},
}
neutronv20.update_dict(parsed_args, body[self.resource],
['name', 'description', 'shared', 'tenant_id'])
return body
def args2body(self, parsed_args):
body = {self.resource: {}, }
if parsed_args.servicechain_spec:
body[self.resource]['servicechain_spec'] = \
neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'servicechain_spec',
parsed_args.servicechain_spec)
if parsed_args.provider_ptg:
body[self.resource]['provider_ptg'] = \
neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'policy_target_group',
parsed_args.provider_ptg)
if parsed_args.consumer_ptg:
body[self.resource]['consumer_ptg'] = \
neutronV20.find_resourceid_by_name_or_id(
self.get_client(), 'policy_target_group',
parsed_args.consumer_ptg)
neutronV20.update_dict(parsed_args, body[self.resource],
['name', 'description', 'param_values'])
return body
def args2body(self, parsed_args):
if not parsed_args.loadbalancer and not parsed_args.default_pool:
message = _('Either --default-pool or --loadbalancer must be '
'specified.')
raise exceptions.CommandError(message)
body = {
'protocol': parsed_args.protocol,
'protocol_port': parsed_args.protocol_port,
'admin_state_up': parsed_args.admin_state
}
if parsed_args.loadbalancer:
loadbalancer_id = _get_loadbalancer_id(self.get_client(),
parsed_args.loadbalancer)
body['loadbalancer_id'] = loadbalancer_id
neutronV20.update_dict(
parsed_args, body,
['default_tls_container_ref', 'sni_container_refs', 'tenant_id'])
_parse_common_args(body, parsed_args, self.get_client())
return {self.resource: body}
def args2body(self, parsed_args):
client = self.get_client()
_network_id = neutronV20.find_resourceid_by_name_or_id(
client, 'network', parsed_args.network_id)
body = {'admin_state_up': parsed_args.admin_state,
'network_id': _network_id, }
_updatable_args2body(parsed_args, body, client)
neutronV20.update_dict(parsed_args, body,
['mac_address', 'tenant_id'])
if parsed_args.vnic_type:
body['binding:vnic_type'] = parsed_args.vnic_type
if parsed_args.binding_profile:
body['binding:profile'] = jsonutils.loads(
parsed_args.binding_profile)
self.args2body_secgroup(parsed_args, body)
self.args2body_extradhcpopt(parsed_args, body)
self.args2body_qos_policy(parsed_args, body)
self.args2body_allowedaddresspairs(parsed_args, body)
return {'port': body}
def args2body(self, parsed_args):
resource = {
'admin_state_up': parsed_args.admin_state,
'protocol': parsed_args.protocol,
'lb_algorithm': parsed_args.lb_algorithm
}
if not parsed_args.listener and not parsed_args.loadbalancer:
message = _('At least one of --listener or --loadbalancer must be '
'specified.')
raise exceptions.CommandError(message)
if parsed_args.listener:
listener_id = _get_listener_id(self.get_client(),
parsed_args.listener)
resource['listener_id'] = listener_id
if parsed_args.loadbalancer:
loadbalancer_id = _get_loadbalancer_id(self.get_client(),
parsed_args.loadbalancer)
resource['loadbalancer_id'] = loadbalancer_id
neutronV20.update_dict(
parsed_args, resource,
['description', 'name', 'session_persistence', 'tenant_id'])
return {self.resource: resource}
def args2body(self, parsed_args):
_rule = ''
if parsed_args.firewall_rule_id:
_rule = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'firewall_rule',
parsed_args.firewall_rule_id)
_insert_before = ''
if 'insert_before' in parsed_args:
if parsed_args.insert_before:
_insert_before = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'firewall_rule',
parsed_args.insert_before)
_insert_after = ''
if 'insert_after' in parsed_args:
if parsed_args.insert_after:
_insert_after = neutronv20.find_resourceid_by_name_or_id(
self.get_client(), 'firewall_rule',
parsed_args.insert_after)
body = {'firewall_rule_id': _rule,
'insert_before': _insert_before,
'insert_after': _insert_after}
neutronv20.update_dict(parsed_args, body, [])
return body
