@

Home 

OpenStack Study: neutron

OpenStack Index

Previous

Next

    def _process_create_resource_router_id(self, context, resource, model):

    def _extend_resource_router_id_dict(self, context, resource, model):

    def _get_resource_router_id_binding(self, context, model, resource_id=None, router_id=None):

    def _get_resource_router_id_bindings(self, context, model, resource_ids=None, router_ids=None):

    def _make_resource_router_id_dict(self, resource_router_binding, model, fields=None):

    def _delete_resource_router_id_binding(self, context, resource_id, model):

\OpenStack\neutron-2014.1\neutron\db\routerservicetype_db.py

class RouterServiceTypeBinding(model_base.BASEV2):

class RouterServiceTypeDbMixin(object):

    def _process_create_router_service_type_id(self, context, router):

    def _extend_router_service_type_id_dict(self, context, router):

    def _get_router_service_type_id_binding(self, context, router_id):

    def _make_router_service_type_id_dict(self, router_service_type):

\OpenStack\neutron-2014.1\neutron\db\securitygroups_db.py

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

class SecurityGroupPortBinding(model_base.BASEV2):

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

class SecurityGroupDbMixin(ext_sg.SecurityGroupPluginBase):

    def create_security_group_bulk(self, context, security_group_rule):

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

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

    def get_security_groups_count(self, context, filters=None):

    def get_security_group(self, context, id, fields=None, tenant_id=None):

    def _get_security_group(self, context, id):

    def delete_security_group(self, context, id):

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

    def _make_security_group_dict(self, security_group, fields=None):

    def _make_security_group_binding_dict(self, security_group, fields=None):

    def _create_port_security_group_binding(self, context, port_id, security_group_id):

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

    def _delete_port_security_group_bindings(self, context, port_id):

    def create_security_group_rule_bulk(self, context, security_group_rule):

    def create_security_group_rule_bulk_native(self, context, security_group_rule):

    def create_security_group_rule(self, context, security_group_rule):

    def _get_ip_proto_number(self, protocol):

    def _validate_port_range(self, rule):

    def _validate_security_group_rules(self, context, security_group_rule):

    def _make_security_group_rule_dict(self, security_group_rule, fields=None):

    def _make_security_group_rule_filter_dict(self, security_group_rule):

    def _check_for_duplicate_rules(self, context, security_group_rules):

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

    def get_security_group_rules_count(self, context, filters=None):

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

    def _get_security_group_rule(self, context, id):

    def delete_security_group_rule(self, context, id):

    def _extend_port_dict_security_group(self, port_res, port_db):

    def _process_port_create_security_group(self, context, port, security_group_ids):

    def _ensure_default_security_group(self, context, tenant_id):

    def _get_security_groups_on_port(self, context, port):

    def _ensure_default_security_group_on_port(self, context, port):

    def _check_update_deletes_security_groups(self, port):

    def _check_update_has_security_groups(self, port):

\OpenStack\neutron-2014.1\neutron\db\securitygroups_rpc_base.py

class SecurityGroupServerRpcMixin(sg_db.SecurityGroupDbMixin):

    def create_security_group_rule(self, context, security_group_rule):

    def create_security_group_rule_bulk(self, context, security_group_rule):

    def delete_security_group_rule(self, context, sgrid):

    def update_security_group_on_port(self, context, id, port, original_port, updated_port):

    def is_security_group_member_updated(self, context, original_port, updated_port):

    def notify_security_groups_member_updated(self, context, port):

class SecurityGroupServerRpcCallbackMixin(object):

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

    def _select_rules_for_ports(self, context, ports):

    def _select_ips_for_remote_group(self, context, remote_group_ids):

    def _select_remote_group_ids(self, ports):

    def _select_network_ids(self, ports):

    def _select_dhcp_ips_for_network_ids(self, context, network_ids):

    def _convert_remote_group_id_to_ip_prefix(self, context, ports):

    def _add_ingress_dhcp_rule(self, port, ips):

    def _add_ingress_ra_rule(self, port, ips):

    def _apply_provider_rule(self, context, ports):

    def _security_group_rules_for_ports(self, context, ports):

\OpenStack\neutron-2014.1\neutron\db\servicetype_db.py

class ProviderResourceAssociation(model_base.BASEV2):

class ServiceTypeManager(object):

    def get_instance(cls):

    def __init__(self):

    def _initialize_db(self):

    def _load_conf(self):

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

    def get_default_service_provider(self, context, service_type):

    def add_resource_association(self, context, service_type, provider_name, resource_id):

    def del_resource_associations(self, context, resource_ids):

\OpenStack\neutron-2014.1\neutron\db\sqlalchemyutils.py

def paginate_query(query, model, limit, sorts, marker_obj=None):

\OpenStack\neutron-2014.1\neutron\db\vpn\vpn_db.py

class IPsecPeerCidr(model_base.BASEV2):

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

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

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

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

class VPNPluginDb(VPNPluginBase, base_db.CommonDbMixin):

    def __init__(self):

    def update_status(self, context, model, v_id, status):

    def _get_resource(self, context, model, v_id):

    def assert_update_allowed(self, obj):

    def _make_ipsec_site_connection_dict(self, ipsec_site_conn, fields=None):

    def create_ipsec_site_connection(self, context, ipsec_site_connection):

    def _check_dpd(self, ipsec_sitecon):

    def _check_mtu(self, context, mtu, vpnservice_id):

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

    def delete_ipsec_site_connection(self, context, ipsec_site_conn_id):

    def _get_ipsec_site_connection( self, context, ipsec_site_conn_id):

    def get_ipsec_site_connection(self, context, ipsec_site_conn_id, fields=None):

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

    def update_ipsec_site_conn_status(self, context, conn_id, new_status):

    def _update_connection_status(self, context, conn_id, new_status, updated_pending):

    def _make_ikepolicy_dict(self, ikepolicy, fields=None):

    def create_ikepolicy(self, context, ikepolicy):

    def update_ikepolicy(self, context, ikepolicy_id, ikepolicy):

    def delete_ikepolicy(self, context, ikepolicy_id):

    def get_ikepolicy(self, context, ikepolicy_id, fields=None):

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

    def _make_ipsecpolicy_dict(self, ipsecpolicy, fields=None):

    def create_ipsecpolicy(self, context, ipsecpolicy):

    def update_ipsecpolicy(self, context, ipsecpolicy_id, ipsecpolicy):

    def delete_ipsecpolicy(self, context, ipsecpolicy_id):

    def get_ipsecpolicy(self, context, ipsecpolicy_id, fields=None):

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

    def _make_vpnservice_dict(self, vpnservice, fields=None):

    def _check_router(self, context, router_id):

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

    def create_vpnservice(self, context, vpnservice):

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

    def delete_vpnservice(self, context, vpnservice_id):

    def _get_vpnservice(self, context, vpnservice_id):

    def get_vpnservice(self, context, vpnservice_id, fields=None):

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

    def check_router_in_use(self, context, router_id):

class VPNPluginRpcDbMixin():

    def _get_agent_hosting_vpn_services(self, context, host):

    def update_status_by_agent(self, context, service_status_info_list):

\OpenStack\neutron-2014.1\neutron\db\vpn\__init__.py

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

\OpenStack\neutron-2014.1\neutron\debug\commands.py

class ProbeCommand(NeutronCommand):

    def get_debug_agent(self):

    def run(self, parsed_args):

class CreateProbe(ProbeCommand):

    def get_parser(self, prog_name):

    def run(self, parsed_args):

class DeleteProbe(ProbeCommand):

    def get_parser(self, prog_name):

    def run(self, parsed_args):

class ListProbe(NeutronCommand, lister.Lister):

    def get_debug_agent(self):

    def get_data(self, parsed_args):

class ClearProbe(ProbeCommand):

    def run(self, parsed_args):

class ExecProbe(ProbeCommand):

    def get_parser(self, prog_name):

    def run(self, parsed_args):

class PingAll(ProbeCommand):

    def get_parser(self, prog_name):

    def run(self, parsed_args):

\OpenStack\neutron-2014.1\neutron\debug\debug_agent.py

class NeutronDebugAgent():

    def __init__(self, conf, client, driver):

    def _get_namespace(self, port):

    def create_probe(self, network_id, device_owner='network'):

    def _get_subnet(self, subnet_id):

    def _get_network(self, network_id):

    def clear_probe(self):

    def delete_probe(self, port_id):

    def list_probes(self):

    def exec_command(self, port_id, command=None):

    def ensure_probe(self, network_id):

    def ping_all(self, network_id=None, timeout=1):

    def _create_port(self, network, device_owner):

\OpenStack\neutron-2014.1\neutron\debug\shell.py

class NeutronDebugShell(NeutronShell):

    def __init__(self, api_version):

    def build_option_parser(self, description, version):

    def initialize_app(self, argv):

def main(argv=None):

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

\OpenStack\neutron-2014.1\neutron\extensions\agent.py

class AgentNotFound(exceptions.NotFound):

class AgentNotFoundByTypeHost(exceptions.NotFound):

class MultipleAgentFoundByTypeHost(exceptions.Conflict):

class Agent(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class AgentPluginBase(object):

    def create_agent(self, context, agent):

    def delete_agent(self, context, id):

    def update_agent(self, context, agent):

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

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

\OpenStack\neutron-2014.1\neutron\extensions\allowedaddresspairs.py

class AllowedAddressPairsMissingIP(nexception.InvalidInput):

class AddressPairAndPortSecurityRequired(nexception.Conflict):

class DuplicateAddressPairInRequest(nexception.InvalidInput):

class AddressPairMatchesPortFixedIPAndMac(nexception.InvalidInput):

def _validate_allowed_address_pairs(address_pairs, valid_values=None):

class Allowedaddresspairs(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\dhcpagentscheduler.py

class NetworkSchedulerController(wsgi.Controller):

    def index(self, request, **kwargs):

    def create(self, request, body, **kwargs):

    def delete(self, request, id, **kwargs):

class DhcpAgentsHostingNetworkController(wsgi.Controller):

    def index(self, request, **kwargs):

class Dhcpagentscheduler(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class InvalidDHCPAgent(agent.AgentNotFound):

class NetworkHostedByDHCPAgent(exceptions.Conflict):

class NetworkNotHostedByDhcpAgent(exceptions.Conflict):

class DhcpAgentSchedulerPluginBase(object):

    def add_network_to_dhcp_agent(self, context, id, network_id):

    def remove_network_from_dhcp_agent(self, context, id, network_id):

    def list_networks_on_dhcp_agent(self, context, id):

    def list_dhcp_agents_hosting_network(self, context, network_id):

\OpenStack\neutron-2014.1\neutron\extensions\external_net.py

class ExternalNetworkInUse(qexception.InUse):

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

    def get_alias_namespace_compatibility_map(self):

\OpenStack\neutron-2014.1\neutron\extensions\extraroute.py

class InvalidRoutes(qexception.InvalidInput):

class RouterInterfaceInUseByRoute(qexception.InUse):

class RoutesExhausted(qexception.BadRequest):

class Extraroute():

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

class ExtraDhcpOptNotFound(exceptions.NotFound):

class ExtraDhcpOptBadData(exceptions.InvalidInput):

def _validate_list_of_dict_or_none(data, key_specs=None):

class Extra_dhcp_opt(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\extensions\firewall.py

class FirewallNotFound(qexception.NotFound):

class FirewallInUse(qexception.InUse):

class FirewallInPendingState(qexception.Conflict):

class FirewallPolicyNotFound(qexception.NotFound):

class FirewallPolicyInUse(qexception.InUse):

class FirewallRuleNotFound(qexception.NotFound):

class FirewallRuleInUse(qexception.InUse):

class FirewallRuleNotAssociatedWithPolicy(qexception.InvalidInput):

class FirewallRuleInvalidProtocol(qexception.InvalidInput):

class FirewallRuleInvalidAction(qexception.InvalidInput):

class FirewallInvalidPortValue(qexception.InvalidInput):

class FirewallRuleInfoMissing(qexception.InvalidInput):

class FirewallInternalDriverError(qexception.NeutronException):

def convert_protocol(value):

def convert_action_to_case_insensitive(value):

def convert_port_to_string(value):

def _validate_port_range(data, key_specs=None):

def _validate_ip_or_subnet_or_none(data, valid_values=None):

class Firewall(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_plugin_interface(cls):

    def update_attributes_map(self, attributes):

    def get_extended_resources(self, version):

class FirewallPluginBase(ServicePluginBase):

    def get_plugin_name(self):

    def get_plugin_type(self):

    def get_plugin_description(self):

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

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

    def create_firewall(self, context, firewall):

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

    def delete_firewall(self, context, id):

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

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

    def create_firewall_rule(self, context, firewall_rule):

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

    def delete_firewall_rule(self, context, id):

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

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

    def create_firewall_policy(self, context, firewall_policy):

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

    def delete_firewall_policy(self, context, id):

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

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

\OpenStack\neutron-2014.1\neutron\extensions\flavor.py

class Flavor(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\extensions\l3.py

class RouterNotFound(qexception.NotFound):

class RouterInUse(qexception.InUse):

class RouterInterfaceNotFound(qexception.NotFound):

class RouterInterfaceNotFoundForSubnet(qexception.NotFound):

class RouterInterfaceInUseByFloatingIP(qexception.InUse):

class FloatingIPNotFound(qexception.NotFound):

class ExternalGatewayForFloatingIPNotFound(qexception.NotFound):

class FloatingIPPortAlreadyAssociated(qexception.InUse):

class L3PortInUse(qexception.InUse):

class RouterExternalGatewayInUseByFloatingIp(qexception.InUse):

class L3(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def update_attributes_map(self, attributes):

    def get_extended_resources(self, version):

class RouterPluginBase(object):

    def create_router(self, context, router):

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

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

    def delete_router(self, context, id):

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

    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 get_floatingip(self, context, id, fields=None):

    def delete_floatingip(self, context, id):

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

    def get_routers_count(self, context, filters=None):

    def get_floatingips_count(self, context, filters=None):

\OpenStack\neutron-2014.1\neutron\extensions\l3agentscheduler.py

class RouterSchedulerController(wsgi.Controller):

    def get_plugin(self):

    def index(self, request, **kwargs):

    def create(self, request, body, **kwargs):

    def delete(self, request, id, **kwargs):

class L3AgentsHostingRouterController(wsgi.Controller):

    def get_plugin(self):

    def index(self, request, **kwargs):

class L3agentscheduler(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class InvalidL3Agent(agent.AgentNotFound):

class RouterHostedByL3Agent(exceptions.Conflict):

class RouterSchedulingFailed(exceptions.Conflict):

class RouterNotHostedByL3Agent(exceptions.Conflict):

class L3AgentSchedulerPluginBase(object):

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

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

    def list_routers_on_l3_agent(self, context, id):

    def list_l3_agents_hosting_router(self, context, router_id):

\OpenStack\neutron-2014.1\neutron\extensions\l3_ext_gw_mode.py

class L3_ext_gw_mode(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_required_extensions(self):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\lbaas_agentscheduler.py

class PoolSchedulerController(wsgi.Controller):

    def index(self, request, **kwargs):

class LbaasAgentHostingPoolController(wsgi.Controller):

    def index(self, request, **kwargs):

class Lbaas_agentscheduler(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class NoEligibleLbaasAgent(loadbalancer.NoEligibleBackend):

class NoActiveLbaasAgent(agent.AgentNotFound):

class LbaasAgentSchedulerPluginBase(object):

    def list_pools_on_lbaas_agent(self, context, id):

    def get_lbaas_agent_hosting_pool(self, context, pool_id):

\OpenStack\neutron-2014.1\neutron\extensions\loadbalancer.py

class NoEligibleBackend(qexception.NotFound):

class VipNotFound(qexception.NotFound):

class VipExists(qexception.NeutronException):

class PoolNotFound(qexception.NotFound):

class MemberNotFound(qexception.NotFound):

class HealthMonitorNotFound(qexception.NotFound):

class PoolMonitorAssociationNotFound(qexception.NotFound):

class PoolMonitorAssociationExists(qexception.Conflict):

class StateInvalid(qexception.NeutronException):

class PoolInUse(qexception.InUse):

class HealthMonitorInUse(qexception.InUse):

class PoolStatsNotFound(qexception.NotFound):

class ProtocolMismatch(qexception.BadRequest):

class MemberExists(qexception.NeutronException):

class Loadbalancer(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_plugin_interface(cls):

    def update_attributes_map(self, attributes):

    def get_extended_resources(self, version):

class LoadBalancerPluginBase(ServicePluginBase):

    def get_plugin_name(self):

    def get_plugin_type(self):

    def get_plugin_description(self):

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

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

    def create_vip(self, context, vip):

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

    def delete_vip(self, context, id):

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

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

    def create_pool(self, context, pool):

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

    def delete_pool(self, context, id):

    def stats(self, context, pool_id):

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

    def get_pool_health_monitor(self, context, id, pool_id, fields=None):

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

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

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

    def create_member(self, context, member):

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

    def delete_member(self, context, id):

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

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

    def create_health_monitor(self, context, health_monitor):

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

    def delete_health_monitor(self, context, id):

\OpenStack\neutron-2014.1\neutron\extensions\metering.py

class MeteringLabelNotFound(qexception.NotFound):

class DuplicateMeteringRuleInPost(qexception.InUse):

class MeteringLabelRuleNotFound(qexception.NotFound):

class MeteringLabelRuleOverlaps(qexception.NotFound):

class Metering(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_plugin_interface(cls):

    def get_resources(cls):

    def update_attributes_map(self, attributes):

    def get_extended_resources(self, version):

class MeteringPluginBase(service_base.ServicePluginBase):

    def get_plugin_name(self):

    def get_plugin_description(self):

    def get_plugin_type(self):

    def create_metering_label(self, context, metering_label):

    def delete_metering_label(self, context, label_id):

    def get_metering_label(self, context, label_id, fields=None):

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

    def create_metering_label_rule(self, context, metering_label_rule):

    def get_metering_label_rule(self, context, rule_id, fields=None):

    def delete_metering_label_rule(self, context, rule_id):

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

\OpenStack\neutron-2014.1\neutron\extensions\multiprovidernet.py

class SegmentsSetInConjunctionWithProviders(qexception.InvalidInput):

class SegmentsContainDuplicateEntry(qexception.InvalidInput):

def _convert_and_validate_segments(segments, valid_values=None):

class Multiprovidernet(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\extensions\portbindings.py

class Portbindings(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\extensions\portsecurity.py

class PortSecurityPortHasSecurityGroup(qexception.InUse):

class PortSecurityAndIPRequiredForSecurityGroups(qexception.InvalidInput):

class PortSecurityBindingNotFound(qexception.InvalidExtensionEnv):

class Portsecurity(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\providernet.py

def _raise_if_updates_provider_attributes(attrs):

class Providernet(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\extensions\quotasv2.py

class QuotaSetsController(wsgi.Controller):

    def __init__(self, plugin):

    def _update_attributes(self):

    def _get_quotas(self, request, tenant_id):

    def create(self, request, body=None):

    def index(self, request):

    def tenant(self, request):

    def show(self, request, id):

    def _check_admin(self, context, reason=_("Only admin can view or configure quota")):

    def delete(self, request, id):

    def update(self, request, id, body=None):

class Quotasv2(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\routedserviceinsertion.py

class Routedserviceinsertion(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\routerservicetype.py

class Routerservicetype(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\securitygroup.py

class SecurityGroupInvalidPortRange(qexception.InvalidInput):

class SecurityGroupInvalidPortValue(qexception.InvalidInput):

class SecurityGroupInvalidIcmpValue(qexception.InvalidInput):

class SecurityGroupInUse(qexception.InUse):

class SecurityGroupCannotRemoveDefault(qexception.InUse):

class SecurityGroupCannotUpdateDefault(qexception.InUse):

class SecurityGroupDefaultAlreadyExists(qexception.InUse):

class SecurityGroupRuleInvalidProtocol(qexception.InvalidInput):

class SecurityGroupRulesNotSingleTenant(qexception.InvalidInput):

class SecurityGroupRemoteGroupAndRemoteIpPrefix(qexception.InvalidInput):

class SecurityGroupProtocolRequiredWithPorts(qexception.InvalidInput):

class SecurityGroupNotSingleGroupRules(qexception.InvalidInput):

class SecurityGroupNotFound(qexception.NotFound):

class SecurityGroupRuleNotFound(qexception.NotFound):

class DuplicateSecurityGroupRuleInPost(qexception.InUse):

class SecurityGroupRuleExists(qexception.InUse):

def convert_protocol(value):

def convert_ethertype_to_case_insensitive(value):

def convert_validate_port_value(port):

def convert_to_uuid_list_or_none(value_list):

def _validate_name_not_default(data, valid_values=None):

class Securitygroup(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

class SecurityGroupPluginBase(object):

    def create_security_group(self, context, security_group):

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

    def delete_security_group(self, context, id):

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

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

    def create_security_group_rule(self, context, security_group_rule):

    def delete_security_group_rule(self, context, id):

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

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

\OpenStack\neutron-2014.1\neutron\extensions\servicetype.py

class Servicetype(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_extended_resources(self, version):

\OpenStack\neutron-2014.1\neutron\extensions\vpnaas.py

class VPNServiceNotFound(qexception.NotFound):

class IPsecSiteConnectionNotFound(qexception.NotFound):

class IPsecSiteConnectionDpdIntervalValueError(qexception.InvalidInput):

class IPsecSiteConnectionMtuError(qexception.InvalidInput):

class IKEPolicyNotFound(qexception.NotFound):

class IPsecPolicyNotFound(qexception.NotFound):

class IKEPolicyInUse(qexception.InUse):

class VPNServiceInUse(qexception.InUse):

class RouterInUseByVPNService(qexception.InUse):

class VPNStateInvalidToUpdate(qexception.BadRequest):

class IPsecPolicyInUse(qexception.InUse):

class DeviceDriverImportError(qexception.NeutronException):

class SubnetIsNotConnectedToRouter(qexception.BadRequest):

class RouterIsNotExternal(qexception.BadRequest):

class Vpnaas(extensions.ExtensionDescriptor):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_resources(cls):

    def get_plugin_interface(cls):

    def update_attributes_map(self, attributes):

    def get_extended_resources(self, version):

class VPNPluginBase(ServicePluginBase):

    def get_plugin_name(self):

    def get_plugin_type(self):

    def get_plugin_description(self):

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

    def get_vpnservice(self, context, vpnservice_id, fields=None):

    def create_vpnservice(self, context, vpnservice):

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

    def delete_vpnservice(self, context, vpnservice_id):

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

    def get_ipsec_site_connection(self, context, ipsecsite_conn_id, fields=None):

    def create_ipsec_site_connection(self, context, ipsec_site_connection):

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

    def delete_ipsec_site_connection(self, context, ipsecsite_conn_id):

    def get_ikepolicy(self, context, ikepolicy_id, fields=None):

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

    def create_ikepolicy(self, context, ikepolicy):

    def update_ikepolicy(self, context, ikepolicy_id, ikepolicy):

    def delete_ikepolicy(self, context, ikepolicy_id):

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

    def get_ipsecpolicy(self, context, ipsecpolicy_id, fields=None):

    def create_ipsecpolicy(self, context, ipsecpolicy):

    def update_ipsecpolicy(self, context, ipsecpolicy_id, ipsecpolicy):

    def delete_ipsecpolicy(self, context, ipsecpolicy_id):

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

\OpenStack\neutron-2014.1\neutron\hooks.py

def setup_hook(config):

\OpenStack\neutron-2014.1\neutron\manager.py

class Manager(periodic_task.PeriodicTasks):

    def __init__(self, host=None):

    def periodic_tasks(self, context, raise_on_error=False):

    def init_host(self):

    def after_start(self):

def validate_post_plugin_load():

def validate_pre_plugin_load():

class NeutronManager(object):

    def __init__(self, options=None, config_file=None):

    def _get_plugin_instance(self, namespace, plugin_provider):

    def _load_services_from_core_plugin(self):

    def _load_service_plugins(self):

    def _create_instance(cls):

    def get_instance(cls):

    def get_plugin(cls):

    def get_service_plugins(cls):

\OpenStack\neutron-2014.1\neutron\neutron_plugin_base_v2.py

class NeutronPluginBaseV2(object):

    def create_subnet(self, context, subnet):

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

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

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

    def get_subnets_count(self, context, filters=None):

    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 get_networks(self, context, filters=None, fields=None, sorts=None, limit=None, marker=None, page_reverse=False):

    def get_networks_count(self, context, filters=None):

    def delete_network(self, context, id):

    def create_port(self, context, port):

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

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

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

    def get_ports_count(self, context, filters=None):

    def delete_port(self, context, id):

    def start_rpc_listener(self):

\OpenStack\neutron-2014.1\neutron\notifiers\nova.py

class Notifier(object):

    def __init__(self):

    def _is_compute_port(self, port):

    def _get_network_changed_event(self, device_id):

    def _plugin(self):

    def send_network_change(self, action, original_obj, returned_obj):

    def create_port_changed_event(self, action, original_obj, returned_obj):

    def record_port_status_changed(self, port, current_port_status, previous_port_status, initiator):

    def send_port_status(self, mapper, connection, port):

    def send_events(self):

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

\OpenStack\neutron-2014.1\neutron\openstack\common\cache\backends.py

class BaseCache(object):

    def __init__(self, parsed_url, options=None):

    def _set(self, key, value, ttl, not_exists=False):

    def set(self, key, value, ttl, not_exists=False):

    def __setitem__(self, key, value):

    def setdefault(self, key, value):

    def _get(self, key, default):

    def get(self, key, default=None):

    def __getitem__(self, key):

    def __delitem__(self, key):

    def _clear(self):

    def clear(self):

    def _incr(self, key, delta):

    def incr(self, key, delta=1):

    def _append_tail(self, key, tail):

    def append_tail(self, key, tail):

    def append(self, key, value):

    def __contains__(self, key):

    def _get_many(self, keys, default):

    def get_many(self, keys, default=NOTSET):

    def _set_many(self, data, ttl):

    def set_many(self, data, ttl=None):

    def update(self, **kwargs):

    def _unset_many(self, keys):

    def unset_many(self, keys):

\OpenStack\neutron-2014.1\neutron\openstack\common\cache\cache.py

def _get_olso_configs():

def register_oslo_configs(conf):

def get_cache(url='memory:

\OpenStack\neutron-2014.1\neutron\openstack\common\cache\_backends\memory.py

class MemoryBackend(backends.BaseCache):

    def __init__(self, parsed_url, options=None):

    def _set_unlocked(self, key, value, ttl=0):

    def _set(self, key, value, ttl=0, not_exists=False):

    def _get_unlocked(self, key, default=None):

    def _get(self, key, default=None):

    def _exists_unlocked(self, key):

    def __contains__(self, key):

    def _incr_append(self, key, other):

    def _incr(self, key, delta):

    def _append_tail(self, key, tail):

    def _purge_expired(self):

    def __delitem__(self, key):

    def _clear(self):

    def _get_many(self, keys, default):

    def _set_many(self, data, ttl=0):

    def _unset_many(self, keys):

\OpenStack\neutron-2014.1\neutron\openstack\common\cache\_backends\__init__.py

\OpenStack\neutron-2014.1\neutron\openstack\common\cache\__init__.py

\OpenStack\neutron-2014.1\neutron\openstack\common\context.py

def generate_request_id():

class RequestContext(object):

    def __init__(self, auth_token=None, user=None, tenant=None, is_admin=False, read_only=False, show_deleted=False, request_id=None):

    def to_dict(self):

def get_admin_context(show_deleted="no"):

def get_context_from_function_and_args(function, args, kwargs):

\OpenStack\neutron-2014.1\neutron\openstack\common\db\api.py

def safe_for_db_retry(f):

def _wrap_db_retry(f):

 def wrapper(*args, **kwargs):

class DBAPI(object):

    def __init__(self, backend_mapping=None):

    def __getattr__(self, key):

\OpenStack\neutron-2014.1\neutron\openstack\common\db\exception.py

class DBError(Exception):

    def __init__(self, inner_exception=None):

class DBDuplicateEntry(DBError):

    def __init__(self, columns=[], inner_exception=None):

class DBDeadlock(DBError):

    def __init__(self, inner_exception=None):

class DBInvalidUnicodeParameter(Exception):

class DbMigrationError(DBError):

    def __init__(self, message=None):

class DBConnectionError(DBError):

\OpenStack\neutron-2014.1\neutron\openstack\common\db\sqlalchemy\models.py

class ModelBase(object):

    def save(self, session=None):

    def __setitem__(self, key, value):

    def __getitem__(self, key):

    def get(self, key, default=None):

    def _extra_keys(self):

    def __iter__(self):

    def next(self):

    def update(self, values):

    def iteritems(self):

class TimestampMixin(object):

class SoftDeleteMixin(object):

    def soft_delete(self, session=None):

\OpenStack\neutron-2014.1\neutron\openstack\common\db\sqlalchemy\session.py

def set_defaults(sql_connection, sqlite_db, max_pool_size=None, max_overflow=None, pool_timeout=None):

def cleanup():

class SqliteForeignKeysListener(PoolListener):

    def connect(self, dbapi_con, con_record):

def get_session(autocommit=True, expire_on_commit=False, sqlite_fk=False, slave_session=False, mysql_traditional_mode=False):

def _raise_if_duplicate_entry_error(integrity_error, engine_name):

    def get_columns_from_uniq_cons_or_name(columns):

def _raise_if_deadlock_error(operational_error, engine_name):

def _wrap_db_error(f):

    def _wrap(*args, **kwargs):

def get_engine(sqlite_fk=False, slave_engine=False, mysql_traditional_mode=False):

def _synchronous_switch_listener(dbapi_conn, connection_rec):

def _add_regexp_listener(dbapi_con, con_record):

    def regexp(expr, item):

def _thread_yield(dbapi_con, con_record):

def _ping_listener(engine, dbapi_conn, connection_rec, connection_proxy):

def _set_mode_traditional(dbapi_con, connection_rec, connection_proxy):

def _is_db_connection_error(args):

def _raise_if_db_connection_lost(error, engine):

def create_engine(sql_connection, sqlite_fk=False, mysql_traditional_mode=False):

class Query(sqlalchemy.orm.query.Query):

    def soft_delete(self, synchronize_session='evaluate'):

class Session(sqlalchemy.orm.session.Session):

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

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

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

def get_maker(engine, autocommit=True, expire_on_commit=False):

def _patch_mysqldb_with_stacktrace_comments():

    def _do_query(self, q):

def _assert_matching_drivers():

\OpenStack\neutron-2014.1\neutron\openstack\common\db\sqlalchemy\utils.py

def sanitize_db_url(url):

class InvalidSortKey(Exception):

def paginate_query(query, model, limit, sort_keys, marker=None, sort_dir=None, sort_dirs=None):

def get_table(engine, name):

class InsertFromSelect(UpdateBase):

    def __init__(self, table, select):

def visit_insert_from_select(element, compiler, **kw):

class ColumnError(Exception):

    def is_deleted_column_constraint(constraint):

def get_connect_string(backend, database, user=None, passwd=None):

def is_backend_avail(backend, database, user=None, passwd=None):

def get_db_connection_info(conn_pieces):

\OpenStack\neutron-2014.1\neutron\openstack\common\db\sqlalchemy\__init__.py

\OpenStack\neutron-2014.1\neutron\openstack\common\db\__init__.py

\OpenStack\neutron-2014.1\neutron\openstack\common\eventlet_backdoor.py

class EventletBackdoorConfigValueError(Exception):

    def __init__(self, port_range, help_msg, ex):

def _dont_use_this():

def _find_objects(t):

def _print_greenthreads():

def _print_nativethreads():

def _parse_port_range(port_range):

def _listen(host, start_port, end_port, listen_func):

def initialize_if_enabled():

    def displayhook(val):

\OpenStack\neutron-2014.1\neutron\openstack\common\excutils.py

class save_and_reraise_exception(object):

    def __init__(self, reraise=True):

    def __enter__(self):

    def __exit__(self, exc_type, exc_val, exc_tb):

def forever_retry_uncaught_exceptions(infunc):

    def inner_func(*args, **kwargs):

\OpenStack\neutron-2014.1\neutron\openstack\common\fileutils.py

def ensure_tree(path):

def read_cached_file(filename, force_reload=False):

def delete_if_exists(path, remove=os.unlink):

def remove_path_on_error(path, remove=delete_if_exists):

def file_open(*args, **kwargs):

def write_to_tempfile(content, path=None, suffix='', prefix='tmp'):

\OpenStack\neutron-2014.1\neutron\openstack\common\fixture\config.py

class Config(fixtures.Fixture):

    def __init__(self, conf=cfg.CONF):

    def setUp(self):

    def config(self, **kw):

\OpenStack\neutron-2014.1\neutron\openstack\common\fixture\lockutils.py

class LockFixture(fixtures.Fixture):

    def __init__(self, name, lock_file_prefix=None):

    def setUp(self):

\OpenStack\neutron-2014.1\neutron\openstack\common\fixture\mockpatch.py

class PatchObject(fixtures.Fixture):

    def __init__(self, obj, attr, **kwargs):

    def setUp(self):

class Patch(fixtures.Fixture):

    def __init__(self, obj, **kwargs):

    def setUp(self):

OpenStack Index

Previous

Next