OpenStack Study: neutron

OpenStack Index

    def remove_security_rule(self, switch_port_name, direction, acl_type, local_port, protocol, remote_address):

    def _create_security_acl(self, direction, acl_type, action, local_port, protocol, remote_addr, weight):

    def _filter_security_acls(self, acls, action, direction, acl_type, local_port, protocol, remote_addr=""):

    def _get_new_weight(self, acls):

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

class AgentNotifierApi(proxy.RpcProxy):

    def __init__(self, topic):

    def network_delete(self, context, network_id):

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

    def port_delete(self, context, port_id):

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

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

class HyperVPluginDB(object):

    def initialize(self):

    def reserve_vlan(self, session):

    def reserve_flat_net(self, session):

    def reserve_specific_vlan(self, session, physical_network, vlan_id):

    def reserve_specific_flat_net(self, session, physical_network):

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

    def get_port(self, port_id):

    def get_network_binding(self, session, network_id):

    def set_port_status(self, port_id, status):

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

    def _add_missing_allocatable_vlans(self, session, vlan_ids, physical_network):

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

    def _remove_unconfigured_vlans(self, session, allocations):

    def sync_vlan_allocations(self, network_vlan_ranges):

\OpenStack\neutron-2014.1\neutron\plugins\hyperv\hyperv_neutron_plugin.py

class BaseNetworkProvider(object):

    def __init__(self):

    def create_network(self, session, attrs):

    def delete_network(self, session, binding):

    def extend_network_dict(self, network, binding):

class LocalNetworkProvider(BaseNetworkProvider):

    def create_network(self, session, attrs):

    def extend_network_dict(self, network, binding):

class FlatNetworkProvider(BaseNetworkProvider):

    def create_network(self, session, attrs):

    def delete_network(self, session, binding):

    def extend_network_dict(self, network, binding):

class VlanNetworkProvider(BaseNetworkProvider):

    def create_network(self, session, attrs):

    def delete_network(self, session, binding):

    def extend_network_dict(self, network, binding):

class HyperVNeutronPlugin(agents_db.AgentDbMixin, db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, l3_gwmode_db.L3_NAT_db_mixin, portbindings_base.PortBindingBaseMixin):

    def __init__(self, configfile=None):

    def _set_tenant_network_type(self):

    def _setup_rpc(self):

    def _parse_network_vlan_ranges(self):

    def _check_vlan_id_in_range(self, physical_network, vlan_id):

    def _create_network_providers_map(self):

    def _process_provider_create(self, context, session, attrs):

    def create_network(self, context, network):

    def _extend_network_dict_provider(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):

    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\hyperv\model.py

class VlanAllocation(model_base.BASEV2):

    def __init__(self, physical_network, vlan_id):

class NetworkBinding(model_base.BASEV2):

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

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

class HyperVRpcCallbacks( dhcp_rpc_base.DhcpRpcCallbackMixin, l3_rpc_base.L3RpcCallbackMixin):

    def __init__(self, notifier):

    def create_rpc_dispatcher(self):

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

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

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

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

class SdnvePluginApi(agent_rpc.PluginApi):

    def sdnve_info(self, context, info):

class SdnveNeutronAgent():

    def __init__(self, integ_br, interface_mappings, info, root_helper, polling_interval, controller_ip, reset_br, out_of_band):

    def _report_state(self):

    def setup_rpc(self):

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

    def create_rpc_dispatcher(self):

    def setup_integration_br(self, bridge_name, reset_br, out_of_band, controller_ip=None):

    def setup_physical_interfaces(self, interface_mappings):

    def sdnve_info(self):

    def rpc_loop(self):

    def daemon_loop(self):

def create_agent_config_map(config):

def main():

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

class SdnveException(exceptions.NeutronException):

class BadInputException(exceptions.BadRequest):

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

class RequestHandler(object):

    def __init__(self, controller_ips=None, port=None, ssl=None, base_url=None, userid=None, password=None, timeout=10, formats=None):

    def serialize(self, data):

    def deserialize(self, data, status_code):

    def content_type(self, format=None):

    def delete(self, url, body=None, headers=None, params=None):

    def get(self, url, body=None, headers=None, params=None):

    def post(self, url, body=None, headers=None, params=None):

    def put(self, url, body=None, headers=None, params=None):

    def do_request(self, method, url, body=None, headers=None, params=None, connection_type=None):

class Client(RequestHandler):

    def __init__(self):

    def process_request(self, body):

    def sdnve_list(self, resource, **params):

    def sdnve_show(self, resource, specific, **params):

    def sdnve_create(self, resource, body):

    def sdnve_update(self, resource, specific, body=None):

    def sdnve_delete(self, resource, specific):

    def _tenant_id_conversion(self, osid):

    def sdnve_get_tenant_byid(self, os_tenant_id):

    def sdnve_check_and_create_tenant(self, os_tenant_id, network_type=None):

    def sdnve_get_controller(self):

class KeystoneClient(object):

    def __init__(self, username=None, tenant_name=None, password=None, auth_url=None):

    def get_tenant_byid(self, id):

    def get_tenant_type(self, id):

    def get_tenant_name(self, id):

\OpenStack\neutron-2014.1\neutron\plugins\ibm\sdnve_api_fake.py

class FakeClient():

    def __init__(self, **kwargs):

    def sdnve_list(self, resource, **_params):

    def sdnve_show(self, resource, specific, **_params):

    def sdnve_create(self, resource, body):

    def sdnve_update(self, resource, specific, body=None):

    def sdnve_delete(self, resource, specific):

    def sdnve_get_tenant_byid(self, id):

    def sdnve_check_and_create_tenant(self, id, network_type=None):

    def sdnve_get_controller(self):

\OpenStack\neutron-2014.1\neutron\plugins\ibm\sdnve_neutron_plugin.py

class SdnveRpcCallbacks():

    def __init__(self, notifier):

    def create_rpc_dispatcher(self):

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

class AgentNotifierApi(proxy.RpcProxy):

    def __init__(self, topic):

    def info_update(self, context, info):

def _ha(func):

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

class SdnvePluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, portbindings_db.PortBindingMixin, l3_gwmode_db.L3_NAT_db_mixin, agents_db.AgentDbMixin, ):

    def __init__(self, configfile=None):

    def sdnve_controller_select(self):

    def setup_rpc(self):

    def _update_base_binding_dict(self, tenant_type):

    def set_controller(self, context):

    def _process_request(self, request, current):

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

    def create_subnet(self, context, subnet):

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

    def delete_subnet(self, context, id):

    def create_router(self, context, router):

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

    def delete_router(self, context, id):

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

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

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

    def create_floatingip(self, context, floatingip):

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

    def delete_floatingip(self, context, id):

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

class NetworkSegment:

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

class LinuxBridgeManager:

    def __init__(self, interface_mappings, root_helper):

    def device_exists(self, device):

    def interface_exists_on_bridge(self, bridge, interface):

    def get_bridge_name(self, network_id):

    def get_subinterface_name(self, physical_interface, vlan_id):

    def get_tap_device_name(self, interface_id):

    def get_vxlan_device_name(self, segmentation_id):

    def get_all_neutron_bridges(self):

    def get_interfaces_on_bridge(self, bridge_name):

    def get_tap_devices_count(self, bridge_name):

    def get_interface_by_ip(self, ip):

    def get_bridge_for_tap_device(self, tap_device_name):

    def is_device_on_bridge(self, device_name):

    def ensure_vlan_bridge(self, network_id, physical_interface, vlan_id):

    def ensure_vxlan_bridge(self, network_id, segmentation_id):

    def get_interface_details(self, interface):

    def ensure_flat_bridge(self, network_id, physical_interface):

    def ensure_local_bridge(self, network_id):

    def ensure_vlan(self, physical_interface, vlan_id):

    def ensure_vxlan(self, segmentation_id):

    def update_interface_ip_details(self, destination, source, ips, gateway):

    def ensure_bridge(self, bridge_name, interface=None, ips=None, gateway=None):

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

    def add_tap_interface(self, network_id, network_type, physical_network, segmentation_id, tap_device_name):

    def add_interface(self, network_id, network_type, physical_network, segmentation_id, port_id):

    def delete_vlan_bridge(self, bridge_name):

    def remove_empty_bridges(self):

    def remove_interface(self, bridge_name, interface_name):

    def delete_vlan(self, interface):

    def delete_vxlan(self, interface):

    def update_devices(self, registered_devices):

    def get_tap_devices(self):

    def vxlan_ucast_supported(self):

    def vxlan_mcast_supported(self):

    def vxlan_module_supported(self):

    def check_vxlan_support(self):

    def fdb_ip_entry_exists(self, mac, ip, interface):

    def fdb_bridge_entry_exists(self, mac, interface, agent_ip=None):

    def add_fdb_ip_entry(self, mac, ip, interface):

    def remove_fdb_ip_entry(self, mac, ip, interface):

    def add_fdb_bridge_entry(self, mac, agent_ip, interface, operation="add"):

    def remove_fdb_bridge_entry(self, mac, agent_ip, interface):

    def add_fdb_entries(self, agent_ip, ports, interface):

    def remove_fdb_entries(self, agent_ip, ports, interface):

class LinuxBridgeRpcCallbacks(sg_rpc.SecurityGroupAgentRpcCallbackMixin, l2pop_rpc.L2populationRpcCallBackMixin):

    def __init__(self, context, agent):

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

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

    def fdb_add(self, context, fdb_entries):

    def fdb_remove(self, context, fdb_entries):

    def _fdb_chg_ip(self, context, fdb_entries):

    def fdb_update(self, context, fdb_entries):

    def create_rpc_dispatcher(self):

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

class LinuxBridgeNeutronAgentRPC(sg_rpc.SecurityGroupAgentRpcMixin):

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

    def _report_state(self):

    def setup_rpc(self, physical_interfaces):

    def setup_linux_bridge(self, interface_mappings):

    def remove_port_binding(self, network_id, interface_id):

    def process_network_devices(self, device_info):

    def treat_devices_added(self, devices):

    def treat_devices_removed(self, devices):

    def daemon_loop(self):

def main():

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

def interpret_vlan_id(vlan_id):

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

def sync_network_states(network_vlan_ranges):

def get_network_state(physical_network, vlan_id):

def reserve_network(session):

def reserve_specific_network(session, physical_network, vlan_id):

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

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

def get_network_binding(session, network_id):

def get_port_from_device(device):

def set_port_status(port_id, status):

\OpenStack\neutron-2014.1\neutron\plugins\linuxbridge\db\l2network_models_v2.py

class NetworkState(model_base.BASEV2):

    def __init__(self, physical_network, vlan_id):

    def __repr__(self):

class NetworkBinding(model_base.BASEV2):

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

    def __repr__(self):

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

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

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

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

class LinuxBridgePluginV2(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_vlan_ranges(self):

    def _add_network_vlan_range(self, physical_network, vlan_min, vlan_max):

    def _add_network(self, physical_network):

    def _extend_network_dict_provider(self, context, network):

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

    def _notify_port_updated(self, context, port):

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

def get_flavor_by_network(session, net_id):

def add_network_flavor_binding(session, flavor, net_id):

def get_flavor_by_router(session, router_id):

def add_router_flavor_binding(session, flavor, router_id):

\OpenStack\neutron-2014.1\neutron\plugins\metaplugin\meta_models_v2.py

class NetworkFlavor(models_v2.model_base.BASEV2):

    def __repr__(self):

class RouterFlavor(models_v2.model_base.BASEV2):

    def __repr__(self):

\OpenStack\neutron-2014.1\neutron\plugins\metaplugin\meta_neutron_plugin.py

def _meta_network_model_hook(context, original_model, query):

def _meta_port_model_hook(context, original_model, query):

def _meta_flavor_filter_hook(query, filters):

class FlavorNotFound(exc.NotFound):

class FaildToAddFlavorBinding(exc.NeutronException):

class MetaPluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, extraroute_db.ExtraRoute_db_mixin):

    def __init__(self, configfile=None):

        def _is_opt_registered(opts, opt):

    def _load_plugin(self, plugin_provider):

    def _get_plugin(self, flavor):

    def _get_l3_plugin(self, flavor):

    def __getattr__(self, key):

    def _extend_network_dict(self, context, network):

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

    def _get_flavor_by_network_id(self, context, network_id):

    def _get_flavor_by_router_id(self, context, router_id):

    def _get_plugin_by_network_id(self, context, network_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 _make_port_dict(self, port):

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

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

    def create_subnet(self, context, subnet):

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

    def delete_subnet(self, context, id):

    def _extend_router_dict(self, context, router):

    def create_router(self, context, router):

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

    def delete_router(self, context, id):

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

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

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

\OpenStack\neutron-2014.1\neutron\plugins\metaplugin\proxy_neutron_plugin.py

class ProxyPluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, l3_db.L3_NAT_db_mixin):

    def __init__(self, configfile=None):

    def _get_client(self):

    def create_subnet(self, context, subnet):

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

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

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

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

class DhcpNoOpDriver(dhcp.DhcpLocalProcess):

    def existing_dhcp_networks(cls, conf, root_helper):

    def check_version(cls):

    def disable(self, retain_port=False):

    def reload_allocations(self):

    def spawn_process(self):

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

def subnet_str(cidr):

def net_addr(addr):

def get_ethertype_value(ethertype):

def get_protocol_value(protocol):

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

def handle_api_error(fn):

 def wrapped(*args, **kwargs):

class MidonetResourceNotFound(n_exc.NotFound):

class MidonetApiException(n_exc.NeutronException):

class MidoClient:

    def __init__(self, mido_api):

    def _fill_dto(cls, dto, fields):

    def _create_dto(cls, dto, fields):

    def _update_dto(cls, dto, fields):

    def create_bridge(self, **kwargs):

    def delete_bridge(self, id):

    def get_bridge(self, id):

    def update_bridge(self, id, **kwargs):

    def create_dhcp(self, bridge, gateway_ip, cidr, host_rts=None, dns_servers=None):

    def add_dhcp_host(self, bridge, cidr, ip, mac):

    def remove_dhcp_host(self, bridge, cidr, ip, mac):

    def delete_dhcp_host(self, bridge_id, cidr, ip, mac):

    def delete_dhcp(self, bridge, cidr):

    def delete_port(self, id, delete_chains=False):

    def get_port(self, id):

    def add_bridge_port(self, bridge, **kwargs):

    def update_port(self, id, **kwargs):

    def add_router_port(self, router, **kwargs):

    def create_router(self, **kwargs):

    def delete_router(self, id):

    def get_router(self, id):

    def update_router(self, id, **kwargs):

    def delete_route(self, id):

    def add_dhcp_route_option(self, bridge, cidr, gw_ip, dst_ip):

    def link(self, port, peer_id):

    def delete_port_routes(self, routes, port_id):

    def get_router_routes(self, router_id):

    def unlink(self, port):

    def remove_rules_by_property(self, tenant_id, chain_name, key, value):

    def add_router_chains(self, router, inbound_chain_name, outbound_chain_name):

    def delete_router_chains(self, id):

    def delete_port_chains(self, id):

    def get_link_port(self, router, peer_router_id):

    def add_router_route(self, router, type='Normal', src_network_addr=None, src_network_length=None, dst_network_addr=None, dst_network_length=None, next_hop_port=None, next_hop_gateway=None, weight=100):

    def add_static_nat(self, tenant_id, chain_name, from_ip, to_ip, port_id, nat_type='dnat', **kwargs):

    def add_dynamic_snat(self, tenant_id, pre_chain_name, post_chain_name, snat_ip, port_id, **kwargs):

    def remove_static_route(self, router, ip):

    def update_port_chains(self, port, inbound_chain_id, outbound_chain_id):

    def create_chain(self, tenant_id, name):

    def delete_chain(self, id):

    def delete_chains_by_names(self, tenant_id, names):

    def get_chain_by_name(self, tenant_id, name):

    def get_port_group_by_name(self, tenant_id, name):

    def create_port_group(self, tenant_id, name):

    def delete_port_group_by_name(self, tenant_id, name):

    def add_port_to_port_group_by_name(self, tenant_id, name, port_id):

    def remove_port_from_port_groups(self, port_id):

    def add_chain_rule(self, chain, action='accept', **kwargs):

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

def _get_nat_ips(type, fip):

def _nat_chain_names(router_id):

def _sg_chain_names(sg_id):

def _port_chain_names(port_id):

def _sg_port_group_name(sg_id):

def _rule_direction(sg_direction):

def _is_router_interface_port(port):

def _is_router_gw_port(port):

def _is_vif_port(port):

def _is_dhcp_port(port):

def _check_resource_exists(func, id, name, raise_exc=False):

class MidoRpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin):

    def create_rpc_dispatcher(self):

class MidonetPluginException(n_exc.NeutronException):

class MidonetPluginV2(db_base_plugin_v2.NeutronDbPluginV2, portbindings_db.PortBindingMixin, external_net_db.External_net_db_mixin, l3_db.L3_NAT_db_mixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, securitygroups_db.SecurityGroupDbMixin):

    def __init__(self):

    def _get_provider_router(self):

    def _dhcp_mappings(self, context, fixed_ips, mac):

    def _metadata_subnets(self, context, fixed_ips):

    def _initialize_port_chains(self, port, in_chain, out_chain, sg_ids):

    def _bind_port_to_sgs(self, context, port, sg_ids):

    def _unbind_port_from_sgs(self, context, port_id):

    def _create_accept_chain_rule(self, context, sg_rule, chain=None):

    def _remove_nat_rules(self, context, fip):

    def setup_rpc(self):

    def create_subnet(self, context, subnet):

    def delete_subnet(self, context, id):

    def create_network(self, context, network):

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

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

    def delete_network(self, context, id):

    def create_port(self, context, port):

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

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

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

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

    def create_router(self, context, router):

    def _set_router_gateway(self, id, gw_router, gw_ip):

    def _remove_router_gateway(self, id):

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

    def delete_router(self, context, id):

    def _link_bridge_to_gw_router(self, bridge, gw_router, gw_ip, cidr):

    def _unlink_bridge_from_gw_router(self, bridge, gw_router):

    def _link_bridge_to_router(self, router, bridge_port, net_addr, net_len, gw_ip, metadata_gw_ip):

    def _unlink_bridge_from_router(self, router_id, bridge_port_id):

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

    def _assoc_fip(self, fip):

    def create_floatingip(self, context, floatingip):

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

    def disassociate_floatingips(self, context, port_id):

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

    def delete_security_group(self, context, id):

    def create_security_group_rule(self, context, security_group_rule):

    def delete_security_group_rule(self, context, sg_rule_id):

    def _add_chain_rule(self, chain, action, **kwargs):

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

class MechanismDriverError(exceptions.NeutronException):

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

def add_network_segment(session, network_id, segment):

def get_network_segments(session, network_id):

def ensure_port_binding(session, port_id):

def get_port(session, port_id):

def get_port_from_device_mac(device_mac):

def get_port_and_sgs(port_id):

def get_port_binding_host(port_id):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\brocade\db\models.py

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

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

def create_network(context, net_id, vlan, segment_id, network_type, tenant_id):

def delete_network(context, net_id):

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

def get_networks(context, filters=None, fields=None):

def create_port(context, port_id, network_id, physical_interface, vlan_id, tenant_id, admin_state_up):

def get_port(context, port_id):

def get_ports(context, network_id=None):

def delete_port(context, port_id):

def update_port_state(context, port_id, admin_state_up):

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

class BrocadeMechanism():

    def __init__(self):

    def initialize(self):

    def brocade_init(self):

    def create_network_precommit(self, mech_context):

    def create_network_postcommit(self, mech_context):

    def delete_network_precommit(self, mech_context):

    def delete_network_postcommit(self, mech_context):

    def update_network_precommit(self, mech_context):

    def update_network_postcommit(self, mech_context):

    def create_port_precommit(self, mech_context):

    def create_port_postcommit(self, mech_context):

    def delete_port_precommit(self, mech_context):

    def delete_port_postcommit(self, mech_context):

    def update_port_precommit(self, mech_context):

    def update_port_postcommit(self, mech_context):

    def create_subnet_precommit(self, mech_context):

    def create_subnet_postcommit(self, mech_context):

    def delete_subnet_precommit(self, mech_context):

    def delete_subnet_postcommit(self, mech_context):

    def update_subnet_precommit(self, mech_context):

    def update_subnet_postcommit(self, mech_context):

    def mac_reformat_62to34(interface_mac):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\brocade\nos\nctemplates.py

def nos_unknown_host_cb(host, fingerprint):

class NOSdriver():

    def __init__(self):

    def connect(self, host, username, password):

    def close_session(self):

    def create_network(self, host, username, password, net_id):

    def delete_network(self, host, username, password, net_id):

    def associate_mac_to_network(self, host, username, password, net_id, mac):

    def dissociate_mac_from_network(self, host, username, password, net_id, mac):

    def create_vlan_interface(self, mgr, vlan_id):

    def delete_vlan_interface(self, mgr, vlan_id):

    def get_port_profiles(self, mgr):

    def get_port_profile(self, mgr, name):

    def create_port_profile(self, mgr, name):

    def delete_port_profile(self, mgr, name):

    def activate_port_profile(self, mgr, name):

    def deactivate_port_profile(self, mgr, name):

    def associate_mac_to_port_profile(self, mgr, name, mac_address):

    def dissociate_mac_from_port_profile(self, mgr, name, mac_address):

    def create_vlan_profile_for_port_profile(self, mgr, name):

    def configure_l2_mode_for_vlan_profile(self, mgr, name):

    def configure_trunk_mode_for_vlan_profile(self, mgr, name):

    def configure_allowed_vlans_for_vlan_profile(self, mgr, name, vlan_id):

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

class ML2MechCiscoConfig(object):

    def __init__(self):

    def _create_ml2_mech_device_cisco_dictionary(self):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\constants.py

class Store(object):

    def initialize():

    def put_credential(cred_name, username, password):

    def get_username(cred_name):

    def get_password(cred_name):

    def get_credential(cred_name):

    def delete_credential(cred_name):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\exceptions.py

class CredentialNotFound(exceptions.NeutronException):

class CredentialNameNotFound(exceptions.NeutronException):

class CredentialAlreadyExists(exceptions.NeutronException):

class NexusComputeHostNotConfigured(exceptions.NeutronException):

class NexusConnectFailed(exceptions.NeutronException):

class NexusConfigFailed(exceptions.NeutronException):

class NexusPortBindingNotFound(exceptions.NeutronException):

    def __init__(self, **kwargs):

class NexusMissingRequiredFields(exceptions.NeutronException):

class NoNexusSviSwitch(exceptions.NeutronException):

class SubnetNotSpecified(exceptions.NeutronException):

class SubnetInterfacePresent(exceptions.NeutronException):

class PortIdForNexusSvi(exceptions.NeutronException):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\mech_cisco_nexus.py

class CiscoNexusMechanismDriver(api.MechanismDriver):

    def initialize(self):

    def _valid_network_segment(self, segment):

    def _get_vlanid(self, segment):

    def _is_deviceowner_compute(self, port):

    def _is_status_active(self, port):

    def _get_switch_info(self, host_id):

    def _configure_nxos_db(self, vlan_id, device_id, host_id):

    def _configure_switch_entry(self, vlan_id, device_id, host_id):

    def _delete_nxos_db(self, vlan_id, device_id, host_id):

    def _delete_switch_entry(self, vlan_id, device_id, host_id):

    def _is_vm_migration(self, context):

    def _port_action(self, port, segment, func):

    def update_port_precommit(self, context):

    def update_port_postcommit(self, context):

    def delete_port_precommit(self, context):

    def delete_port_postcommit(self, context):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\network_db_v2.py

def get_all_credentials(tenant_id):

def get_credential(tenant_id, credential_id):

def get_credential_name(tenant_id, credential_name):

def add_credential(tenant_id, credential_name, user_name, password):

def remove_credential(tenant_id, credential_id):

def update_credential(tenant_id, credential_id, new_user_name=None, new_password=None):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\network_models_v2.py

class Credential(model_base.BASEV2):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\nexus_db_v2.py

def get_nexusport_binding(port_id, vlan_id, switch_ip, instance_id):

def get_nexusvlan_binding(vlan_id, switch_ip):

def add_nexusport_binding(port_id, vlan_id, switch_ip, instance_id):

def remove_nexusport_binding(port_id, vlan_id, switch_ip, instance_id):

def update_nexusport_binding(port_id, new_vlan_id):

def get_nexusvm_binding(vlan_id, instance_id):

def get_port_vlan_switch_binding(port_id, vlan_id, switch_ip):

def get_port_switch_bindings(port_id, switch_ip):

def get_nexussvi_bindings():

def _lookup_nexus_bindings(query_type, session=None, **bfilter):

def _lookup_all_nexus_bindings(session=None, **bfilter):

def _lookup_one_nexus_binding(session=None, **bfilter):

def _lookup_first_nexus_binding(session=None, **bfilter):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\nexus_models_v2.py

class NexusPortBinding(model_base.BASEV2):

    def __repr__(self):

    def __eq__(self, other):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\nexus_network_driver.py

class CiscoNexusDriver(object):

    def __init__(self):

    def _import_ncclient(self):

    def _edit_config(self, nexus_host, target='running', config='', allowed_exc_strs=None):

    def get_credential(self, nexus_ip):

    def nxos_connect(self, nexus_host):

    def create_xml_snippet(self, customized_config):

    def create_vlan(self, nexus_host, vlanid, vlanname):

    def delete_vlan(self, nexus_host, vlanid):

    def enable_port_trunk(self, nexus_host, interface):

    def disable_switch_port(self, nexus_host, interface):

    def enable_vlan_on_trunk_int(self, nexus_host, vlanid, interface):

    def disable_vlan_on_trunk_int(self, nexus_host, vlanid, interface):

    def create_and_trunk_vlan(self, nexus_host, vlan_id, vlan_name, nexus_port):

    def delete_and_untrunk_vlan(self, nexus_host, vlan_id, nexus_port):

    def create_vlan_svi(self, nexus_host, vlan_id, gateway_ip):

    def delete_vlan_svi(self, nexus_host, vlan_id):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\cisco\nexus\nexus_snippets.py

class L2populationDbMixin(base_db.CommonDbMixin):

    def get_agent_ip_by_host(self, session, agent_host):

    def get_agent_ip(self, agent):

    def get_agent_uptime(self, agent):

    def get_agent_tunnel_types(self, agent):

    def get_agent_by_host(self, session, agent_host):

    def get_network_ports(self, session, network_id):

    def get_agent_network_active_port_count(self, session, agent_host, network_id):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\l2pop\mech_driver.py

class L2populationMechanismDriver(api.MechanismDriver, l2pop_db.L2populationDbMixin):

    def initialize(self):

    def _get_port_fdb_entries(self, port):

    def delete_port_precommit(self, context):

    def delete_port_postcommit(self, context):

    def _get_diff_ips(self, orig, port):

    def _fixed_ips_changed(self, context, orig, port, diff_ips):

    def update_port_postcommit(self, context):

    def _get_port_infos(self, context, port):

    def _update_port_up(self, context):

    def _update_port_down(self, context, port_context, agent_active_ports_count_for_flooding=0):

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

class L2populationAgentNotifyAPI(proxy.RpcProxy):

    def __init__(self, topic=topics.AGENT):

    def _notification_fanout(self, context, method, fdb_entries):

    def _notification_host(self, context, method, fdb_entries, host):

    def add_fdb_entries(self, context, fdb_entries, host=None):

    def remove_fdb_entries(self, context, fdb_entries, host=None):

    def update_fdb_entries(self, context, fdb_entries, host=None):

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

class NCSMechanismDriver(api.MechanismDriver):

    def initialize(self):

    def create_network_postcommit(self, context):

    def update_network_postcommit(self, context):

    def delete_network_postcommit(self, context):

    def create_subnet_postcommit(self, context):

    def update_subnet_postcommit(self, context):

    def delete_subnet_postcommit(self, context):

    def create_port_postcommit(self, context):

    def update_port_postcommit(self, context):

    def delete_port_postcommit(self, context):

    def synchronize(self, operation, object_type, context):

    def sync_full(self, context):

    def sync_object(self, operation, object_type, context):

    def add_security_groups(self, context, dbcontext, port):

    def sendjson(self, method, urlpath, obj):

    def escape_keys(self, obj):

    def escape(self, string):

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

def try_del(d, keys):

class JsessionId(requests.auth.AuthBase):

    def __init__(self, url, username, password):

    def obtain_auth_cookies(self):

    def __call__(self, r):

class OpenDaylightMechanismDriver(api.MechanismDriver):

    def initialize(self):

    def create_network_postcommit(self, context):

    def update_network_postcommit(self, context):

    def delete_network_postcommit(self, context):

    def create_subnet_postcommit(self, context):

    def update_subnet_postcommit(self, context):

    def delete_subnet_postcommit(self, context):

    def create_port_postcommit(self, context):

    def update_port_postcommit(self, context):

    def delete_port_postcommit(self, context):

    def synchronize(self, operation, object_type, context):

    def filter_create_network_attributes(self, network, context, dbcontext):

    def filter_create_subnet_attributes(self, subnet, context, dbcontext):

    def filter_create_port_attributes(self, port, context, dbcontext):

    def sync_resources(self, resource_name, collection_name, resources, context, dbcontext, attr_filter):

    def sync_full(self, context):

    def filter_update_network_attributes(self, network, context, dbcontext):

    def filter_update_subnet_attributes(self, subnet, context, dbcontext):

    def filter_update_port_attributes(self, port, context, dbcontext):

    def sync_single_resource(self, operation, object_type, obj_id, context, attr_filter_create, attr_filter_update):

    def sync_object(self, operation, object_type, context):

    def add_security_groups(self, context, dbcontext, port):

    def sendjson(self, method, urlpath, obj, ignorecodes=[]):

    def bind_port(self, context):

    def check_segment(self, segment):

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

class AgentMechanismDriverBase(api.MechanismDriver):

    def __init__(self, agent_type, supported_vnic_types=[portbindings.VNIC_NORMAL]):

    def initialize(self):

    def bind_port(self, context):

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

class SimpleAgentMechanismDriverBase(AgentMechanismDriverBase):

    def __init__(self, agent_type, vif_type, vif_details, supported_vnic_types=[portbindings.VNIC_NORMAL]):

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

    def check_segment_for_agent(self, segment, agent):

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

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

    def eos_network_representation(self, segmentation_type):

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

    def eos_vm_representation(self):

    def eos_port_representation(self):

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

    def eos_tenant_representation(self):

def remember_tenant(tenant_id):

def forget_tenant(tenant_id):

def get_all_tenants():

def num_provisioned_tenants():

def remember_vm(vm_id, host_id, port_id, network_id, tenant_id):

def forget_vm(vm_id, host_id, port_id, network_id, tenant_id):

def remember_network(tenant_id, network_id, segmentation_id):

def forget_network(tenant_id, network_id):

def get_segmentation_id(tenant_id, network_id):

def is_vm_provisioned(vm_id, host_id, port_id, network_id, tenant_id):

def is_network_provisioned(tenant_id, network_id, seg_id=None):

def is_tenant_provisioned(tenant_id):

def num_nets_provisioned(tenant_id):

def num_vms_provisioned(tenant_id):

def get_networks(tenant_id):

def get_vms(tenant_id):

def get_ports(tenant_id):

def get_tenants():

class NeutronNets(db_base_plugin_v2.NeutronDbPluginV2):

    def __init__(self):

    def get_network_name(self, tenant_id, network_id):

    def get_all_networks_for_tenant(self, tenant_id):

    def get_all_ports_for_tenant(self, tenant_id):

    def _get_network(self, tenant_id, network_id):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\mech_arista\exceptions.py

class AristaRpcError(exceptions.NeutronException):

class AristaConfigError(exceptions.NeutronException):

\OpenStack\neutron-2014.1\neutron\plugins\ml2\drivers\mech_arista\mechanism_arista.py

class AristaRPCWrapper(object):

    def __init__(self):

    def _get_exit_mode_cmds(self, modes):

    def initialize_cli_commands(self):

    def check_cli_commands(self):

    def _keystone_url(self):

    def get_tenants(self):

    def plug_port_into_network(self, vm_id, host_id, port_id, net_id, tenant_id, port_name, device_owner):

    def plug_host_into_network(self, vm_id, host, port_id, network_id, tenant_id, port_name):

    def plug_dhcp_port_into_network(self, dhcp_id, host, port_id, network_id, tenant_id, port_name):

    def unplug_host_from_network(self, vm_id, host, port_id, network_id, tenant_id):

    def unplug_dhcp_port_from_network(self, dhcp_id, host, port_id, network_id, tenant_id):

    def create_network(self, tenant_id, network):

    def create_network_bulk(self, tenant_id, network_list):

    def create_network_segments(self, tenant_id, network_id, network_name, segments):

    def delete_network(self, tenant_id, network_id):

    def delete_network_bulk(self, tenant_id, network_id_list):

    def delete_vm(self, tenant_id, vm_id):

    def delete_vm_bulk(self, tenant_id, vm_id_list):

    def create_vm_port_bulk(self, tenant_id, vm_port_list, vms):

    def delete_tenant(self, tenant_id):

    def delete_tenant_bulk(self, tenant_list):

    def delete_this_region(self):

    def register_with_eos(self):

    def clear_region_updated_time(self):

    def region_in_sync(self):

    def get_region_updated_time(self):

    def _run_eos_cmds(self, commands, commands_to_log=None):

    def _build_command(self, cmds):

    def _run_openstack_cmds(self, commands, commands_to_log=None):

    def _eapi_host_url(self):

    def _validate_config(self):

class SyncService(object):

    def __init__(self, rpc_wrapper, neutron_db):

    def synchronize(self):

    def _get_eos_networks(self, eos_tenants, tenant):

    def _get_eos_vms(self, eos_tenants, tenant):

class AristaDriver(driver_api.MechanismDriver):

    def __init__(self, rpc=None):

    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_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 delete_tenant(self, tenant_id):

    def _host_name(self, hostname):

    def _synchronization_thread(self):

    def stop_synchronization_thread(self):

    def _cleanup_db(self):

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

class BigSwitchMechanismDriver(NeutronRestProxyV2Base, api.MechanismDriver):

    def initialize(self, server_timeout=None):

    def create_network_postcommit(self, context):

    def update_network_postcommit(self, context):

    def delete_network_postcommit(self, context):

    def create_port_postcommit(self, context):

    def update_port_postcommit(self, context):

    def delete_port_postcommit(self, context):

    def _prepare_port_for_controller(self, context):

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

class HypervMechanismDriver(mech_agent.SimpleAgentMechanismDriverBase):

    def __init__(self):

    def check_segment_for_agent(self, segment, agent):

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

class LinuxbridgeMechanismDriver(mech_agent.SimpleAgentMechanismDriverBase):

    def __init__(self):

    def check_segment_for_agent(self, segment, agent):

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

class OfagentMechanismDriver(mech_agent.SimpleAgentMechanismDriverBase):

    def __init__(self):

    def check_segment_for_agent(self, segment, agent):

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