OpenStack Study: neutron

OpenStack Index

    def delete_member(self, context, member, host):

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

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id, host):

    def delete_pool_health_monitor(self, context, health_monitor, pool_id, host):

    def agent_updated(self, context, admin_state_up, host):

class AgentDriverBase(abstract_driver.LoadBalancerAbstractDriver):

    def __init__(self, plugin):

    def _set_callbacks_on_plugin(self):

    def get_pool_agent(self, context, pool_id):

    def create_vip(self, context, vip):

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

    def delete_vip(self, context, vip):

    def create_pool(self, context, pool):

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

    def delete_pool(self, context, pool):

    def create_member(self, context, member):

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

    def delete_member(self, context, member):

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

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id):

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

    def stats(self, context, pool_id):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\common\__init__.py

class Dispatcher(object):

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

    def dispatch_lb(self, d_context, *args, **kwargs):

    def _consume_lb(self, sync_item, sync_queue, driver, a_sync):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\agent\lb_operations.py

def handler(event, handler):

def _provision_load_balancer(driver, context, vip, flavor, vip_utif_info, vip_ip_allocation_info, pool_utif_info=None, pool_ip_allocation_info=None, pool=None, members=None, monitors=None):

def _update_load_balancer(driver, context, vip, old_pool_id=None, old_port_id=None, removed_ip=None, pool_utif_info=None, pool_ip_allocation_info=None, new_pool=None, members=None, monitors=None):

def _delete_load_balancer(driver, context, vip):

def _update_server_pool(driver, context, vip, pool, monitors=None):

def _add_or_update_pool_member(driver, context, vip, member, protocol):

def _remove_member_from_pool(driver, context, vip, member):

def _delete_member(driver, context, vip, member):

def _create_pool_hm(driver, context, vip, hm, pool_id):

def _update_pool_hm(driver, context, vip, hm, pool_id):

def _delete_pool_hm(driver, context, vip, hm, pool_id):

def _poll_graph(driver, context, vip):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\agent\__init__.py

class Events:

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\db.py

def initialize():

def add_pool_port(context, pool_id, port_id):

def get_pool_port(context, pool_id):

def delete_pool_backend(context, pool_id):

def delete_pool_port(context, backend_port):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\driver.py

def get_conf(x):

class EmbraneLbaas(abstract_driver.LoadBalancerAbstractDriver):

    def __init__(self, plugin):

    def _validate_vip(self, vip):

    def _delete_vip(self, context, vip):

    def _delete_member(self, context, member):

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

    def _update_vip_graph_state(self, context, vip):

    def _create_backend_port(self, context, db_pool):

    def _retrieve_utif_info(self, context, neutron_port):

    def create_vip(self, context, vip):

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

    def delete_vip(self, context, vip):

    def create_pool(self, context, pool):

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

    def delete_pool(self, context, pool):

    def create_member(self, context, member):

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

    def delete_member(self, context, member):

    def stats(self, context, pool_id):

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

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id):

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

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\models.py

class PoolPort(model_base.BASEV2):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\poller.py

class Poller(object):

    def __init__(self, driver):

    def start_polling(self, interval):

    def _run(self):

    def synchronize_vips(self, ctx):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\embrane\__init__.py

def save_config(conf_path, logical_config, socket_path=None, user_group='nogroup'):

def _build_global(config, socket_path=None, user_group='nogroup'):

def _build_defaults(config):

def _build_frontend(config):

def _build_backend(config):

def _get_first_ip_from_port(port):

def _get_server_health_option(config):

def _get_session_persistence(config):

def _has_http_cookie_persistence(config):

def _expand_expected_codes(codes):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\haproxy\namespace_driver.py

class HaproxyNSDriver(agent_device_driver.AgentDeviceDriver):

    def __init__(self, conf, plugin_rpc):

    def get_name(cls):

    def create(self, logical_config):

    def update(self, logical_config):

    def _spawn(self, logical_config, extra_cmd_args=()):

    def undeploy_instance(self, pool_id):

    def exists(self, pool_id):

    def get_stats(self, pool_id):

    def _get_backend_stats(self, parsed_stats):

    def _get_servers_stats(self, parsed_stats):

    def _get_stats_from_socket(self, socket_path, entity_type):

    def _parse_stats(self, raw_stats):

    def _get_state_file_path(self, pool_id, kind, ensure_state_dir=True):

    def _plug(self, namespace, port, reuse_existing=True):

    def _unplug(self, namespace, port_id):

    def deploy_instance(self, logical_config):

    def _refresh_device(self, pool_id):

    def create_vip(self, vip):

    def update_vip(self, old_vip, vip):

    def delete_vip(self, vip):

    def create_pool(self, pool):

    def update_pool(self, old_pool, pool):

    def delete_pool(self, pool):

    def create_member(self, member):

    def update_member(self, old_member, member):

    def delete_member(self, member):

    def create_pool_health_monitor(self, health_monitor, pool_id):

    def update_pool_health_monitor(self, old_health_monitor, health_monitor, pool_id):

    def delete_pool_health_monitor(self, health_monitor, pool_id):

class Wrap(object):

    def __init__(self, d):

    def __getitem__(self, key):

def get_ns_name(namespace_id):

def kill_pids_in_file(root_helper, pid_path):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\haproxy\plugin_driver.py

class HaproxyOnHostPluginDriver(agent_driver_base.AgentDriverBase):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\haproxy\__init__.py

class NCCException(n_exc.NeutronException):

    def __init__(self, error):

class NSClient(object):

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

    def create_resource(self, tenant_id, resource_path, object_name, object_data):

    def retrieve_resource(self, tenant_id, resource_path, parse_response=True):

    def update_resource(self, tenant_id, resource_path, object_name, object_data):

    def remove_resource(self, tenant_id, resource_path, parse_response=True):

    def _resource_operation(self, method, tenant_id, resource_path, object_name=None, object_data=None):

    def _is_valid_response(self, response_status):

    def _setup_req_headers(self, tenant_id):

    def _get_response_dict(self, response):

    def _execute_request(self, method, resource_uri, headers, body=None):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\netscaler\netscaler_driver.py

class NetScalerPluginDriver(abstract_driver.LoadBalancerAbstractDriver):

    def __init__(self, plugin):

    def create_vip(self, context, vip):

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

    def delete_vip(self, context, vip):

    def create_pool(self, context, pool):

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

    def delete_pool(self, context, pool):

    def create_member(self, context, member):

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

    def delete_member(self, context, member):

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

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id):

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

    def stats(self, context, pool_id):

    def _prepare_vip_for_creation(self, vip):

    def _prepare_vip_for_update(self, vip):

    def _prepare_pool_for_creation(self, pool):

    def _prepare_pool_for_update(self, pool):

    def _prepare_member_for_creation(self, member):

    def _prepare_member_for_update(self, member):

    def _prepare_healthmonitor_for_creation(self, health_monitor, pool_id):

    def _prepare_healthmonitor_for_update(self, health_monitor):

    def _get_network_info(self, context, entity):

    def _get_vip_network_info(self, context, vip):

    def _get_pool_network_info(self, context, pool):

    def _get_pools_on_subnet(self, context, tenant_id, subnet_id):

    def _get_snatport_for_subnet(self, context, tenant_id, subnet_id):

    def _create_snatport_for_subnet(self, context, tenant_id, subnet_id, ip_address):

    def _remove_snatport_for_subnet(self, context, tenant_id, subnet_id):

    def _create_snatport_for_subnet_if_not_exists(self, context, tenant_id, subnet_id, network_info):

    def _remove_snatport_for_subnet_if_not_used(self, context, tenant_id, subnet_id):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\netscaler\__init__.py

class LoadBalancerDriver(abstract_driver.LoadBalancerAbstractDriver):

    def __init__(self, plugin):

    def create_vip(self, context, vip):

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

    def delete_vip(self, context, vip):

    def create_pool(self, context, pool):

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

    def delete_pool(self, context, pool,):

    def _handle_pool(self, context, pool, delete=False):

    def create_member(self, context, member):

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

    def delete_member(self, context, member):

    def _handle_member(self, context, member, delete=False):

    def create_health_monitor(self, context, health_monitor):

    def update_pool_health_monitor(self, context, old_health_monitor, health_monitor, pool_id):

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

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

    def _handle_pool_health_monitor(self, context, health_monitor, pool_id, delete=False):

    def stats(self, context, pool_id):

    def _get_vip_network_id(self, context, extended_vip):

    def _start_completion_handling_thread(self):

    def _update_workflow(self, wf_name, action, wf_params, context, delete=False, lbaas_entity=None, entity_id=None):

    def _remove_workflow(self, ids, context):

    def _remove_service(self, service_name):

    def _get_service(self, pool_id, network_id):

    def _create_service(self, pool_id, network_id):

    def _get_available_service(self, service_name):

    def _workflow_exists(self, pool_id):

    def _create_workflow(self, wf_name, wf_template_name, create_workflow_params=None):

    def _verify_workflow_templates(self):

class vDirectRESTClient:

    def __init__(self, server='localhost', user=None, password=None, port=2189, ssl=True, timeout=5000, base_uri=''):

    def call(self, action, resource, data, headers, binary=False):

class OperationAttributes:

    def __init__(self, operation_url, object_graph, lbaas_entity=None, entity_id=None, delete=False):

    def __repr__(self):

class OperationCompletionHandler(threading.Thread):

    def __init__(self, queue, rest_client, plugin):

    def join(self, timeout=None):

    def handle_operation_completion(self, oper):

    def run(self):

def _rest_wrapper(response, success_codes=[202]):

def _update_vip_graph_status(plugin, oper, status):

def _update_vip_graph_status_cascade(plugin, ids, ctx, status):

def _remove_object_from_db(plugin, oper):

def _translate_vip_object_graph(extended_vip, plugin, context):

    def _create_key(prefix, property_name):

    def _trans_prop_name(prop_name):

    def get_ids(extended_vip):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\radware\exceptions.py

class RadwareLBaasException(exceptions.NeutronException):

class AuthenticationMissing(RadwareLBaasException):

class WorkflowMissing(RadwareLBaasException):

class RESTRequestFailure(RadwareLBaasException):

class UnsupportedEntityOperation(RadwareLBaasException):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\drivers\radware\__init__.py

class LoadBalancerPlugin(ldb.LoadBalancerPluginDb, agent_scheduler.LbaasAgentSchedulerDbMixin):

    def __init__(self):

    def _load_drivers(self):

    def _check_orphan_pool_associations(self, context, provider_names):

    def _get_driver_for_provider(self, provider):

    def _get_driver_for_pool(self, context, pool_id):

    def get_plugin_type(self):

    def get_plugin_description(self):

    def create_vip(self, context, vip):

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

    def _delete_db_vip(self, context, id):

    def delete_vip(self, context, id):

    def _get_provider_name(self, context, pool):

    def create_pool(self, context, pool):

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

    def _delete_db_pool(self, context, id):

    def delete_pool(self, context, id):

    def create_member(self, context, member):

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

    def _delete_db_member(self, context, id):

    def delete_member(self, context, id):

    def create_health_monitor(self, context, health_monitor):

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

    def _delete_db_pool_health_monitor(self, context, hm_id, pool_id):

    def _delete_db_health_monitor(self, context, id):

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

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

    def stats(self, context, pool_id):

    def populate_vip_graph(self, context, vip):

    def validate_provider(self, provider):

\OpenStack\neutron-2014.1\neutron\services\loadbalancer\__init__.py

class MeteringPluginRpc(proxy.RpcProxy):

    def __init__(self, host):

    def _get_sync_data_metering(self, context):

class MeteringAgent(MeteringPluginRpc, manager.Manager):

    def __init__(self, host, conf=None):

    def _load_drivers(self):

    def _metering_notification(self):

    def _purge_metering_info(self):

    def _add_metering_info(self, label_id, pkts, bytes):

    def _add_metering_infos(self):

    def _metering_loop(self):

    def _invoke_driver(self, context, meterings, func_name):

    def _sync_routers_task(self, context):

    def router_deleted(self, context, router_id):

    def routers_updated(self, context, routers=None):

    def _update_routers(self, context, routers):

    def _get_traffic_counters(self, context, routers):

    def update_metering_label_rules(self, context, routers):

    def add_metering_label(self, context, routers):

    def remove_metering_label(self, context, routers):

class MeteringAgentWithStateReport(MeteringAgent):

    def __init__(self, host, conf=None):

    def _report_state(self):

    def agent_updated(self, context, payload):

def main():

\OpenStack\neutron-2014.1\neutron\services\metering\agents\__init__.py

class MeteringAbstractDriver(object):

    def __init__(self, plugin, conf):

    def update_routers(self, context, routers):

    def remove_router(self, context, router_id):

    def update_metering_label_rules(self, context, routers):

    def add_metering_label(self, context, routers):

    def remove_metering_label(self, context, routers):

    def get_traffic_counters(self, context, routers):

\OpenStack\neutron-2014.1\neutron\services\metering\drivers\iptables\iptables_driver.py

class IptablesManagerTransaction(object):

    def __init__(self, im):

    def __enter__(self):

    def __exit__(self, type, value, traceback):

class RouterWithMetering(object):

    def __init__(self, conf, router):

class IptablesMeteringDriver(abstract_driver.MeteringAbstractDriver):

    def __init__(self, plugin, conf):

    def _update_router(self, router):

    def update_routers(self, context, routers):

    def remove_router(self, context, router_id):

    def get_external_device_name(self, port_id):

    def _process_metering_label_rules(self, rm, rules, label_chain, rules_chain):

    def _process_associate_metering_label(self, router):

    def _process_disassociate_metering_label(self, router):

    def add_metering_label(self, context, routers):

    def update_metering_label_rules(self, context, routers):

    def _update_metering_label_rules(self, router):

    def remove_metering_label(self, context, routers):

    def get_traffic_counters(self, context, routers):

\OpenStack\neutron-2014.1\neutron\services\metering\drivers\iptables\__init__.py

class NoopMeteringDriver(abstract_driver.MeteringAbstractDriver):

    def update_routers(self, context, routers):

    def remove_router(self, context, router_id):

    def update_metering_label_rules(self, context, routers):

    def add_metering_label(self, context, routers):

    def remove_metering_label(self, context, routers):

    def get_traffic_counters(self, context, routers):

\OpenStack\neutron-2014.1\neutron\services\metering\drivers\noop\__init__.py

class MeteringCallbacks(metering_db.MeteringDbMixin):

    def __init__(self, plugin):

    def create_rpc_dispatcher(self):

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

class MeteringPlugin(metering_db.MeteringDbMixin):

    def __init__(self):

    def create_metering_label(self, context, metering_label):

    def delete_metering_label(self, context, label_id):

    def create_metering_label_rule(self, context, metering_label_rule):

    def delete_metering_label_rule(self, context, rule_id):

\OpenStack\neutron-2014.1\neutron\services\metering\__init__.py

def normalize_provider_name(name):

def parse_service_provider_opt():

 def validate_name(name):

class ServiceProviderNotFound(n_exc.InvalidInput):

class DefaultServiceProviderNotFound(n_exc.InvalidInput):

class ServiceProviderAlreadyAssociated(n_exc.Conflict):

class ProviderConfiguration(object):

    def __init__(self, prov_data):

    def _ensure_driver_unique(self, driver):

    def _ensure_default_unique(self, type, default):

    def add_provider(self, provider):

    def _check_entry(self, k, v, filters):

    def _fields(self, resource, fields):

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

\OpenStack\neutron-2014.1\neutron\services\service_base.py

class ServicePluginBase(extensions.PluginInterface):

    def get_plugin_type(self):

    def get_plugin_name(self):

    def get_plugin_description(self):

def load_drivers(service_type, plugin):

\OpenStack\neutron-2014.1\neutron\services\vpn\agent.py

class VPNAgent(l3_agent.L3NATAgentWithStateReport):

    def __init__(self, host, conf=None):

    def setup_device_drivers(self, host):

    def get_namespace(self, router_id):

    def add_nat_rule(self, router_id, chain, rule, top=False):

    def remove_nat_rule(self, router_id, chain, rule, top=False):

    def iptables_apply(self, router_id):

    def _router_added(self, router_id, router):

    def _router_removed(self, router_id):

    def _process_routers(self, routers, all_routers=False):

def main():

\OpenStack\neutron-2014.1\neutron\services\vpn\common\topics.py

def make_route_id(cidr, interface):

class CsrRestClient(object):

    def __init__(self, host, tunnel_ip, username, password, timeout=None):

    def _response_info_for(self, response, method):

    def _request(self, method, url, **kwargs):

    def authenticate(self):

    def _do_request(self, method, resource, payload=None, more_headers=None, full_url=False):

    def get_request(self, resource, full_url=False):

    def post_request(self, resource, payload=None):

    def put_request(self, resource, payload=None):

    def delete_request(self, resource):

    def create_ike_policy(self, policy_info):

    def create_ipsec_policy(self, policy_info):

    def create_pre_shared_key(self, psk_info):

    def create_ipsec_connection(self, connection_info):

    def configure_ike_keepalive(self, keepalive_info):

    def create_static_route(self, route_info):

    def delete_static_route(self, route_id):

    def delete_ipsec_connection(self, conn_id):

    def delete_ipsec_policy(self, policy_id):

    def delete_ike_policy(self, policy_id):

    def delete_pre_shared_key(self, key_id):

    def read_tunnel_statuses(self):

\OpenStack\neutron-2014.1\neutron\services\vpn\device_drivers\cisco_ipsec.py

class CsrResourceCreateFailure(exceptions.NeutronException):

class CsrDriverMismatchError(exceptions.NeutronException):

class CsrUnknownMappingError(exceptions.NeutronException):

def find_available_csrs_from_config(config_files):

class CiscoCsrIPsecVpnDriverApi(proxy.RpcProxy):

    def get_vpn_services_on_host(self, context, host):

    def update_status(self, context, status):

class CiscoCsrIPsecDriver(device_drivers.DeviceDriver):

    def __init__(self, agent, host):

    def create_rpc_dispatcher(self):

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

    def create_vpn_service(self, service_data):

    def update_connection(self, context, vpn_service_id, conn_data):

    def update_service(self, context, service_data):

    def update_all_services_and_connections(self, context):

    def mark_existing_connections_as_dirty(self):

    def remove_unknown_connections(self, context):

    def build_report_for_connections_on(self, vpn_service):

    def build_report_for_service(self, vpn_service):

    def report_status(self, context):

    def report_status_internal(self, context):

    def sync(self, context, routers):

    def create_router(self, process_id):

    def destroy_router(self, process_id):

class CiscoCsrVpnService(object):

    def __init__(self, service_data, csr):

    def create_connection(self, conn_data):

    def get_connection(self, conn_id):

    def conn_status(self, conn_id):

    def snapshot_conn_state(self, ipsec_conn):

    def get_ipsec_connections_status(self):

    def find_matching_connection(self, tunnel_id):

    def no_connections_up(self):

    def update_last_status(self):

class CiscoCsrIPSecConnection(object):

    def __init__(self, conn_info, csr):

    def find_current_status_in(self, statuses):

    def update_status_and_build_report(self, current_status):

    def translate_dialect(self, resource, attribute, info):

    def create_psk_info(self, psk_id, conn_info):

    def create_ike_policy_info(self, ike_policy_id, conn_info):

    def create_ipsec_policy_info(self, ipsec_policy_id, info):

    def create_site_connection_info(self, site_conn_id, ipsec_policy_id, conn_info):

    def create_routes_info(self, site_conn_id, conn_info):

    def _check_create(self, resource, which):

    def do_create_action(self, action_suffix, info, resource_id, title):

    def _verify_deleted(self, status, resource, which):

    def do_rollback(self):

    def create_ipsec_site_connection(self, context, conn_info):

    def delete_ipsec_site_connection(self, context, conn_id):

\OpenStack\neutron-2014.1\neutron\services\vpn\device_drivers\ipsec.py

def _get_template(template_file):

class BaseSwanProcess():

    def __init__(self, conf, root_helper, process_id, vpnservice, namespace):

    def translate_dialect(self):

    def update_vpnservice(self, vpnservice):

    def _dialect(self, obj, key):

    def ensure_configs(self):

    def ensure_config_file(self, kind, template, vpnservice):

    def remove_config(self):

    def _get_config_filename(self, kind):

    def _ensure_dir(self, dir_path):

    def ensure_config_dir(self, vpnservice):

    def _gen_config_content(self, template_file, vpnservice):

    def get_status(self):

    def status(self):

    def active(self):

    def update(self):

    def enable(self):

    def disable(self):

    def restart(self):

    def start(self):

    def stop(self):

    def _update_connection_status(self, status_output):

class OpenSwanProcess(BaseSwanProcess):

    def __init__(self, conf, root_helper, process_id, vpnservice, namespace):

    def _execute(self, cmd, check_exit_code=True):

    def ensure_configs(self):

    def get_status(self):

    def restart(self):

    def _get_nexthop(self, address):

    def _virtual_privates(self):

    def start(self):

    def disconnect(self):

    def stop(self):

class IPsecVpnDriverApi(proxy.RpcProxy):

    def get_vpn_services_on_host(self, context, host):

    def update_status(self, context, status):

class IPsecDriver(device_drivers.DeviceDriver):

    def __init__(self, agent, host):

    def create_rpc_dispatcher(self):

    def _update_nat(self, vpnservice, func):

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

    def create_process(self, process_id, vpnservice, namespace):

    def ensure_process(self, process_id, vpnservice=None):

    def create_router(self, process_id):

    def destroy_router(self, process_id):

    def get_process_status_cache(self, process):

    def is_status_updated(self, process, previous_status):

    def unset_updated_pending_status(self, process):

    def copy_process_status(self, process):

    def update_downed_connections(self, process_id, new_status):

    def report_status(self, context):

    def sync(self, context, routers):

class OpenSwanDriver(IPsecDriver):

    def create_process(self, process_id, vpnservice, namespace):

\OpenStack\neutron-2014.1\neutron\services\vpn\device_drivers\__init__.py

class DeviceDriver(object):

    def __init__(self, agent, host):

    def sync(self, context, processes):

    def create_router(self, process_id):

    def destroy_router(self, process_id):

\OpenStack\neutron-2014.1\neutron\services\vpn\plugin.py

class VPNPlugin(vpn_db.VPNPluginDb):

class VPNDriverPlugin(VPNPlugin, vpn_db.VPNPluginRpcDbMixin):

    def __init__(self):

    def _get_driver_for_vpnservice(self, vpnservice):

    def _get_driver_for_ipsec_site_connection(self, context, ipsec_site_connection):

    def create_ipsec_site_connection(self, context, ipsec_site_connection):

    def delete_ipsec_site_connection(self, context, ipsec_conn_id):

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

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

    def delete_vpnservice(self, context, vpnservice_id):

\OpenStack\neutron-2014.1\neutron\services\vpn\service_drivers\cisco_csr_db.py

class CsrInternalError(exceptions.NeutronException):

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

def get_next_available_id(session, table_field, id_type):

def get_next_available_tunnel_id(session):

def get_next_available_ike_policy_id(session):

def get_next_available_ipsec_policy_id(session):

def find_conn_with_policy(policy_field, policy_id, conn_id, session):

def find_connection_using_ike_policy(ike_policy_id, conn_id, session):

def find_connection_using_ipsec_policy(ipsec_policy_id, conn_id, session):

def lookup_policy(policy_type, policy_field, conn_id, session):

def lookup_ike_policy_id_for(conn_id, session):

def lookup_ipsec_policy_id_for(conn_id, session):

def determine_csr_policy_id(policy_type, conn_policy_field, map_policy_field, policy_id, conn_id, session):

def determine_csr_ike_policy_id(ike_policy_id, conn_id, session):

def determine_csr_ipsec_policy_id(ipsec_policy_id, conn_id, session):

def get_tunnel_mapping_for(conn_id, session):

def create_tunnel_mapping(context, conn_info):

def delete_tunnel_mapping(context, conn_info):

\OpenStack\neutron-2014.1\neutron\services\vpn\service_drivers\cisco_ipsec.py

class CsrValidationFailure(exceptions.BadRequest):

class CsrUnsupportedError(exceptions.NeutronException):

class CiscoCsrIPsecVpnDriverCallBack(object):

    def __init__(self, driver):

    def create_rpc_dispatcher(self):

    def get_vpn_services_on_host(self, context, host=None):

    def update_status(self, context, status):

class CiscoCsrIPsecVpnAgentApi(service_drivers.BaseIPsecVpnAgentApi):

    def __init__(self, topic, default_version):

class CiscoCsrIPsecVPNDriver(service_drivers.VpnDriver):

    def __init__(self, service_plugin):

    def service_type(self):

    def validate_lifetime(self, for_policy, policy_info):

    def validate_ike_version(self, policy_info):

    def validate_mtu(self, conn_info):

    def validate_public_ip_present(self, vpn_service):

    def validate_peer_id(self, ipsec_conn):

    def validate_ipsec_connection(self, context, ipsec_conn, vpn_service):

    def create_ipsec_site_connection(self, context, ipsec_site_connection):

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

    def delete_ipsec_site_connection(self, context, ipsec_site_connection):

    def create_ikepolicy(self, context, ikepolicy):

    def delete_ikepolicy(self, context, ikepolicy):

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

    def create_ipsecpolicy(self, context, ipsecpolicy):

    def delete_ipsecpolicy(self, context, ipsecpolicy):

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

    def create_vpnservice(self, context, vpnservice):

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

    def delete_vpnservice(self, context, vpnservice):

    def get_cisco_connection_mappings(self, conn_id, context):

    def _make_vpnservice_dict(self, vpnservice, context):

\OpenStack\neutron-2014.1\neutron\services\vpn\service_drivers\ipsec.py

class IPsecVpnDriverCallBack(object):

    def __init__(self, driver):

    def create_rpc_dispatcher(self):

    def get_vpn_services_on_host(self, context, host=None):

    def update_status(self, context, status):

class IPsecVpnAgentApi(service_drivers.BaseIPsecVpnAgentApi):

    def __init__(self, topic, default_version):

class IPsecVPNDriver(service_drivers.VpnDriver):

    def __init__(self, service_plugin):

    def service_type(self):

    def create_ipsec_site_connection(self, context, ipsec_site_connection):

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

    def delete_ipsec_site_connection(self, context, ipsec_site_connection):

    def create_ikepolicy(self, context, ikepolicy):

    def delete_ikepolicy(self, context, ikepolicy):

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

    def create_ipsecpolicy(self, context, ipsecpolicy):

    def delete_ipsecpolicy(self, context, ipsecpolicy):

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

    def create_vpnservice(self, context, vpnservice):

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

    def delete_vpnservice(self, context, vpnservice):

    def _make_vpnservice_dict(self, vpnservice):

\OpenStack\neutron-2014.1\neutron\services\vpn\service_drivers\__init__.py

class VpnDriver(object):

    def __init__(self, service_plugin):

    def service_type(self):

    def create_vpnservice(self, context, vpnservice):

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

    def delete_vpnservice(self, context, vpnservice):

class BaseIPsecVpnAgentApi(proxy.RpcProxy):

    def __init__(self, to_agent_topic, topic, default_version):

    def _agent_notification(self, context, method, router_id, version=None, **kwargs):

    def vpnservice_updated(self, context, router_id, **kwargs):

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

def fake_use_fatal_exceptions(*args):

class BaseTestCase(testtools.TestCase):

    def _cleanup_coreplugin(self):

    def setup_coreplugin(self, core_plugin=None):

    def _cleanup_test_notifier(self):

    def setup_notification_driver(self, notification_driver=None):

    def setUp(self):

    def config(self, **kw):

    def assert_max_execution_time(self, max_execution_time=5):

\OpenStack\neutron-2014.1\neutron\tests\functional\agent\linux\test_async_process.py

class TestAsyncProcess(base.BaseTestCase):

    def setUp(self):

    def _check_stdout(self, proc):

    def test_stopping_async_process_lifecycle(self):

    def test_async_process_respawns(self):

\OpenStack\neutron-2014.1\neutron\tests\functional\agent\linux\test_ovsdb_monitor.py

def get_rand_name(name='test'):

def create_ovs_resource(name_prefix, creation_func):

class BaseMonitorTest(base.BaseTestCase):

    def setUp(self):

        def cleanup_bridge():

    def _check_command(self, cmd, error_text, skip_msg):

    def _check_test_requirements(self):

class TestOvsdbMonitor(BaseMonitorTest):

    def setUp(self):

    def collect_initial_output(self):

    def test_killed_monitor_respawns(self):

class TestSimpleInterfaceMonitor(BaseMonitorTest):

    def setUp(self):

    def test_has_updates(self):

\OpenStack\neutron-2014.1\neutron\tests\functional\agent\linux\__init__.py

def exception_handler(exc_info):

def get_ignored_traceback(tb):

class FilteredTraceback(object):

    def __init__(self, tb, filtered_traceback):

    def tb_next(self):

\OpenStack\neutron-2014.1\neutron\tests\tools.py

def setup_mock_calls(mocked_call, expected_calls_and_values):

def verify_mock_calls(mocked_call, expected_calls_and_values):

\OpenStack\neutron-2014.1\neutron\tests\unit\agent\linux\test_async_process.py

class TestAsyncProcess(base.BaseTestCase):

    def setUp(self):

    def test_construtor_raises_exception_for_negative_respawn_interval(self):

    def test__spawn(self):

    def test__handle_process_error_kills_with_respawn(self):

    def test__handle_process_error_kills_without_respawn(self):

    def _test__watch_process(self, callback, kill_event):

    def test__watch_process_exits_on_callback_failure(self):

    def test__watch_process_exits_on_exception(self):

        def foo():

    def test__watch_process_exits_on_sent_kill_event(self):

    def _test_read_output_queues_and_returns_result(self, output):

    def test__read_queues_and_returns_output(self):

    def test__read_returns_none_for_missing_output(self):

    def test_start_raises_exception_if_process_already_started(self):

    def test_start_invokes__spawn(self):

    def test__iter_queue_returns_empty_list_for_empty_queue(self):

    def test__iter_queue_returns_queued_data(self):

    def _test_iter_output_calls_iter_queue_on_output_queue(self, output_type):

    def test_iter_stdout(self):

    def test_iter_stderr(self):

    def _test__kill(self, respawning, pid=None):

    def test__kill_when_respawning_does_not_clear_kill_event(self):

    def test__kill_when_not_respawning_clears_kill_event(self):

    def test__kill_targets_process_for_pid(self):

    def _test__get_pid_to_kill(self, expected=_marker, root_helper=None, pids=None):

        def _find_child_pids(x):

    def test__get_pid_to_kill_returns_process_pid_without_root_helper(self):

    def test__get_pid_to_kill_returns_child_pid_with_root_helper(self):

    def test__get_pid_to_kill_returns_last_child_pid_with_root_Helper(self):

    def test__get_pid_to_kill_returns_none_with_root_helper(self):

    def _test__kill_process(self, pid, expected, exception_message=None):

    def test__kill_process_returns_true_for_valid_pid(self):

    def test__kill_process_returns_true_for_stale_pid(self):

    def test__kill_process_returns_false_for_execute_exception(self):

    def test_stop_calls_kill(self):

    def test_stop_raises_exception_if_already_started(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\agent\linux\test_ovsdb_monitor.py

class TestOvsdbMonitor(base.BaseTestCase):

    def setUp(self):

    def read_output_queues_and_returns_result(self, output_type, output):

    def test__read_stdout_returns_none_for_empty_read(self):

    def test__read_stdout_queues_root_wrapper_errors_to_stderr_output(self):

    def test__read_stdout_queues_normal_output_to_stdout_queue(self):

    def test__read_stderr_returns_none(self):

class TestSimpleInterfaceMonitor(base.BaseTestCase):

    def setUp(self):

    def test_is_active_is_false_by_default(self):

    def test_is_active_can_be_true(self):

    def test_has_updates_is_true_by_default(self):

    def test_has_updates_is_false_if_active_with_no_output(self):

    def test__kill_sets_data_received_to_false(self):

    def test__read_stdout_sets_data_received_and_returns_output(self):

    def test__read_stdout_does_not_set_data_received_for_empty_ouput(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\agent\linux\test_polling.py

class TestGetPollingManager(base.BaseTestCase):

    def test_return_always_poll_by_default(self):

    def test_manage_polling_minimizer(self):

class TestBasePollingManager(base.BaseTestCase):

    def setUp(self):

    def test_force_polling_sets_interval_attribute(self):

    def test_polling_completed_sets_interval_attribute(self):

    def mock_is_polling_required(self, return_value):

    def test_is_polling_required_returns_true_when_forced(self):

    def test_is_polling_required_returns_true_when_polling_not_completed(self):

    def test_is_polling_required_returns_true_when_updates_are_present(self):

    def test_is_polling_required_returns_false_for_no_updates(self):

class TestAlwaysPoll(base.BaseTestCase):

    def test_is_polling_required_always_returns_true(self):

class TestInterfacePollingMinimizer(base.BaseTestCase):

    def setUp(self):

    def test_start_calls_monitor_start(self):

    def test_stop_calls_monitor_stop(self):

    def mock_has_updates(self, return_value):

    def test__is_polling_required_returns_when_updates_are_present(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\agent\linux\__init__.py

class TestDhcpAgentNotifyAPI(base.BaseTestCase):

    def setUp(self):

    def _test__schedule_network(self, network, new_agents=None, existing_agents=None, expected_casts=0, expected_warnings=0):

    def test__schedule_network(self):

    def test__schedule_network_no_existing_agents(self):

    def test__schedule_network_no_new_agents(self):

    def _test__get_enabled_agents(self, network, agents=None, port_count=0, expected_warnings=0, expected_errors=0):

    def test__get_enabled_agents(self):

    def test__get_enabled_agents_with_inactive_ones(self):

    def test__get_enabled_agents_with_notification_required(self):

    def test__notify_agents_fanout_required(self):

    def _test__notify_agents(self, method, expected_scheduling=0, expected_casts=0):

    def test__notify_agents_cast_required_with_scheduling(self):

    def test__notify_agents_cast_required_wo_scheduling_on_port_update(self):

    def test__notify_agents_cast_required_wo_scheduling_on_subnet_create(self):

    def test__notify_agents_no_action(self):

    def test__fanout_message(self):

    def test__cast_message(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\api\rpc\agentnotifiers\__init__.py

class HTTPResponseMock():

    def __init__(self, sock, debuglevel=0, strict=0, method=None, buffering=False):

    def read(self):

    def getheader(self, header):

class HTTPResponseMock404(HTTPResponseMock):

    def read(self):

class HTTPResponseMock500(HTTPResponseMock):

    def __init__(self, sock, debuglevel=0, strict=0, method=None, buffering=False, errmsg='500 Internal Server Error'):

    def read(self):

class HTTPConnectionMock(object):

    def __init__(self, server, port, timeout):

    def request(self, action, uri, body, headers):

    def getresponse(self):

    def close(self):

class HTTPConnectionMock404(HTTPConnectionMock):

    def __init__(self, server, port, timeout):

class HTTPConnectionMock500(HTTPConnectionMock):

    def __init__(self, server, port, timeout):

class VerifyMultiTenantFloatingIP(HTTPConnectionMock):

    def request(self, action, uri, body, headers):

class HTTPSMockBase(HTTPConnectionMock):

    def __init__(self, host, port=None, key_file=None, cert_file=None, strict=None, timeout=None, source_address=None):

    def request(self, method, url, body=None, headers={}):

class HTTPSNoValidation(HTTPSMockBase):

    def connect(self):

class HTTPSCAValidation(HTTPSMockBase):

    def connect(self):

class HTTPSHostValidation(HTTPSMockBase):

    def connect(self):

def get_cert_contents(path):

\OpenStack\neutron-2014.1\neutron\tests\unit\bigswitch\test_agent_scheduler.py

class BigSwitchDhcpAgentNotifierTestCase( test_agent_scheduler.OvsDhcpAgentNotifierTestCase, test_base.BigSwitchTestBase):

    def setUp(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\bigswitch\test_base.py

class BigSwitchTestBase(object):

    def setup_config_files(self):

    def setup_patches(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\bigswitch\test_capabilities.py

class CapabilitiesTests(test_router_db.RouterDBTestCase):

    def test_floating_ip_capability(self):

    def test_floating_ip_capability_neg(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\bigswitch\test_restproxy_agent.py

class BaseAgentTestCase(base.BaseTestCase):

    def setUp(self):

class TestRestProxyAgentOVS(BaseAgentTestCase):

    def setUp(self):

    def mock_agent(self):

    def mock_port_update(self, **kwargs):

    def test_port_update(self):

    def test_port_update_not_vifport(self):

    def test_port_update_without_secgroup(self):

    def mock_update_ports(self, vif_port_set=None, registered_ports=None):

    def test_update_ports_unchanged(self):

    def test_update_ports_changed(self):

    def mock_process_devices_filter(self, port_info):

    def test_process_devices_filter_add(self):

    def test_process_devices_filter_remove(self):

    def test_process_devices_filter_both(self):

    def test_process_devices_filter_none(self):

class TestRestProxyAgent(BaseAgentTestCase):

    def mock_main(self):

    def test_main(self):

\OpenStack\neutron-2014.1\neutron\tests\unit\bigswitch\test_restproxy_plugin.py

class BigSwitchProxyPluginV2TestCase(test_base.BigSwitchTestBase, test_plugin.NeutronDbPluginV2TestCase):

    def setUp(self, plugin_name=None):

class TestBigSwitchProxyBasicGet(test_plugin.TestBasicGet, BigSwitchProxyPluginV2TestCase):

class TestBigSwitchProxyV2HTTPResponse(test_plugin.TestV2HTTPResponse, BigSwitchProxyPluginV2TestCase):

    def test_failover_memory(self):

class TestBigSwitchProxyPortsV2(test_plugin.TestPortsV2, BigSwitchProxyPluginV2TestCase, test_bindings.PortBindingsTestCase):

    def setUp(self, plugin_name=None):

    def test_update_port_status_build(self):

    def _get_ports(self, netid):

    def test_rollback_for_port_create(self):

    def test_rollback_for_port_update(self):

    def test_rollback_for_port_delete(self):

    def test_correct_shared_net_tenant_id(self):

        def rest_port_op(self, ten_id, netid, port):

    def test_create404_triggers_sync(self):

    def test_port_vif_details_default(self):

    def test_port_vif_details_override(self):

    def test_port_move(self):

    def _make_port(self, fmt, net_id, expected_res_status=None, arg_list=None, **kwargs):

class TestVifDifferentDefault(BigSwitchProxyPluginV2TestCase):

    def setup_config_files(self):

    def test_default_viftype(self):

class TestBigSwitchProxyNetworksV2(test_plugin.TestNetworksV2, BigSwitchProxyPluginV2TestCase):

    def _get_networks(self, tenant_id):

    def test_rollback_on_network_create(self):

    def test_rollback_on_network_update(self):

    def test_rollback_on_network_delete(self):

class TestBigSwitchProxySubnetsV2(test_plugin.TestSubnetsV2, BigSwitchProxyPluginV2TestCase):

class TestBigSwitchProxySync(BigSwitchProxyPluginV2TestCase):

    def test_send_data(self):

class TestBigSwitchAddressPairs(BigSwitchProxyPluginV2TestCase, test_addr_pair.TestAllowedAddressPairs):

\OpenStack\neutron-2014.1\neutron\tests\unit\bigswitch\test_router_db.py

class RouterRulesTestExtensionManager(object):

    def get_resources(self):

    def get_actions(self):

    def get_request_extensions(self):

class DHCPOptsTestCase(test_base.BigSwitchTestBase, test_extradhcp.TestExtraDhcpOpt):

    def setUp(self, plugin=None):

class RouterDBTestCase(test_base.BigSwitchTestBase, test_l3_plugin.L3NatDBIntTestCase):

    def setUp(self):

    def tearDown(self):

    def test_router_remove_router_interface_wrong_subnet_returns_400(self):

    def test_router_remove_router_interface_wrong_port_returns_404(self):

    def test_multi_tenant_flip_alllocation(self):

    def _make_floatingip_for_tenant_port(self, net_id, port_id, tenant_id):

    def test_floatingip_with_invalid_create_port(self):

    def test_create_floatingip_no_ext_gateway_return_404(self):

    def test_router_update_gateway(self):

    def test_router_add_interface_overlapped_cidr(self):

    def test_router_add_interface_overlapped_cidr_returns_400(self):

    def test_list_nets_external(self):

OpenStack Index

• index_neutron.htm
• index_neutron_1.htm
• index_neutron_10.htm
• index_neutron_11.htm
• index_neutron_12.htm
• index_neutron_13.htm
• index_neutron_14.htm
• index_neutron_15.htm
• index_neutron_16.htm
• index_neutron_17.htm
• index_neutron_18.htm
• index_neutron_2.htm
• index_neutron_3.htm
• index_neutron_4.htm
• index_neutron_5.htm
• index_neutron_6.htm
• index_neutron_7.htm
• index_neutron_8.htm
• index_neutron_9.htm