@

Home 

OpenStack Study: neutron

OpenStack Index

Previous

Next

    def delete_port(self, context, port_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 _get_tenant_default_router_rules(self, tenant):

    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_floatingip(self, context, floatingip):

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

    def delete_floatingip(self, context, id):

    def disassociate_floatingips(self, context, port_id):

    def _send_floatingip_update(self, context):

    def _add_host_route(self, context, destination, port):

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\routerrule_db.py

class RouterRule(model_base.BASEV2):

class NextHop(model_base.BASEV2):

class RouterRule_db_mixin(l3_db.L3_NAT_db_mixin):

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

    def create_router(self, context, router):

    def _update_router_rules(self, context, router, rules):

    def _make_router_rule_list(self, router_rules):

    def _get_router_rules_by_router_id(self, context, id):

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

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

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

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\servermanager.py

class RemoteRestError(exceptions.NeutronException):

    def __init__(self, **kwargs):

class ServerProxy(object):

    def __init__(self, server, port, ssl, auth, neutron_id, timeout, base_uri, name, mypool, combined_cert):

    def get_capabilities(self):

    def rest_call(self, action, resource, data='', headers={}, timeout=False, reconnect=False):

    def _put_consistency_hash(self, newhash):

class ServerPool(object):

    def __init__(self, timeout=False, base_uri=BASE_URI, name='NeutronRestProxy'):

    def get_capabilities(self):

    def server_proxy_for(self, server, port):

    def _get_combined_cert_for_server(self, server, port):

    def _combine_certs_to_file(self, certs, cfile):

    def _get_host_cert_path(self, host_dir, server):

    def _get_ca_cert_paths(self, ca_dir):

    def _fetch_and_store_cert(self, server, port, path):

    def _file_put_contents(self, path, contents):

    def server_failure(self, resp, ignore_codes=[]):

    def action_success(self, resp):

    def rest_call(self, action, resource, data, headers, ignore_codes, timeout=False):

    def rest_action(self, action, resource, data='', errstr='%s', ignore_codes=[], headers={}, timeout=False):

    def rest_create_router(self, tenant_id, router):

    def rest_update_router(self, tenant_id, router, router_id):

    def rest_delete_router(self, tenant_id, router_id):

    def rest_add_router_interface(self, tenant_id, router_id, intf_details):

    def rest_remove_router_interface(self, tenant_id, router_id, interface_id):

    def rest_create_network(self, tenant_id, network):

    def rest_update_network(self, tenant_id, net_id, network):

    def rest_delete_network(self, tenant_id, net_id):

    def rest_create_port(self, tenant_id, net_id, port):

    def rest_delete_port(self, tenant_id, network_id, port_id):

    def rest_update_port(self, tenant_id, net_id, port):

    def rest_create_floatingip(self, tenant_id, floatingip):

    def rest_update_floatingip(self, tenant_id, floatingip, oldid):

    def rest_delete_floatingip(self, tenant_id, oldid):

    def _consistency_watchdog(self, polling_interval=60):

class HTTPSConnectionWithValidation(httplib.HTTPSConnection):

    def connect(self):

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\tests\test_server.py

class TestNetworkCtrl(object):

    def __init__(self, host='', port=8000, default_status='404 Not Found', default_response='404 Not Found', debug=False):

    def match(self, prior, method_regexp, uri_regexp, handler, data=None, multi=True):

    def remove_id(self, id_):

    def request_handler(self, method, uri, body):

    def server(self):

        def app(environ, start_response):

    def run(self):

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\tests\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\vcsversion.py

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\version.py

def canonical_version_string():

def version_string():

def vcs_version_string():

def version_string_with_vcs():

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

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

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

class BrocadePort(model_base.BASEV2):

def create_network(context, net_id, vlan):

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 get_port_from_device(session, port_id):

def update_port_state(context, port_id, admin_state_up):

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

\OpenStack\neutron-2014.1\neutron\plugins\brocade\NeutronPlugin.py

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

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 BrocadePluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, extraroute_db.ExtraRoute_db_mixin, sg_db_rpc.SecurityGroupServerRpcMixin, l3_agentschedulers_db.L3AgentSchedulerDbMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, portbindings_base.PortBindingBaseMixin):

    def __init__(self):

    def brocade_init(self):

    def _setup_rpc(self):

    def create_network(self, context, network):

    def delete_network(self, context, net_id):

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

    def create_port(self, context, port):

    def delete_port(self, context, port_id):

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

    def _notify_port_updated(self, context, port):

    def _get_base_binding_dict(self):

    def get_plugin_version(self):

    def mac_reformat_62to34(interface_mac):

\OpenStack\neutron-2014.1\neutron\plugins\brocade\nos\fake_nosdriver.py

class NOSdriver():

    def __init__(self):

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

    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\brocade\nos\nctemplates.py

\OpenStack\neutron-2014.1\neutron\plugins\brocade\nos\nosdriver.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\brocade\nos\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\brocade\tests\noscli.py

class NOSCli(object):

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

    def execute(self, cmd):

    def _create(self, net_id):

    def _delete(self, net_id):

    def _associate(self, net_id, mac):

    def _dissociate(self, net_id, mac):

\OpenStack\neutron-2014.1\neutron\plugins\brocade\tests\nostest.py

def nostest(host, username, password):

\OpenStack\neutron-2014.1\neutron\plugins\brocade\vlanbm.py

class VlanBitmap(object):

    def __init__(self, ctxt):

    def get_next_vlan(self, vlan_id=None):

    def release_vlan(self, vlan_id):

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\common\cisco_constants.py

\OpenStack\neutron-2014.1\neutron\plugins\cisco\common\cisco_credentials_v2.py

class Store(object):

    def initialize():

    def get_username(cred_name):

    def get_password(cred_name):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\common\cisco_exceptions.py

class NetworkSegmentIDNotFound(exceptions.NeutronException):

class NoMoreNics(exceptions.NeutronException):

class NetworkVlanBindingAlreadyExists(exceptions.NeutronException):

class VlanIDNotFound(exceptions.NeutronException):

class VlanIDOutsidePool(exceptions.NeutronException):

class VlanIDNotAvailable(exceptions.NeutronException):

class QosNotFound(exceptions.NeutronException):

class QosNameAlreadyExists(exceptions.NeutronException):

class CredentialNotFound(exceptions.NeutronException):

class CredentialNameNotFound(exceptions.NeutronException):

class CredentialAlreadyExists(exceptions.NeutronException):

class ProviderNetworkExists(exceptions.NeutronException):

class NexusComputeHostNotConfigured(exceptions.NeutronException):

class NexusConnectFailed(exceptions.NeutronException):

class NexusConfigFailed(exceptions.NeutronException):

class NexusPortBindingNotFound(exceptions.NeutronException):

    def __init__(self, **kwargs):

class NoNexusSviSwitch(exceptions.NeutronException):

class PortVnicBindingAlreadyExists(exceptions.NeutronException):

class PortVnicNotFound(exceptions.NeutronException):

class SubnetNotSpecified(exceptions.NeutronException):

class SubnetInterfacePresent(exceptions.NeutronException):

class PortIdForNexusSvi(exceptions.NeutronException):

class InvalidDetach(exceptions.NeutronException):

class PolicyProfileAlreadyExists(exceptions.NeutronException):

class PolicyProfileIdNotFound(exceptions.NotFound):

class NetworkProfileAlreadyExists(exceptions.NeutronException):

class NetworkProfileNotFound(exceptions.NotFound):

class NoMoreNetworkSegments(exceptions.NoNetworkAvailable):

class VMNetworkNotFound(exceptions.NotFound):

class VxlanIDInUse(exceptions.InUse):

class VxlanIDNotFound(exceptions.NotFound):

class VxlanIDOutsidePool(exceptions.NeutronException):

class VSMConnectionFailed(exceptions.ServiceUnavailable):

class VSMError(exceptions.NeutronException):

class NetworkBindingNotFound(exceptions.NotFound):

class PortBindingNotFound(exceptions.NotFound):

class ProfileTenantBindingNotFound(exceptions.NotFound):

class NoClusterFound(exceptions.NotFound):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\common\cisco_faults.py

class Fault(webob.exc.HTTPException):

    def __init__(self, exception):

    def __call__(self, req):

class PortNotFound(webob.exc.HTTPClientError):

class CredentialNotFound(webob.exc.HTTPClientError):

class QosNotFound(webob.exc.HTTPClientError):

class NovatenantNotFound(webob.exc.HTTPClientError):

class RequestedStateInvalid(webob.exc.HTTPClientError):

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

class CiscoConfigOptions():

    def __init__(self):

    def _create_device_dictionary(self):

def get_device_dictionary():

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\db\n1kv_db_v2.py

def del_trunk_segment_binding(db_session, trunk_segment_id, segment_pairs):

def del_multi_segment_binding(db_session, multi_segment_id, segment_pairs):

def add_trunk_segment_binding(db_session, trunk_segment_id, segment_pairs):

def add_multi_segment_binding(db_session, multi_segment_id, segment_pairs):

def add_multi_segment_encap_profile_name(db_session, multi_segment_id, segment_pair, profile_name):

def get_multi_segment_network_binding(db_session, multi_segment_id, segment_pair):

def get_multi_segment_members(db_session, multi_segment_id):

def get_multi_segment_encap_dict(db_session, multi_segment_id):

def get_trunk_network_binding(db_session, trunk_segment_id, segment_pair):

def get_trunk_members(db_session, trunk_segment_id):

def is_trunk_member(db_session, segment_id):

def is_multi_segment_member(db_session, segment_id):

def get_network_binding(db_session, network_id):

def add_network_binding(db_session, network_id, network_type, physical_network, segmentation_id, multicast_ip, network_profile_id, add_segments):

def get_segment_range(network_profile):

def get_multicast_ip(network_profile):

def _get_multicast_ip_range(network_profile):

def get_port_binding(db_session, port_id):

def add_port_binding(db_session, port_id, policy_profile_id):

def sync_vlan_allocations(db_session, net_p):

def get_vlan_allocation(db_session, physical_network, vlan_id):

def reserve_vlan(db_session, network_profile):

def reserve_vxlan(db_session, network_profile):

def alloc_network(db_session, network_profile_id):

def reserve_specific_vlan(db_session, physical_network, vlan_id):

def release_vlan(db_session, physical_network, vlan_id):

def sync_vxlan_allocations(db_session, net_p):

def get_vxlan_allocation(db_session, vxlan_id):

def reserve_specific_vxlan(db_session, vxlan_id):

def release_vxlan(db_session, vxlan_id):

def set_port_status(port_id, status):

def get_vm_network(db_session, policy_profile_id, network_id):

def add_vm_network(db_session, name, policy_profile_id, network_id, port_count):

def update_vm_network_port_count(db_session, name, port_count):

def delete_vm_network(db_session, policy_profile_id, network_id):

def create_network_profile(db_session, network_profile):

def delete_network_profile(db_session, id):

def update_network_profile(db_session, id, network_profile):

def get_network_profile(db_session, id):

def _get_network_profiles(db_session=None, physical_network=None):

def create_policy_profile(policy_profile):

def delete_policy_profile(id):

def update_policy_profile(db_session, id, policy_profile):

def get_policy_profile(db_session, id):

def create_profile_binding(db_session, tenant_id, profile_id, profile_type):

def _profile_binding_exists(db_session, tenant_id, profile_id, profile_type):

def get_profile_binding(db_session, tenant_id, profile_id):

def delete_profile_binding(db_session, tenant_id, profile_id):

def _get_profile_bindings(db_session, profile_type=None):

class NetworkProfile_db_mixin(object):

    def _replace_fake_tenant_id_with_real(self, context):

    def _get_network_collection_for_tenant(self, db_session, model, tenant_id):

    def _make_profile_bindings_dict(self, profile_binding, fields=None):

    def _make_network_profile_dict(self, network_profile, fields=None):

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

    def create_network_profile(self, context, network_profile):

    def delete_network_profile(self, context, id):

    def update_network_profile(self, context, id, network_profile):

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

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

    def add_network_profile_tenant(self, db_session, network_profile_id, tenant_id):

    def network_profile_exists(self, context, id):

    def _get_segment_range(self, data):

    def _validate_network_profile_args(self, context, p):

    def _validate_segment_range(self, network_profile):

    def _validate_multicast_ip_range(self, network_profile):

    def _validate_network_profile(self, net_p):

    def _validate_segment_range_uniqueness(self, context, net_p):

    def _get_network_profile_by_name(self, db_session, name):

class PolicyProfile_db_mixin(object):

    def _get_policy_collection_for_tenant(self, db_session, model, tenant_id):

    def _make_policy_profile_dict(self, policy_profile, fields=None):

    def _make_profile_bindings_dict(self, profile_binding, fields=None):

    def _policy_profile_exists(self, id):

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

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

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

    def update_policy_profile(self, context, id, policy_profile):

    def add_policy_profile_tenant(self, db_session, policy_profile_id, tenant_id):

    def remove_policy_profile_tenant(self, policy_profile_id, tenant_id):

    def _delete_policy_profile(self, policy_profile_id):

    def _get_policy_profile_by_name(self, name):

    def _remove_all_fake_policy_profiles(self):

    def _add_policy_profile(self, policy_profile_name, policy_profile_id, tenant_id=None):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\db\n1kv_models_v2.py

class N1kvVlanAllocation(model_base.BASEV2):

class N1kvVxlanAllocation(model_base.BASEV2):

class N1kvPortBinding(model_base.BASEV2):

class N1kvNetworkBinding(model_base.BASEV2):

class N1kVmNetwork(model_base.BASEV2):

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

class PolicyProfile(model_base.BASEV2):

class ProfileBinding(model_base.BASEV2):

class N1kvTrunkSegmentBinding(model_base.BASEV2):

class N1kvMultiSegmentNetworkBinding(model_base.BASEV2):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\db\network_db_v2.py

def get_all_qoss(tenant_id):

def get_qos(tenant_id, qos_id):

def add_qos(tenant_id, qos_name, qos_desc):

def remove_qos(tenant_id, qos_id):

def update_qos(tenant_id, qos_id, new_qos_name=None):

def get_all_credentials():

def get_credential(credential_id):

def get_credential_name(credential_name):

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

def remove_credential(credential_id):

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

def get_all_n1kv_credentials():

def add_provider_network(network_id, network_type, segmentation_id):

def remove_provider_network(network_id):

def is_provider_network(network_id):

def is_provider_vlan(vlan_id):

def get_ovs_vlans():

class Credential_db_mixin(object):

    def _make_credential_dict(self, credential, fields=None):

    def create_credential(self, context, credential):

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

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

    def update_credential(self, context, id, credential):

    def delete_credential(self, context, id):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\db\network_models_v2.py

class QoS(model_base.BASEV2):

class Credential(model_base.BASEV2):

class ProviderNetwork(model_base.BASEV2):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\db\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_bindings(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\cisco\db\nexus_models_v2.py

class NexusPortBinding(model_base.BASEV2):

    def __repr__(self):

    def __eq__(self, other):

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\extensions\credential.py

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\extensions\n1kv.py

class N1kv(extensions.ExtensionDescriptor):

    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\cisco\extensions\network_profile.py

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\extensions\policy_profile.py

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

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

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

class QosController(common.NeutronController, wsgi.Controller):

    def __init__(self, plugin):

    def index(self, request, tenant_id):

    def _items(self, request, tenant_id, is_detail):

    def show(self, request, tenant_id, id):

    def create(self, request, tenant_id):

    def update(self, request, tenant_id, id):

    def delete(self, request, tenant_id, id):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\extensions\_credential_view.py

def get_view_builder(req):

class ViewBuilder(object):

    def __init__(self, base_url):

    def build(self, credential_data, is_detail=False):

    def _build_simple(self, credential_data):

    def _build_detail(self, credential_data):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\extensions\_qos_view.py

def get_view_builder(req):

class ViewBuilder(object):

    def __init__(self, base_url):

    def build(self, qos_data, is_detail=False):

    def _build_simple(self, qos_data):

    def _build_detail(self, qos_data):

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\l2device_plugin_base.py

class L2DevicePluginBase(object):

    def create_network(self, tenant_id, net_name, net_id, vlan_name, vlan_id, **kwargs):

    def delete_network(self, tenant_id, net_id, **kwargs):

    def update_network(self, tenant_id, net_id, name, **kwargs):

    def create_port(self, tenant_id, net_id, port_state, port_id, **kwargs):

    def delete_port(self, tenant_id, net_id, port_id, **kwargs):

    def update_port(self, tenant_id, net_id, port_id, **kwargs):

    def plug_interface(self, tenant_id, net_id, port_id, remote_interface_id, **kwargs):

    def unplug_interface(self, tenant_id, net_id, port_id, **kwargs):

    def create_subnet(self, tenant_id, net_id, ip_version, subnet_cidr, **kwargs):

    def get_subnets(self, tenant_id, net_id, **kwargs):

    def get_subnet(self, tenant_id, net_id, subnet_id, **kwargs):

    def update_subnet(self, tenant_id, net_id, subnet_id, **kwargs):

    def delete_subnet(self, tenant_id, net_id, subnet_id, **kwargs):

    def __subclasshook__(cls, klass):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\models\virt_phy_sw_v2.py

class VirtualPhysicalSwitchModelV2(neutron_plugin_base_v2.NeutronPluginBaseV2):

    def __init__(self):

    def __getattribute__(self, name):

    def _func_name(self, offset=0):

    def _invoke_plugin_per_device(self, plugin_key, function_name, args, **kwargs):

    def _get_segmentation_id(self, network_id):

    def _get_provider_vlan_id(self, 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, sorts=None, limit=None, marker=None, page_reverse=False):

    def _invoke_nexus_for_net_create(self, context, tenant_id, net_id, instance_id, host_id):

    def _check_valid_port_device_owner(self, port):

    def _get_port_host_id_from_bindings(self, port):

    def create_port(self, context, port):

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

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

    def _check_nexus_net_create_needed(self, new_port, old_port):

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

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

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

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

    def create_subnet(self, context, subnet):

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

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

    def delete_subnet(self, context, id, kwargs):

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

\OpenStack\neutron-2014.1\neutron\plugins\cisco\models\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\cisco\n1kv\n1kv_client.py

class Client(object):

    def __init__(self, **kwargs):

    def list_port_profiles(self):

    def list_events(self, event_type=None, epoch=None):

    def create_bridge_domain(self, network, overlay_subtype):

    def delete_bridge_domain(self, name):

    def create_network_segment(self, network, network_profile):

    def update_network_segment(self, network_segment_id, body):

    def delete_network_segment(self, network_segment_id):

    def create_logical_network(self, network_profile, tenant_id):

    def delete_logical_network(self, logical_network_name):

    def create_network_segment_pool(self, network_profile, tenant_id):

    def update_network_segment_pool(self, network_profile):

    def delete_network_segment_pool(self, network_segment_pool_id):

    def create_ip_pool(self, subnet):

    def update_ip_pool(self, subnet):

    def delete_ip_pool(self, subnet_id):

    def create_vm_network(self, port, vm_network_name, policy_profile):

    def delete_vm_network(self, vm_network_name):

    def create_n1kv_port(self, port, vm_network_name):

    def update_n1kv_port(self, vm_network_name, port_id, body):

    def delete_n1kv_port(self, vm_network_name, port_id):

    def _do_request(self, method, action, body=None, headers=None):

    def _serialize(self, data):

    def _deserialize(self, data, status_code):

    def _set_content_type(self, format=None):

    def _delete(self, action, body=None, headers=None):

    def _get(self, action, body=None, headers=None):

    def _post(self, action, body=None, headers=None):

    def _put(self, action, body=None, headers=None):

    def _get_vsm_hosts(self):

    def _get_auth_header(self, host_ip):

    def get_clusters(self):

    def create_encapsulation_profile(self, encap):

    def update_encapsulation_profile(self, context, profile_name, body):

    def delete_encapsulation_profile(self, name):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\n1kv\n1kv_neutron_plugin.py

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

    def create_rpc_dispatcher(self):

class N1kvNeutronPluginV2(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, extraroute_db.ExtraRoute_db_mixin, l3_db.L3_NAT_db_mixin, portbindings_db.PortBindingMixin, n1kv_db_v2.NetworkProfile_db_mixin, n1kv_db_v2.PolicyProfile_db_mixin, network_db_v2.Credential_db_mixin, agentschedulers_db.AgentSchedulerDbMixin):

    def __init__(self, configfile=None):

    def _setup_rpc(self):

    def _setup_vsm(self):

    def _poll_policy_profiles(self):

    def _populate_policy_profiles(self):

    def _poll_policies(self, event_type=None, epoch=None, tenant_id=None):

    def _extend_network_dict_provider(self, context, network):

    def _process_provider_create(self, context, attrs):

    def _check_provider_update(self, context, attrs):

    def _get_cluster(self, segment1, segment2, clusters):

    def _extend_mapping_dict(self, context, mapping_dict, segment):

    def _send_add_multi_segment_request(self, context, net_id, segment_pairs):

    def _send_del_multi_segment_request(self, context, net_id, segment_pairs):

    def _get_encap_segments(self, context, segment_pairs):

    def _populate_member_segments(self, context, network, segment_pairs, oper):

    def _parse_multi_segments(self, context, attrs, param):

    def _parse_trunk_segments(self, context, attrs, param, physical_network, sub_type):

    def _extend_network_dict_member_segments(self, context, network):

    def _extend_network_dict_profile(self, context, network):

    def _extend_port_dict_profile(self, context, port):

    def _process_network_profile(self, context, network):

    def _process_policy_profile(self, context, attrs):

    def _send_create_logical_network_request(self, network_profile, tenant_id):

    def _send_delete_logical_network_request(self, network_profile):

    def _send_create_network_profile_request(self, context, profile):

    def _send_update_network_profile_request(self, profile):

    def _send_delete_network_profile_request(self, profile):

    def _send_create_network_request(self, context, network, segment_pairs):

    def _send_update_network_request(self, context, network, add_segments, del_segments):

    def _send_delete_network_request(self, context, network):

    def _send_create_subnet_request(self, context, subnet):

    def _send_update_subnet_request(self, subnet):

    def _send_delete_subnet_request(self, context, subnet):

    def _send_create_port_request(self, context, port):

    def _send_update_port_request(self, port_id, mac_address, vm_network_name):

    def _send_delete_port_request(self, context, id):

    def _get_segmentation_id(self, context, id):

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

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

    def delete_port(self, context, 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 update_subnet(self, context, id, subnet):

    def delete_subnet(self, context, id):

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

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

    def create_network_profile(self, context, network_profile):

    def delete_network_profile(self, context, id):

    def update_network_profile(self, context, net_profile_id, network_profile):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\n1kv\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\cisco\network_plugin.py

class PluginV2(db_base_plugin_v2.NeutronDbPluginV2):

    def supported_extension_aliases(self):

    def __init__(self):

    def __getattribute__(self, name):

    def __getattr__(self, name):

    def _extend_fault_map(self):

    def get_all_qoss(self, tenant_id):

    def get_qos_details(self, tenant_id, qos_id):

    def create_qos(self, tenant_id, qos_name, qos_desc):

    def delete_qos(self, tenant_id, qos_id):

    def rename_qos(self, tenant_id, qos_id, new_name):

    def get_all_credentials(self):

    def get_credential_details(self, credential_id):

    def rename_credential(self, credential_id, new_name, new_password):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\nexus\cisco_nexus_network_driver_v2.py

class CiscoNEXUSDriver():

    def __init__(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, cutomized_config):

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

    def delete_vlan(self, nexus_host, vlanid):

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

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

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

    def delete_and_untrunk_vlan(self, nexus_host, vlan_id, etype, 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\cisco\nexus\cisco_nexus_plugin_v2.py

class NexusPlugin(L2DevicePluginBase):

    def __init__(self):

    def create_network(self, network, attachment):

    def add_router_interface(self, vlan_name, vlan_id, subnet_id, gateway_ip, router_id):

    def remove_router_interface(self, vlan_id, router_id):

    def _find_switch_for_svi(self):

    def delete_network(self, tenant_id, net_id, **kwargs):

    def update_network(self, tenant_id, net_id, **kwargs):

    def create_port(self, tenant_id, net_id, port_state, port_id, **kwargs):

    def delete_port(self, device_id, vlan_id):

    def update_port(self, tenant_id, net_id, port_id, port_state, **kwargs):

    def plug_interface(self, tenant_id, net_id, port_id, remote_interface_id, **kwargs):

    def unplug_interface(self, tenant_id, net_id, port_id, **kwargs):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\nexus\cisco_nexus_snippets.py

\OpenStack\neutron-2014.1\neutron\plugins\cisco\nexus\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\cisco\test\nexus\fake_nexus_driver.py

class CiscoNEXUSFakeDriver():

    def __init__(self):

    def nxos_connect(self, nexus_host, nexus_ssh_port, nexus_user, nexus_password):

    def create_xml_snippet(self, cutomized_config):

    def enable_vlan(self, mgr, vlanid, vlanname):

    def disable_vlan(self, mgr, vlanid):

    def disable_switch_port(self, mgr, interface):

    def enable_vlan_on_trunk_int(self, mgr, etype, interface, vlanid):

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

    def create_vlan(self, vlan_name, vlan_id, nexus_host, nexus_user, nexus_password, nexus_ports, nexus_ssh_port, vlan_ids):

    def delete_vlan(self, vlan_id, nexus_host, nexus_user, nexus_password, nexus_ports, nexus_ssh_port):

    def build_vlans_cmd(self):

    def add_vlan_int(self, vlan_id, nexus_host, nexus_user, nexus_password, nexus_ports, nexus_ssh_port, vlan_ids=None):

    def remove_vlan_int(self, vlan_id, nexus_host, nexus_user, nexus_password, nexus_ports, nexus_ssh_port):

\OpenStack\neutron-2014.1\neutron\plugins\cisco\test\nexus\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\cisco\test\__init__.py

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

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

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

def verify_vlan_range(vlan_range):

def parse_network_vlan_range(network_vlan_range):

def parse_network_vlan_ranges(network_vlan_ranges_cfg_entries):

def in_pending_status(status):

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

\OpenStack\neutron-2014.1\neutron\plugins\embrane\agent\dispatcher.py

class Dispatcher(object):

    def __init__(self, plugin, async=True):

    def dispatch_l3(self, d_context, args=(), kwargs={}):

    def _consume_l3(self, sync_item, sync_queue, plugin, a_sync):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\agent\operations\router_operations.py

def handler(event, handler):

def _create_dva_and_assign_address(api, tenant_id, neutron_router, flavor, utif_info=None, ip_allocation_info=None):

def _update_dva_and_assign_address(api, tenant_id, neutron_router, utif_info=None, ip_allocation_info=None, routes_info=[]):

def _delete_dva(api, tenant_id, neutron_router):

def _grow_dva_iface_and_assign_address(api, tenant_id, neutron_router, utif_info=None, ip_allocation_info=None):

def _shrink_dva_iface(api, tenant_id, neutron_router, port_id):

def _create_nat_rule(api, tenant_id, neutron_router, nat_info=None):

def _delete_nat_rule(api, tenant_id, neutron_router, floating_ip_id):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\agent\operations\__init__.py

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

\OpenStack\neutron-2014.1\neutron\plugins\embrane\base_plugin.py

class EmbranePlugin(object):

    def __init__(self):

    def _run_embrane_config(self):

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

    def _delete_router(self, context, router_id):

    def _update_db_router_state(self, context, neutron_router, dva_state):

    def _set_db_router_state(self, context, neutron_router, new_state):

    def _update_db_interfaces_state(self, context, neutron_router):

    def _update_neutron_state(self, context, neutron_router, state):

    def _retrieve_prefix_from_port(self, context, neutron_port):

    def create_router(self, context, router):

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

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

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

    def delete_router(self, context, id):

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

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

    def create_floatingip(self, context, floatingip):

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

    def disassociate_floatingips(self, context, port_id):

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

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

class Events:

\OpenStack\neutron-2014.1\neutron\plugins\embrane\common\contexts.py

class DispatcherContext(object):

    def __init__(self, event, item, neutron_context, chain=None):

class OperationContext(DispatcherContext):

    def __init__(self, event, context, item, chain, function, args, kwargs):

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

class EmbranePluginException(neutron_exec.NeutronException):

class UnsupportedException(EmbranePluginException):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\common\operation.py

class Operation(object):

    def __init__(self, procedure, args=(), kwargs={}, nextop=None):

    def execute(self):

    def execute_all(self):

    def has_next(self):

    def add_bottom_operation(self, operation):

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

def set_db_item_state(context, neutron_item, new_state):

def retrieve_subnet(context, subnet_id):

def retrieve_ip_allocation_info(context, neutron_port):

def retrieve_nat_info(context, fip, fixed_prefix, floating_prefix, router):

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

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\fake\fakeplugin_support.py

class FakePluginSupport(base.SupportBase):

    def __init__(self):

    def retrieve_utif_info(self, context, neutron_port):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\fake\fake_l2_plugin.py

class FakeL2Plugin(db_base_plugin_v2.NeutronDbPluginV2):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\fake\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\openvswitch\openvswitch_support.py

class OpenvswitchSupport(base.SupportBase):

    def __init__(self):

    def retrieve_utif_info(self, context, neutron_port):

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

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\support_base.py

class SupportBase(object):

    def __init__(self):

    def retrieve_utif_info(self, context, neutron_port=None, network=None):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\support_exceptions.py

class UtifInfoError(embrane_exc.EmbranePluginException):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\l2base\__init__.py

\OpenStack\neutron-2014.1\neutron\plugins\embrane\plugins\embrane_fake_plugin.py

class EmbraneFakePlugin(base.EmbranePlugin, extraroute_db.ExtraRoute_db_mixin, l2.FakeL2Plugin):

    def __init__(self):

\OpenStack\neutron-2014.1\neutron\plugins\embrane\plugins\embrane_ovs_plugin.py

class EmbraneOvsPlugin(base.EmbranePlugin, l2.OVSNeutronPluginV2):

    def __init__(self):

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

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

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

class HyperVSecurityAgent(sg_rpc.SecurityGroupAgentRpcMixin):

    def __init__(self, context, plugin_rpc):

    def _setup_rpc(self):

    def _create_rpc_dispatcher(self):

class HyperVSecurityCallbackMixin(sg_rpc.SecurityGroupAgentRpcCallbackMixin):

    def __init__(self, sg_agent):

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

class HyperVNeutronAgent(object):

    def __init__(self):

    def _set_agent_state(self):

    def _report_state(self):

    def _setup_rpc(self):

    def _load_physical_network_mappings(self):

    def _get_vswitch_for_physical_network(self, phys_network_name):

    def _get_network_vswitch_map_by_port_id(self, port_id):

    def network_delete(self, context, network_id=None):

    def port_delete(self, context, port_id=None):

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

    def _create_rpc_dispatcher(self):

    def _get_vswitch_name(self, network_type, physical_network):

    def _provision_network(self, port_id, net_uuid, network_type, physical_network, segmentation_id):

    def _reclaim_local_network(self, net_uuid):

    def _port_bound(self, port_id, net_uuid, network_type, physical_network, segmentation_id):

    def _port_unbound(self, port_id):

    def _port_enable_control_metrics(self):

    def _update_ports(self, registered_ports):

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

    def _treat_devices_added(self, devices):

    def _treat_devices_removed(self, devices):

    def _process_network_ports(self, port_info):

    def daemon_loop(self):

def main():

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

class HyperVSecurityGroupsDriver(firewall.FirewallDriver):

    def __init__(self):

    def prepare_port_filter(self, port):

    def _create_port_rules(self, port_id, rules):

    def _remove_port_rules(self, port_id, rules):

    def _create_param_map(self, rule):

    def apply_port_filter(self, port):

    def update_port_filter(self, port):

    def remove_port_filter(self, port):

    def ports(self):

    def _get_rule_remote_address(self, rule):

    def _get_rule_prop_or_default(self, rule, prop):

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

class HyperVException(n_exc.NeutronException):

class HyperVUtils(object):

    def __init__(self):

    def _conn(self):

    def get_switch_ports(self, vswitch_name):

    def vnic_port_exists(self, port_id):

    def get_vnic_ids(self):

    def _get_vnic_settings(self, vnic_name):

    def connect_vnic_to_vswitch(self, vswitch_name, switch_port_name):

    def _get_vm_from_res_setting_data(self, res_setting_data):

    def _modify_virt_resource(self, res_setting_data):

    def _check_job_status(self, ret_val, jobpath):

    def _create_switch_port(self, vswitch_name, switch_port_name):

    def disconnect_switch_port( self, vswitch_name, switch_port_name, delete_port):

    def _get_vswitch(self, vswitch_name):

    def _get_vswitch_external_port(self, vswitch):

    def set_vswitch_port_vlan_id(self, vlan_id, switch_port_name):

    def _get_switch_port_path_by_name(self, switch_port_name):

    def get_vswitch_id(self, vswitch_name):

    def get_port_by_id(self, port_id, vswitch_name):

    def enable_port_metrics_collection(self, switch_port_name):

    def enable_control_metrics(self, switch_port_name):

    def can_enable_control_metrics(self, switch_port_name):

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

def _get_windows_version():

def _check_min_windows_version(major, minor, build=0):

def get_hypervutils():

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

class HyperVUtilsV2(utils.HyperVUtils):

    def __init__(self):

    def connect_vnic_to_vswitch(self, vswitch_name, switch_port_name):

    def _modify_virt_resource(self, res_setting_data):

    def _add_virt_resource(self, vm, res_setting_data):

    def _remove_virt_resource(self, res_setting_data):

    def _add_virt_feature(self, element, res_setting_data):

    def _remove_virt_feature(self, feature_resource):

    def disconnect_switch_port( self, vswitch_name, switch_port_name, delete_port):

    def _get_vswitch(self, vswitch_name):

    def _get_vswitch_external_port(self, vswitch):

    def set_vswitch_port_vlan_id(self, vlan_id, switch_port_name):

    def _get_vlan_setting_data_from_port_alloc(self, port_alloc):

    def _get_vlan_setting_data(self, switch_port_name, create=True):

    def _get_switch_port_allocation(self, switch_port_name, create=False):

    def _get_setting_data(self, class_name, element_name, create=True):

    def _get_default_setting_data(self, class_name):

    def _get_first_item(self, obj):

    def enable_port_metrics_collection(self, switch_port_name):

    def enable_control_metrics(self, switch_port_name):

    def can_enable_control_metrics(self, switch_port_name):

    def _is_port_vm_started(self, port):

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

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

    def create_default_reject_all_rules(self, switch_port_name):

    def _bind_security_rule(self, port, direction, acl_type, action, local_port, protocol, remote_address, weight):

    def _create_acl(self, direction, acl_type, action):

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

    def _filter_acls(self, acls, action, direction, acl_type, remote_addr=""):

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

    def _get_new_weight(self, acls):

class HyperVUtilsV2R2(HyperVUtilsV2):

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

OpenStack Index

Previous

Next