OpenStack Study: neutron

OpenStack Index

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\extensions\__init__.py

def create_l2_gw_service(cluster, tenant_id, display_name, devices):

def plug_l2_gw_service(cluster, lswitch_id, lport_id, gateway_id, vlan_id=None):

def get_l2_gw_service(cluster, gateway_id):

def get_l2_gw_services(cluster, tenant_id=None, fields=None, filters=None):

def update_l2_gw_service(cluster, gateway_id, display_name):

def delete_l2_gw_service(cluster, gateway_id):

def _build_gateway_device_body(tenant_id, display_name, neutron_id, connector_type, connector_ip, client_certificate, tz_uuid):

def create_gateway_device(cluster, tenant_id, display_name, neutron_id, tz_uuid, connector_type, connector_ip, client_certificate):

def update_gateway_device(cluster, gateway_id, tenant_id, display_name, neutron_id, tz_uuid, connector_type, connector_ip, client_certificate):

def delete_gateway_device(cluster, device_uuid):

def get_gateway_device_status(cluster, device_uuid):

def get_gateway_devices_status(cluster, tenant_id=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\lsn.py

def service_cluster_exists(cluster, svc_cluster_id):

def lsn_for_network_create(cluster, network_id):

def lsn_for_network_get(cluster, network_id):

def lsn_delete(cluster, lsn_id):

def lsn_port_host_entries_update( cluster, lsn_id, lsn_port_id, conf, hosts_data):

def lsn_port_create(cluster, lsn_id, port_data):

def lsn_port_delete(cluster, lsn_id, lsn_port_id):

def _lsn_port_get(cluster, lsn_id, filters):

def lsn_port_by_mac_get(cluster, lsn_id, mac_address):

def lsn_port_by_subnet_get(cluster, lsn_id, subnet_id):

def lsn_port_info_get(cluster, lsn_id, lsn_port_id):

def lsn_port_plug_network(cluster, lsn_id, lsn_port_id, lswitch_port_id):

def _lsn_configure_action( cluster, lsn_id, action, is_enabled, obj):

def _lsn_port_configure_action( cluster, lsn_id, lsn_port_id, action, is_enabled, obj):

def lsn_port_dhcp_configure( cluster, lsn_id, lsn_port_id, is_enabled=True, dhcp_options=None):

def lsn_metadata_configure( cluster, lsn_id, is_enabled=True, metadata_info=None):

def _lsn_port_host_action( cluster, lsn_id, lsn_port_id, host_obj, extra_action, action):

def lsn_port_dhcp_host_add(cluster, lsn_id, lsn_port_id, host_data):

def lsn_port_dhcp_host_remove(cluster, lsn_id, lsn_port_id, host_data):

def lsn_port_metadata_host_add(cluster, lsn_id, lsn_port_id, host_data):

def lsn_port_metadata_host_remove(cluster, lsn_id, lsn_port_id, host_data):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\queue.py

def create_lqueue(cluster, queue_data):

def delete_lqueue(cluster, queue_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\router.py

def _prepare_lrouter_body(name, neutron_router_id, tenant_id, router_type, distributed=None, **kwargs):

def _create_implicit_routing_lrouter(cluster, neutron_router_id, tenant_id, display_name, nexthop, distributed=None):

def create_implicit_routing_lrouter(cluster, neutron_router_id, tenant_id, display_name, nexthop):

def create_implicit_routing_lrouter_with_distribution( cluster, neutron_router_id, tenant_id, display_name, nexthop, distributed=None):

def create_explicit_routing_lrouter(cluster, neutron_router_id, tenant_id, display_name, nexthop, distributed=None):

def delete_lrouter(cluster, lrouter_id):

def get_lrouter(cluster, lrouter_id):

def query_lrouters(cluster, fields=None, filters=None):

def get_lrouters(cluster, tenant_id, fields=None, filters=None):

def update_implicit_routing_lrouter(cluster, r_id, display_name, nexthop):

def get_explicit_routes_lrouter(cluster, router_id, protocol_type='static'):

def delete_explicit_route_lrouter(cluster, router_id, route_id):

def create_explicit_route_lrouter(cluster, router_id, route):

def update_explicit_routes_lrouter(cluster, router_id, routes):

def get_default_route_explicit_routing_lrouter_v33(cluster, router_id):

def get_default_route_explicit_routing_lrouter_v32(cluster, router_id):

def update_default_gw_explicit_routing_lrouter(cluster, router_id, next_hop):

def update_explicit_routing_lrouter(cluster, router_id, display_name, next_hop, routes=None):

def query_lrouter_lports(cluster, lr_uuid, fields="*", filters=None, relations=None):

def create_router_lport(cluster, lrouter_uuid, tenant_id, neutron_port_id, display_name, admin_status_enabled, ip_addresses, mac_address=None):

def update_router_lport(cluster, lrouter_uuid, lrouter_port_uuid, tenant_id, neutron_port_id, display_name, admin_status_enabled, ip_addresses):

def delete_router_lport(cluster, lrouter_uuid, lport_uuid):

def delete_peer_router_lport(cluster, lr_uuid, ls_uuid, lp_uuid):

def find_router_gw_port(context, cluster, router_id):

def plug_router_port_attachment(cluster, router_id, port_id, attachment_uuid, nsx_attachment_type, attachment_vlan=None):

def _create_nat_match_obj(**kwargs):

def _create_lrouter_nat_rule(cluster, router_id, nat_rule_obj):

def _build_snat_rule_obj(min_src_ip, max_src_ip, nat_match_obj):

def create_lrouter_nosnat_rule_v2(cluster, _router_id, _match_criteria=None):

def create_lrouter_nodnat_rule_v2(cluster, _router_id, _match_criteria=None):

def create_lrouter_snat_rule_v2(cluster, router_id, min_src_ip, max_src_ip, match_criteria=None):

def create_lrouter_dnat_rule_v2(cluster, router_id, dst_ip, to_dst_port=None, match_criteria=None):

def create_lrouter_nosnat_rule_v3(cluster, router_id, order=None, match_criteria=None):

def create_lrouter_nodnat_rule_v3(cluster, router_id, order=None, match_criteria=None):

def create_lrouter_snat_rule_v3(cluster, router_id, min_src_ip, max_src_ip, order=None, match_criteria=None):

def create_lrouter_dnat_rule_v3(cluster, router_id, dst_ip, to_dst_port=None, order=None, match_criteria=None):

def delete_nat_rules_by_match(cluster, router_id, rule_type, max_num_expected, min_num_expected=0, **kwargs):

def delete_router_nat_rule(cluster, router_id, rule_id):

def query_nat_rules(cluster, router_id, fields="*", filters=None):

def update_lrouter_port_ips(cluster, lrouter_id, lport_id, ips_to_add, ips_to_remove):

def create_lrouter(cluster, *args, **kwargs):

def get_default_route_explicit_routing_lrouter(cluster, *args, **kwargs):

def update_lrouter(cluster, *args, **kwargs):

def create_lrouter_dnat_rule(cluster, *args, **kwargs):

def create_lrouter_snat_rule(cluster, *args, **kwargs):

def create_lrouter_nosnat_rule(cluster, *args, **kwargs):

def create_lrouter_nodnat_rule(cluster, *args, **kwargs):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\secgroup.py

def mk_body(**kwargs):

def query_security_profiles(cluster, fields=None, filters=None):

def create_security_profile(cluster, tenant_id, neutron_id, security_profile):

def update_security_group_rules(cluster, spid, rules):

def update_security_profile(cluster, spid, name):

def delete_security_profile(cluster, spid):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\switch.py

def _configure_extensions(lport_obj, mac_address, fixed_ips, port_security_enabled, security_profiles, queue_id, mac_learning_enabled, allowed_address_pairs):

def get_lswitch_by_id(cluster, lswitch_id):

def get_lswitches(cluster, neutron_net_id):

def create_lswitch(cluster, neutron_net_id, tenant_id, display_name, transport_zones_config, shared=None, **kwargs):

def update_lswitch(cluster, lswitch_id, display_name, tenant_id=None, **kwargs):

def delete_network(cluster, net_id, lswitch_id):

def delete_networks(cluster, net_id, lswitch_ids):

def query_lswitch_lports(cluster, ls_uuid, fields="*", filters=None, relations=None):

def delete_port(cluster, switch, port):

def get_ports(cluster, networks=None, devices=None, tenants=None):

def get_port_by_neutron_tag(cluster, lswitch_uuid, neutron_port_id):

def get_port(cluster, network, port, relations=None):

def update_port(cluster, lswitch_uuid, lport_uuid, neutron_port_id, tenant_id, display_name, device_id, admin_status_enabled, mac_address=None, fixed_ips=None, port_security_enabled=None, security_profiles=None, queue_id=None, mac_learning_enabled=None, allowed_address_pairs=None):

def create_lport(cluster, lswitch_uuid, tenant_id, neutron_port_id, display_name, device_id, admin_status_enabled, mac_address=None, fixed_ips=None, port_security_enabled=None, security_profiles=None, queue_id=None, mac_learning_enabled=None, allowed_address_pairs=None):

def get_port_status(cluster, lswitch_id, port_id):

def plug_interface(cluster, lswitch_id, lport_id, att_obj):

def plug_vif_interface( cluster, lswitch_id, port_id, port_type, attachment=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\versioning.py

def versioned(func_table):

def get_function_by_version(func_table, func_name, ver):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsxlib\__init__.py

def _build_uri_path(resource, resource_id=None, parent_resource_id=None, fields=None, relations=None, filters=None, types=None, is_attachment=False, extra_action=None):

def format_exception(etype, e, exception_locals):

def do_request(*args, **kwargs):

def get_single_query_page(path, cluster, page_cursor=None, page_length=1000, neutron_only=True):

def get_all_query_pages(path, cluster):

def mk_body(**kwargs):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\nsx_cluster.py

class NSXCluster(object):

    def __init__(self, **kwargs):

    def _sanity_check(self, options):

    def _process_attribute(self, attribute):

    def _process_nsx_controllers(self):

    def _process_nvp_controllers(self):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\plugin.py

class NsxPluginV2(addr_pair_db.AllowedAddressPairsMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, db_base_plugin_v2.NeutronDbPluginV2, dhcpmeta_modes.DhcpMetadataAccess, dist_rtr.DistributedRouter_mixin, external_net_db.External_net_db_mixin, extraroute_db.ExtraRoute_db_mixin, l3_gwmode_db.L3_NAT_db_mixin, mac_db.MacLearningDbMixin, networkgw_db.NetworkGatewayMixin, portbindings_db.PortBindingMixin, portsecurity_db.PortSecurityDbMixin, qos_db.QoSDbMixin, securitygroups_db.SecurityGroupDbMixin):

    def __init__(self):

    def _ensure_default_network_gateway(self):

    def _build_ip_address_list(self, context, fixed_ips, subnet_ids=None):

    def _create_and_attach_router_port(self, cluster, context, nsx_router_id, port_data, attachment_type, attachment, attachment_vlan=None, subnet_ids=None):

    def _update_router_gw_info(self, context, router_id, info):

    def _update_router_port_attachment(self, cluster, context, nsx_router_id, port_data, nsx_router_port_id, attachment_type, attachment, attachment_vlan=None):

    def _get_port_by_device_id(self, context, device_id, device_owner):

    def _find_router_subnets_cidrs(self, context, router_id):

    def _nsx_find_lswitch_for_port(self, context, port_data):

    def _nsx_create_port_helper(self, session, ls_uuid, port_data, do_port_security=True):

    def _handle_create_port_exception(self, context, port_id, ls_uuid, lp_uuid):

    def _nsx_create_port(self, context, port_data):

    def _nsx_delete_port(self, context, port_data):

    def _nsx_delete_router_port(self, context, port_data):

    def _nsx_create_router_port(self, context, port_data):

    def _find_router_gw_port(self, context, port_data):

    def _nsx_create_ext_gw_port(self, context, port_data):

    def _nsx_delete_ext_gw_port(self, context, port_data):

    def _nsx_create_l2_gw_port(self, context, port_data):

    def _nsx_create_fip_port(self, context, port_data):

    def _nsx_delete_fip_port(self, context, port_data):

    def _extend_fault_map(self):

    def _validate_provider_create(self, context, network):

    def _extend_network_dict_provider(self, context, network, multiprovider=None, bindings=None):

    def _handle_lswitch_selection(self, context, cluster, network, network_bindings, max_ports, allow_extra_lswitches):

    def _convert_to_nsx_transport_zones(self, cluster, network=None, bindings=None):

    def _convert_to_transport_zones_dict(self, network):

    def create_network(self, context, network):

    def delete_network(self, context, id):

    def get_network(self, context, id, fields=None):

    def get_networks(self, context, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False):

    def update_network(self, context, id, network):

    def create_port(self, context, port):

    def update_port(self, context, id, port):

    def delete_port(self, context, id, l3_port_check=True, nw_gw_port_check=True):

    def get_port(self, context, id, fields=None):

    def get_router(self, context, id, fields=None):

    def _create_lrouter(self, context, router, nexthop):

    def create_router(self, context, router):

    def _update_lrouter(self, context, router_id, name, nexthop, routes=None):

    def _update_lrouter_routes(self, context, router_id, routes):

    def update_router(self, context, router_id, router):

    def _delete_lrouter(self, context, router_id, nsx_router_id):

    def delete_router(self, context, router_id):

    def _add_subnet_snat_rule(self, context, router, subnet):

    def _delete_subnet_snat_rule(self, context, router, subnet):

    def add_router_interface(self, context, router_id, interface_info):

    def remove_router_interface(self, context, router_id, interface_info):

    def _retrieve_and_delete_nat_rules(self, context, floating_ip_address, internal_ip, nsx_router_id, min_num_rules_expected=0):

    def _remove_floatingip_address(self, context, fip_db):

    def _get_fip_assoc_data(self, context, fip, floatingip_db):

    def _update_fip_assoc(self, context, fip, floatingip_db, external_port):

    def delete_floatingip(self, context, id):

    def disassociate_floatingips(self, context, port_id):

    def create_network_gateway(self, context, network_gateway):

    def delete_network_gateway(self, context, gateway_id):

    def get_network_gateway(self, context, id, fields=None):

    def get_network_gateways(self, context, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False):

    def update_network_gateway(self, context, id, network_gateway):

    def connect_network(self, context, network_gateway_id, network_mapping_info):

    def disconnect_network(self, context, network_gateway_id, network_mapping_info):

    def _get_nsx_device_id(self, context, device_id):

    def _rollback_gw_device(self, context, device_id, gw_data=None, new_status=None, is_create=False, log_level=logging.ERROR):

    def create_gateway_device_handler(self, context, gateway_device, client_certificate):

    def update_gateway_device_handler(self, context, gateway_device, old_gateway_device_data, client_certificate):

    def get_gateway_device(self, context, device_id, fields=None):

    def get_gateway_devices(self, context, filters=None, fields=None):

    def create_gateway_device(self, context, gateway_device):

    def update_gateway_device(self, context, device_id, gateway_device):

    def delete_gateway_device(self, context, device_id):

    def create_security_group(self, context, security_group, default_sg=False):

    def update_security_group(self, context, secgroup_id, security_group):

    def delete_security_group(self, context, security_group_id):

    def _validate_security_group_rules(self, context, rules):

    def create_security_group_rule(self, context, security_group_rule):

    def create_security_group_rule_bulk(self, context, security_group_rule):

    def delete_security_group_rule(self, context, sgrid):

    def create_qos_queue(self, context, qos_queue, check_policy=True):

    def delete_qos_queue(self, context, queue_id, raise_in_use=True):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\plugins\service.py

class NsxAdvancedPlugin(sr_db.ServiceRouter_mixin, base.NsxPluginV2, rsi_db.RoutedServiceInsertionDbMixin, firewall_db.Firewall_db_mixin, loadbalancer_db.LoadBalancerPluginDb, vpn_db.VPNPluginDb ):

    def __init__(self):

    def _set_create_lswitch_proxy(self):

    def _proxy_create_lswitch(self, *args, **kwargs):

    def _load_vcns_drivers(self):

    def _set_router_type(self, router_id, router_type):

    def _get_router_type(self, context=None, router_id=None, router=None):

    def _find_router_type(self, router):

    def _is_advanced_service_router(self, context=None, router_id=None, router=None):

    def _vcns_create_ext_gw_port(self, context, port_data):

    def _vcns_delete_ext_gw_port(self, context, port_data):

    def _get_external_attachment_info(self, context, router):

    def _get_external_gateway_address(self, context, router):

    def _vcns_update_static_routes(self, context, **kwargs):

    def _get_nat_rules(self, context, router):

    def _update_nat_rules(self, context, router):

    def _update_interface(self, context, router, sync=False):

    def _update_router_gw_info(self, context, router_id, info):

    def _add_subnet_snat_rule(self, context, router, subnet):

    def _delete_subnet_snat_rule(self, context, router, subnet):

    def _remove_floatingip_address(self, context, fip_db):

    def _create_advanced_service_router(self, context, neutron_router_id, name, lrouter, lswitch):

    def _create_integration_lswitch(self, tenant_id, name):

    def _add_router_integration_interface(self, tenant_id, name, lrouter, lswitch):

    def _create_lrouter(self, context, router, nexthop):

    def _delete_lrouter(self, context, router_id, nsx_router_id):

    def _update_lrouter(self, context, router_id, name, nexthop, routes=None):

    def _retrieve_and_delete_nat_rules(self, context, floating_ip_address, internal_ip, router_id, min_num_rules_expected=0):

    def _update_fip_assoc(self, context, fip, floatingip_db, external_port):

    def _get_nsx_lrouter_status(self, id):

    def _get_vse_status(self, context, id):

    def _get_all_nsx_lrouters_statuses(self, tenant_id, fields):

    def _get_all_vse_statuses(self, context):

    def get_router(self, context, id, fields=None):

    def get_routers(self, context, filters=None, fields=None, **kwargs):

    def add_router_interface(self, context, router_id, interface_info):

    def remove_router_interface(self, context, router_id, interface_info):

    def create_floatingip(self, context, floatingip):

    def update_floatingip(self, context, id, floatingip):

    def delete_floatingip(self, context, id):

    def disassociate_floatingips(self, context, port_id):

    def _firewall_set_status( self, context, firewall_id, status, firewall=None):

    def _ensure_firewall_update_allowed(self, context, firewall_id):

    def _ensure_firewall_policy_update_allowed( self, context, firewall_policy_id):

    def _ensure_update_or_delete_firewall_rule( self, context, firewall_rule_id):

    def _make_firewall_rule_list_by_policy_id(self, context, fw_policy_id):

    def _get_edge_id_by_vcns_edge_binding(self, context, router_id):

    def _get_firewall_list_from_firewall_policy(self, context, policy_id):

    def _get_firewall_list_from_firewall_rule(self, context, rule_id):

    def _vcns_update_firewall(self, context, fw, router_id=None, **kwargs):

    def _vcns_delete_firewall(self, context, router_id=None, **kwargs):

    def create_firewall(self, context, firewall):

    def update_firewall(self, context, id, firewall):

    def delete_firewall(self, context, id):

    def get_firewall(self, context, id, fields=None):

    def get_firewalls(self, context, filters=None, fields=None):

    def update_firewall_rule(self, context, id, firewall_rule):

    def update_firewall_policy(self, context, id, firewall_policy):

    def insert_rule(self, context, id, rule_info):

    def remove_rule(self, context, id, rule_info):

    def _get_edge_id_by_vip_id(self, context, vip_id):

    def _get_all_vip_addrs_by_router_id( self, context, router_id):

    def _add_router_service_insertion_binding(self, context, resource_id, router_id, model):

    def _resource_set_status(self, context, model, id, status, obj=None, pool_id=None):

    def _vcns_create_pool_and_monitors(self, context, pool_id, **kwargs):

    def _vcns_update_pool(self, context, pool, **kwargs):

    def create_vip(self, context, vip):

    def update_vip(self, context, id, vip):

    def delete_vip(self, context, id):

    def get_vip(self, context, id, fields=None):

    def get_vips(self, context, filters=None, fields=None):

    def update_pool(self, context, id, pool):

    def create_member(self, context, member):

    def update_member(self, context, id, member):

    def delete_member(self, context, id):

    def update_health_monitor(self, context, id, health_monitor):

    def create_pool_health_monitor(self, context, health_monitor, pool_id):

    def delete_pool_health_monitor(self, context, id, pool_id):

    def _vcns_update_ipsec_config( self, context, vpnservice_id, removed_ipsec_conn_id=None):

    def create_vpnservice(self, context, vpnservice):

    def update_vpnservice(self, context, vpnservice_id, vpnservice):

    def create_ipsec_site_connection(self, context, ipsec_site_connection):

    def update_ipsec_site_connection(self, context, ipsec_site_connection_id, ipsec_site_connection):

    def delete_ipsec_site_connection(self, context, ipsec_site_conn_id):

class VcnsCallbacks(object):

    def __init__(self, plugin):

    def edge_deploy_started(self, task):

    def edge_deploy_result(self, task):

    def edge_delete_result(self, task):

    def interface_update_result(self, task):

    def snat_create_result(self, task):

    def snat_delete_result(self, task):

    def dnat_create_result(self, task):

    def dnat_delete_result(self, task):

    def routes_update_result(self, task):

    def nat_update_result(self, task):

def _process_base_create_lswitch_args(*args, **kwargs):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\plugins\__init__.py

def print_report(write_func, report):

class NetworkReport(NeutronCommand):

    def get_parser(self, prog_name):

    def run(self, parsed_args):

class NetworkMigrate(NeutronCommand):

    def get_parser(self, prog_name):

    def run(self, parsed_args):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\shell\__init__.py

class NsxManage(shell.NeutronShell):

    def __init__(self, api_version):

    def build_option_parser(self, description, version):

    def initialize_app(self, argv):

def main():

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\common\constants.py

class RouterStatus(object):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\common\exceptions.py

class VcnsException(exceptions.NeutronException):

class VcnsGeneralException(VcnsException):

    def __init__(self, message):

class VcnsBadRequest(exceptions.BadRequest):

class VcnsNotFound(exceptions.NotFound):

class VcnsApiException(VcnsException):

    def __init__(self, **kwargs):

class ResourceRedirect(VcnsApiException):

class RequestBad(VcnsApiException):

class Forbidden(VcnsApiException):

class ResourceNotFound(VcnsApiException):

class MediaTypeUnsupport(VcnsApiException):

class ServiceUnavailable(VcnsApiException):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\common\VcnsApiClient.py

def xmldumps(obj):

class VcnsApiHelper(object):

    def __init__(self, address, user, password, format='json'):

    def request(self, method, uri, params=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\common\__init__.py

class EdgeApplianceDriver(object):

    def __init__(self):

    def _assemble_edge(self, name, appliance_size="compact", deployment_container_id=None, datacenter_moid=None, enable_aesni=True, hypervisor_assist=False, enable_fips=False, remote_access=False):

    def _assemble_edge_appliance(self, resource_pool_id, datastore_id):

    def _assemble_edge_vnic(self, name, index, portgroup_id, primary_address=None, subnet_mask=None, secondary=None, type="internal", enable_proxy_arp=False, enable_send_redirects=True, is_connected=True, mtu=1500):

    def _edge_status_to_level(self, status):

    def _enable_loadbalancer(self, edge):

    def get_edge_status(self, edge_id):

    def get_edges_statuses(self):

    def _update_interface(self, task):

    def update_interface(self, router_id, edge_id, index, network, address=None, netmask=None, secondary=None, jobdata=None):

    def _deploy_edge(self, task):

    def _status_edge(self, task):

    def _result_edge(self, task):

    def _delete_edge(self, task):

    def _get_edges(self):

    def deploy_edge(self, router_id, name, internal_network, jobdata=None, wait_for_exec=False, loadbalancer_enable=True):

    def delete_edge(self, router_id, edge_id, jobdata=None):

    def _assemble_nat_rule(self, action, original_address, translated_address, vnic_index=vcns_const.EXTERNAL_VNIC_INDEX, enabled=True):

    def get_nat_config(self, edge_id):

    def _create_nat_rule(self, task):

    def create_snat_rule(self, router_id, edge_id, src, translated, jobdata=None, location=None):

    def _delete_nat_rule(self, task):

    def delete_snat_rule(self, router_id, edge_id, src, jobdata=None):

    def create_dnat_rule(self, router_id, edge_id, dst, translated, jobdata=None, location=None):

    def delete_dnat_rule(self, router_id, edge_id, translated, jobdata=None):

    def _update_nat_rule(self, task):

    def update_nat_rules(self, router_id, edge_id, snats, dnats, jobdata=None):

    def _update_routes(self, task):

    def update_routes(self, router_id, edge_id, gateway, routes, skippable=True, jobdata=None):

    def create_lswitch(self, name, tz_config, tags=None, port_isolation=False, replication_mode="service"):

    def delete_lswitch(self, lswitch_id):

    def get_loadbalancer_config(self, edge_id):

    def enable_service_loadbalancer(self, edge_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\edge_firewall_driver.py

class EdgeFirewallDriver(db_base_plugin_v2.NeutronDbPluginV2):

    def _convert_firewall_action(self, action):

    def _restore_firewall_action(self, action):

    def _get_port_range_from_min_max_ports(self, min_port, max_port):

    def _get_min_max_ports_from_range(self, port_range):

    def _convert_firewall_rule(self, context, rule, index=None):

    def _restore_firewall_rule(self, context, edge_id, response):

    def _convert_firewall(self, context, firewall):

    def _restore_firewall(self, context, edge_id, response):

    def _create_rule_id_mapping( self, context, edge_id, firewall, vcns_fw):

    def _get_firewall(self, context, edge_id):

    def _get_firewall_rule_next(self, context, edge_id, rule_vseid):

    def get_firewall_rule(self, context, id, edge_id):

    def get_firewall(self, context, edge_id):

    def update_firewall(self, context, edge_id, firewall):

    def delete_firewall(self, context, edge_id):

    def update_firewall_rule(self, context, id, edge_id, firewall_rule):

    def delete_firewall_rule(self, context, id, edge_id):

    def _add_rule_above(self, context, ref_rule_id, edge_id, firewall_rule):

    def _add_rule_below(self, context, ref_rule_id, edge_id, firewall_rule):

    def insert_rule(self, context, rule_info, edge_id, fwr):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\edge_ipsecvpn_driver.py

class EdgeIPsecVpnDriver():

    def _check_ikepolicy_ipsecpolicy_allowed(self, ikepolicy, ipsecpolicy):

    def _convert_ipsec_site(self, site, enablePfs=True):

    def update_ipsec_config(self, edge_id, sites, enabled=True):

    def delete_ipsec_config(self, edge_id):

    def get_ipsec_config(self, edge_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\edge_loadbalancer_driver.py

class EdgeLbDriver():

    def _convert_lb_vip(self, context, edge_id, vip, app_profileid):

    def _restore_lb_vip(self, context, edge_id, vip_vse):

    def _convert_lb_pool(self, context, edge_id, pool, members):

    def _restore_lb_pool(self, context, edge_id, pool_vse):

    def _convert_lb_monitor(self, context, monitor):

    def _restore_lb_monitor(self, context, edge_id, monitor_vse):

    def _convert_app_profile(self, name, sess_persist, protocol):

    def create_vip(self, context, edge_id, vip):

    def _get_vip_binding(self, session, id):

    def get_vip(self, context, id):

    def update_vip(self, context, vip, session_persistence_update=True):

    def delete_vip(self, context, id):

    def create_pool(self, context, edge_id, pool, members):

    def get_pool(self, context, id, edge_id):

    def update_pool(self, context, edge_id, pool, members):

    def delete_pool(self, context, id, edge_id):

    def create_health_monitor(self, context, edge_id, health_monitor):

    def get_health_monitor(self, context, id, edge_id):

    def update_health_monitor(self, context, edge_id, old_health_monitor, health_monitor):

    def delete_health_monitor(self, context, id, edge_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\tasks\constants.py

class TaskStatus(object):

class TaskState(object):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\tasks\tasks.py

def nop(task):

class TaskException(exceptions.NeutronException):

    def __init__(self, message=None, **kwargs):

class InvalidState(TaskException):

class TaskStateSkipped(TaskException):

class Task():

    def __init__(self, name, resource_id, execute_callback, status_callback=nop, result_callback=nop, userdata=None):

    def _add_monitor(self, action, func):

    def _move_state(self, state):

    def _invoke_monitor(self, state):

    def _start(self):

    def _executed(self):

    def _update_status(self, status):

    def _finished(self):

    def add_start_monitor(self, func):

    def add_executed_monitor(self, func):

    def add_result_monitor(self, func):

    def wait(self, state):

    def __repr__(self):

class TaskManager():

    def __init__(self, interval=None):

    def _execute(self, task):

    def _result(self, task):

    def _check_pending_tasks(self):

    def _enqueue(self, task):

    def _dequeue(self, task, run_next):

    def _abort(self):

    def _get_task(self):

    def run(self):

    def add(self, task):

    def stop(self):

    def has_pending_task(self):

    def show_pending_tasks(self):

    def count(self):

    def start(self, interval=None):

        def _inner():

        def _loopingcall_callback():

    def set_default_interval(cls, interval):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\tasks\__init__.py

class Vcns(object):

    def __init__(self, address, user, password):

    def do_request(self, method, uri, params=None, format='json', **kwargs):

    def deploy_edge(self, request):

    def get_edge_id(self, job_id):

    def get_edge_deploy_status(self, edge_id):

    def delete_edge(self, edge_id):

    def update_interface(self, edge_id, vnic):

    def get_nat_config(self, edge_id):

    def update_nat_config(self, edge_id, nat):

    def delete_nat_rule(self, edge_id, rule_id):

    def get_edge_status(self, edge_id):

    def get_edges(self):

    def update_routes(self, edge_id, routes):

    def create_lswitch(self, lsconfig):

    def delete_lswitch(self, lswitch_id):

    def get_loadbalancer_config(self, edge_id):

    def enable_service_loadbalancer(self, edge_id, config):

    def update_firewall(self, edge_id, fw_req):

    def delete_firewall(self, edge_id):

    def update_firewall_rule(self, edge_id, vcns_rule_id, fwr_req):

    def delete_firewall_rule(self, edge_id, vcns_rule_id):

    def add_firewall_rule_above(self, edge_id, ref_vcns_rule_id, fwr_req):

    def add_firewall_rule(self, edge_id, fwr_req):

    def get_firewall(self, edge_id):

    def get_firewall_rule(self, edge_id, vcns_rule_id):

    def create_vip(self, edge_id, vip_new):

    def get_vip(self, edge_id, vip_vseid):

    def update_vip(self, edge_id, vip_vseid, vip_new):

    def delete_vip(self, edge_id, vip_vseid):

    def create_pool(self, edge_id, pool_new):

    def get_pool(self, edge_id, pool_vseid):

    def update_pool(self, edge_id, pool_vseid, pool_new):

    def delete_pool(self, edge_id, pool_vseid):

    def create_health_monitor(self, edge_id, monitor_new):

    def get_health_monitor(self, edge_id, monitor_vseid):

    def update_health_monitor(self, edge_id, monitor_vseid, monitor_new):

    def delete_health_monitor(self, edge_id, monitor_vseid):

    def create_app_profile(self, edge_id, app_profile):

    def update_app_profile(self, edge_id, app_profileid, app_profile):

    def delete_app_profile(self, edge_id, app_profileid):

    def update_ipsec_config(self, edge_id, ipsec_config):

    def delete_ipsec_config(self, edge_id):

    def get_ipsec_config(self, edge_id):

    def _build_uri_path(self, edge_id, service, resource=None, resource_id=None, parent_resource_id=None, fields=None, relations=None, filters=None, types=None, is_attachment=False):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\vcns_driver.py

class VcnsDriver(edge_appliance_driver.EdgeApplianceDriver, edge_firewall_driver.EdgeFirewallDriver, edge_loadbalancer_driver.EdgeLbDriver, edge_ipsecvpn_driver.EdgeIPsecVpnDriver):

    def __init__(self, callbacks):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\vshield\__init__.py

def reset():

def init():

def get_resource_and_action(action):

def _set_rules(data):

def _is_attribute_explicitly_set(attribute_name, resource, target):

def _build_subattr_match_rule(attr_name, attr, action, target):

def _build_match_rule(action, target):

class OwnerCheck(policy.Check):

    def __init__(self, kind, match):

    def __call__(self, target, creds):

class FieldCheck(policy.Check):

    def __init__(self, kind, match):

    def __call__(self, target_dict, cred_dict):

def _prepare_check(context, action, target):

def check(context, action, target, plugin=None):

def check_if_exists(context, action, target):

def enforce(context, action, target, plugin=None):

def check_is_admin(context):

def _extract_roles(rule, roles):

def get_admin_roles():

\OpenStack\neutron-2014.1\neutron\quota.py

class ConfDriver(object):

    def _get_quotas(self, context, resources, keys):

    def limit_check(self, context, tenant_id, resources, values):

    def get_tenant_quotas(context, resources, tenant_id):

    def get_all_quotas(context, resources):

    def delete_tenant_quota(context, tenant_id):

    def update_quota_limit(context, tenant_id, resource, limit):

class BaseResource(object):

    def __init__(self, name, flag):

    def default(self):

class CountableResource(BaseResource):

    def __init__(self, name, count, flag=None):

class QuotaEngine(object):

    def __init__(self, quota_driver_class=None):

    def get_driver(self):

    def __contains__(self, resource):

    def register_resource(self, resource):

    def register_resource_by_name(self, resourcename):

    def register_resources(self, resources):

    def count(self, context, resource, *args, **kwargs):

    def limit_check(self, context, tenant_id, **values):

    def resources(self):

def _count_resource(context, plugin, resources, tenant_id):

def register_resources_from_config():

\OpenStack\neutron-2014.1\neutron\scheduler\dhcp_agent_scheduler.py

class ChanceScheduler(object):

    def _schedule_bind_network(self, context, agents, network_id):

    def schedule(self, plugin, context, network):

    def auto_schedule_networks(self, plugin, context, host):

\OpenStack\neutron-2014.1\neutron\scheduler\l3_agent_scheduler.py

class L3Scheduler(object):

    def schedule(self, plugin, context, router_id):

    def auto_schedule_routers(self, plugin, context, host, router_ids):

    def get_candidates(self, plugin, context, sync_router):

    def bind_router(self, context, router_id, chosen_agent):

class ChanceScheduler(L3Scheduler):

    def schedule(self, plugin, context, router_id):

class LeastRoutersScheduler(L3Scheduler):

    def schedule(self, plugin, context, router_id):

\OpenStack\neutron-2014.1\neutron\scheduler\__init__.py

def main():

\OpenStack\neutron-2014.1\neutron\service.py

class WsgiService(object):

    def __init__(self, app_name):

    def start(self):

    def wait(self):

class NeutronApiService(WsgiService):

    def create(cls, app_name='neutron'):

def serve_wsgi(cls):

class RpcWorker(object):

    def __init__(self, plugin):

    def start(self):

    def wait(self):

    def stop(self):

def serve_rpc():

def _run_wsgi(app_name):

class Service(service.Service):

    def __init__(self, host, binary, topic, manager, report_interval=None, periodic_interval=None, periodic_fuzzy_delay=None, *args, **kwargs):

    def start(self):

    def __getattr__(self, key):

    def create(cls, host=None, binary=None, topic=None, manager=None, report_interval=None, periodic_interval=None, periodic_fuzzy_delay=None):

    def kill(self):

    def stop(self):

    def wait(self):

    def periodic_tasks(self, raise_on_error=False):

    def report_state(self):

\OpenStack\neutron-2014.1\neutron\services\firewall\agents\firewall_agent_api.py

class FWaaSPluginApiMixin(proxy.RpcProxy):

    def __init__(self, topic, host):

    def set_firewall_status(self, context, firewall_id, status):

    def firewall_deleted(self, context, firewall_id):

class FWaaSAgentRpcCallbackMixin(object):

    def __init__(self, host):

    def create_firewall(self, context, firewall, host):

    def update_firewall(self, context, firewall, host):

    def delete_firewall(self, context, firewall, host):

\OpenStack\neutron-2014.1\neutron\services\firewall\agents\l3reference\firewall_l3_agent.py

class FWaaSL3PluginApi(api.FWaaSPluginApiMixin):

    def __init__(self, topic, host):

    def get_firewalls_for_tenant(self, context, **kwargs):

    def get_tenants_with_firewalls(self, context, **kwargs):

class FWaaSL3AgentRpcCallback(api.FWaaSAgentRpcCallbackMixin):

    def __init__(self, conf):

    def _get_router_info_list_for_tenant(self, routers, tenant_id):

    def _invoke_driver_for_plugin_api(self, context, fw, func_name):

    def _invoke_driver_for_sync_from_plugin(self, ctx, router_info_list, fw):

    def _process_router_add(self, ri):

    def process_router_add(self, ri):

    def process_services_sync(self, ctx):

    def create_firewall(self, context, firewall, host):

    def update_firewall(self, context, firewall, host):

    def delete_firewall(self, context, firewall, host):

\OpenStack\neutron-2014.1\neutron\services\firewall\agents\l3reference\__init__.py

class vArmourAPIException(Exception):

    def __init__(self, **kwargs):

    def __str__(self):

class AuthenticationFailure(vArmourAPIException):

class vArmourRestAPI(object):

    def __init__(self):

    def auth(self):

    def commit(self):

    def rest_api(self, method, url, body=None, headers=None):

    def del_cfg_objs(self, url, prefix):

    def count_cfg_objs(self, url, prefix):

\OpenStack\neutron-2014.1\neutron\services\firewall\agents\varmour\varmour_router.py

class vArmourL3NATAgent(l3_agent.L3NATAgent, firewall_l3_agent.FWaaSL3AgentRpcCallback):

    def __init__(self, host, conf=None):

    def _destroy_router_namespaces(self, only_router_id=None):

    def _destroy_router_namespace(self, namespace):

    def _create_router_namespace(self, ri):

    def _router_added(self, router_id, router):

    def _router_removed(self, router_id):

    def _spawn_metadata_proxy(self, router_id, ns_name):

    def _destroy_metadata_proxy(self, router_id, ns_name):

    def _set_subnet_info(self, port):

    def _va_unset_zone_interfaces(self, zone_name, remove_zone=False):

    def _va_pif_2_lif(self, pif):

    def _va_set_interface_ip(self, pif, cidr):

    def _va_get_port_name(self, port_list, name):

    def _va_config_trusted_zone(self, ri, plist):

    def _va_config_untrusted_zone(self, ri, plist):

    def _va_config_router_snat_rules(self, ri, plist):

    def _va_config_floating_ips(self, ri):

    def process_router(self, ri):

    def _handle_router_snat_rules(self, ri, ex_gw_port, internal_cidrs, interface_name, action):

    def _send_gratuitous_arp_packet(self, ri, interface_name, ip_address):

    def external_gateway_added(self, ri, ex_gw_port, interface_name, internal_cidrs):

    def _update_routing_table(self, ri, operation, route):

class vArmourL3NATAgentWithStateReport(vArmourL3NATAgent, l3_agent.L3NATAgentWithStateReport):

def main():

\OpenStack\neutron-2014.1\neutron\services\firewall\agents\varmour\varmour_utils.py

def get_router_object_prefix(ri):

def get_firewall_object_prefix(ri, fw):

def get_trusted_zone_name(ri):

def get_untrusted_zone_name(ri):

def get_snat_rule_name(ri):

def get_dnat_rule_name(ri):

def get_router_policy_name(ri):

def get_firewall_policy_name(ri, fw, rule):

\OpenStack\neutron-2014.1\neutron\services\firewall\agents\varmour\__init__.py

class FwaasDriverBase(object):

    def create_firewall(self, apply_list, firewall):

    def delete_firewall(self, apply_list, firewall):

    def update_firewall(self, apply_list, firewall):

    def apply_default_policy(self, apply_list, firewall):

\OpenStack\neutron-2014.1\neutron\services\firewall\drivers\linux\iptables_fwaas.py

class IptablesFwaasDriver(fwaas_base.FwaasDriverBase):

    def __init__(self):

    def create_firewall(self, apply_list, firewall):

    def delete_firewall(self, apply_list, firewall):

    def update_firewall(self, apply_list, firewall):

    def apply_default_policy(self, apply_list, firewall):

    def _setup_firewall(self, apply_list, firewall):

    def _get_chain_name(self, fwid, ver, direction):

    def _setup_chains(self, firewall, ipt_mgr):

    def _remove_default_chains(self, nsid):

    def _remove_chains(self, fwid, ipt_mgr):

    def _add_default_policy_chain_v4v6(self, ipt_mgr):

    def _remove_chain_by_name(self, ver, chain_name, ipt_mgr):

    def _add_rules_to_chain(self, ipt_mgr, ver, chain_name, rules):

    def _enable_policy_chain(self, fwid, ipt_mgr):

    def _convert_fwaas_to_iptables_rule(self, rule):

    def _drop_invalid_packets_rule(self):

    def _allow_established_rule(self):

    def _action_arg(self, action):

    def _protocol_arg(self, protocol):

    def _port_arg(self, direction, protocol, port):

    def _ip_prefix_arg(self, direction, ip_prefix):

\OpenStack\neutron-2014.1\neutron\services\firewall\drivers\linux\__init__.py

class vArmourFwaasDriver(fwaas_base.FwaasDriverBase):

    def __init__(self):

    def create_firewall(self, apply_list, firewall):

    def update_firewall(self, apply_list, firewall):

    def delete_firewall(self, apply_list, firewall):

    def apply_default_policy(self, apply_list, firewall):

    def _update_firewall(self, apply_list, firewall):

    def _setup_policy(self, ri, fw):

    def _clear_policy(self, ri, fw):

    def _make_service(self, ri, fw, rule, servs):

    def _make_service_rule(self, rule):

    def _make_address(self, ri, fw, rule, addrs, is_src):

    def _make_policy(self, name, rule, zone0, zone1, s_addr, d_addr, service):

\OpenStack\neutron-2014.1\neutron\services\firewall\drivers\varmour\__init__.py

class FirewallCallbacks(object):

    def __init__(self, plugin):

    def create_rpc_dispatcher(self):

    def set_firewall_status(self, context, firewall_id, status, **kwargs):

    def firewall_deleted(self, context, firewall_id, **kwargs):

    def get_firewalls_for_tenant(self, context, **kwargs):

    def get_firewalls_for_tenant_without_rules(self, context, **kwargs):

    def get_tenants_with_firewalls(self, context, **kwargs):

class FirewallAgentApi(proxy.RpcProxy):

    def __init__(self, topic, host):

    def create_firewall(self, context, firewall):

    def update_firewall(self, context, firewall):

    def delete_firewall(self, context, firewall):

class FirewallCountExceeded(n_exception.Conflict):

class FirewallPlugin(firewall_db.Firewall_db_mixin):

    def __init__(self):

    def _make_firewall_dict_with_rules(self, context, firewall_id):

    def _rpc_update_firewall(self, context, firewall_id):

    def _rpc_update_firewall_policy(self, context, firewall_policy_id):

    def _ensure_update_firewall(self, context, firewall_id):

    def _ensure_update_firewall_policy(self, context, firewall_policy_id):

    def _ensure_update_or_delete_firewall_rule(self, context, firewall_rule_id):

    def create_firewall(self, context, firewall):

    def update_firewall(self, context, id, firewall):

    def delete_db_firewall_object(self, context, id):

    def delete_firewall(self, context, id):

    def update_firewall_policy(self, context, id, firewall_policy):

    def update_firewall_rule(self, context, id, firewall_rule):

    def delete_firewall_rule(self, context, id):

    def insert_rule(self, context, id, rule_info):

    def remove_rule(self, context, id, rule_info):

\OpenStack\neutron-2014.1\neutron\services\firewall\__init__.py

class L3RouterPluginRpcCallbacks(l3_rpc_base.L3RpcCallbackMixin):

    def create_rpc_dispatcher(self):

class L3RouterPlugin(db_base_plugin_v2.CommonDbMixin, extraroute_db.ExtraRoute_db_mixin, l3_gwmode_db.L3_NAT_db_mixin, l3_agentschedulers_db.L3AgentSchedulerDbMixin):

    def __init__(self):

    def setup_rpc(self):

    def get_plugin_type(self):

    def get_plugin_description(self):

    def create_floatingip(self, context, floatingip):

\OpenStack\neutron-2014.1\neutron\services\l3_router\__init__.py

class LbaasAgentService(rpc_service.Service):

    def start(self):

def main():

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\agent\agent_api.py

class LbaasAgentApi(proxy.RpcProxy):

    def __init__(self, topic, context, host):

    def get_ready_devices(self):

    def pool_destroyed(self, pool_id):

    def pool_deployed(self, pool_id):

    def get_logical_device(self, pool_id):

    def update_status(self, obj_type, obj_id, status):

    def plug_vip_port(self, port_id):

    def unplug_vip_port(self, port_id):

    def update_pool_stats(self, pool_id, stats):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\agent\agent_device_driver.py

class AgentDeviceDriver(object):

    def get_name(cls):

    def deploy_instance(self, logical_config):

    def undeploy_instance(self, pool_id):

    def get_stats(self, pool_id):

    def remove_orphans(self, known_pool_ids):

    def create_vip(self, vip):

    def update_vip(self, old_vip, vip):

    def delete_vip(self, vip):

    def create_pool(self, pool):

    def update_pool(self, old_pool, pool):

    def delete_pool(self, pool):

    def create_member(self, member):

    def update_member(self, old_member, member):

    def delete_member(self, member):

    def create_pool_health_monitor(self, health_monitor, pool_id):

    def update_pool_health_monitor(self, old_health_monitor, health_monitor, pool_id):

    def delete_pool_health_monitor(self, health_monitor, pool_id):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\agent\agent_manager.py

class DeviceNotFoundOnAgent(n_exc.NotFound):

class LbaasAgentManager(periodic_task.PeriodicTasks):

    def __init__(self, conf):

    def _load_drivers(self):

    def _setup_state_rpc(self):

    def _report_state(self):

    def initialize_service_hook(self, started_by):

    def periodic_resync(self, context):

    def collect_stats(self, context):

    def sync_state(self):

    def _get_driver(self, pool_id):

    def _reload_pool(self, pool_id):

    def _destroy_pool(self, pool_id):

    def remove_orphans(self):

    def _handle_failed_driver_call(self, operation, obj_type, obj_id, driver):

    def create_vip(self, context, vip):

    def update_vip(self, context, old_vip, vip):

    def delete_vip(self, context, vip):

    def create_pool(self, context, pool, driver_name):

    def update_pool(self, context, old_pool, pool):

    def delete_pool(self, context, pool):

    def create_member(self, context, member):

    def update_member(self, context, old_member, member):

    def delete_member(self, context, member):

    def create_pool_health_monitor(self, context, health_monitor, pool_id):

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id):

    def delete_pool_health_monitor(self, context, health_monitor, pool_id):

    def agent_updated(self, context, payload):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\agent\__init__.py

class PoolLoadbalancerAgentBinding(model_base.BASEV2):

class LbaasAgentSchedulerDbMixin(agentschedulers_db.AgentSchedulerDbMixin, lbaas_agentscheduler .LbaasAgentSchedulerPluginBase):

    def get_lbaas_agent_hosting_pool(self, context, pool_id, active=None):

    def get_lbaas_agents(self, context, active=None, filters=None):

    def list_pools_on_lbaas_agent(self, context, id):

    def get_lbaas_agent_candidates(self, device_driver, active_agents):

class ChanceScheduler(object):

    def schedule(self, plugin, context, pool, device_driver):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\constants.py

class LoadBalancerAbstractDriver(object):

    def create_vip(self, context, vip):

    def update_vip(self, context, old_vip, vip):

    def delete_vip(self, context, vip):

    def create_pool(self, context, pool):

    def update_pool(self, context, old_pool, pool):

    def delete_pool(self, context, pool):

    def stats(self, context, pool_id):

    def create_member(self, context, member):

    def update_member(self, context, old_member, member):

    def delete_member(self, context, member):

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id):

    def create_pool_health_monitor(self, context, health_monitor, pool_id):

    def delete_pool_health_monitor(self, context, health_monitor, pool_id):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\common\agent_driver_base.py

class DriverNotSpecified(n_exc.NeutronException):

class LoadBalancerCallbacks(object):

    def __init__(self, plugin):

    def create_rpc_dispatcher(self):

    def get_ready_devices(self, context, host=None):

    def get_logical_device(self, context, pool_id=None):

    def pool_deployed(self, context, pool_id):

    def update_status(self, context, obj_type, obj_id, status):

    def pool_destroyed(self, context, pool_id=None):

    def plug_vip_port(self, context, port_id=None, host=None):

    def unplug_vip_port(self, context, port_id=None, host=None):

    def update_pool_stats(self, context, pool_id=None, stats=None, host=None):

class LoadBalancerAgentApi(proxy.RpcProxy):

    def __init__(self, topic):

    def _cast(self, context, method_name, method_args, host, version=None):

    def create_vip(self, context, vip, host):

    def update_vip(self, context, old_vip, vip, host):

    def delete_vip(self, context, vip, host):

    def create_pool(self, context, pool, host, driver_name):

    def update_pool(self, context, old_pool, pool, host):

    def delete_pool(self, context, pool, host):

    def create_member(self, context, member, host):

    def update_member(self, context, old_member, member, host):

OpenStack Index

• index_neutron.htm
• index_neutron_1.htm
• index_neutron_10.htm
• index_neutron_11.htm
• index_neutron_12.htm
• index_neutron_13.htm
• index_neutron_14.htm
• index_neutron_15.htm
• index_neutron_16.htm
• index_neutron_17.htm
• index_neutron_18.htm
• index_neutron_2.htm
• index_neutron_3.htm
• index_neutron_4.htm
• index_neutron_5.htm
• index_neutron_6.htm
• index_neutron_7.htm
• index_neutron_8.htm
• index_neutron_9.htm