OpenStack Study: neutron

OpenStack Index

class OpenvswitchMechanismDriver(mech_agent.SimpleAgentMechanismDriverBase):

    def __init__(self):

    def check_segment_for_agent(self, segment, agent):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\mlnx\config.py

class MlnxMechanismDriver(mech_agent.SimpleAgentMechanismDriverBase):

    def __init__(self):

    def check_segment_for_agent(self, segment, agent):

    def try_to_bind_segment_for_agent(self, context, segment, agent):

    def _get_vif_type(self, requested_vnic_type):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\mlnx\__init__.py

class FlatAllocation(model_base.BASEV2):

class FlatTypeDriver(api.TypeDriver):

    def __init__(self):

    def _parse_networks(self, entries):

    def get_type(self):

    def initialize(self):

    def validate_provider_segment(self, segment):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\type_gre.py

class GreAllocation(model_base.BASEV2):

class GreEndpoints(model_base.BASEV2):

    def __repr__(self):

class GreTypeDriver(type_tunnel.TunnelTypeDriver):

    def get_type(self):

    def initialize(self):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

    def _sync_gre_allocations(self):

    def get_gre_allocation(self, session, gre_id):

    def get_endpoints(self):

    def add_endpoint(self, ip):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\type_local.py

class LocalTypeDriver(api.TypeDriver):

    def __init__(self):

    def get_type(self):

    def initialize(self):

    def validate_provider_segment(self, segment):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\type_tunnel.py

class TunnelTypeDriver(api.TypeDriver):

    def add_endpoint(self, ip):

    def get_endpoints(self):

    def _parse_tunnel_ranges(self, tunnel_ranges, current_range, tunnel_type):

    def validate_provider_segment(self, segment):

class TunnelRpcCallbackMixin(object):

    def __init__(self, notifier, type_manager):

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

class TunnelAgentRpcApiMixin(object):

    def _get_tunnel_update_topic(self):

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

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\type_vlan.py

class VlanAllocation(model_base.BASEV2):

class VlanTypeDriver(api.TypeDriver):

    def __init__(self):

    def _parse_network_vlan_ranges(self):

    def _sync_vlan_allocations(self):

    def get_type(self):

    def initialize(self):

    def validate_provider_segment(self, segment):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\type_vxlan.py

class VxlanAllocation(model_base.BASEV2):

class VxlanEndpoints(model_base.BASEV2):

    def __repr__(self):

class VxlanTypeDriver(type_tunnel.TunnelTypeDriver):

    def get_type(self):

    def initialize(self):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

    def _sync_vxlan_allocations(self):

    def get_vxlan_allocation(self, session, vxlan_vni):

    def get_endpoints(self):

    def add_endpoint(self, ip, udp_port=VXLAN_UDP_PORT):

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

class TypeDriver(object):

    def get_type(self):

    def initialize(self):

    def validate_provider_segment(self, segment):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

class NetworkContext(object):

    def current(self):

    def original(self):

    def network_segments(self):

class SubnetContext(object):

    def current(self):

    def original(self):

class PortContext(object):

    def current(self):

    def original(self):

    def network(self):

    def bound_segment(self):

    def original_bound_segment(self):

    def bound_driver(self):

    def original_bound_driver(self):

    def host_agents(self, agent_type):

    def set_binding(self, segment_id, vif_type, vif_details, status=None):

class MechanismDriver(object):

    def initialize(self):

    def create_network_precommit(self, context):

    def create_network_postcommit(self, context):

    def update_network_precommit(self, context):

    def update_network_postcommit(self, context):

    def delete_network_precommit(self, context):

    def delete_network_postcommit(self, context):

    def create_subnet_precommit(self, context):

    def create_subnet_postcommit(self, context):

    def update_subnet_precommit(self, context):

    def update_subnet_postcommit(self, context):

    def delete_subnet_precommit(self, context):

    def delete_subnet_postcommit(self, context):

    def create_port_precommit(self, context):

    def create_port_postcommit(self, context):

    def update_port_precommit(self, context):

    def update_port_postcommit(self, context):

    def delete_port_precommit(self, context):

    def delete_port_postcommit(self, context):

    def bind_port(self, context):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\driver_context.py

class MechanismDriverContext(object):

    def __init__(self, plugin, plugin_context):

class NetworkContext(MechanismDriverContext, api.NetworkContext):

    def __init__(self, plugin, plugin_context, network, original_network=None):

    def current(self):

    def original(self):

    def network_segments(self):

class SubnetContext(MechanismDriverContext, api.SubnetContext):

    def __init__(self, plugin, plugin_context, subnet, original_subnet=None):

    def current(self):

    def original(self):

class PortContext(MechanismDriverContext, api.PortContext):

    def __init__(self, plugin, plugin_context, port, network, original_port=None):

    def current(self):

    def original(self):

    def network(self):

    def bound_segment(self):

    def original_bound_segment(self):

    def bound_driver(self):

    def original_bound_driver(self):

    def host_agents(self, agent_type):

    def set_binding(self, segment_id, vif_type, vif_details, status=None):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\managers.py

class TypeManager(stevedore.named.NamedExtensionManager):

    def __init__(self):

    def _register_types(self):

    def _check_tenant_network_types(self, types):

    def initialize(self):

    def validate_provider_segment(self, segment):

    def reserve_provider_segment(self, session, segment):

    def allocate_tenant_segment(self, session):

    def release_segment(self, session, segment):

class MechanismManager(stevedore.named.NamedExtensionManager):

    def __init__(self):

    def _register_mechanisms(self):

    def initialize(self):

    def _call_on_drivers(self, method_name, context, continue_on_failure=False):

    def create_network_precommit(self, context):

    def create_network_postcommit(self, context):

    def update_network_precommit(self, context):

    def update_network_postcommit(self, context):

    def delete_network_precommit(self, context):

    def delete_network_postcommit(self, context):

    def create_subnet_precommit(self, context):

    def create_subnet_postcommit(self, context):

    def update_subnet_precommit(self, context):

    def update_subnet_postcommit(self, context):

    def delete_subnet_precommit(self, context):

    def delete_subnet_postcommit(self, context):

    def create_port_precommit(self, context):

    def create_port_postcommit(self, context):

    def update_port_precommit(self, context):

    def update_port_postcommit(self, context):

    def delete_port_precommit(self, context):

    def delete_port_postcommit(self, context):

    def bind_port(self, context):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\models.py

class NetworkSegment(model_base.BASEV2, models_v2.HasId):

class PortBinding(model_base.BASEV2):

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

class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, sg_db_rpc.SecurityGroupServerRpcMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, addr_pair_db.AllowedAddressPairsMixin, extradhcpopt_db.ExtraDhcpOptMixin):

    def supported_extension_aliases(self):

    def __init__(self):

    def _setup_rpc(self):

    def start_rpc_listener(self):

    def _process_provider_segment(self, segment):

    def _process_provider_create(self, network):

    def _get_attribute(self, attrs, key):

    def _extend_network_dict_provider(self, context, network):

    def _filter_nets_provider(self, context, nets, filters):

    def _process_port_binding(self, mech_context, attrs):

    def _update_port_dict_binding(self, port, binding):

    def _get_vif_details(self, binding):

    def _get_profile(self, binding):

    def _delete_port_binding(self, mech_context):

    def _ml2_extend_port_dict_binding(self, port_res, port_db):

    def _ml2_port_model_hook(self, context, original_model, query):

    def _ml2_port_result_filter_hook(self, query, filters):

    def _notify_port_updated(self, mech_context):

    def create_network(self, context, network):

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

    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 delete_network(self, context, id):

    def create_subnet(self, context, subnet):

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

    def delete_subnet(self, context, id):

    def create_port(self, context, port):

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

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

    def update_port_status(self, context, port_id, status):

    def port_bound_to_host(self, port_id, host):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\rpc.py

class RpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin, sg_db_rpc.SecurityGroupServerRpcCallbackMixin, type_tunnel.TunnelRpcCallbackMixin):

    def __init__(self, notifier, type_manager):

    def create_rpc_dispatcher(self):

    def _device_to_port_id(cls, device):

    def get_port_from_device(cls, device):

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

    def _find_segment(self, segments, segment_id):

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

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

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

    def __init__(self, topic):

    def network_delete(self, context, network_id):

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

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

class EswitchManager(object):

    def __init__(self, interface_mappings, endpoint, timeout):

    def get_port_id_by_mac(self, port_mac):

    def get_vnics_mac(self):

    def vnic_port_exists(self, port_mac):

    def remove_network(self, network_id):

    def port_down(self, network_id, physical_network, port_mac):

    def port_up(self, network_id, network_type, physical_network, seg_id, port_id, port_mac):

    def port_release(self, port_mac):

    def provision_network(self, port_id, port_mac, network_id, network_type, physical_network, segmentation_id):

class MlnxEswitchRpcCallbacks(sg_rpc.SecurityGroupAgentRpcCallbackMixin):

    def __init__(self, context, agent):

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

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

    def create_rpc_dispatcher(self):

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

class MlnxEswitchNeutronAgent(sg_rpc.SecurityGroupAgentRpcMixin):

    def __init__(self, interface_mapping):

    def _setup_eswitches(self, interface_mapping):

    def _report_state(self):

    def _setup_rpc(self):

    def update_ports(self, registered_ports):

    def process_network_ports(self, port_info):

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

    def treat_devices_added(self, devices):

    def treat_devices_removed(self, devices):

    def daemon_loop(self):

def main():

\OpenStack\neutron-2014.1\neutron\plugins\mlnx\agent\utils.py

class EswitchUtils(object):

    def __init__(self, daemon_endpoint, timeout):

    def _conn(self):

    def send_msg(self, msg):

    def parse_response_msg(self, recv_msg):

    def get_attached_vnics(self):

    def set_port_vlan_id(self, physical_network, segmentation_id, port_mac):

    def define_fabric_mappings(self, interface_mapping):

    def port_up(self, fabric, port_mac):

    def port_down(self, fabric, port_mac):

    def port_release(self, fabric, port_mac):

    def get_eswitch_ports(self, fabric):

    def get_eswitch_id(self, fabric):

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

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

    def __init__(self, topic):

    def network_delete(self, context, network_id):

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

\OpenStack\neutron-2014.1\neutron\plugins\mlnx\common\comm_utils.py

class RetryDecorator(object):

    def __init__(self, exceptionToCheck, interval=cfg.CONF.ESWITCH.request_timeout / 1000, retries=cfg.CONF.ESWITCH.retries, backoff_rate=cfg.CONF.ESWITCH.backoff_rate):

    def __call__(self, original_func):

        def decorated(*args, **kwargs):

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

class MlnxException(qexc.NeutronException):

class RequestTimeout(qexc.NeutronException):

class OperationFailed(qexc.NeutronException):

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

def _remove_non_allocatable_vlans(session, allocations, physical_network, vlan_ids):

def _add_missing_allocatable_vlans(session, physical_network, vlan_ids):

def _remove_unconfigured_vlans(session, allocations):

def sync_network_states(network_vlan_ranges):

def get_network_state(physical_network, segmentation_id):

def reserve_network(session):

def reserve_specific_network(session, physical_network, segmentation_id):

def release_network(session, physical_network, segmentation_id, network_vlan_ranges):

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

def get_network_binding(session, network_id):

def add_port_profile_binding(session, port_id, vnic_type):

def get_port_profile_binding(session, port_id):

def get_port_from_device(device):

def get_port_from_device_mac(device_mac):

def set_port_status(port_id, status):

\OpenStack\neutron-2014.1\neutron\plugins\mlnx\db\mlnx_models_v2.py

class SegmentationIdAllocation(model_base.BASEV2):

    def __init__(self, physical_network, segmentation_id):

    def __repr__(self):

class NetworkBinding(model_base.BASEV2):

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

    def __repr__(self):

class PortProfileBinding(model_base.BASEV2):

    def __init__(self, port_id, vnic_type):

    def __repr__(self):

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

class MellanoxEswitchPlugin(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):

    def supported_extension_aliases(self):

    def __init__(self):

    def _setup_rpc(self):

    def _parse_network_config(self):

    def _parse_physical_network_types(self):

    def _parse_network_vlan_ranges(self):

    def _extend_network_dict_provider(self, context, network):

    def _set_tenant_network_type(self):

    def _process_provider_create(self, context, attrs):

    def _process_flat_net(self, segmentation_id_set):

    def _process_vlan_net(self, segmentation_id, segmentation_id_set):

    def _process_local_net(self, physical_network_set, segmentation_id_set):

    def _process_net_type(self, network_type, physical_network, physical_network_set):

    def _check_port_binding_for_net_type(self, vnic_type, net_type):

    def _process_port_binding_create(self, context, attrs):

    def create_network(self, context, network):

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

    def delete_network(self, context, net_id):

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

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

    def _extend_port_dict_binding(self, context, port):

    def create_port(self, context, port):

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

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

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

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

\OpenStack\neutron-2014.1\neutron\plugins\mlnx\rpc_callbacks.py

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

    def __init__(self):

    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):

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

class NECPluginApi(agent_rpc.PluginApi):

    def update_ports(self, context, agent_id, datapath_id, port_added, port_removed):

class NECAgentRpcCallback(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):

class NECNeutronAgent(object):

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

    def setup_rpc(self):

    def _report_state(self):

    def _vif_port_to_port_info(self, vif_port):

    def _process_security_group(self, port_added, port_removed):

    def loop_handler(self):

    def daemon_loop(self):

def main():

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

class OFCException(qexc.NeutronException):

    def __init__(self, **kwargs):

class OFCResourceNotFound(qexc.NotFound):

class NECDBException(qexc.NeutronException):

class OFCMappingNotFound(qexc.NotFound):

class OFCServiceUnavailable(OFCException):

    def __init__(self, **kwargs):

class PortInfoNotFound(qexc.NotFound):

class ProfilePortInfoInvalidDataPathId(qexc.InvalidInput):

class ProfilePortInfoInvalidPortNo(qexc.InvalidInput):

class RouterExternalGatewayNotSupported(qexc.BadRequest):

class ProviderNotFound(qexc.NotFound):

class RouterOverLimit(qexc.Conflict):

class RouterProviderMismatch(qexc.Conflict):

\OpenStack\neutron-2014.1\neutron\plugins\nec\common\ofc_client.py

class OFCClient(object):

    def __init__(self, host="127.0.0.1", port=8888, use_ssl=False, key_file=None, cert_file=None, insecure_ssl=False):

    def _format_error_message(self, status, detail):

    def _get_response(self, method, action, body=None):

    def do_single_request(self, method, action, body=None):

    def do_request(self, method, action, body=None):

    def get(self, action):

    def post(self, action, body=None):

    def put(self, action, body=None):

    def delete(self, action):

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

def cmp_dpid(dpid_a, dpid_b):

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

def _get_resource_model(resource):

def clear_db(base=model_base.BASEV2):

def get_ofc_item(session, resource, neutron_id):

def get_ofc_id(session, resource, neutron_id):

def exists_ofc_item(session, resource, neutron_id):

def find_ofc_item(session, resource, ofc_id):

def add_ofc_item(session, resource, neutron_id, ofc_id):

def del_ofc_item(session, resource, neutron_id):

def get_portinfo(session, id):

def add_portinfo(session, id, datapath_id='', port_no=0, vlan_id=OFP_VLAN_NONE, mac=''):

def del_portinfo(session, id):

def get_active_ports_on_ofc(context, network_id, port_id=None):

def get_port_from_device(port_id):

\OpenStack\neutron-2014.1\neutron\plugins\nec\db\models.py

class OFCId(object):

class NeutronId(object):

class OFCTenantMapping(model_base.BASEV2, NeutronId, OFCId):

class OFCNetworkMapping(model_base.BASEV2, NeutronId, OFCId):

class OFCPortMapping(model_base.BASEV2, NeutronId, OFCId):

class OFCRouterMapping(model_base.BASEV2, NeutronId, OFCId):

class OFCFilterMapping(model_base.BASEV2, NeutronId, OFCId):

class PortInfo(model_base.BASEV2):

\OpenStack\neutron-2014.1\neutron\plugins\nec\db\packetfilter.py

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

class PacketFilterDbMixin(object):

    def _make_packet_filter_dict(self, pf_entry, fields=None):

    def _get_packet_filter(self, context, id):

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

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

    def _replace_unspecified_field(self, params, key):

    def _get_eth_type_for_protocol(self, protocol):

    def _set_eth_type_from_protocol(self, filter_dict):

    def _check_eth_type_and_protocol(self, new_filter, current_filter):

    def create_packet_filter(self, context, packet_filter):

    def update_packet_filter(self, context, id, packet_filter):

    def delete_packet_filter(self, context, id):

    def get_packet_filters_for_port(self, context, port):

\OpenStack\neutron-2014.1\neutron\plugins\nec\db\router.py

class RouterProvider(models_v2.model_base.BASEV2):

def _get_router_providers_query(query, provider=None, router_ids=None):

def get_router_providers(session, provider=None, router_ids=None):

def get_routers_by_provider(session, provider, router_ids=None):

def get_router_count_by_provider(session, provider, tenant_id=None):

def get_provider_by_router(session, router_id):

def add_router_provider_binding(session, provider, router_id):

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

class InvalidOFCIdFormat(qexc.NeutronException):

class PFCDriverBase(ofc_driver_base.OFCDriverBase):

    def __init__(self, conf_ofc):

    def filter_supported(cls):

    def _generate_pfc_str(self, raw_str):

    def _generate_pfc_id(self, id_str):

    def _generate_pfc_description(self, desc):

    def _extract_ofc_network_id(self, ofc_network_id):

    def _extract_ofc_port_id(self, ofc_port_id):

    def create_tenant(self, description, tenant_id=None):

    def delete_tenant(self, ofc_tenant_id):

    def create_network(self, ofc_tenant_id, description, network_id=None):

    def delete_network(self, ofc_network_id):

    def create_port(self, ofc_network_id, portinfo, port_id=None, filters=None):

    def delete_port(self, ofc_port_id):

class PFCFilterDriverMixin(object):

    def filter_supported(cls):

    def _set_param(self, filter_dict, body, key, create, convert_to=None):

    def _generate_body(self, filter_dict, apply_ports=None, create=True):

    def _validate_filter_common(self, filter_dict):

    def _validate_duplicate_priority(self, context, filter_dict):

    def validate_filter_create(self, context, filter_dict):

    def validate_filter_update(self, context, filter_dict):

    def create_filter(self, ofc_network_id, filter_dict, portinfo=None, filter_id=None, apply_ports=None):

    def update_filter(self, ofc_filter_id, filter_dict):

    def delete_filter(self, ofc_filter_id):

    def _extract_ofc_filter_id(self, ofc_filter_id):

    def convert_ofc_filter_id(self, context, ofc_filter_id):

class PFCRouterDriverMixin(object):

    def create_router(self, ofc_tenant_id, router_id, description):

    def delete_router(self, ofc_router_id):

    def add_router_interface(self, ofc_router_id, ofc_net_id, ip_address=None, mac_address=None):

    def update_router_interface(self, ofc_router_inf_id, ip_address=None, mac_address=None):

    def delete_router_interface(self, ofc_router_inf_id):

    def list_router_routes(self, ofc_router_id):

    def add_router_route(self, ofc_router_id, destination, nexthop):

    def delete_router_route(self, ofc_router_route_id):

class PFCV3Driver(PFCDriverBase):

    def create_tenant(self, description, tenant_id):

    def delete_tenant(self, ofc_tenant_id):

class PFCV4Driver(PFCDriverBase):

class PFCV5Driver(PFCRouterDriverMixin, PFCDriverBase):

class PFCV51Driver(PFCFilterDriverMixin, PFCV5Driver):

\OpenStack\neutron-2014.1\neutron\plugins\nec\drivers\trema.py

class TremaDriverBase(ofc_driver_base.OFCDriverBase):

    def __init__(self, conf_ofc):

    def _get_network_id(self, ofc_network_id):

    def _get_tenant_id(self, tenant_id):

    def create_tenant(self, description, tenant_id=None):

    def update_tenant(self, ofc_tenant_id, description):

    def delete_tenant(self, ofc_tenant_id):

    def create_network(self, ofc_tenant_id, description, network_id=None):

    def delete_network(self, ofc_network_id):

class TremaFilterDriverMixin(object):

    def filter_supported(cls):

    def create_filter(self, ofc_network_id, filter_dict, portinfo=None, filter_id=None, apply_ports=None):

    def delete_filter(self, ofc_filter_id):

class TremaPortBaseDriver(TremaDriverBase, TremaFilterDriverMixin):

    def create_port(self, ofc_network_id, portinfo, port_id=None, filters=None):

    def delete_port(self, ofc_port_id):

class TremaPortMACBaseDriver(TremaDriverBase, TremaFilterDriverMixin):

    def create_port(self, ofc_network_id, portinfo, port_id=None, filters=None):

    def delete_port(self, ofc_port_id):

class TremaMACBaseDriver(TremaDriverBase):

    def filter_supported(cls):

    def create_port(self, ofc_network_id, portinfo, port_id=None, filters=None):

    def delete_port(self, ofc_port_id):

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

def get_driver(driver_name):

\OpenStack\neutron-2014.1\neutron\plugins\nec\extensions\packetfilter.py

class PacketFilterNotFound(exceptions.NotFound):

class PacketFilterIpVersionNonSupported(exceptions.BadRequest):

class PacketFilterInvalidPriority(exceptions.BadRequest):

class PacketFilterUpdateNotSupported(exceptions.BadRequest):

class PacketFilterDuplicatedPriority(exceptions.BadRequest):

class PacketFilterEtherTypeProtocolMismatch(exceptions.Conflict):

def convert_to_int_dec_and_hex(data):

def convert_to_int_or_none(data):

class Packetfilter(extensions.ExtensionDescriptor):

    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\nec\extensions\router_provider.py

class Router_provider(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

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

class NECPluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, nec_router.RouterMixin, sg_db_rpc.SecurityGroupServerRpcMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, nec_router.L3AgentSchedulerDbMixin, packet_filter.PacketFilterMixin, portbindings_db.PortBindingMixin, addr_pair_db.AllowedAddressPairsMixin):

    def supported_extension_aliases(self):

    def __init__(self):

    def setup_rpc(self):

    def _update_resource_status(self, context, resource, id, status):

    def _update_resource_status_if_changed(self, context, resource_type, resource_dict, new_status):

    def _check_ofc_tenant_in_use(self, context, tenant_id):

    def _cleanup_ofc_tenant(self, context, tenant_id):

    def activate_port_if_ready(self, context, port, network=None):

    def deactivate_port(self, context, port, raise_exc=True):

    def _net_status(self, network):

    def create_network(self, context, network):

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

    def delete_network(self, context, id):

    def _get_base_binding_dict(self):

    def _extend_port_dict_binding_portinfo(self, port_res, portinfo):

    def _validate_portinfo(self, profile):

    def _process_portbindings_portinfo_create(self, context, port_data, port):

    def _process_portbindings_portinfo_update(self, context, port_data, port):

    def extend_port_dict_binding(self, port_res, port_db):

    def _process_portbindings_create(self, context, port_data, port):

    def _process_portbindings_update(self, context, port_data, port):

    def _get_port_handler(self, operation, device_owner):

    def create_port(self, context, port):

    def _update_ofc_port_if_required(self, context, old_port, new_port, portinfo_changed):

        def get_ofport_exist(port):

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

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

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

    def __init__(self, topic):

    def port_update(self, context, port):

class DhcpRpcCallback(dhcp_rpc_base.DhcpRpcCallbackMixin):

class L3RpcCallback(l3_rpc_base.L3RpcCallbackMixin):

class SecurityGroupServerRpcCallback( sg_db_rpc.SecurityGroupServerRpcCallbackMixin):

    def get_port_from_device(device):

class NECPluginV2RPCCallbacks(object):

    def __init__(self, plugin):

    def create_rpc_dispatcher(self):

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

    def _get_port(self, context, port_id):

\OpenStack\neutron-2014.1\neutron\plugins\nec\nec_router.py

class RouterMixin(extraroute_db.ExtraRoute_db_mixin, l3_gwmode_db.L3_NAT_db_mixin):

    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, interface_info):

    def create_router_port(self, context, port):

    def delete_router_port(self, context, port):

    def _get_gw_port_detail(self, context, driver, gw_port_id):

    def _get_gw_port(self, context, router_id):

    def _check_router_in_use(self, context, router_id):

    def _get_router_for_floatingip(self, context, internal_port, internal_subnet_id, external_network_id):

    def _get_sync_routers(self, context, router_ids=None, active=None):

    def _get_router_driver_by_id(self, context, router_id):

    def _get_provider_by_router_id(self, context, router_id):

    def _extend_router_dict_provider(self, router_res, provider):

    def extend_router_dict_provider(self, router_res, router_db):

class L3AgentSchedulerDbMixin(l3_agentschedulers_db.L3AgentSchedulerDbMixin):

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

    def schedule_router(self, context, router):

    def add_router_to_l3_agent(self, context, id, router_id):

class L3AgentNotifyAPI(l3_rpc_agent_api.L3AgentNotifyAPI):

    def _notification(self, context, method, router_ids, operation, data):

def load_driver(plugin, ofc_manager):

def get_provider_with_default(provider):

def get_driver_by_provider(provider):

\OpenStack\neutron-2014.1\neutron\plugins\nec\ofc_driver_base.py

class OFCDriverBase(object):

    def create_tenant(self, description, tenant_id=None):

    def delete_tenant(self, ofc_tenant_id):

    def create_network(self, ofc_tenant_id, description, network_id=None):

    def delete_network(self, ofc_network_id):

    def create_port(self, ofc_network_id, portinfo, port_id=None, filters=None):

    def delete_port(self, ofc_port_id):

\OpenStack\neutron-2014.1\neutron\plugins\nec\ofc_manager.py

class OFCManager(object):

    def __init__(self, plugin):

    def _get_ofc_id(self, context, resource, neutron_id):

    def _exists_ofc_item(self, context, resource, neutron_id):

    def _add_ofc_item(self, context, resource, neutron_id, ofc_id):

    def _del_ofc_item(self, context, resource, neutron_id):

    def ensure_ofc_tenant(self, context, tenant_id):

    def create_ofc_tenant(self, context, tenant_id):

    def exists_ofc_tenant(self, context, tenant_id):

    def delete_ofc_tenant(self, context, tenant_id):

    def create_ofc_network(self, context, tenant_id, network_id, network_name=None):

    def exists_ofc_network(self, context, network_id):

    def delete_ofc_network(self, context, network_id, network):

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

    def exists_ofc_port(self, context, port_id):

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

    def create_ofc_packet_filter(self, context, filter_id, filter_dict):

    def update_ofc_packet_filter(self, context, filter_id, filter_dict):

    def exists_ofc_packet_filter(self, context, filter_id):

    def delete_ofc_packet_filter(self, context, filter_id):

    def create_ofc_router(self, context, tenant_id, router_id, name=None):

    def exists_ofc_router(self, context, router_id):

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

    def add_ofc_router_interface(self, context, router_id, port_id, port):

    def delete_ofc_router_interface(self, context, router_id, port_id):

    def update_ofc_router_route(self, context, router_id, new_routes):

\OpenStack\neutron-2014.1\neutron\plugins\nec\packet_filter.py

class PacketFilterMixin(pf_db.PacketFilterDbMixin):

    def packet_filter_enabled(self):

    def remove_packet_filter_extension_if_disabled(self, aliases):

    def create_packet_filter(self, context, packet_filter):

    def update_packet_filter(self, context, id, packet_filter):

        def _packet_filter_changed(old_pf, new_pf):

    def _update_packet_filter(self, context, new_pf, pf_data):

    def delete_packet_filter(self, context, id):

    def activate_packet_filter_if_ready(self, context, packet_filter):

    def deactivate_packet_filter(self, context, packet_filter):

    def activate_packet_filters_by_port(self, context, port_id):

    def deactivate_packet_filters_by_port(self, context, port_id, raise_exc=True):

    def get_packet_filters_for_port(self, context, port):

\OpenStack\neutron-2014.1\neutron\plugins\nec\router_drivers.py

class RouterDriverBase(object):

    def __init__(self, plugin, ofc_manager):

    def floating_ip_support(self):

    def create_router(self, context, tenant_id, router):

    def update_router(self, context, router_id, old_router, new_router):

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

    def add_interface(self, context, router_id, port):

    def delete_interface(self, context, router_id, port):

class RouterL3AgentDriver(RouterDriverBase):

    def create_router(self, context, tenant_id, router):

    def update_router(self, context, router_id, old_router, new_router):

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

    def add_interface(self, context, router_id, port):

    def delete_interface(self, context, router_id, port):

class RouterOpenFlowDriver(RouterDriverBase):

    def floating_ip_support(self):

    def _process_gw_port(self, gw_info, routes):

    def create_router(self, context, tenant_id, router):

    def update_router(self, context, router_id, old_router, new_router):

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

    def add_interface(self, context, router_id, port):

    def delete_interface(self, context, router_id, port):

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

def nuage_register_cfg_opts():

\OpenStack\neutron-2014.1\neutron\plugins\nuage\common\constants.py

class OperationNotSupported(n_exc.InvalidConfigurationOption):

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

class Netpartition(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):

class NetPartitionPluginBase(object):

    def create_net_partition(self, context, router):

    def update_net_partition(self, context, id, router):

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

    def delete_net_partition(self, context, id):

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

\OpenStack\neutron-2014.1\neutron\plugins\nuage\extensions\nuage_router.py

class Nuage_router(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\plugins\nuage\extensions\nuage_subnet.py

class Nuage_subnet(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

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

def add_entrouter_mapping(session, np_id, router_id, n_l3id):

def add_rtrzone_mapping(session, neutron_router_id, nuage_zone_id, nuage_user_id=None, nuage_group_id=None):

def add_subnetl2dom_mapping(session, neutron_subnet_id, nuage_sub_id, np_id, l2dom_id=None, nuage_user_id=None, nuage_group_id=None):

def update_subnetl2dom_mapping(subnet_l2dom, new_dict):

def add_port_vport_mapping(session, port_id, nuage_vport_id, nuage_vif_id, static_ip):

def update_port_vport_mapping(port_mapping, new_dict):

def get_port_mapping_by_id(session, id):

def get_ent_rtr_mapping_by_rtrid(session, rtrid):

def get_rtr_zone_mapping(session, router_id):

def get_subnet_l2dom_by_id(session, id):

def add_net_partition(session, netpart_id, l3dom_id, l2dom_id, ent_name):

def delete_net_partition(session, net_partition):

def get_ent_rtr_mapping_by_entid(session, entid):

def get_net_partition_by_name(session, name):

def get_net_partition_by_id(session, id):

def get_net_partitions(session, filters=None, fields=None):

\OpenStack\neutron-2014.1\neutron\plugins\nuage\nuage_models.py

class NetPartition(model_base.BASEV2, models_v2.HasId):

class NetPartitionRouter(model_base.BASEV2):

class RouterZone(model_base.BASEV2):

class SubnetL2Domain(model_base.BASEV2):

class PortVPortMapping(model_base.BASEV2):

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

class NuagePlugin(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, l3_db.L3_NAT_db_mixin, netpartition.NetPartitionPluginBase):

    def __init__(self):

    def nuageclient_init(self):

    def _resource_finder(self, context, for_resource, resource, user_req):

    def _update_port_ip(self, context, port, new_ip):

    def _create_update_port(self, context, port, port_mapping, subnet_mapping):

    def create_port(self, context, port):

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

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

    def _check_view_auth(self, context, resource, action):

    def _extend_port_dict_binding(self, context, port):

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

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

    def _check_router_subnet_for_tenant(self, context):

    def create_network(self, context, network):

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

    def delete_network(self, context, id):

    def _get_net_partition_for_subnet(self, context, subnet):

    def _validate_create_subnet(self, subnet):

    def create_subnet(self, context, subnet):

    def delete_subnet(self, context, id):

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

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

    def _get_net_partition_for_router(self, context, router):

    def create_router(self, context, router):

    def delete_router(self, context, id):

    def _make_net_partition_dict(self, net_partition, fields=None):

    def _create_net_partition(self, session, net_part_name):

    def _create_default_net_partition(self, default_net_part):

    def create_net_partition(self, context, net_partition):

    def delete_net_partition(self, context, id):

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

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

\OpenStack\neutron-2014.1\neutron\plugins\nuage\__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 OVSBridge(ovs_lib.OVSBridge):

    def __init__(self, br_name, root_helper, ryuapp):

    def find_datapath_id(self):

    def get_datapath(self, retry_max=cfg.CONF.AGENT.get_datapath_retry_times):

    def setup_ofp(self, controller_names=None, protocols='OpenFlow13', retry_max=cfg.CONF.AGENT.get_datapath_retry_times):

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

class OFASecurityGroupAgent(sg_rpc.SecurityGroupAgentRpcMixin):

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

class OFANeutronAgentRyuApp(app_manager.RyuApp):

    def start(self):

    def _agent_main(self, ryuapp):

class OFANeutronAgent(sg_rpc.SecurityGroupAgentRpcCallbackMixin):

    def __init__(self, ryuapp, 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 ryu_send_msg(self, msg):

    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 create_rpc_dispatcher(self):

    def _provision_local_vlan_outbound_for_tunnel(self, lvid, segmentation_id, ofports):

    def _provision_local_vlan_inbound_for_tunnel(self, lvid, network_type, segmentation_id):

    def _local_vlan_for_tunnel(self, lvid, network_type, segmentation_id):

    def _provision_local_vlan_outbound(self, br, lvid, actions, physical_network):

    def _provision_local_vlan_inbound(self, lvid, vlan_vid, physical_network):

    def _local_vlan_for_flat(self, lvid, physical_network):

    def _local_vlan_for_vlan(self, lvid, physical_network, segmentation_id):

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

    def _reclaim_local_vlan_outbound(self, lvm):

    def _reclaim_local_vlan_inbound(self, lvm, vlan_vid):

    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 _tun_br_sort_incoming_traffic_depend_in_port(self, br):

    def _tun_br_goto_table_ucast_unicast(self, br):

    def _tun_br_goto_table_flood_broad_multi_cast(self, br):

    def _tun_br_set_table_tun_by_tunnel_type(self, br):

    def _tun_br_output_patch_int(self, br):

    def _tun_br_goto_table_flood_unknown_unicast(self, br):

    def _tun_br_default_drop(self, br):

    def setup_tunnel_br(self, tun_br):

    def _phys_br_prepare_create_veth(self, br, int_veth_name, phys_veth_name):

    def _phys_br_create_veth(self, br, int_veth_name, phys_veth_name, physical_network, ip_wrapper):

    def _phys_br_block_untranslated_traffic(self, br, physical_network):

    def _phys_br_enable_veth_to_pass_traffic(self, int_veth, phys_veth):

    def _phys_br_patch_physical_bridge_with_integration_bridge( self, br, physical_network, bridge, ip_wrapper):

    def setup_physical_bridges(self, bridge_mappings):

    def update_ports(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(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 tunnel_sync(self):

    def ovsdb_monitor_loop(self, polling_manager=None):

    def daemon_loop(self):

def create_agent_config_map(config):

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

• 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