OpenStack Study: neutron

OpenStack Index

def get_log_args(conf, log_file_name):

def register_root_helper(conf):

def register_agent_state_opts_helper(conf):

def register_interface_driver_opts_helper(conf):

def register_use_namespaces_opts_helper(conf):

def get_root_helper(conf):

def setup_conf():

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

class DhcpAgent(manager.Manager):

    def __init__(self, host=None):

    def _populate_networks_cache(self):

    def after_start(self):

    def run(self):

    def call_driver(self, action, network, **action_kwargs):

    def sync_state(self):

    def _periodic_resync_helper(self):

    def periodic_resync(self):

    def safe_get_network_info(self, network_id):

    def enable_dhcp_helper(self, network_id):

    def safe_configure_dhcp_for_network(self, network):

    def configure_dhcp_for_network(self, network):

    def disable_dhcp_helper(self, network_id):

    def refresh_dhcp_helper(self, network_id):

    def network_create_end(self, context, payload):

    def network_update_end(self, context, payload):

    def network_delete_end(self, context, payload):

    def subnet_update_end(self, context, payload):

    def subnet_delete_end(self, context, payload):

    def port_update_end(self, context, payload):

    def port_delete_end(self, context, payload):

    def enable_isolated_metadata_proxy(self, network):

        def callback(pid_file):

    def disable_isolated_metadata_proxy(self, network):

class DhcpPluginApi(proxy.RpcProxy):

    def __init__(self, topic, context, use_namespaces):

    def get_active_networks_info(self):

    def get_network_info(self, network_id):

    def get_dhcp_port(self, network_id, device_id):

    def create_dhcp_port(self, port):

    def update_dhcp_port(self, port_id, port):

    def release_dhcp_port(self, network_id, device_id):

    def release_port_fixed_ip(self, network_id, device_id, subnet_id):

class NetworkCache(object):

    def __init__(self):

    def get_network_ids(self):

    def get_network_by_id(self, network_id):

    def get_network_by_subnet_id(self, subnet_id):

    def get_network_by_port_id(self, port_id):

    def put(self, network):

    def remove(self, network):

    def put_port(self, port):

    def remove_port(self, port):

    def get_port_by_id(self, port_id):

    def get_state(self):

class DhcpAgentWithStateReport(DhcpAgent):

    def __init__(self, host=None):

    def _report_state(self):

    def agent_updated(self, context, payload):

    def after_start(self):

def register_options():

def main():

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

class FirewallDriver(object):

    def prepare_port_filter(self, port):

    def apply_port_filter(self, port):

    def update_port_filter(self, port):

    def remove_port_filter(self, port):

    def filter_defer_apply_on(self):

    def filter_defer_apply_off(self):

    def ports(self):

    def defer_apply(self):

class NoopFirewallDriver(FirewallDriver):

    def prepare_port_filter(self, port):

    def apply_port_filter(self, port):

    def update_port_filter(self, port):

    def remove_port_filter(self, port):

    def filter_defer_apply_on(self):

    def filter_defer_apply_off(self):

    def ports(self):

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

class L2populationRpcCallBackMixin(object):

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

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

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

    def fdb_add(self, context, fdb_entries):

    def fdb_remove(self, context, fdb_entries):

    def fdb_update(self, context, fdb_entries):

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

class L3PluginApi(proxy.RpcProxy):

    def __init__(self, topic, host):

    def get_routers(self, context, router_ids=None):

    def get_external_network_id(self, context):

    def update_floatingip_statuses(self, context, router_id, fip_statuses):

class RouterInfo(object):

    def __init__(self, router_id, root_helper, use_namespaces, router):

    def router(self):

    def router(self, value):

    def perform_snat_action(self, snat_callback, *args):

class L3NATAgent(firewall_l3_agent.FWaaSL3AgentRpcCallback, manager.Manager):

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

    def _check_config_params(self):

    def _cleanup_namespaces(self, routers):

    def _destroy_stale_router_namespaces(self, router_namespaces):

    def _destroy_router_namespace(self, namespace):

    def _create_router_namespace(self, ri):

    def _fetch_external_net_id(self, force=False):

    def _router_added(self, router_id, router):

    def _router_removed(self, router_id):

    def _spawn_metadata_proxy(self, router_id, ns_name):

        def callback(pid_file):

    def _destroy_metadata_proxy(self, router_id, ns_name):

    def _set_subnet_info(self, port):

    def _get_existing_devices(self, ri):

    def process_router(self, ri):

    def _handle_router_snat_rules(self, ri, ex_gw_port, internal_cidrs, interface_name, action):

    def process_router_floating_ip_nat_rules(self, ri):

    def process_router_floating_ip_addresses(self, ri, ex_gw_port):

    def _get_ex_gw_port(self, ri):

    def _arping(self, ri, interface_name, ip_address):

    def _send_gratuitous_arp_packet(self, ri, interface_name, ip_address):

    def get_internal_device_name(self, port_id):

    def get_external_device_name(self, port_id):

    def external_gateway_added(self, ri, ex_gw_port, interface_name, internal_cidrs):

    def external_gateway_removed(self, ri, ex_gw_port, interface_name, internal_cidrs):

    def metadata_filter_rules(self):

    def metadata_nat_rules(self):

    def external_gateway_nat_rules(self, ex_gw_ip, internal_cidrs, interface_name):

    def internal_network_added(self, ri, network_id, port_id, internal_cidr, mac_address):

    def internal_network_removed(self, ri, port_id, internal_cidr):

    def internal_network_nat_rules(self, ex_gw_ip, internal_cidr):

    def floating_forward_rules(self, floating_ip, fixed_ip):

    def router_deleted(self, context, router_id):

    def routers_updated(self, context, routers):

    def router_removed_from_agent(self, context, payload):

    def router_added_to_agent(self, context, payload):

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

    def _rpc_loop(self):

    def _process_router_delete(self):

    def _router_ids(self):

    def _sync_routers_task(self, context):

    def after_start(self):

    def _update_routing_table(self, ri, operation, route):

    def routes_updated(self, ri):

class L3NATAgentWithStateReport(L3NATAgent):

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

    def _report_state(self):

    def agent_updated(self, context, payload):

def main(manager='neutron.agent.l3_agent.L3NATAgentWithStateReport'):

\OpenStack\neutron-2014.1\neutron\agent\linux\async_process.py

class AsyncProcessException(Exception):

class AsyncProcess(object):

    def __init__(self, cmd, root_helper=None, respawn_interval=None):

    def _reset_queues(self):

    def start(self):

    def stop(self):

    def _spawn(self):

    def _kill(self, respawning=False):

    def _get_pid_to_kill(self):

    def _kill_process(self, pid):

    def _handle_process_error(self):

    def _watch_process(self, callback, kill_event):

    def _read(self, stream, queue):

    def _read_stdout(self):

    def _read_stderr(self):

    def _iter_queue(self, queue):

    def iter_stdout(self):

    def iter_stderr(self):

\OpenStack\neutron-2014.1\neutron\agent\linux\daemon.py

class Pidfile(object):

    def __init__(self, pidfile, procname, uuid=None):

    def __str__(self):

    def unlock(self):

    def write(self, pid):

    def read(self):

    def is_running(self):

class Daemon(object):

    def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null', procname='python', uuid=None):

    def _fork(self):

    def daemonize(self):

    def delete_pid(self):

    def handle_sigterm(self, signum, frame):

    def start(self):

    def run(self):

\OpenStack\neutron-2014.1\neutron\agent\linux\dhcp.py

class DictModel(object):

    def __init__(self, d):

class NetModel(DictModel):

    def __init__(self, use_namespaces, d):

    def namespace(self):

class DhcpBase(object):

    def __init__(self, conf, network, root_helper='sudo', version=None, plugin=None):

    def enable(self):

    def disable(self, retain_port=False):

    def restart(self):

    def active(self):

    def reload_allocations(self):

    def existing_dhcp_networks(cls, conf, root_helper):

    def check_version(cls):

class DhcpLocalProcess(DhcpBase):

    def _enable_dhcp(self):

    def enable(self):

    def disable(self, retain_port=False):

    def _remove_config_files(self):

    def get_conf_file_name(self, kind, ensure_conf_dir=False):

    def _get_value_from_conf_file(self, kind, converter=None):

    def pid(self):

    def active(self):

    def interface_name(self):

    def interface_name(self, value):

    def spawn_process(self):

class Dnsmasq(DhcpLocalProcess):

    def check_version(cls):

    def existing_dhcp_networks(cls, conf, root_helper):

    def spawn_process(self):

    def _release_lease(self, mac_address, ip):

    def reload_allocations(self):

    def _iter_hosts(self):

    def _output_hosts_file(self):

    def _read_hosts_file_leases(self, filename):

    def _release_unused_leases(self):

    def _output_addn_hosts_file(self):

    def _output_opts_file(self):

    def _make_subnet_interface_ip_map(self):

    def _format_option(self, tag, option, *args):

    def _enable_metadata(self, subnet):

    def lease_update(cls):

class DeviceManager(object):

    def __init__(self, conf, root_helper, plugin):

    def get_interface_name(self, network, port):

    def get_device_id(self, network):

    def _get_device(self, network, port):

    def _set_default_route(self, network, port):

    def setup_dhcp_port(self, network):

    def setup(self, network, reuse_existing=False):

    def update(self, network):

    def destroy(self, network, device_name):

\OpenStack\neutron-2014.1\neutron\agent\linux\external_process.py

class ProcessManager(object):

    def __init__(self, conf, uuid, root_helper='sudo', namespace=None):

    def enable(self, cmd_callback):

    def disable(self):

    def get_pid_file_name(self, ensure_pids_dir=False):

    def pid(self):

    def active(self):

\OpenStack\neutron-2014.1\neutron\agent\linux\interface.py

class LinuxInterfaceDriver(object):

    def __init__(self, conf):

    def init_l3(self, device_name, ip_cidrs, namespace=None, preserve_ips=[]):

    def check_bridge_exists(self, bridge):

    def get_device_name(self, port):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

class NullDriver(LinuxInterfaceDriver):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

class OVSInterfaceDriver(LinuxInterfaceDriver):

    def __init__(self, conf):

    def _get_tap_name(self, dev_name, prefix=None):

    def _ovs_add_port(self, bridge, device_name, port_id, mac_address, internal=True):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

class MidonetInterfaceDriver(LinuxInterfaceDriver):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

class IVSInterfaceDriver(LinuxInterfaceDriver):

    def __init__(self, conf):

    def _get_tap_name(self, dev_name, prefix=None):

    def _ivs_add_port(self, device_name, port_id, mac_address):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

class BridgeInterfaceDriver(LinuxInterfaceDriver):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

class MetaInterfaceDriver(LinuxInterfaceDriver):

    def __init__(self, conf):

    def _get_flavor_by_network_id(self, network_id):

    def _get_driver_by_network_id(self, network_id):

    def _set_device_plugin_tag(self, network_id, device_name, namespace=None):

    def _get_device_plugin_tag(self, device_name, namespace=None):

    def get_device_name(self, port):

    def plug(self, network_id, port_id, device_name, mac_address, bridge=None, namespace=None, prefix=None):

    def unplug(self, device_name, bridge=None, namespace=None, prefix=None):

    def _load_driver(self, driver_provider):

\OpenStack\neutron-2014.1\neutron\agent\linux\iptables_firewall.py

class IptablesFirewallDriver(firewall.FirewallDriver):

    def __init__(self):

    def ports(self):

    def prepare_port_filter(self, port):

    def update_port_filter(self, port):

    def remove_port_filter(self, port):

    def _setup_chains(self):

    def _setup_chains_apply(self, ports):

    def _remove_chains(self):

    def _remove_chains_apply(self, ports):

    def _setup_chain(self, port, DIRECTION):

    def _remove_chain(self, port, DIRECTION):

    def _add_fallback_chain_v4v6(self):

    def _add_chain_by_name_v4v6(self, chain_name):

    def _remove_chain_by_name_v4v6(self, chain_name):

    def _add_rule_to_chain_v4v6(self, chain_name, ipv4_rules, ipv6_rules):

    def _get_device_name(self, port):

    def _add_chain(self, port, direction):

    def _split_sgr_by_ethertype(self, security_group_rules):

    def _select_sgr_by_direction(self, port, direction):

    def _setup_spoof_filter_chain(self, port, table, mac_ip_pairs, rules):

    def _build_ipv4v6_mac_ip_list(self, mac, ip_address, mac_ipv4_pairs, mac_ipv6_pairs):

    def _spoofing_rule(self, port, ipv4_rules, ipv6_rules):

    def _drop_dhcp_rule(self):

    def _accept_inbound_icmpv6(self):

    def _add_rule_by_security_group(self, port, direction):

    def _convert_sgr_to_iptables_rules(self, security_group_rules):

    def _drop_invalid_packets(self, iptables_rules):

    def _allow_established(self, iptables_rules):

    def _protocol_arg(self, protocol):

    def _port_arg(self, direction, protocol, port_range_min, port_range_max):

    def _ip_prefix_arg(self, direction, ip_prefix):

    def _port_chain_name(self, port, direction):

    def filter_defer_apply_on(self):

    def filter_defer_apply_off(self):

class OVSHybridIptablesFirewallDriver(IptablesFirewallDriver):

    def _port_chain_name(self, port, direction):

    def _get_device_name(self, port):

\OpenStack\neutron-2014.1\neutron\agent\linux\iptables_manager.py

def get_binary_name():

def get_chain_name(chain_name, wrap=True):

class IptablesRule(object):

    def __init__(self, chain, rule, wrap=True, top=False, binary_name=binary_name, tag=None):

    def __eq__(self, other):

    def __ne__(self, other):

    def __str__(self):

class IptablesTable(object):

    def __init__(self, binary_name=binary_name):

    def add_chain(self, name, wrap=True):

    def _select_chain_set(self, wrap):

    def ensure_remove_chain(self, name, wrap=True):

    def remove_chain(self, name, wrap=True):

    def add_rule(self, chain, rule, wrap=True, top=False, tag=None):

    def _wrap_target_chain(self, s, wrap):

    def remove_rule(self, chain, rule, wrap=True, top=False):

    def empty_chain(self, chain, wrap=True):

    def clear_rules_by_tag(self, tag):

class IptablesManager(object):

    def __init__(self, _execute=None, state_less=False, root_helper=None, use_ipv6=False, namespace=None, binary_name=binary_name):

    def defer_apply_on(self):

    def defer_apply_off(self):

    def apply(self):

    def _apply(self):

    def _apply_synchronized(self):

    def _find_table(self, lines, table_name):

    def _find_rules_index(self, lines):

    def _modify_rules(self, current_lines, table, table_name):

        def _strip_packets_bytes(line):

        def _weed_out_duplicate_chains(line):

        def _weed_out_duplicate_rules(line):

        def _weed_out_removes(line):

    def _get_traffic_counters_cmd_tables(self, chain, wrap=True):

    def get_traffic_counters(self, chain, wrap=True, zero=False):

\OpenStack\neutron-2014.1\neutron\agent\linux\ip_lib.py

class SubProcessBase(object):

    def __init__(self, root_helper=None, namespace=None):

    def _run(self, options, command, args):

    def _as_root(self, options, command, args, use_root_namespace=False):

    def _execute(cls, options, command, args, root_helper=None, namespace=None):

class IPWrapper(SubProcessBase):

    def __init__(self, root_helper=None, namespace=None):

    def device(self, name):

    def get_devices(self, exclude_loopback=False):

    def add_tuntap(self, name, mode='tap'):

    def add_veth(self, name1, name2, namespace2=None):

    def ensure_namespace(self, name):

    def namespace_is_empty(self):

    def garbage_collect_namespace(self):

    def add_device_to_namespace(self, device):

    def add_vxlan(self, name, vni, group=None, dev=None, ttl=None, tos=None, local=None, port=None, proxy=False):

    def get_namespaces(cls, root_helper):

class IPDevice(SubProcessBase):

    def __init__(self, name, root_helper=None, namespace=None):

    def __eq__(self, other):

    def __str__(self):

class IpCommandBase(object):

    def __init__(self, parent):

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

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

class IpDeviceCommandBase(IpCommandBase):

    def name(self):

class IpLinkCommand(IpDeviceCommandBase):

    def set_address(self, mac_address):

    def set_mtu(self, mtu_size):

    def set_up(self):

    def set_down(self):

    def set_netns(self, namespace):

    def set_name(self, name):

    def set_alias(self, alias_name):

    def delete(self):

    def address(self):

    def state(self):

    def mtu(self):

    def qdisc(self):

    def qlen(self):

    def alias(self):

    def attributes(self):

    def _parse_line(self, value):

class IpAddrCommand(IpDeviceCommandBase):

    def add(self, ip_version, cidr, broadcast, scope='global'):

    def delete(self, ip_version, cidr):

    def flush(self):

    def list(self, scope=None, to=None, filters=None):

class IpRouteCommand(IpDeviceCommandBase):

    def add_gateway(self, gateway, metric=None):

    def delete_gateway(self, gateway):

    def get_gateway(self, scope=None, filters=None):

    def pullup_route(self, interface_name):

class IpNetnsCommand(IpCommandBase):

    def add(self, name):

    def delete(self, name):

    def execute(self, cmds, addl_env={}, check_exit_code=True):

    def exists(self, name):

def device_exists(device_name, root_helper=None, namespace=None):

def iproute_arg_supported(command, arg, root_helper=None):

\OpenStack\neutron-2014.1\neutron\agent\linux\ovsdb_monitor.py

class OvsdbMonitor(async_process.AsyncProcess):

    def __init__(self, table_name, columns=None, format=None, root_helper=None, respawn_interval=None):

    def _read_stdout(self):

    def _read_stderr(self):

class SimpleInterfaceMonitor(OvsdbMonitor):

    def __init__(self, root_helper=None, respawn_interval=None):

    def is_active(self):

    def has_updates(self):

    def start(self, block=False, timeout=5):

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

    def _read_stdout(self):

\OpenStack\neutron-2014.1\neutron\agent\linux\ovs_lib.py

class VifPort:

    def __init__(self, port_name, ofport, vif_id, vif_mac, switch):

    def __str__(self):

class BaseOVS(object):

    def __init__(self, root_helper):

    def run_vsctl(self, args, check_error=False):

    def add_bridge(self, bridge_name):

    def delete_bridge(self, bridge_name):

    def bridge_exists(self, bridge_name):

    def get_bridge_name_for_port_name(self, port_name):

    def port_exists(self, port_name):

class OVSBridge(BaseOVS):

    def __init__(self, br_name, root_helper):

    def set_controller(self, controller_names):

    def del_controller(self):

    def get_controller(self):

    def set_protocols(self, protocols):

    def create(self):

    def destroy(self):

    def reset_bridge(self):

    def add_port(self, port_name):

    def delete_port(self, port_name):

    def set_db_attribute(self, table_name, record, column, value):

    def clear_db_attribute(self, table_name, record, column):

    def run_ofctl(self, cmd, args, process_input=None):

    def count_flows(self):

    def remove_all_flows(self):

    def get_port_ofport(self, port_name):

    def get_datapath_id(self):

    def add_flow(self, **kwargs):

    def mod_flow(self, **kwargs):

    def delete_flows(self, **kwargs):

    def defer_apply_on(self):

    def defer_apply_off(self):

    def add_tunnel_port(self, port_name, remote_ip, local_ip, tunnel_type=p_const.TYPE_GRE, vxlan_udp_port=constants.VXLAN_UDP_PORT):

    def add_patch_port(self, local_name, remote_name):

    def db_get_map(self, table, record, column, check_error=False):

    def db_get_val(self, table, record, column, check_error=False):

    def db_str_to_map(self, full_str):

    def get_port_name_list(self):

    def get_port_stats(self, port_name):

    def get_xapi_iface_id(self, xs_vif_uuid):

    def get_vif_ports(self):

    def get_vif_port_set(self):

    def get_port_tag_dict(self):

    def get_vif_port_by_id(self, port_id):

    def delete_ports(self, all_ports=False):

    def get_local_port_mac(self):

def get_bridge_for_iface(root_helper, iface):

def get_bridges(root_helper):

def get_installed_ovs_usr_version(root_helper):

def get_installed_ovs_klm_version():

def get_installed_kernel_version():

def get_bridge_external_bridge_id(root_helper, bridge):

def _compare_installed_and_required_version( installed_kernel_version, installed_version, required_version, check_type, version_type):

def check_ovs_vxlan_version(root_helper):

def _build_flow_expr_str(flow_dict, cmd):

\OpenStack\neutron-2014.1\neutron\agent\linux\polling.py

def get_polling_manager(minimize_polling=False, root_helper=None, ovsdb_monitor_respawn_interval=( constants.DEFAULT_OVSDBMON_RESPAWN)):

class BasePollingManager(object):

    def __init__(self):

    def force_polling(self):

    def polling_completed(self):

    def _is_polling_required(self):

    def is_polling_required(self):

class AlwaysPoll(BasePollingManager):

    def is_polling_required(self):

class InterfacePollingMinimizer(BasePollingManager):

    def __init__(self, root_helper=None, ovsdb_monitor_respawn_interval=( constants.DEFAULT_OVSDBMON_RESPAWN)):

    def start(self):

    def stop(self):

    def _is_polling_required(self):

\OpenStack\neutron-2014.1\neutron\agent\linux\utils.py

def create_process(cmd, root_helper=None, addl_env=None):

def execute(cmd, root_helper=None, process_input=None, addl_env=None, check_exit_code=True, return_stderr=False):

def get_interface_mac(interface):

def replace_file(file_name, data):

def find_child_pids(pid):

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

class MetadataProxyHandler(object):

    def __init__(self, conf):

    def _get_neutron_client(self):

    def __call__(self, req):

    def _get_instance_and_tenant_id(self, req):

    def _proxy_request(self, instance_id, tenant_id, req):

    def _sign_instance_id(self, instance_id):

class UnixDomainHttpProtocol(eventlet.wsgi.HttpProtocol):

    def __init__(self, request, client_address, server):

class WorkerService(wsgi.WorkerService):

    def start(self):

class UnixDomainWSGIServer(wsgi.Server):

    def __init__(self, name):

    def start(self, application, file_socket, workers, backlog):

    def _run(self, application, socket):

class UnixDomainMetadataProxy(object):

    def __init__(self, conf):

    def _init_state_reporting(self):

    def _report_state(self):

    def run(self):

def main():

\OpenStack\neutron-2014.1\neutron\agent\metadata\namespace_proxy.py

class UnixDomainHTTPConnection(httplib.HTTPConnection):

    def __init__(self, host, port=None, strict=None, timeout=None, proxy_info=None):

    def connect(self):

class NetworkMetadataProxyHandler(object):

    def __init__(self, network_id=None, router_id=None):

    def __call__(self, req):

    def _proxy_request(self, remote_address, method, path_info, query_string, body):

class ProxyDaemon(daemon.Daemon):

    def __init__(self, pidfile, port, network_id=None, router_id=None):

    def run(self):

def main():

\OpenStack\neutron-2014.1\neutron\agent\metadata\__init__.py

class FakeDhcpPlugin(object):

    def __getattribute__(self, name):

        def fake_method(*args):

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

def setup_conf():

def collect_neutron_ports(bridges, root_helper):

def delete_neutron_ports(ports, root_helper):

def main():

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

def create_consumers(dispatcher, prefix, topic_details):

class PluginReportStateAPI(proxy.RpcProxy):

    def __init__(self, topic):

    def report_state(self, context, agent_state, use_call=False):

class PluginApi(proxy.RpcProxy):

    def __init__(self, topic):

    def get_device_details(self, context, device, agent_id):

    def update_device_down(self, context, device, agent_id, host=None):

    def update_device_up(self, context, device, agent_id, host=None):

    def tunnel_sync(self, context, tunnel_ip, tunnel_type=None):

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

def _is_valid_driver_combination():

def is_firewall_enabled():

def _disable_extension(extension, aliases):

def disable_security_group_extension_by_config(aliases):

class SecurityGroupServerRpcApiMixin(object):

    def security_group_rules_for_devices(self, context, devices):

class SecurityGroupAgentRpcCallbackMixin(object):

    def _security_groups_agent_not_set(self):

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

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

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

class SecurityGroupAgentRpcMixin(object):

    def init_firewall(self, defer_refresh_firewall=False):

    def prepare_devices_filter(self, device_ids):

    def security_groups_rule_updated(self, security_groups):

    def security_groups_member_updated(self, security_groups):

    def _security_group_updated(self, security_groups, attribute):

    def security_groups_provider_updated(self):

    def remove_devices_filter(self, device_ids):

    def refresh_firewall(self, device_ids=None):

    def firewall_refresh_needed(self):

    def setup_port_filters(self, new_devices, updated_devices):

class SecurityGroupAgentRpcApiMixin(object):

    def _get_security_group_topic(self):

    def security_groups_rule_updated(self, context, security_groups):

    def security_groups_member_updated(self, context, security_groups):

    def security_groups_provider_updated(self, context):

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

def get_filters(request, attr_info, skips=[]):

def get_previous_link(request, items, id_key):

def get_next_link(request, items, id_key):

def get_limit_and_marker(request):

def _get_pagination_max_limit():

def _get_limit_param(request, max_limit):

def list_args(request, arg):

def get_sorts(request, attr_info):

def get_page_reverse(request):

def get_pagination_links(request, items, limit, marker, page_reverse, key="id"):

class PaginationHelper(object):

    def __init__(self, request, primary_key='id'):

    def update_fields(self, original_fields, fields_to_add):

    def update_args(self, args):

    def paginate(self, items):

    def get_links(self, items):

class PaginationEmulatedHelper(PaginationHelper):

    def __init__(self, request, primary_key='id'):

    def update_fields(self, original_fields, fields_to_add):

    def paginate(self, items):

    def get_links(self, items):

class PaginationNativeHelper(PaginationEmulatedHelper):

    def update_args(self, args):

    def paginate(self, items):

class NoPaginationHelper(PaginationHelper):

class SortingHelper(object):

    def __init__(self, request, attr_info):

    def update_args(self, args):

    def update_fields(self, original_fields, fields_to_add):

    def sort(self, items):

class SortingEmulatedHelper(SortingHelper):

    def __init__(self, request, attr_info):

    def update_fields(self, original_fields, fields_to_add):

    def sort(self, items):

        def cmp_func(obj1, obj2):

class SortingNativeHelper(SortingHelper):

    def __init__(self, request, attr_info):

    def update_args(self, args):

class NoSortingHelper(SortingHelper):

class NeutronController(object):

    def __init__(self, plugin):

    def _prepare_request_body(self, body, params):

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

class PluginInterface(object):

    def __subclasshook__(cls, klass):

class ExtensionDescriptor(object):

    def get_name(self):

    def get_alias(self):

    def get_description(self):

    def get_namespace(self):

    def get_updated(self):

    def get_resources(self):

    def get_actions(self):

    def get_request_extensions(self):

    def get_extended_resources(self, version):

    def get_plugin_interface(self):

    def update_attributes_map(self, extended_attributes, extension_attrs_map=None):

    def get_alias_namespace_compatibility_map(self):

class ActionExtensionController(wsgi.Controller):

    def __init__(self, application):

    def add_action(self, action_name, handler):

    def action(self, request, id):

class RequestExtensionController(wsgi.Controller):

    def __init__(self, application):

    def add_handler(self, handler):

    def process(self, request, *args, **kwargs):

class ExtensionController(wsgi.Controller):

    def __init__(self, extension_manager):

    def _translate(self, ext):

    def index(self, request):

    def show(self, request, id):

    def delete(self, request, id):

    def create(self, request):

class ExtensionMiddleware(wsgi.Middleware):

    def __init__(self, application, ext_mgr=None):

    def factory(cls, global_config, **local_config):

        def _factory(app):

    def _action_ext_controllers(self, application, ext_mgr, mapper):

    def _request_ext_controllers(self, application, ext_mgr, mapper):

    def __call__(self, req):

    def _dispatch(req):

def plugin_aware_extension_middleware_factory(global_config, **local_config):

    def _factory(app):

class ExtensionManager(object):

    def __init__(self, path):

    def get_resources(self):

    def get_actions(self):

    def get_request_extensions(self):

    def extend_resources(self, version, attr_map):

    def _check_extension(self, extension):

    def _load_all_extensions(self):

    def _load_all_extensions_from_path(self, path):

    def add_extension(self, ext):

class PluginAwareExtensionManager(ExtensionManager):

    def __init__(self, path, plugins):

    def _check_extension(self, extension):

    def _plugins_support(self, extension):

    def _plugins_implement_interface(self, extension):

    def get_instance(cls):

    def check_if_plugin_extensions_loaded(self):

class RequestExtension(object):

    def __init__(self, method, url_route, handler):

class ActionExtension(object):

    def __init__(self, collection, action_name, handler):

class ResourceExtension(object):

    def __init__(self, collection, controller, parent=None, path_prefix="", collection_actions={}, member_actions={}, attr_map={}):

def get_extensions_path():

def append_api_extensions_path(paths):

\OpenStack\neutron-2014.1\neutron\api\rpc\agentnotifiers\dhcp_rpc_agent_api.py

class DhcpAgentNotifyAPI(proxy.RpcProxy):

    def __init__(self, topic=topics.DHCP_AGENT, plugin=None):

    def plugin(self):

    def _schedule_network(self, context, network, existing_agents):

    def _get_enabled_agents(self, context, network, agents, method, payload):

    def _notify_agents(self, context, method, payload, network_id):

    def _cast_message(self, context, method, payload, host, topic=topics.DHCP_AGENT):

    def _fanout_message(self, context, method, payload):

    def network_removed_from_agent(self, context, network_id, host):

    def network_added_to_agent(self, context, network_id, host):

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

    def notify(self, context, data, method_name):

\OpenStack\neutron-2014.1\neutron\api\rpc\agentnotifiers\l3_rpc_agent_api.py

class L3AgentNotifyAPI(proxy.RpcProxy):

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

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

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

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

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

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

    def router_deleted(self, context, router_id):

    def routers_updated(self, context, router_ids, operation=None, data=None):

    def router_removed_from_agent(self, context, router_id, host):

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

\OpenStack\neutron-2014.1\neutron\api\rpc\agentnotifiers\metering_rpc_agent_api.py

class MeteringAgentNotifyAPI(proxy.RpcProxy):

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

    def _agent_notification(self, context, method, routers):

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

    def _notification(self, context, method, routers):

    def router_deleted(self, context, router_id):

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

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

def _verify_dict_keys(expected_keys, target_dict, strict=True):

def is_attr_set(attribute):

def _validate_values(data, valid_values=None):

def _validate_not_empty_string_or_none(data, max_len=None):

def _validate_not_empty_string(data, max_len=None):

def _validate_string_or_none(data, max_len=None):

def _validate_string(data, max_len=None):

def _validate_boolean(data, valid_values=None):

def _validate_range(data, valid_values=None):

def _validate_no_whitespace(data):

def _validate_mac_address(data, valid_values=None):

def _validate_mac_address_or_none(data, valid_values=None):

def _validate_ip_address(data, valid_values=None):

def _validate_ip_pools(data, valid_values=None):

def _validate_fixed_ips(data, valid_values=None):

def _validate_nameservers(data, valid_values=None):

def _validate_hostroutes(data, valid_values=None):

def _validate_ip_address_or_none(data, valid_values=None):

def _validate_subnet(data, valid_values=None):

def _validate_subnet_list(data, valid_values=None):

def _validate_subnet_or_none(data, valid_values=None):

def _validate_regex(data, valid_values=None):

def _validate_regex_or_none(data, valid_values=None):

def _validate_uuid(data, valid_values=None):

def _validate_uuid_or_none(data, valid_values=None):

def _validate_uuid_list(data, valid_values=None):

def _validate_dict_item(key, key_validator, data):

def _validate_dict(data, key_specs=None):

def _validate_dict_or_none(data, key_specs=None):

def _validate_dict_or_empty(data, key_specs=None):

def _validate_dict_or_nodata(data, key_specs=None):

def _validate_non_negative(data, valid_values=None):

def convert_to_boolean(data):

def convert_to_int(data):

def convert_kvp_str_to_list(data):

def convert_kvp_list_to_dict(kvp_list):

def convert_none_to_empty_list(value):

def convert_none_to_empty_dict(value):

def convert_to_list(data):

def get_attr_metadata():

\OpenStack\neutron-2014.1\neutron\api\v2\base.py

class Controller(object):

    def __init__(self, plugin, collection, resource, attr_info, allow_bulk=False, member_actions=None, parent=None, allow_pagination=False, allow_sorting=False):

    def _get_primary_key(self, default_primary_key='id'):

    def _is_native_bulk_supported(self):

    def _is_native_pagination_supported(self):

    def _is_native_sorting_supported(self):

    def _is_visible(self, context, attr_name, data):

    def _view(self, context, data, fields_to_strip=None):

    def _do_field_list(self, original_fields):

    def __getattr__(self, name):

    def _get_pagination_helper(self, request):

    def _get_sorting_helper(self, request):

    def _items(self, request, do_authz=False, parent_id=None):

    def _item(self, request, id, do_authz=False, field_list=None, parent_id=None):

    def _send_dhcp_notification(self, context, data, methodname):

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

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

    def _emulate_bulk_create(self, obj_creator, request, body, parent_id=None):

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

        def notify(create_result):

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

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

    def _populate_tenant_id(context, res_dict, is_create):

    def prepare_request_body(context, body, is_create, resource, attr_info, allow_bulk=False):

    def _verify_attributes(res_dict, attr_info):

    def _validate_network_tenant_ownership(self, request, resource_item):

def create_resource(collection, resource, plugin, params, allow_bulk=False, member_actions=None, parent=None, allow_pagination=False, allow_sorting=False):

\OpenStack\neutron-2014.1\neutron\api\v2\resource.py

class Request(wsgi.Request):

    def resource(request):

def translate(translatable, locale):

\OpenStack\neutron-2014.1\neutron\api\v2\resource_helper.py

def build_plural_mappings(special_mappings, resource_map):

def build_resource_info(plural_mappings, resource_map, which_service, action_map=None, register_quota=False, translate_name=False, allow_bulk=False):

\OpenStack\neutron-2014.1\neutron\api\v2\router.py

class Index(wsgi.Application):

    def __init__(self, resources):

    def __call__(self, req):

class APIRouter(wsgi.Router):

    def factory(cls, global_config, **local_config):

    def __init__(self, **local_config):

        def _map_resource(collection, resource, params, parent=None):

\OpenStack\neutron-2014.1\neutron\api\v2\__init__.py

class Versions(object):

    def factory(cls, global_config, **local_config):

    def __call__(self, req):

\OpenStack\neutron-2014.1\neutron\api\views\versions.py

def get_view_builder(req):

class ViewBuilder(object):

    def __init__(self, base_url):

    def build(self, version_data):

    def _build_links(self, version_data):

    def generate_href(self, version_number):

\OpenStack\neutron-2014.1\neutron\api\views\__init__.py

class NeutronKeystoneContext(wsgi.Middleware):

    def __call__(self, req):

def pipeline_factory(loader, global_conf, **local_conf):

\OpenStack\neutron-2014.1\neutron\cmd\usage_audit.py

def main():

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

def parse(args):

def setup_logging(conf):

def load_paste_app(app_name):

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

class NeutronException(Exception):

    def __init__(self, **kwargs):

    def __unicode__(self):

    def use_fatal_exceptions(self):

class BadRequest(NeutronException):

class NotFound(NeutronException):

class Conflict(NeutronException):

class NotAuthorized(NeutronException):

class ServiceUnavailable(NeutronException):

class AdminRequired(NotAuthorized):

class PolicyNotAuthorized(NotAuthorized):

class NetworkNotFound(NotFound):

class SubnetNotFound(NotFound):

class PortNotFound(NotFound):

class PortNotFoundOnNetwork(NotFound):

class PolicyFileNotFound(NotFound):

class PolicyRuleNotFound(NotFound):

class PolicyInitError(NeutronException):

class PolicyCheckError(NeutronException):

class StateInvalid(BadRequest):

class InUse(NeutronException):

class NetworkInUse(InUse):

class SubnetInUse(InUse):

class PortInUse(InUse):

class MacAddressInUse(InUse):

class HostRoutesExhausted(BadRequest):

class DNSNameServersExhausted(BadRequest):

class IpAddressInUse(InUse):

class VlanIdInUse(InUse):

class FlatNetworkInUse(InUse):

class TunnelIdInUse(InUse):

class TenantNetworksDisabled(ServiceUnavailable):

class ResourceExhausted(ServiceUnavailable):

class NoNetworkAvailable(ResourceExhausted):

class SubnetMismatchForPort(BadRequest):

class MalformedRequestBody(BadRequest):

class Invalid(NeutronException):

    def __init__(self, message=None):

class InvalidInput(BadRequest):

class InvalidAllocationPool(BadRequest):

class OverlappingAllocationPools(Conflict):

class OutOfBoundsAllocationPool(BadRequest):

class MacAddressGenerationFailure(ServiceUnavailable):

class IpAddressGenerationFailure(Conflict):

class BridgeDoesNotExist(NeutronException):

class PreexistingDeviceFailure(NeutronException):

class SudoRequired(NeutronException):

class QuotaResourceUnknown(NotFound):

class OverQuota(Conflict):

class QuotaMissingTenant(BadRequest):

class InvalidQuotaValue(Conflict):

class InvalidSharedSetting(Conflict):

class InvalidExtensionEnv(BadRequest):

class ExtensionsNotFound(NotFound):

class InvalidContentType(NeutronException):

class ExternalIpAddressExhausted(BadRequest):

class TooManyExternalNetworks(NeutronException):

class InvalidConfigurationOption(NeutronException):

class GatewayConflictWithAllocationPools(InUse):

class GatewayIpInUse(InUse):

class NetworkVlanRangeError(NeutronException):

    def __init__(self, **kwargs):

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