OpenStack Study: neutron

OpenStack Index

class NVSDAgentRpcCallback(object):

    def __init__(self, context, agent, sg_agent):

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

class SecurityGroupServerRpcApi(proxy.RpcProxy, sg_rpc.SecurityGroupServerRpcApiMixin):

    def __init__(self, topic):

class SecurityGroupAgentRpcCallback( sg_rpc.SecurityGroupAgentRpcCallbackMixin):

    def __init__(self, context, sg_agent):

class SecurityGroupAgentRpc(sg_rpc.SecurityGroupAgentRpcMixin):

    def __init__(self, context, root_helper):

class NVSDNeutronAgent(object):

    def __init__(self, integ_br, root_helper, polling_interval):

    def setup_rpc(self):

    def _update_ports(self, registered_ports):

    def _process_devices_filter(self, port_info):

    def daemon_loop(self):

def main():

\OpenStack\neutron-2014.1\neutron\plugins\oneconvergence\agent\__init__.py

class NVSDAPIException(n_exc.NeutronException):

class RequestTimeout(NVSDAPIException):

class UnAuthorizedException(NVSDAPIException):

class NotFoundException(NVSDAPIException):

class BadRequestException(NVSDAPIException):

class ServerException(NVSDAPIException):

class ConnectionClosedException(NVSDAPIException):

class ForbiddenException(NVSDAPIException):

class InternalServerError(NVSDAPIException):

\OpenStack\neutron-2014.1\neutron\plugins\oneconvergence\lib\nvsdlib.py

class NVSDApi(object):

    def build_error_msg(self, method, resource, tenant_id, resource_id):

    def set_connection(self):

    def send_request(self, method, uri, body=None, resource=None, tenant_id='', resource_id=None):

    def create_network(self, network):

    def update_network(self, network, network_update):

    def delete_network(self, network, subnets=[]):

    def create_subnet(self, subnet):

    def delete_subnet(self, subnet):

    def update_subnet(self, subnet, subnet_update):

    def create_port(self, tenant_id, port):

    def update_port(self, tenant_id, port, port_update):

    def delete_port(self, port_id, port):

    def _get_ports(self, tenant_id, network_id):

    def create_floatingip(self, floating_ip):

    def update_floatingip(self, floating_ip, floating_ip_update):

    def delete_floatingip(self, floating_ip):

    def create_router(self, router):

    def update_router(self, router):

    def delete_router(self, tenant_id, router_id):

\OpenStack\neutron-2014.1\neutron\plugins\oneconvergence\lib\nvsd_db.py

def get_port_from_device(port_id):

\OpenStack\neutron-2014.1\neutron\plugins\oneconvergence\lib\plugin_helper.py

def initialize_plugin_helper():

class NVSDController(object):

    def __init__(self):

    def do_request(self, method, url=None, headers=None, data=None, timeout=10):

    def login(self):

    def request(self, method, url, body="", content_type="application/json"):

\OpenStack\neutron-2014.1\neutron\plugins\oneconvergence\lib\__init__.py

class NVSDPluginRpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin, l3_rpc_base.L3RpcCallbackMixin, sg_db_rpc.SecurityGroupServerRpcCallbackMixin):

    def create_rpc_dispatcher(self):

    def get_port_from_device(device):

class NVSDPluginV2AgentNotifierApi(rpc.proxy.RpcProxy, sg_rpc.SecurityGroupAgentRpcApiMixin):

    def __init__(self, topic):

    def port_update(self, context, port):

class OneConvergencePluginV2(db_base_plugin_v2.NeutronDbPluginV2, extraroute_db.ExtraRoute_db_mixin, l3_agentschedulers_db.L3AgentSchedulerDbMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, external_net_db.External_net_db_mixin, l3_gwmode_db.L3_NAT_db_mixin, portbindings_base.PortBindingBaseMixin, sg_db_rpc.SecurityGroupServerRpcMixin):

    def supported_extension_aliases(self):

    def __init__(self):

    def oneconvergence_init(self):

    def setup_rpc(self):

    def create_network(self, context, network):

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

    def delete_network(self, context, net_id):

    def create_subnet(self, context, subnet):

    def delete_subnet(self, context, subnet_id):

    def update_subnet(self, context, subnet_id, subnet):

    def create_port(self, context, port):

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

    def delete_port(self, context, port_id, l3_port_check=True):

    def create_floatingip(self, context, floatingip):

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

    def delete_floatingip(self, context, floating_ip_id):

    def create_router(self, context, router):

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

    def delete_router(self, context, router_id):

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

class LocalVLANMapping:

    def __init__(self, vlan, network_type, physical_network, segmentation_id, vif_ports=None):

    def __str__(self):

class Port(object):

    def __init__(self, p):

    def __eq__(self, other):

    def __ne__(self, other):

    def __hash__(self):

class OVSPluginApi(agent_rpc.PluginApi, sg_rpc.SecurityGroupServerRpcApiMixin):

class OVSSecurityGroupAgent(sg_rpc.SecurityGroupAgentRpcMixin):

    def __init__(self, context, plugin_rpc, root_helper):

class OVSNeutronAgent(sg_rpc.SecurityGroupAgentRpcCallbackMixin, l2population_rpc.L2populationRpcCallBackMixin):

    def __init__(self, integ_br, tun_br, local_ip, bridge_mappings, root_helper, polling_interval, tunnel_types=None, veth_mtu=None, l2_population=False, minimize_polling=False, ovsdb_monitor_respawn_interval=( constants.DEFAULT_OVSDBMON_RESPAWN)):

    def _check_ovs_version(self):

    def _report_state(self):

    def setup_rpc(self):

    def get_net_uuid(self, vif_id):

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

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

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

    def fdb_add(self, context, fdb_entries):

    def fdb_remove(self, context, fdb_entries):

    def _add_fdb_flow(self, port_info, agent_ip, lvm, ofport):

    def _del_fdb_flow(self, port_info, agent_ip, lvm, ofport):

    def fdb_update(self, context, fdb_entries):

    def create_rpc_dispatcher(self):

    def provision_local_vlan(self, net_uuid, network_type, physical_network, segmentation_id):

    def reclaim_local_vlan(self, net_uuid):

    def port_bound(self, port, net_uuid, network_type, physical_network, segmentation_id):

    def port_unbound(self, vif_id, net_uuid=None):

    def port_dead(self, port):

    def setup_integration_br(self):

    def setup_ancillary_bridges(self, integ_br, tun_br):

    def setup_tunnel_br(self, tun_br):

    def setup_physical_bridges(self, bridge_mappings):

    def scan_ports(self, registered_ports, updated_ports=None):

    def check_changed_vlans(self, registered_ports):

    def update_ancillary_ports(self, registered_ports):

    def treat_vif_port(self, vif_port, port_id, network_id, network_type, physical_network, segmentation_id, admin_state_up):

    def setup_tunnel_port(self, port_name, remote_ip, tunnel_type):

    def cleanup_tunnel_port(self, tun_ofport, tunnel_type):

    def treat_devices_added_or_updated(self, devices):

    def treat_ancillary_devices_added(self, devices):

    def treat_devices_removed(self, devices):

    def treat_ancillary_devices_removed(self, devices):

    def process_network_ports(self, port_info):

    def process_ancillary_network_ports(self, port_info):

    def get_ip_in_hex(self, ip_address):

    def tunnel_sync(self):

    def _agent_has_updates(self, polling_manager):

    def _port_info_has_changes(self, port_info):

    def rpc_loop(self, polling_manager=None):

    def daemon_loop(self):

def handle_sigterm(signum, frame):

def create_agent_config_map(config):

def main():

\OpenStack\neutron-2014.1\neutron\plugins\openvswitch\agent\__init__.py

def get_network_binding(session, network_id):

def add_network_binding(session, network_id, network_type, physical_network, segmentation_id):

def sync_vlan_allocations(network_vlan_ranges):

def get_vlan_allocation(physical_network, vlan_id):

def reserve_vlan(session):

def reserve_specific_vlan(session, physical_network, vlan_id):

def release_vlan(session, physical_network, vlan_id, network_vlan_ranges):

def sync_tunnel_allocations(tunnel_id_ranges):

def get_tunnel_allocation(tunnel_id):

def reserve_tunnel(session):

def reserve_specific_tunnel(session, tunnel_id):

def release_tunnel(session, tunnel_id, tunnel_id_ranges):

def get_port(port_id):

def get_port_from_device(port_id):

def set_port_status(port_id, status):

def get_tunnel_endpoints():

def _generate_tunnel_id(session):

def add_tunnel_endpoint(ip, max_retries=10):

\OpenStack\neutron-2014.1\neutron\plugins\openvswitch\ovs_models_v2.py

class VlanAllocation(model_base.BASEV2):

    def __init__(self, physical_network, vlan_id):

    def __repr__(self):

class TunnelAllocation(model_base.BASEV2):

    def __init__(self, tunnel_id):

    def __repr__(self):

class NetworkBinding(model_base.BASEV2):

    def __init__(self, network_id, network_type, physical_network, segmentation_id):

    def __repr__(self):

class TunnelEndpoint(model_base.BASEV2):

    def __init__(self, ip_address, id):

    def __repr__(self):

\OpenStack\neutron-2014.1\neutron\plugins\openvswitch\ovs_neutron_plugin.py

class OVSRpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin, l3_rpc_base.L3RpcCallbackMixin, sg_db_rpc.SecurityGroupServerRpcCallbackMixin):

    def __init__(self, notifier, tunnel_type):

    def create_rpc_dispatcher(self):

    def get_port_from_device(cls, device):

    def get_device_details(self, rpc_context, **kwargs):

    def update_device_down(self, rpc_context, **kwargs):

    def update_device_up(self, rpc_context, **kwargs):

    def tunnel_sync(self, rpc_context, **kwargs):

class AgentNotifierApi(proxy.RpcProxy, sg_rpc.SecurityGroupAgentRpcApiMixin):

    def __init__(self, topic):

    def network_delete(self, context, network_id):

    def port_update(self, context, port, network_type, segmentation_id, physical_network):

    def tunnel_update(self, context, tunnel_ip, tunnel_id, tunnel_type):

class OVSNeutronPluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, extraroute_db.ExtraRoute_db_mixin, l3_gwmode_db.L3_NAT_db_mixin, sg_db_rpc.SecurityGroupServerRpcMixin, l3_agentschedulers_db.L3AgentSchedulerDbMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, portbindings_db.PortBindingMixin, extradhcpopt_db.ExtraDhcpOptMixin, addr_pair_db.AllowedAddressPairsMixin):

    def supported_extension_aliases(self):

    def __init__(self, configfile=None):

    def setup_rpc(self):

    def _parse_network_vlan_ranges(self):

    def _parse_tunnel_id_ranges(self):

    def _extend_network_dict_provider_ovs(self, network, net_db, net_binding=None):

    def _process_provider_create(self, context, attrs):

    def create_network(self, context, network):

    def update_network(self, context, id, 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 create_port(self, context, port):

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

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

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

class PLUMgridException(base_exec.NeutronException):

class PLUMgridConnectionFailed(PLUMgridException):

\OpenStack\neutron-2014.1\neutron\plugins\plumgrid\common\__init__.py

class Plumlib():

    def __init__(self):

    def director_conn(self, director_plumgrid, director_port, timeout, director_admin, director_password):

    def create_network(self, tenant_id, net_db, network):

    def update_network(self, tenant_id, net_id):

    def delete_network(self, net_db, net_id):

    def create_subnet(self, sub_db, net_db, ipnet):

    def update_subnet(self, org_sub_db, new_sub_db, ipnet):

    def delete_subnet(self, tenant_id, net_db, net_id):

    def create_port(self, port_db, router_db):

    def update_port(self, port_db, router_db):

    def delete_port(self, port_db, router_db):

    def create_router(self, tenant_id, router_db):

    def update_router(self, router_db, router_id):

    def delete_router(self, tenant_id, router_id):

    def add_router_interface(self, tenant_id, router_id, port_db, ipnet):

    def remove_router_interface(self, tenant_id, net_id, router_id):

    def create_floatingip(self, net_db, floating_ip):

    def update_floatingip(self, net_db, floating_ip, id):

    def delete_floatingip(self, net_db, floating_ip_org, id):

\OpenStack\neutron-2014.1\neutron\plugins\plumgrid\drivers\plumlib.py

class Plumlib(object):

    def __init__(self):

    def director_conn(self, director_plumgrid, director_port, timeout, director_admin, director_password):

    def create_network(self, tenant_id, net_db, network):

    def update_network(self, tenant_id, net_id):

    def delete_network(self, net_db, net_id):

    def create_subnet(self, sub_db, net_db, ipnet):

    def update_subnet(self, org_sub_db, new_sub_db, ipnet):

    def delete_subnet(self, tenant_id, net_db, net_id):

    def create_port(self, port_db, router_db):

    def update_port(self, port_db, router_db):

    def delete_port(self, port_db, router_db):

    def create_router(self, tenant_id, router_db):

    def update_router(self, router_db, router_id):

    def delete_router(self, tenant_id, router_id):

    def add_router_interface(self, tenant_id, router_id, port_db, ipnet):

    def remove_router_interface(self, tenant_id, net_id, router_id):

    def create_floatingip(self, net_db, floating_ip):

    def update_floatingip(self, net_db, floating_ip, id):

    def delete_floatingip(self, net_db, floating_ip_org, id):

\OpenStack\neutron-2014.1\neutron\plugins\plumgrid\drivers\__init__.py

class NeutronPluginPLUMgridV2(db_base_plugin_v2.NeutronDbPluginV2, portbindings_db.PortBindingMixin, external_net_db.External_net_db_mixin, l3_db.L3_NAT_db_mixin):

    def __init__(self):

    def plumgrid_init(self):

    def create_network(self, context, network):

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

    def delete_network(self, context, net_id):

    def create_port(self, context, port):

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

    def delete_port(self, context, port_id, l3_port_check=True):

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

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

    def create_subnet(self, context, subnet):

    def delete_subnet(self, context, subnet_id):

    def update_subnet(self, context, subnet_id, subnet):

    def create_router(self, context, router):

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

    def delete_router(self, context, router_id):

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

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

    def create_floatingip(self, context, floatingip):

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

    def delete_floatingip(self, context, id):

    def _get_plugin_version(self):

    def _port_viftype_binding(self, context, port):

    def _network_admin_state(self, network):

    def _allocate_pools_for_subnet(self, context, subnet):

\OpenStack\neutron-2014.1\neutron\plugins\plumgrid\plumgrid_plugin\__init__.py

def _get_my_ip():

def _get_ip_from_nic(nic):

def _get_ip(cfg_ip_str, cfg_interface_str):

def _get_tunnel_ip():

def _get_ovsdb_ip():

class OVSBridge(ovs_lib.OVSBridge):

    def __init__(self, br_name, root_helper):

    def find_datapath_id(self):

    def set_manager(self, target):

    def get_ofport(self, name):

    def _get_ports(self, get_port):

    def _get_external_port(self, name):

    def get_external_ports(self):

class VifPortSet(object):

    def __init__(self, int_br, ryu_rest_client):

    def setup(self):

class RyuPluginApi(agent_rpc.PluginApi, sg_rpc.SecurityGroupServerRpcApiMixin):

    def get_ofp_rest_api_addr(self, context):

class RyuSecurityGroupAgent(sg_rpc.SecurityGroupAgentRpcMixin):

    def __init__(self, context, plugin_rpc, root_helper):

class OVSNeutronOFPRyuAgent(sg_rpc.SecurityGroupAgentRpcCallbackMixin):

    def __init__(self, integ_br, tunnel_ip, ovsdb_ip, ovsdb_port, polling_interval, root_helper):

    def _setup_rpc(self):

    def _create_rpc_dispatcher(self):

    def _setup_integration_br(self, root_helper, integ_br, tunnel_ip, ovsdb_port, ovsdb_ip):

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

    def _update_ports(self, registered_ports):

    def _process_devices_filter(self, port_info):

    def daemon_loop(self):

def main():

\OpenStack\neutron-2014.1\neutron\plugins\ryu\agent\__init__.py

def network_all_tenant_list():

def get_port_from_device(port_id):

class TunnelKey(object):

    def __init__(self, key_min=_KEY_MIN_HARD, key_max=_KEY_MAX_HARD):

    def _last_key(self, session):

    def _find_key(self, session, last_key):

    def _allocate(self, session, network_id):

    def allocate(self, session, network_id):

    def delete(self, session, network_id):

    def all_list(self):

def set_port_status(session, port_id, status):

\OpenStack\neutron-2014.1\neutron\plugins\ryu\db\models_v2.py

class TunnelKeyLast(model_base.BASEV2):

    def __repr__(self):

class TunnelKey(model_base.BASEV2):

    def __repr__(self):

\OpenStack\neutron-2014.1\neutron\plugins\ryu\db\__init__.py

class RyuRpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin, l3_rpc_base.L3RpcCallbackMixin, sg_db_rpc.SecurityGroupServerRpcCallbackMixin):

    def __init__(self, ofp_rest_api_addr):

    def create_rpc_dispatcher(self):

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

    def get_port_from_device(cls, device):

class AgentNotifierApi(proxy.RpcProxy, sg_rpc.SecurityGroupAgentRpcApiMixin):

    def __init__(self, topic):

    def port_update(self, context, port):

class RyuNeutronPluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, extraroute_db.ExtraRoute_db_mixin, l3_gwmode_db.L3_NAT_db_mixin, sg_db_rpc.SecurityGroupServerRpcMixin, portbindings_base.PortBindingBaseMixin):

    def supported_extension_aliases(self):

    def __init__(self, configfile=None):

    def _setup_rpc(self):

    def _create_all_tenant_network(self):

    def _client_create_network(self, net_id, tunnel_key):

    def _client_delete_network(self, net_id):

    def create_network(self, context, network):

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

    def delete_network(self, context, id):

    def create_port(self, context, port):

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

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

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

class ApiClientBase(object):

    def _create_connection(self, host, port, is_ssl):

    def _conn_params(http_conn):

    def user(self):

    def password(self):

    def config_gen(self):

    def config_gen(self, value):

    def auth_cookie(self, conn):

    def set_auth_cookie(self, conn, cookie):

    def acquire_connection(self, auto_login=True, headers=None, rid=-1):

    def release_connection(self, http_conn, bad_state=False, service_unavail=False, rid=-1):

    def _wait_for_login(self, conn, headers=None):

    def _get_provider_data(self, conn_or_conn_params, default=None):

    def _set_provider_data(self, conn_or_conn_params, data):

    def _normalize_conn_params(self, conn_or_conn_params):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\api_client\client.py

class NsxApiClient(eventlet_client.EventletApiClient):

    def __init__(self, api_providers, user, password, concurrent_connections=base.DEFAULT_CONCURRENT_CONNECTIONS, gen_timeout=base.GENERATION_ID_TIMEOUT, use_https=True, connect_timeout=base.DEFAULT_CONNECT_TIMEOUT, request_timeout=30, http_timeout=10, retries=2, redirects=2):

    def login(self, user=None, password=None):

    def request(self, method, url, body="", content_type="application/json"):

    def get_version(self):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\api_client\eventlet_client.py

class EventletApiClient(base.ApiClientBase):

    def __init__(self, api_providers, user, password, concurrent_connections=base.DEFAULT_CONCURRENT_CONNECTIONS, gen_timeout=base.GENERATION_ID_TIMEOUT, use_https=True, connect_timeout=base.DEFAULT_CONNECT_TIMEOUT):

    def acquire_redirect_connection(self, conn_params, auto_login=True, headers=None):

    def _login(self, conn=None, headers=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\api_client\eventlet_request.py

class EventletApiRequest(request.ApiRequest):

    def __init__(self, client_obj, url, method="GET", body=None, headers=None, request_timeout=request.DEFAULT_REQUEST_TIMEOUT, retries=request.DEFAULT_RETRIES, auto_login=True, redirects=request.DEFAULT_REDIRECTS, http_timeout=request.DEFAULT_HTTP_TIMEOUT, client_conn=None):

    def _spawn(cls, func, *args, **kwargs):

    def spawn(self, func, *args, **kwargs):

    def joinall(cls):

    def join(self):

    def start(self):

    def copy(self):

    def _run(self):

    def _handle_request(self):

class LoginRequestEventlet(EventletApiRequest):

    def __init__(self, client_obj, user, password, client_conn=None, headers=None):

    def session_cookie(self):

class GetApiProvidersRequestEventlet(EventletApiRequest):

    def __init__(self, client_obj):

    def api_providers(self):

        def _provider_from_listen_addr(addr):

class GenericRequestEventlet(EventletApiRequest):

    def __init__(self, client_obj, method, url, body, content_type, auto_login=False, request_timeout=request.DEFAULT_REQUEST_TIMEOUT, http_timeout=request.DEFAULT_HTTP_TIMEOUT, retries=request.DEFAULT_RETRIES, redirects=request.DEFAULT_REDIRECTS):

    def session_cookie(self):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\api_client\exception.py

class NsxApiException(Exception):

    def __init__(self, **kwargs):

    def __str__(self):

class UnAuthorizedRequest(NsxApiException):

class ResourceNotFound(NsxApiException):

class Conflict(NsxApiException):

class ServiceUnavailable(NsxApiException):

class Forbidden(NsxApiException):

class ReadOnlyMode(Forbidden):

class RequestTimeout(NsxApiException):

class BadRequest(NsxApiException):

class InvalidSecurityCertificate(BadRequest):

def fourZeroZero(response=None):

def fourZeroFour(response=None):

def fourZeroNine(response=None):

def fiveZeroThree(response=None):

def fourZeroThree(response=None):

def zero(self, response=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\api_client\request.py

class ApiRequest(object):

    def start(self):

    def join(self):

    def copy(self):

    def _issue_request(self):

    def _redirect_params(self, conn, headers, allow_release_conn=False):

    def _rid(self):

    def request_error(self):

    def _request_str(self, conn, url):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\api_client\version.py

def find_version(headers):

class Version(object):

    def __init__(self, version):

    def __str__(self):

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

def ctrl_conn_to_str(conn):

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

def help(name):

def get_nsx_controllers(cluster):

def config_helper(config_entity, cluster):

def get_control_cluster_nodes(cluster):

def get_gateway_services(cluster):

def get_transport_zones(cluster):

def get_transport_nodes(cluster):

def is_transport_node_connected(cluster, node_uuid):

def main():

\OpenStack\neutron-2014.1\neutron\plugins\vmware\common\config.py

class ReplicationModes:

def validate_config_options():

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

class NsxPluginException(n_exc.NeutronException):

class InvalidVersion(NsxPluginException):

class InvalidConnection(NsxPluginException):

class InvalidClusterConfiguration(NsxPluginException):

class InvalidNovaZone(NsxPluginException):

class NoMorePortsException(NsxPluginException):

class NatRuleMismatch(NsxPluginException):

class InvalidAttachmentType(NsxPluginException):

class MaintenanceInProgress(NsxPluginException):

class L2GatewayAlreadyInUse(n_exc.Conflict):

class InvalidSecurityCertificate(NsxPluginException):

class ServiceOverQuota(n_exc.Conflict):

class VcnsDriverException(NsxPluginException):

class ServiceClusterUnavailable(NsxPluginException):

class PortConfigurationError(NsxPluginException):

    def __init__(self, **kwargs):

class LsnNotFound(n_exc.NotFound):

class LsnPortNotFound(n_exc.NotFound):

class LsnMigrationConflict(n_exc.Conflict):

class LsnConfigurationConflict(NsxPluginException):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\common\nsx_utils.py

def fetch_nsx_switches(session, cluster, neutron_net_id):

def get_nsx_switch_ids(session, cluster, neutron_network_id):

def get_nsx_switch_and_port_id(session, cluster, neutron_port_id):

def get_nsx_security_group_id(session, cluster, neutron_id):

def get_nsx_router_id(session, cluster, neutron_router_id):

def create_nsx_cluster(cluster_opts, concurrent_connections, gen_timeout):

def get_nsx_device_status(cluster, nsx_uuid):

def get_nsx_device_statuses(cluster, tenant_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\common\securitygroups.py

def _convert_to_nsx_rule(session, cluster, rule, with_id=False):

def _convert_to_nsx_rules(session, cluster, rules, with_id=False):

def get_security_group_rules_nsx_format(session, cluster, security_group_rules, with_id=False):

def merge_security_group_rules_with_current(session, cluster, new_rules, current_rules):

def remove_security_group_with_id_and_id_field(rules, rule_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\common\sync.py

class NsxCache(object):

    def __init__(self):

    def __getitem__(self, key):

    def _update_resources(self, resources, new_resources):

        def do_hash(item):

    def _delete_resources(self, resources):

    def _get_resource_ids(self, resources, changed_only):

    def get_lswitches(self, changed_only=False):

    def get_lrouters(self, changed_only=False):

    def get_lswitchports(self, changed_only=False):

    def update_lswitch(self, lswitch):

    def update_lrouter(self, lrouter):

    def update_lswitchport(self, lswitchport):

    def process_updates(self, lswitches=None, lrouters=None, lswitchports=None):

    def process_deletes(self):

class SyncParameters():

    def __init__(self, min_chunk_size):

def _start_loopingcall(min_chunk_size, state_sync_interval, func):

class NsxSynchronizer():

    def __init__(self, plugin, cluster, state_sync_interval, req_delay, min_chunk_size, max_rand_delay=0):

    def _get_tag_dict(self, tags):

    def synchronize_network(self, context, neutron_network_data, lswitches=None):

    def _synchronize_lswitches(self, ctx, ls_uuids, scan_missing=False):

    def synchronize_router(self, context, neutron_router_data, lrouter=None):

    def _synchronize_lrouters(self, ctx, lr_uuids, scan_missing=False):

    def synchronize_port(self, context, neutron_port_data, lswitchport=None, ext_networks=None):

    def _synchronize_lswitchports(self, ctx, lp_uuids, scan_missing=False):

    def _get_chunk_size(self, sp):

    def _fetch_data(self, uri, cursor, page_size):

    def _fetch_nsx_data_chunk(self, sp):

    def _synchronize_state(self, sp):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\common\utils.py

class NetworkTypes:

def get_tags(**kwargs):

def device_id_to_vm_id(device_id, obfuscate=False):

def check_and_truncate(display_name):

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

def get_network_bindings(session, network_id):

def get_network_bindings_by_vlanid(session, vlan_id):

def add_network_binding(session, network_id, binding_type, phy_uuid, vlan_id):

def add_neutron_nsx_network_mapping(session, neutron_id, nsx_switch_id):

def add_neutron_nsx_port_mapping(session, neutron_id, nsx_switch_id, nsx_port_id):

def add_neutron_nsx_router_mapping(session, neutron_id, nsx_router_id):

def add_neutron_nsx_security_group_mapping(session, neutron_id, nsx_id):

def get_nsx_switch_ids(session, neutron_id):

def get_nsx_switch_and_port_id(session, neutron_id):

def get_nsx_router_id(session, neutron_id):

def get_nsx_security_group_id(session, neutron_id):

def _delete_by_neutron_id(session, model, neutron_id):

def delete_neutron_nsx_port_mapping(session, neutron_id):

def delete_neutron_nsx_router_mapping(session, neutron_id):

def unset_default_network_gateways(session):

def set_default_network_gateway(session, gw_id):

def set_multiprovider_network(session, network_id):

def is_multiprovider_network(session, network_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\distributedrouter.py

class DistributedRouter_mixin(nsxrouter.NsxRouterMixin):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\lsn_db.py

class LsnPort(models_v2.model_base.BASEV2):

    def __init__(self, lsn_port_id, subnet_id, mac_address, lsn_id):

class Lsn(models_v2.model_base.BASEV2):

    def __init__(self, net_id, lsn_id):

def lsn_add(context, network_id, lsn_id):

def lsn_remove(context, lsn_id):

def lsn_remove_for_network(context, network_id):

def lsn_get_for_network(context, network_id, raise_on_err=True):

def lsn_port_add_for_lsn(context, lsn_port_id, subnet_id, mac, lsn_id):

def lsn_port_get_for_subnet(context, subnet_id, raise_on_err=True):

def lsn_port_get_for_mac(context, mac_address, raise_on_err=True):

def lsn_port_remove(context, lsn_port_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\maclearning.py

class MacLearningState(model_base.BASEV2):

class MacLearningDbMixin(object):

    def _make_mac_learning_state_dict(self, port, fields=None):

    def _extend_port_mac_learning_state(self, port_res, port_db):

    def _update_mac_learning_state(self, context, port_id, enabled):

    def _create_mac_learning_state(self, context, port):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\models.py

class TzNetworkBinding(model_base.BASEV2):

    def __init__(self, network_id, binding_type, phy_uuid, vlan_id):

    def __repr__(self):

class NeutronNsxNetworkMapping(model_base.BASEV2):

class NeutronNsxSecurityGroupMapping(model_base.BASEV2):

class NeutronNsxPortMapping(model_base.BASEV2):

    def __init__(self, neutron_id, nsx_switch_id, nsx_port_id):

class NeutronNsxRouterMapping(model_base.BASEV2):

class MultiProviderNetworks(model_base.BASEV2):

    def __init__(self, network_id):

class NSXRouterExtAttributes(model_base.BASEV2):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\networkgw_db.py

class GatewayInUse(exceptions.InUse):

class GatewayNotFound(exceptions.NotFound):

class GatewayDeviceInUse(exceptions.InUse):

class GatewayDeviceNotFound(exceptions.NotFound):

class NetworkGatewayPortInUse(exceptions.InUse):

class GatewayConnectionInUse(exceptions.InUse):

class MultipleGatewayConnections(exceptions.NeutronException):

class GatewayConnectionNotFound(exceptions.NotFound):

class NetworkGatewayUnchangeable(exceptions.InUse):

class NetworkConnection(model_base.BASEV2, models_v2.HasTenant):

class NetworkGatewayDeviceReference(model_base.BASEV2):

class NetworkGatewayDevice(model_base.BASEV2, models_v2.HasId, models_v2.HasTenant):

class NetworkGateway(model_base.BASEV2, models_v2.HasId, models_v2.HasTenant):

class NetworkGatewayMixin(networkgw.NetworkGatewayPluginBase):

    def _get_network_gateway(self, context, gw_id):

    def _make_gw_connection_dict(self, gw_conn):

    def _make_network_gateway_dict(self, network_gateway, fields=None):

    def _set_mapping_info_defaults(self, mapping_info):

    def _validate_network_mapping_info(self, network_mapping_info):

    def _retrieve_gateway_connections(self, context, gateway_id, mapping_info={}, only_one=False):

    def _unset_default_network_gateways(self, context):

    def _set_default_network_gateway(self, context, gw_id):

    def prevent_network_gateway_port_deletion(self, context, port):

    def create_network_gateway(self, context, network_gateway):

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

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

    def delete_network_gateway(self, context, id):

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

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

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

    def _make_gateway_device_dict(self, gateway_device, fields=None, include_nsx_id=False):

    def _get_gateway_device(self, context, device_id):

    def _is_device_in_use(self, context, device_id):

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

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

    def create_gateway_device(self, context, gateway_device, initial_status=STATUS_UNKNOWN):

    def update_gateway_device(self, context, gateway_device_id, gateway_device, include_nsx_id=False):

    def delete_gateway_device(self, context, device_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\nsxrouter.py

class NsxRouterMixin(object):

    def _extend_nsx_router_dict(self, router_res, router_db):

    def _process_nsx_router_create( self, context, router_db, router_req):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\qos_db.py

class QoSQueue(model_base.BASEV2, models_v2.HasId, models_v2.HasTenant):

class PortQueueMapping(model_base.BASEV2):

class NetworkQueueMapping(model_base.BASEV2):

class QoSDbMixin(qos.QueuePluginBase):

    def create_qos_queue(self, context, qos_queue):

    def get_qos_queue(self, context, queue_id, fields=None):

    def _get_qos_queue(self, context, queue_id):

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

    def delete_qos_queue(self, context, queue_id):

    def _process_port_queue_mapping(self, context, port_data, queue_id):

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

    def _delete_port_queue_mapping(self, context, port_id):

    def _process_network_queue_mapping(self, context, net_data, queue_id):

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

    def _delete_network_queue_mapping(self, context, network_id):

    def _extend_dict_qos_queue(self, obj_res, obj_db):

    def _extend_port_dict_qos_queue(self, port_res, port_db):

    def _extend_network_dict_qos_queue(self, network_res, network_db):

    def _make_qos_queue_dict(self, queue, fields=None):

    def _make_port_queue_binding_dict(self, queue, fields=None):

    def _make_network_queue_binding_dict(self, queue, fields=None):

    def _check_for_queue_and_create(self, context, port):

    def _validate_qos_queue(self, context, qos_queue):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\servicerouter.py

class ServiceRouter_mixin(dist_rtr.DistributedRouter_mixin):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\vcns_db.py

def add_vcns_router_binding(session, router_id, vse_id, lswitch_id, status):

def get_vcns_router_binding(session, router_id):

def update_vcns_router_binding(session, router_id, **kwargs):

def delete_vcns_router_binding(session, router_id):

def add_vcns_edge_firewallrule_binding(session, map_info):

def delete_vcns_edge_firewallrule_binding(session, id):

def get_vcns_edge_firewallrule_binding(session, id, edge_id):

def get_vcns_edge_firewallrule_binding_by_vseid( session, edge_id, rule_vseid):

def cleanup_vcns_edge_firewallrule_binding(session, edge_id):

def add_vcns_edge_vip_binding(session, map_info):

def get_vcns_edge_vip_binding(session, id):

def delete_vcns_edge_vip_binding(session, id):

def add_vcns_edge_pool_binding(session, map_info):

def get_vcns_edge_pool_binding(session, id, edge_id):

def get_vcns_edge_pool_binding_by_vseid(session, edge_id, pool_vseid):

def delete_vcns_edge_pool_binding(session, id, edge_id):

def add_vcns_edge_monitor_binding(session, map_info):

def get_vcns_edge_monitor_binding(session, id, edge_id):

def delete_vcns_edge_monitor_binding(session, id, edge_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dbexts\vcns_models.py

class VcnsRouterBinding(model_base.BASEV2, models_v2.HasStatusDescription):

class VcnsEdgeFirewallRuleBinding(model_base.BASEV2):

class VcnsEdgePoolBinding(model_base.BASEV2):

class VcnsEdgeVipBinding(model_base.BASEV2):

class VcnsEdgeMonitorBinding(model_base.BASEV2):

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

class DhcpMetadataAccess(object):

    def setup_dhcpmeta_access(self):

    def _setup_rpc_dhcp_metadata(self, notifier=None):

    def _setup_nsx_dhcp_metadata(self):

    def _init_extensions(self):

    def _check_services_requirements(self):

    def get_lsn(self, context, network_id, fields=None):

    def create_lsn(self, context, lsn):

    def handle_network_dhcp_access(self, context, network, action):

    def handle_port_dhcp_access(self, context, port_data, action):

    def handle_port_metadata_access(self, context, port, is_delete=False):

    def handle_router_metadata_access(self, context, router_id, interface=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dhcp_meta\combined.py

class DhcpAgentNotifyAPI(dhcp_rpc_agent_api.DhcpAgentNotifyAPI):

    def __init__(self, plugin, manager):

    def notify(self, context, data, methodname):

def handle_network_dhcp_access(plugin, context, network, action):

def handle_port_dhcp_access(plugin, context, port, action):

def handle_port_metadata_access(plugin, context, port, is_delete=False):

def handle_router_metadata_access(plugin, context, router_id, interface=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dhcp_meta\constants.py

def register_lsn_opts(config):

class LsnManager(object):

    def __init__(self, plugin):

    def cluster(self):

    def lsn_exists(self, context, network_id):

    def lsn_get(self, context, network_id, raise_on_err=True):

    def lsn_create(self, context, network_id):

    def lsn_delete(self, context, lsn_id):

    def lsn_delete_by_network(self, context, network_id):

    def lsn_port_get(self, context, network_id, subnet_id, raise_on_err=True):

    def lsn_port_get_by_mac(self, context, network_id, mac, raise_on_err=True):

    def lsn_port_create(self, context, lsn_id, subnet_info):

    def lsn_port_delete(self, context, lsn_id, lsn_port_id):

    def lsn_port_dispose(self, context, network_id, mac_address):

    def lsn_port_dhcp_setup( self, context, network_id, port_id, port_data, subnet_config=None):

    def lsn_port_metadata_setup(self, context, lsn_id, subnet):

    def lsn_port_dhcp_configure(self, context, lsn_id, lsn_port_id, subnet):

    def lsn_metadata_configure(self, context, subnet_id, is_enabled):

    def _lsn_port_host_conf(self, context, network_id, subnet_id, data, hdlr):

    def lsn_port_dhcp_host_add(self, context, network_id, subnet_id, host):

    def lsn_port_dhcp_host_remove(self, context, network_id, subnet_id, host):

    def lsn_port_meta_host_add(self, context, network_id, subnet_id, host):

    def lsn_port_meta_host_remove(self, context, network_id, subnet_id, host):

    def lsn_port_update( self, context, network_id, subnet_id, dhcp=None, meta=None):

class PersistentLsnManager(LsnManager):

    def __init__(self, plugin):

    def lsn_get(self, context, network_id, raise_on_err=True):

    def lsn_save(self, context, network_id, lsn_id):

    def lsn_create(self, context, network_id):

    def lsn_delete(self, context, lsn_id):

    def lsn_port_get(self, context, network_id, subnet_id, raise_on_err=True):

    def lsn_port_get_by_mac(self, context, network_id, mac, raise_on_err=True):

    def lsn_port_save(self, context, lsn_port_id, subnet_id, mac_addr, lsn_id):

    def lsn_port_create(self, context, lsn_id, subnet_info):

    def lsn_port_delete(self, context, lsn_id, lsn_port_id):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dhcp_meta\migration.py

class DhcpMetadataBuilder(object):

    def __init__(self, plugin, agent_notifier):

    def dhcp_agent_get_all(self, context, network_id):

    def dhcp_port_get_all(self, context, network_id):

    def router_id_get(self, context, subnet=None):

    def metadata_deallocate(self, context, router_id, subnet_id):

    def metadata_allocate(self, context, router_id, subnet_id):

    def dhcp_deallocate(self, context, network_id, agents, ports):

    def dhcp_allocate(self, context, network_id, subnet):

class MigrationManager(object):

    def __init__(self, plugin, lsn_manager, agent_notifier):

    def validate(self, context, network_id):

    def migrate(self, context, network_id, subnet=None):

    def report(self, context, network_id, subnet_id=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dhcp_meta\nsx.py

def register_dhcp_opts(config):

def register_metadata_opts(config):

class DhcpAgentNotifyAPI(object):

    def __init__(self, plugin, lsn_manager):

    def notify(self, context, data, methodname):

    def _port_update(self, context, port):

    def _subnet_create(self, context, subnet, clean_on_err=True):

    def _subnet_update(self, context, subnet):

    def _subnet_delete(self, context, subnet):

def is_user_port(p, check_dev_id=False):

def check_services_requirements(cluster):

def handle_network_dhcp_access(plugin, context, network, action):

def handle_port_dhcp_access(plugin, context, port, action):

def handle_port_metadata_access(plugin, context, port, is_delete=False):

def handle_router_metadata_access(plugin, context, router_id, interface=None):

\OpenStack\neutron-2014.1\neutron\plugins\vmware\dhcp_meta\rpc.py

class NSXRpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin):

    def create_rpc_dispatcher(self):

def handle_network_dhcp_access(plugin, context, network, action):

def handle_port_dhcp_access(plugin, context, port_data, action):

def handle_port_metadata_access(plugin, context, port, is_delete=False):

def handle_router_metadata_access(plugin, context, router_id, interface=None):

def _find_metadata_port(plugin, context, ports):

def _create_metadata_access_network(plugin, context, router_id):

def _destroy_metadata_access_network(plugin, context, router_id, ports):

def _notify_rpc_agent(context, payload, event):

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

def convert_to_boolean_if_not_none(data):

class Distributedrouter(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_required_extensions(self):

    def get_resources(cls):

    def get_extended_resources(self, version):

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

class Lsn(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

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

class Maclearning(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

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

def _validate_device_list(data, valid_values=None):

def _validate_connector_type(data, valid_values=None):

class Networkgw(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class NetworkGatewayPluginBase(object):

    def create_network_gateway(self, context, network_gateway):

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

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

    def delete_network_gateway(self, context, id):

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

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

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

    def create_gateway_device(self, context, gateway_device):

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

    def delete_gateway_device(self, context, id):

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

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

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

class Nvp_qos(qos.Qos):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

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

class DefaultQueueCreateNotAdmin(qexception.InUse):

class DefaultQueueAlreadyExists(qexception.InUse):

class QueueInvalidDscp(qexception.InvalidInput):

class QueueMinGreaterMax(qexception.InvalidInput):

class QueueInvalidBandwidth(qexception.InvalidInput):

class QueueNotFound(qexception.NotFound):

class QueueInUseByPort(qexception.InUse):

class QueuePortBindingNotFound(qexception.NotFound):

def convert_to_unsigned_int_or_none(val):

def convert_to_unsigned_int_or_none_max_63(val):

class Qos(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class QueuePluginBase(object):

    def create_qos_queue(self, context, queue):

    def delete_qos_queue(self, context, id):

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

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

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

class Servicerouter(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

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