@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

class API(base.Base):

    def __init__(self, **kwargs):

    def get_all(self, context):

    def get(self, context, network_uuid):

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

    def delete(self, context, network_uuid):

    def disassociate(self, context, network_uuid):

    def get_fixed_ip(self, context, id):

    def get_fixed_ip_by_address(self, context, address):

    def get_floating_ip(self, context, id):

    def get_floating_ip_pools(self, context):

    def get_floating_ip_by_address(self, context, address):

    def get_floating_ips_by_project(self, context):

    def get_floating_ips_by_fixed_address(self, context, fixed_address):

    def get_instance_id_by_floating_address(self, context, address):

    def get_vifs_by_instance(self, context, instance):

    def get_vif_by_mac_address(self, context, mac_address):

    def allocate_floating_ip(self, context, pool=None):

    def release_floating_ip(self, context, address, affect_auto_assigned=False):

    def associate_floating_ip(self, context, instance, floating_address, fixed_address, affect_auto_assigned=False):

    def disassociate_floating_ip(self, context, instance, address, affect_auto_assigned=False):

    def allocate_for_instance(self, context, instance, vpn, requested_networks, macs=None, security_groups=None, dhcp_options=None):

    def deallocate_for_instance(self, context, instance, requested_networks=None):

    def allocate_port_for_instance(self, context, instance, port_id, network_id=None, requested_ip=None):

    def deallocate_port_for_instance(self, context, instance, port_id):

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

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

    def add_fixed_ip_to_instance(self, context, instance, network_id):

    def remove_fixed_ip_from_instance(self, context, instance, address):

    def add_network_to_project(self, context, project_id, network_uuid=None):

    def associate(self, context, network_uuid, host=_sentinel, project=_sentinel):

    def get_instance_nw_info(self, context, instance):

    def _get_instance_nw_info(self, context, instance):

    def validate_networks(self, context, requested_networks, num_instances):

    def get_instance_uuids_by_ip_filter(self, context, filters):

    def get_dns_domains(self, context):

    def add_dns_entry(self, context, address, name, dns_type, domain):

    def modify_dns_entry(self, context, name, address, domain):

    def delete_dns_entry(self, context, name, domain):

    def delete_dns_domain(self, context, domain):

    def get_dns_entries_by_address(self, context, address, domain):

    def get_dns_entries_by_name(self, context, name, domain):

    def create_private_dns_domain(self, context, domain, availability_zone):

    def create_public_dns_domain(self, context, domain, project=None):

    def setup_networks_on_host(self, context, instance, host=None, teardown=False):

    def _is_multi_host(self, context, instance):

    def _get_floating_ip_addresses(self, context, instance):

    def migrate_instance_start(self, context, instance, migration):

    def migrate_instance_finish(self, context, instance, migration):

\OpenStack\nova-2014.1\nova\network\dns_driver.py

class DNSDriver(object):

    def __init__(self):

    def get_domains(self):

    def create_entry(self, _name, _address, _type, _domain):

    def delete_entry(self, _name, _domain):

    def modify_address(self, _name, _address, _domain):

    def get_entries_by_address(self, _address, _domain):

    def get_entries_by_name(self, _name, _domain):

    def create_domain(self, _fqdomain):

    def delete_domain(self, _fqdomain):

\OpenStack\nova-2014.1\nova\network\driver.py

def load_network_driver(network_driver=None):

\OpenStack\nova-2014.1\nova\network\floating_ips.py

class FloatingIP(object):

    def init_host_floating_ips(self):

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

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

    def _floating_ip_owned_by_project(self, context, floating_ip):

    def allocate_floating_ip(self, context, project_id, auto_assigned=False, pool=None):

    def deallocate_floating_ip(self, context, address, affect_auto_assigned=False):

    def associate_floating_ip(self, context, floating_address, fixed_address, affect_auto_assigned=False):

    def _associate_floating_ip(self, context, floating_address, fixed_address, interface, instance_uuid):

        def do_associate():

    def disassociate_floating_ip(self, context, address, affect_auto_assigned=False):

    def _disassociate_floating_ip(self, context, address, interface, instance_uuid):

        def do_disassociate():

    def get_floating_ip(self, context, id):

    def get_floating_pools(self, context):

    def get_floating_ip_pools(self, context):

    def get_floating_ip_by_address(self, context, address):

    def get_floating_ips_by_project(self, context):

    def get_floating_ips_by_fixed_address(self, context, fixed_address):

    def _is_stale_floating_ip_address(self, context, floating_ip):

    def migrate_instance_start(self, context, instance_uuid, floating_addresses, rxtx_factor=None, project_id=None, source=None, dest=None):

    def migrate_instance_finish(self, context, instance_uuid, floating_addresses, host=None, rxtx_factor=None, project_id=None, source=None, dest=None):

    def _prepare_domain_entry(self, context, domainref):

    def get_dns_domains(self, context):

    def add_dns_entry(self, context, address, name, dns_type, domain):

    def modify_dns_entry(self, context, address, name, domain):

    def delete_dns_entry(self, context, name, domain):

    def _delete_all_entries_for_ip(self, context, address):

    def get_dns_entries_by_address(self, context, address, domain):

    def get_dns_entries_by_name(self, context, name, domain):

    def create_private_dns_domain(self, context, domain, av_zone):

    def create_public_dns_domain(self, context, domain, project):

    def delete_dns_domain(self, context, domain):

class LocalManager(base.Base, FloatingIP):

    def __init__(self):

\OpenStack\nova-2014.1\nova\network\l3.py

class L3Driver(object):

    def __init__(self, l3_lib=None):

    def initialize(self, **kwargs):

    def initialize_network(self, network):

    def initialize_gateway(self, network):

    def remove_gateway(self, network_ref):

    def is_initialized(self):

    def add_floating_ip(self, floating_ip, fixed_ip, l3_interface_id, network=None):

    def remove_floating_ip(self, floating_ip, fixed_ip, l3_interface_id, network=None):

    def add_vpn(self, public_ip, port, private_ip):

    def remove_vpn(self, public_ip, port, private_ip):

    def clean_conntrack(self, fixed_ip):

    def teardown(self):

class LinuxNetL3(L3Driver):

    def __init__(self):

    def initialize(self, **kwargs):

    def is_initialized(self):

    def initialize_network(self, cidr):

    def initialize_gateway(self, network_ref):

    def remove_gateway(self, network_ref):

    def add_floating_ip(self, floating_ip, fixed_ip, l3_interface_id, network=None):

    def remove_floating_ip(self, floating_ip, fixed_ip, l3_interface_id, network=None):

    def add_vpn(self, public_ip, port, private_ip):

    def remove_vpn(self, public_ip, port, private_ip):

    def clean_conntrack(self, fixed_ip):

    def teardown(self):

class NullL3(L3Driver):

    def __init__(self):

    def initialize(self, **kwargs):

    def is_initialized(self):

    def initialize_network(self, cidr):

    def initialize_gateway(self, network_ref):

    def remove_gateway(self, network_ref):

    def add_floating_ip(self, floating_ip, fixed_ip, l3_interface_id, network=None):

    def remove_floating_ip(self, floating_ip, fixed_ip, l3_interface_id, network=None):

    def add_vpn(self, public_ip, port, private_ip):

    def remove_vpn(self, public_ip, port, private_ip):

    def clean_conntrack(self, fixed_ip):

    def teardown(self):

\OpenStack\nova-2014.1\nova\network\ldapdns.py

def create_modlist(newattrs):

class DNSEntry(object):

    def __init__(self, ldap_object):

    def _get_tuple_for_domain(cls, lobj, domain):

    def _get_all_domains(cls, lobj):

    def _set_tuple(self, tuple):

    def _qualify(self, name):

    def _dequalify(self, name):

    def _dn(self):

    def _rdn(self):

class DomainEntry(DNSEntry):

    def _soa(cls):

    def create_domain(cls, lobj, domain):

    def __init__(self, ldap_object, domain):

    def delete(self):

    def update_soa(self):

    def subentry_with_name(self, name):

    def subentries_with_ip(self, ip):

    def add_entry(self, name, address):

    def remove_entry(self, name):

class HostEntry(DNSEntry):

    def __init__(self, parent, tuple):

    def remove_name(self, name):

    def modify_address(self, name, address):

    def _names(self):

    def _ip(self):

    def _parent(self):

class LdapDNS(dns_driver.DNSDriver):

    def __init__(self):

    def get_domains(self):

    def create_entry(self, name, address, type, domain):

    def delete_entry(self, name, domain):

    def get_entries_by_address(self, address, domain):

    def get_entries_by_name(self, name, domain):

    def modify_address(self, name, address, domain):

    def create_domain(self, domain):

    def delete_domain(self, domain):

    def delete_dns_file(self):

\OpenStack\nova-2014.1\nova\network\linux_net.py

def get_binary_name():

class IptablesRule(object):

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

    def __eq__(self, other):

    def __ne__(self, other):

    def __str__(self):

class IptablesTable(object):

    def __init__(self):

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

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

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

    def _wrap_target_chain(self, s):

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

    def remove_rules_regex(self, regex):

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

class IptablesManager(object):

    def __init__(self, execute=None):

    def defer_apply_on(self):

    def defer_apply_off(self):

    def dirty(self):

    def apply(self):

    def _apply(self):

    def _find_table(self, lines, table_name):

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

        def _weed_out_duplicates(line):

        def _weed_out_removes(line):

class LinuxNetInterfaceDriver(object):

    def plug(self, network, mac_address):

    def unplug(self, network):

    def get_dev(self, network):

class LinuxBridgeInterfaceDriver(LinuxNetInterfaceDriver):

    def plug(self, network, mac_address, gateway=True):

    def unplug(self, network, gateway=True):

    def get_dev(self, network):

    def ensure_vlan_bridge(vlan_num, bridge, bridge_interface, net_attrs=None, mac_address=None):

    def remove_vlan_bridge(vlan_num, bridge):

    def ensure_vlan(vlan_num, bridge_interface, mac_address=None):

    def remove_vlan(vlan_num):

    def ensure_bridge(bridge, interface, net_attrs=None, gateway=True, filtering=True):

    def remove_bridge(bridge, gateway=True, filtering=True):

def ensure_ebtables_rules(rules, table='filter'):

def remove_ebtables_rules(rules, table='filter'):

def isolate_dhcp_address(interface, address):

def remove_isolate_dhcp_address(interface, address):

def get_gateway_rules(bridge):

class LinuxOVSInterfaceDriver(LinuxNetInterfaceDriver):

    def plug(self, network, mac_address, gateway=True):

    def unplug(self, network):

    def get_dev(self, network):

class NeutronLinuxBridgeInterfaceDriver(LinuxNetInterfaceDriver):

    def plug(self, network, mac_address, gateway=True):

    def unplug(self, network):

    def get_dev(self, network):

    def get_bridge(self, network):

\OpenStack\nova-2014.1\nova\network\manager.py

class RPCAllocateFixedIP(object):

    def _allocate_fixed_ips(self, context, instance_id, host, networks, **kwargs):

    def _rpc_allocate_fixed_ip(self, context, instance_id, network_id, **kwargs):

    def deallocate_fixed_ip(self, context, address, host=None, teardown=True, instance=None):

class NetworkManager(manager.Manager):

    def __init__(self, network_driver=None, *args, **kwargs):

    def _import_ipam_lib(self, ipam_lib):

    def _get_dhcp_ip(self, context, network_ref, host=None):

    def get_dhcp_leases(self, ctxt, network_ref):

    def init_host(self):

    def _disassociate_stale_fixed_ips(self, context):

    def set_network_host(self, context, network_ref):

    def _do_trigger_security_group_members_refresh_for_instance(self, instance_id):

    def get_floating_ips_by_fixed_address(self, context, fixed_address):

    def get_instance_uuids_by_ip_filter(self, context, filters):

    def _get_networks_for_instance(self, context, instance_id, project_id, requested_networks=None):

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

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

    def get_instance_nw_info(self, context, instance_id, rxtx_factor, host, instance_uuid=None, **kwargs):

    def build_network_info_model(self, context, vifs, networks, rxtx_factor, instance_host):

    def _get_network_dict(self, network):

    def _get_subnets_from_network(self, context, network, vif, instance_host=None):

    def _allocate_mac_addresses(self, context, instance_uuid, networks, macs):

    def _add_virtual_interface(self, context, instance_uuid, network_id, mac=None):

    def add_fixed_ip_to_instance(self, context, instance_id, host, network_id, rxtx_factor=None):

    def get_backdoor_port(self, context):

    def remove_fixed_ip_from_instance(self, context, instance_id, host, address, rxtx_factor=None):

    def _validate_instance_zone_for_dns_domain(self, context, instance):

    def allocate_fixed_ip(self, context, instance_id, network, **kwargs):

    def deallocate_fixed_ip(self, context, address, host=None, teardown=True, instance=None):

    def lease_fixed_ip(self, context, address):

    def release_fixed_ip(self, context, address):

    def _convert_int_args(kwargs):

    def create_networks(self, context, label, cidr=None, multi_host=None, num_networks=None, network_size=None, cidr_v6=None, gateway=None, gateway_v6=None, bridge=None, bridge_interface=None, dns1=None, dns2=None, fixed_cidr=None, **kwargs):

    def _do_create_networks(self, context, label, cidr, multi_host, num_networks, network_size, cidr_v6, gateway, gateway_v6, bridge, bridge_interface, dns1=None, dns2=None, fixed_cidr=None, **kwargs):

    def delete_network(self, context, fixed_range, uuid, require_disassociated=True):

    def _bottom_reserved_ips(self):

    def _top_reserved_ips(self):

    def _create_fixed_ips(self, context, network_id, fixed_cidr=None):

    def _allocate_fixed_ips(self, context, instance_id, host, networks, **kwargs):

    def setup_networks_on_host(self, context, instance_id, host, teardown=False):

    def rpc_setup_network_on_host(self, context, network_id, teardown):

    def _setup_network_on_host(self, context, network):

    def _teardown_network_on_host(self, context, network):

    def validate_networks(self, context, networks):

    def _get_network_by_id(self, context, network_id):

    def _get_networks_by_uuids(self, context, network_uuids):

    def get_vifs_by_instance(self, context, instance_id):

    def get_instance_id_by_floating_address(self, context, address):

    def get_network(self, context, network_uuid):

    def get_all_networks(self, context):

    def disassociate_network(self, context, network_uuid):

    def get_fixed_ip(self, context, id):

    def get_fixed_ip_by_address(self, context, address):

    def get_vif_by_mac_address(self, context, mac_address):

    def _periodic_update_dns(self, context):

    def update_dns(self, context, network_ids):

    def add_network_to_project(self, ctxt, project_id, network_uuid):

class FlatManager(NetworkManager):

    def _allocate_fixed_ips(self, context, instance_id, host, networks, **kwargs):

    def deallocate_fixed_ip(self, context, address, host=None, teardown=True, instance=None):

    def _setup_network_on_host(self, context, network):

    def _teardown_network_on_host(self, context, network):

    def get_floating_ip(self, context, id):

    def get_floating_pools(self, context):

    def get_floating_ip_pools(self, context):

    def get_floating_ip_by_address(self, context, address):

    def get_floating_ips_by_project(self, context):

    def get_floating_ips_by_fixed_address(self, context, fixed_address):

    def allocate_floating_ip(self, context, project_id, pool):

    def deallocate_floating_ip(self, context, address, affect_auto_assigned):

    def associate_floating_ip(self, context, floating_address, fixed_address, affect_auto_assigned=False):

    def disassociate_floating_ip(self, context, address, affect_auto_assigned=False):

    def migrate_instance_start(self, context, instance_uuid, floating_addresses, rxtx_factor=None, project_id=None, source=None, dest=None):

    def migrate_instance_finish(self, context, instance_uuid, floating_addresses, host=None, rxtx_factor=None, project_id=None, source=None, dest=None):

    def update_dns(self, context, network_ids):

class FlatDHCPManager(RPCAllocateFixedIP, floating_ips.FloatingIP, NetworkManager):

    def init_host(self):

    def _setup_network_on_host(self, context, network):

    def _teardown_network_on_host(self, context, network):

    def _get_network_dict(self, network):

class VlanManager(RPCAllocateFixedIP, floating_ips.FloatingIP, NetworkManager):

    def __init__(self, network_driver=None, *args, **kwargs):

    def init_host(self):

    def allocate_fixed_ip(self, context, instance_id, network, **kwargs):

    def add_network_to_project(self, context, project_id, network_uuid=None):

    def associate(self, context, network_uuid, associations):

    def _get_network_by_id(self, context, network_id):

    def _get_networks_by_uuids(self, context, network_uuids):

    def _get_networks_for_instance(self, context, instance_id, project_id, requested_networks=None):

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

    def _setup_network_on_host(self, context, network):

    def _teardown_network_on_host(self, context, network):

    def _get_network_dict(self, network):

    def _bottom_reserved_ips(self):

    def _top_reserved_ips(self):

\OpenStack\nova-2014.1\nova\network\minidns.py

class MiniDNS(dns_driver.DNSDriver):

    def __init__(self):

    def get_domains(self):

    def qualify(self, name, domain):

    def create_entry(self, name, address, type, domain):

    def parse_line(self, line):

    def delete_entry(self, name, domain):

    def modify_address(self, name, address, domain):

    def get_entries_by_address(self, address, domain):

    def get_entries_by_name(self, name, domain):

    def delete_dns_file(self):

    def create_domain(self, fqdomain):

    def delete_domain(self, fqdomain):

\OpenStack\nova-2014.1\nova\network\model.py

def ensure_string_keys(d):

class Model(dict):

    def __repr__(self):

    def _set_meta(self, kwargs):

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

class IP(Model):

    def __init__(self, address=None, type=None, **kwargs):

    def __eq__(self, other):

    def __ne__(self, other):

    def is_in_subnet(self, subnet):

    def hydrate(cls, ip):

class FixedIP(IP):

    def __init__(self, floating_ips=None, **kwargs):

    def add_floating_ip(self, floating_ip):

    def floating_ip_addresses(self):

    def hydrate(fixed_ip):

    def __eq__(self, other):

    def __ne__(self, other):

class Route(Model):

    def __init__(self, cidr=None, gateway=None, interface=None, **kwargs):

    def hydrate(cls, route):

class Subnet(Model):

    def __init__(self, cidr=None, dns=None, gateway=None, ips=None, routes=None, **kwargs):

    def __eq__(self, other):

    def __ne__(self, other):

    def add_route(self, new_route):

    def add_dns(self, dns):

    def add_ip(self, ip):

    def as_netaddr(self):

    def hydrate(cls, subnet):

class Network(Model):

    def __init__(self, id=None, bridge=None, label=None, subnets=None, **kwargs):

    def add_subnet(self, subnet):

    def hydrate(cls, network):

    def __eq__(self, other):

    def __ne__(self, other):

class VIF8021QbgParams(Model):

    def __init__(self, managerid, typeid, typeidversion, instanceid):

class VIF8021QbhParams(Model):

    def __init__(self, profileid):

class VIF(Model):

    def __init__(self, id=None, address=None, network=None, type=None, details=None, devname=None, ovs_interfaceid=None, qbh_params=None, qbg_params=None, active=False, **kwargs):

    def __eq__(self, other):

    def __ne__(self, other):

    def fixed_ips(self):

    def floating_ips(self):

    def labeled_ips(self):

    def is_hybrid_plug_enabled(self):

    def is_neutron_filtering_enabled(self):

    def hydrate(cls, vif):

def get_netmask(ip, subnet):

class NetworkInfo(list):

    def fixed_ips(self):

    def floating_ips(self):

    def hydrate(cls, network_info):

    def json(self):

class NetworkInfoAsyncWrapper(NetworkInfo):

    def allocate_net_info(arg1, arg2) return call_neutron_to_allocate(arg1, arg2) network_info = NetworkInfoAsyncWrapper(allocate_net_info, arg1, arg2) [do a long running operation -- real network_info will be retrieved in the background] [do something with network_info] """ :

    def __init__(self, async_method, *args, **kwargs):

    def _sync_wrapper(self, wrapped, *args, **kwargs):

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

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

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

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

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

    def wait(self, do_raise=True):

\OpenStack\nova-2014.1\nova\network\neutronv2\api.py

class API(base.Base):

    def __init__(self):

    def setup_networks_on_host(self, context, instance, host=None, teardown=False):

    def _get_available_networks(self, context, project_id, net_ids=None, neutron=None):

    def _create_port(self, port_client, instance, network_id, port_req_body, fixed_ip=None, security_group_ids=None, available_macs=None, dhcp_opts=None):

    def allocate_for_instance(self, context, instance, **kwargs):

    def _refresh_neutron_extensions_cache(self, context):

    def _has_port_binding_extension(self, context, refresh_cache=False):

    def _populate_neutron_extension_values(self, context, instance, port_req_body):

    def deallocate_for_instance(self, context, instance, **kwargs):

    def allocate_port_for_instance(self, context, instance, port_id, network_id=None, requested_ip=None):

    def deallocate_port_for_instance(self, context, instance, port_id):

    def list_ports(self, context, **search_opts):

    def show_port(self, context, port_id):

    def get_instance_nw_info(self, context, instance, networks=None, port_ids=None, use_slave=False):

    def _get_instance_nw_info(self, context, instance, networks=None, port_ids=None):

    def _gather_port_ids_and_networks(self, context, instance, networks=None, port_ids=None):

    def add_fixed_ip_to_instance(self, context, instance, network_id):

    def remove_fixed_ip_from_instance(self, context, instance, address):

    def validate_networks(self, context, requested_networks, num_instances):

    def _get_instance_uuids_by_ip(self, context, address):

    def get_instance_uuids_by_ip_filter(self, context, filters):

    def _get_port_id_by_fixed_address(self, client, instance, address):

    def associate_floating_ip(self, context, instance, floating_address, fixed_address, affect_auto_assigned=False):

    def get_all(self, context):

    def get(self, context, network_uuid):

    def delete(self, context, network_uuid):

    def disassociate(self, context, network_uuid):

    def associate(self, context, network_uuid, host=_sentinel, project=_sentinel):

    def get_fixed_ip(self, context, id):

    def get_fixed_ip_by_address(self, context, address):

    def _setup_net_dict(self, client, network_id):

    def _setup_port_dict(self, client, port_id):

    def _setup_pools_dict(self, client):

    def _setup_ports_dict(self, client, project_id=None):

    def get_floating_ip(self, context, id):

    def _get_floating_ip_pools(self, client, project_id=None):

    def get_floating_ip_pools(self, context):

    def _format_floating_ip_model(self, fip, pool_dict, port_dict):

    def get_floating_ip_by_address(self, context, address):

    def get_floating_ips_by_project(self, context):

    def get_floating_ips_by_fixed_address(self, context, fixed_address):

    def get_instance_id_by_floating_address(self, context, address):

    def get_vifs_by_instance(self, context, instance):

    def get_vif_by_mac_address(self, context, mac_address):

    def _get_floating_ip_pool_id_by_name_or_id(self, client, name_or_id):

    def allocate_floating_ip(self, context, pool=None):

    def _get_floating_ip_by_address(self, client, address):

    def _get_floating_ips_by_fixed_and_port(self, client, fixed_ip, port):

    def release_floating_ip(self, context, address, affect_auto_assigned=False):

    def disassociate_floating_ip(self, context, instance, address, affect_auto_assigned=False):

    def migrate_instance_start(self, context, instance, migration):

    def migrate_instance_finish(self, context, instance, migration):

    def add_network_to_project(self, context, project_id, network_uuid=None):

    def _nw_info_get_ips(self, client, port):

    def _nw_info_get_subnets(self, context, port, network_IPs):

    def _nw_info_build_network(self, port, networks, subnets):

    def _build_network_info_model(self, context, instance, networks=None, port_ids=None):

    def _get_subnets_from_port(self, context, port):

    def get_dns_domains(self, context):

    def add_dns_entry(self, context, address, name, dns_type, domain):

    def modify_dns_entry(self, context, name, address, domain):

    def delete_dns_entry(self, context, name, domain):

    def delete_dns_domain(self, context, domain):

    def get_dns_entries_by_address(self, context, address, domain):

    def get_dns_entries_by_name(self, context, name, domain):

    def create_private_dns_domain(self, context, domain, availability_zone):

    def create_public_dns_domain(self, context, domain, project=None):

def _ensure_requested_network_ordering(accessor, unordered, preferred):

\OpenStack\nova-2014.1\nova\network\neutronv2\constants.py

\OpenStack\nova-2014.1\nova\network\neutronv2\__init__.py

def _get_client(token=None):

def get_client(context, admin=False):

\OpenStack\nova-2014.1\nova\network\noop_dns_driver.py

class NoopDNSDriver(dns_driver.DNSDriver):

    def __init__(self):

    def get_domains(self):

    def create_entry(self, _name, _address, _type, _domain):

    def delete_entry(self, _name, _domain):

    def modify_address(self, _name, _address, _domain):

    def get_entries_by_address(self, _address, _domain):

    def get_entries_by_name(self, _name, _domain):

    def create_domain(self, _fqdomain):

    def delete_domain(self, _fqdomain):

\OpenStack\nova-2014.1\nova\network\nova_ipam_lib.py

def get_ipam_lib(net_man):

class NeutronNovaIPAMLib(object):

    def __init__(self, net_manager):

    def get_subnets_by_net_id(self, context, tenant_id, net_id, _vif_id=None):

        def ips_to_strs(net):

    def get_routes_by_ip_block(self, context, block_id, project_id):

    def get_v4_ips_by_interface(self, context, net_id, vif_id, project_id):

    def get_v6_ips_by_interface(self, context, net_id, vif_id, project_id):

    def get_floating_ips_by_fixed_address(self, context, fixed_address):

\OpenStack\nova-2014.1\nova\network\rpcapi.py

class NetworkAPI(object):

    def __init__(self, topic=None):

    def create_networks(self, ctxt, **kwargs):

    def delete_network(self, ctxt, uuid, fixed_range):

    def disassociate_network(self, ctxt, network_uuid):

    def get_fixed_ip(self, ctxt, id):

    def get_fixed_ip_by_address(self, ctxt, address):

    def get_floating_ip(self, ctxt, id):

    def get_floating_ip_pools(self, ctxt):

    def get_floating_ip_by_address(self, ctxt, address):

    def get_floating_ips_by_project(self, ctxt):

    def get_floating_ips_by_fixed_address(self, ctxt, fixed_address):

    def get_instance_id_by_floating_address(self, ctxt, address):

    def allocate_floating_ip(self, ctxt, project_id, pool, auto_assigned):

    def deallocate_floating_ip(self, ctxt, address, affect_auto_assigned):

    def associate_floating_ip(self, ctxt, floating_address, fixed_address, affect_auto_assigned):

    def disassociate_floating_ip(self, ctxt, address, affect_auto_assigned):

    def allocate_for_instance(self, ctxt, instance_id, project_id, host, rxtx_factor, vpn, requested_networks, macs=None, dhcp_options=None):

    def deallocate_for_instance(self, ctxt, instance, requested_networks=None):

    def add_fixed_ip_to_instance(self, ctxt, instance_id, rxtx_factor, host, network_id):

    def remove_fixed_ip_from_instance(self, ctxt, instance_id, rxtx_factor, host, address):

    def add_network_to_project(self, ctxt, project_id, network_uuid):

    def associate(self, ctxt, network_uuid, associations):

    def get_instance_nw_info(self, ctxt, instance_id, rxtx_factor, host, project_id):

    def validate_networks(self, ctxt, networks):

    def get_instance_uuids_by_ip_filter(self, ctxt, filters):

    def get_dns_domains(self, ctxt):

    def add_dns_entry(self, ctxt, address, name, dns_type, domain):

    def modify_dns_entry(self, ctxt, address, name, domain):

    def delete_dns_entry(self, ctxt, name, domain):

    def delete_dns_domain(self, ctxt, domain):

    def get_dns_entries_by_address(self, ctxt, address, domain):

    def get_dns_entries_by_name(self, ctxt, name, domain):

    def create_private_dns_domain(self, ctxt, domain, av_zone):

    def create_public_dns_domain(self, ctxt, domain, project):

    def setup_networks_on_host(self, ctxt, instance_id, host, teardown):

    def set_network_host(self, ctxt, network_ref):

    def rpc_setup_network_on_host(self, ctxt, network_id, teardown, host):

    def _rpc_allocate_fixed_ip(self, ctxt, instance_id, network_id, address, vpn, host):

    def deallocate_fixed_ip(self, ctxt, address, host, instance):

    def update_dns(self, ctxt, network_ids):

    def _associate_floating_ip(self, ctxt, floating_address, fixed_address, interface, host, instance_uuid=None):

    def _disassociate_floating_ip(self, ctxt, address, interface, host, instance_uuid=None):

    def lease_fixed_ip(self, ctxt, address, host):

    def release_fixed_ip(self, ctxt, address, host):

    def migrate_instance_start(self, ctxt, instance_uuid, rxtx_factor, project_id, source_compute, dest_compute, floating_addresses, host=None):

    def migrate_instance_finish(self, ctxt, instance_uuid, rxtx_factor, project_id, source_compute, dest_compute, floating_addresses, host=None):

\OpenStack\nova-2014.1\nova\network\security_group\neutron_driver.py

class SecurityGroupAPI(security_group_base.SecurityGroupBase):

    def create_security_group(self, context, name, description):

    def update_security_group(self, context, security_group, name, description):

    def _convert_to_nova_security_group_format(self, security_group):

    def _convert_to_nova_security_group_rule_format(self, rule):

    def get(self, context, name=None, id=None, map_exception=False):

    def list(self, context, names=None, ids=None, project=None, search_opts=None):

    def validate_id(self, id):

    def destroy(self, context, security_group):

    def add_rules(self, context, id, name, vals):

    def _make_neutron_security_group_dict(self, name, description):

    def _make_neutron_security_group_rules_list(self, rules):

    def remove_rules(self, context, security_group, rule_ids):

    def get_rule(self, context, id):

    def _get_ports_from_server_list(self, servers, neutron):

        def _chunk_by_ids(servers, limit):

    def _get_secgroups_from_port_list(self, ports, neutron):

        def _chunk_by_ids(sg_ids, limit):

    def get_instances_security_groups_bindings(self, context, servers, detailed=False):

    def get_instance_security_groups(self, context, instance_uuid, detailed=False):

    def _has_security_group_requirements(self, port):

    def add_to_instance(self, context, instance, security_group_name):

    def remove_from_instance(self, context, instance, security_group_name):

    def populate_security_groups(self, instance, security_groups):

\OpenStack\nova-2014.1\nova\network\security_group\openstack_driver.py

def get_openstack_security_group_driver():

def is_neutron_security_groups():

\OpenStack\nova-2014.1\nova\network\security_group\security_group_base.py

class SecurityGroupBase(object):

    def parse_cidr(self, cidr):

    def new_group_ingress_rule(grantee_group_id, protocol, from_port, to_port):

    def new_cidr_ingress_rule(grantee_cidr, protocol, from_port, to_port):

    def _new_ingress_rule(ip_protocol, from_port, to_port, group_id=None, cidr=None):

    def create_security_group_rule(self, context, security_group, new_rule):

    def rule_exists(self, security_group, new_rule):

    def validate_property(self, value, property, allowed):

    def ensure_default(self, context):

    def trigger_handler(self, event, *args):

    def trigger_rules_refresh(self, context, id):

    def trigger_members_refresh(self, context, group_ids):

    def populate_security_groups(self, instance, security_groups):

    def create_security_group(self, context, name, description):

    def update_security_group(self, context, security_group, name, description):

    def get(self, context, name=None, id=None, map_exception=False):

    def list(self, context, names=None, ids=None, project=None, search_opts=None):

    def destroy(self, context, security_group):

    def add_rules(self, context, id, name, vals):

    def remove_rules(self, context, security_group, rule_ids):

    def get_rule(self, context, id):

    def get_instance_security_groups(self, context, instance_uuid, detailed=False):

    def add_to_instance(self, context, instance, security_group_name):

    def remove_from_instance(self, context, instance, security_group_name):

    def raise_invalid_property(msg):

    def raise_group_already_exists(msg):

    def raise_invalid_group(msg):

    def raise_invalid_cidr(cidr, decoding_exception=None):

    def raise_over_quota(msg):

    def raise_not_found(msg):

\OpenStack\nova-2014.1\nova\network\security_group\__init__.py

\OpenStack\nova-2014.1\nova\network\__init__.py

def API():

\OpenStack\nova-2014.1\nova\notifications.py

def notify_decorator(name, fn):

def send_api_fault(url, status, exception):

def send_update(context, old_instance, new_instance, service=None, host=None):

def send_update_with_states(context, instance, old_vm_state, new_vm_state, old_task_state, new_task_state, service="compute", host=None, verify_states=False):

def _send_instance_update_notification(context, instance, old_vm_state=None, old_task_state=None, new_vm_state=None, new_task_state=None, service="compute", host=None, old_display_name=None):

def audit_period_bounds(current_period=False):

def bandwidth_usage(instance_ref, audit_start, ignore_missing_network_data=True):

def image_meta(system_metadata):

def info_from_instance(context, instance_ref, network_info, system_metadata, **kw):

\OpenStack\nova-2014.1\nova\objects\aggregate.py

class Aggregate(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, aggregate, db_aggregate):

    def _assert_no_hosts(self, action):

    def get_by_id(cls, context, aggregate_id):

    def create(self, context):

    def save(self, context):

    def update_metadata(self, context, updates):

    def destroy(self, context):

    def add_host(self, context, host):

    def delete_host(self, context, host):

    def availability_zone(self):

class AggregateList(base.ObjectListBase, base.NovaObject):

    def get_all(cls, context):

    def get_by_host(cls, context, host, key=None):

\OpenStack\nova-2014.1\nova\objects\base.py

class NotSpecifiedSentinel:

def get_attrname(name):

def make_class_properties(cls):

class NovaObjectMetaclass(type):

    def __init__(cls, names, bases, dict_):

def remotable_classmethod(fn):

    def wrapper(cls, context, *args, **kwargs):

def remotable(fn):

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

class NovaObject(object):

    def __init__(self, context=None, **kwargs):

    def obj_name(cls):

    def obj_class_from_name(cls, objname, objver):

    def _obj_from_primitive(cls, context, objver, primitive):

    def obj_from_primitive(cls, primitive, context=None):

    def __deepcopy__(self, memo):

    def obj_clone(self):

    def obj_make_compatible(self, primitive, target_version):

    def obj_to_primitive(self, target_version=None):

    def obj_load_attr(self, attrname):

    def save(self, context):

    def obj_what_changed(self):

    def obj_get_changes(self):

    def obj_reset_changes(self, fields=None):

    def obj_attr_is_set(self, attrname):

    def obj_fields(self):

    def iteritems(self):

    def __getitem__(self, name):

    def __setitem__(self, name, value):

    def __contains__(self, name):

    def get(self, key, value=NotSpecifiedSentinel):

    def update(self, updates):

class NovaPersistentObject(object):

class ObjectListBase(object):

    def __iter__(self):

    def __len__(self):

    def __getitem__(self, index):

    def __contains__(self, value):

    def count(self, value):

    def index(self, value):

    def sort(self, cmp=None, key=None, reverse=False):

    def _attr_objects_to_primitive(self):

    def _attr_objects_from_primitive(self, value):

    def obj_make_compatible(self, primitive, target_version):

    def obj_what_changed(self):

class NovaObjectSerializer(messaging.NoOpSerializer):

    def conductor(self):

    def _process_object(self, context, objprim):

    def _process_iterable(self, context, action_fn, values):

    def serialize_entity(self, context, entity):

    def deserialize_entity(self, context, entity):

def obj_to_primitive(obj):

def obj_make_list(context, list_obj, item_cls, db_list, **extra_args):

\OpenStack\nova-2014.1\nova\objects\block_device.py

def _expected_cols(expected_attrs):

class BlockDeviceMapping(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, block_device_obj, db_block_device, expected_attrs=None):

    def create(self, context):

    def destroy(self, context):

    def save(self, context):

    def get_by_volume_id(cls, context, volume_id, instance_uuid=None, expected_attrs=None):

    def is_root(self):

    def is_volume(self):

    def is_image(self):

    def get_image_mapping(self):

    def obj_load_attr(self, attrname):

class BlockDeviceMappingList(base.ObjectListBase, base.NovaObject):

    def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False):

    def root_bdm(self):

    def root_metadata(self, context, image_api, volume_api):

def block_device_make_list(context, db_list, **extra_args):

\OpenStack\nova-2014.1\nova\objects\compute_node.py

class ComputeNode(base.NovaPersistentObject, base.NovaObject):

    def obj_make_compatible(self, primitive, target_version):

    def _from_db_object(context, compute, db_compute):

    def get_by_id(cls, context, compute_id):

    def get_by_service_id(cls, context, service_id):

    def _convert_stats_to_db_format(self, updates):

    def create(self, context):

    def save(self, context, prune_stats=False):

    def destroy(self, context):

    def service(self):

class ComputeNodeList(base.ObjectListBase, base.NovaObject):

    def get_all(cls, context):

    def get_by_hypervisor(cls, context, hypervisor_match):

\OpenStack\nova-2014.1\nova\objects\dns_domain.py

class DNSDomain(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, vif, db_vif):

    def get_by_domain(cls, context, domain):

    def register_for_zone(cls, context, domain, zone):

    def register_for_project(cls, context, domain, project):

    def delete_by_domain(cls, context, domain):

class DNSDomainList(base.ObjectListBase, base.NovaObject):

    def get_all(cls, context):

\OpenStack\nova-2014.1\nova\objects\external_event.py

class InstanceExternalEvent(obj_base.NovaObject):

    def make_key(name, tag=None):

    def key(self):

\OpenStack\nova-2014.1\nova\objects\fields.py

class KeyTypeError(TypeError):

    def __init__(self, expected, value):

class ElementTypeError(TypeError):

    def __init__(self, expected, key, value):

class AbstractFieldType(six.with_metaclass(abc.ABCMeta, object)):

    def coerce(self, obj, attr, value):

    def from_primitive(self, obj, attr, value):

    def to_primitive(self, obj, attr, value):

    def describe(self):

class FieldType(AbstractFieldType):

    def coerce(obj, attr, value):

    def from_primitive(obj, attr, value):

    def to_primitive(obj, attr, value):

    def describe(self):

class UnspecifiedDefault(object):

class Field(object):

    def __init__(self, field_type, nullable=False, default=UnspecifiedDefault):

    def nullable(self):

    def default(self):

    def _null(self, obj, attr):

    def coerce(self, obj, attr, value):

    def from_primitive(self, obj, attr, value):

    def to_primitive(self, obj, attr, value):

    def describe(self):

class String(FieldType):

    def coerce(obj, attr, value):

class UUID(FieldType):

    def coerce(obj, attr, value):

class Integer(FieldType):

    def coerce(obj, attr, value):

class Float(FieldType):

    def coerce(self, obj, attr, value):

class Boolean(FieldType):

    def coerce(obj, attr, value):

class DateTime(FieldType):

    def coerce(obj, attr, value):

    def from_primitive(self, obj, attr, value):

    def to_primitive(obj, attr, value):

class IPAddress(FieldType):

    def coerce(obj, attr, value):

    def from_primitive(self, obj, attr, value):

    def to_primitive(obj, attr, value):

class IPV4Address(IPAddress):

    def coerce(obj, attr, value):

class IPV6Address(IPAddress):

    def coerce(obj, attr, value):

class IPV4AndV6Address(IPAddress):

    def coerce(obj, attr, value):

class IPNetwork(IPAddress):

    def coerce(obj, attr, value):

class IPV4Network(IPNetwork):

    def coerce(obj, attr, value):

class IPV6Network(IPNetwork):

    def coerce(obj, attr, value):

class CompoundFieldType(FieldType):

    def __init__(self, element_type, **field_args):

class List(CompoundFieldType):

    def coerce(self, obj, attr, value):

    def to_primitive(self, obj, attr, value):

    def from_primitive(self, obj, attr, value):

class Dict(CompoundFieldType):

    def coerce(self, obj, attr, value):

    def to_primitive(self, obj, attr, value):

    def from_primitive(self, obj, attr, value):

class Object(FieldType):

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

    def coerce(self, obj, attr, value):

    def to_primitive(obj, attr, value):

    def from_primitive(obj, attr, value):

    def describe(self):

class NetworkModel(FieldType):

    def coerce(obj, attr, value):

    def to_primitive(obj, attr, value):

    def from_primitive(obj, attr, value):

class AutoTypedField(Field):

    def __init__(self, **kwargs):

class StringField(AutoTypedField):

class UUIDField(AutoTypedField):

class IntegerField(AutoTypedField):

class FloatField(AutoTypedField):

class BooleanField(AutoTypedField):

class DateTimeField(AutoTypedField):

class IPAddressField(AutoTypedField):

class IPV4AddressField(AutoTypedField):

class IPV6AddressField(AutoTypedField):

class IPNetworkField(AutoTypedField):

class IPV4NetworkField(AutoTypedField):

class IPV6NetworkField(AutoTypedField):

class DictOfStringsField(AutoTypedField):

class DictOfNullableStringsField(AutoTypedField):

class ListOfStringsField(AutoTypedField):

class ObjectField(AutoTypedField):

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

class ListOfObjectsField(AutoTypedField):

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

\OpenStack\nova-2014.1\nova\objects\fixed_ip.py

class FixedIP(obj_base.NovaPersistentObject, obj_base.NovaObject):

    def floating_ips(self):

    def _from_db_object(context, fixedip, db_fixedip, expected_attrs=None):

    def get_by_id(cls, context, id, expected_attrs=None):

    def get_by_address(cls, context, address, expected_attrs=None):

    def get_by_floating_address(cls, context, address):

    def get_by_network_and_host(cls, context, network_id, host):

    def associate(cls, context, address, instance_uuid, network_id=None, reserved=False):

    def associate_pool(cls, context, network_id, instance_uuid=None, host=None):

    def disassociate_by_address(cls, context, address):

    def _disassociate_all_by_timeout(cls, context, host, time_str):

    def disassociate_all_by_timeout(cls, context, host, time):

    def create(self, context):

    def save(self, context):

    def disassociate(self, context):

class FixedIPList(obj_base.ObjectListBase, obj_base.NovaObject):

    def get_all(cls, context):

    def get_by_instance_uuid(cls, context, instance_uuid):

    def get_by_host(cls, context, host):

    def get_by_virtual_interface_id(cls, context, vif_id):

    def get_by_network(cls, context, network, host=None):

    def bulk_create(self, context, fixed_ips):

\OpenStack\nova-2014.1\nova\objects\flavor.py

class Flavor(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, flavor, db_flavor, expected_attrs=None):

    def _load_projects(self, context):

    def obj_load_attr(self, attrname):

    def get_by_id(cls, context, id):

    def get_by_name(cls, context, name):

    def get_by_flavor_id(cls, context, flavor_id, read_deleted=None):

    def add_access(self, context, project_id):

    def remove_access(self, context, project_id):

    def create(self, context):

    def save(self, context):

    def destroy(self, context):

class FlavorList(base.ObjectListBase, base.NovaObject):

    def get_all(cls, context, inactive=False, filters=None, sort_key='flavorid', sort_dir='asc', limit=None, marker=None):

\OpenStack\nova-2014.1\nova\objects\floating_ip.py

class FloatingIP(obj_base.NovaPersistentObject, obj_base.NovaObject):

    def _from_db_object(context, floatingip, db_floatingip, expected_attrs=None):

    def obj_load_attr(self, attrname):

    def get_by_id(cls, context, id):

    def get_by_address(cls, context, address):

    def get_pool_names(cls, context):

    def allocate_address(cls, context, project_id, pool, auto_assigned=False):

    def associate(cls, context, floating_address, fixed_address, host):

    def deallocate(cls, context, address):

    def destroy(cls, context, address):

    def disassociate(cls, context, address):

    def save(self, context):

class FloatingIPList(obj_base.ObjectListBase, obj_base.NovaObject):

    def get_all(cls, context):

    def get_by_host(cls, context, host):

    def get_by_project(cls, context, project_id):

    def get_by_fixed_address(cls, context, fixed_address):

    def get_by_fixed_ip_id(cls, context, fixed_ip_id):

\OpenStack\nova-2014.1\nova\objects\instance.py

def _expected_cols(expected_attrs):

class Instance(base.NovaPersistentObject, base.NovaObject):

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

    def _reset_metadata_tracking(self, fields=None):

    def obj_reset_changes(self, fields=None):

    def obj_what_changed(self):

    def _obj_from_primitive(cls, context, objver, primitive):

    def obj_make_compatible(self, primitive, target_version):

    def name(self):

    def _from_db_object(context, instance, db_inst, expected_attrs=None):

    def get_by_uuid(cls, context, uuid, expected_attrs=None, use_slave=False):

    def get_by_id(cls, context, inst_id, expected_attrs=None):

    def create(self, context):

    def destroy(self, context):

    def _save_info_cache(self, context):

    def _save_security_groups(self, context):

    def _save_fault(self, context):

    def _save_pci_devices(self, context):

    def save(self, context, expected_vm_state=None, expected_task_state=None, admin_state_reset=False):

    def refresh(self, context, use_slave=False):

    def obj_load_attr(self, attrname):

    def get_flavor(self, namespace=None):

    def set_flavor(self, flavor, namespace=None):

    def delete_flavor(self, namespace):

    def delete_metadata_key(self, context, key):

def _make_instance_list(context, inst_list, db_inst_list, expected_attrs):

class InstanceList(base.ObjectListBase, base.NovaObject):

    def get_by_filters(cls, context, filters, sort_key='created_at', sort_dir='desc', limit=None, marker=None, expected_attrs=None, use_slave=False):

    def get_by_host(cls, context, host, expected_attrs=None, use_slave=False):

    def get_by_host_and_node(cls, context, host, node, expected_attrs=None):

    def get_by_host_and_not_type(cls, context, host, type_id=None, expected_attrs=None):

    def get_hung_in_rebooting(cls, context, reboot_window, expected_attrs=None):

    def _get_active_by_window_joined(cls, context, begin, end=None, project_id=None, host=None, expected_attrs=None):

    def get_active_by_window_joined(cls, context, begin, end=None, project_id=None, host=None, expected_attrs=None):

    def get_by_security_group_id(cls, context, security_group_id):

    def get_by_security_group(cls, context, security_group):

    def fill_faults(self):

\OpenStack\nova-2014.1\nova\objects\instance_action.py

class InstanceAction(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, action, db_action):

    def pack_action_start(context, instance_uuid, action_name):

    def pack_action_finish(context, instance_uuid):

    def get_by_request_id(cls, context, instance_uuid, request_id):

    def action_start(cls, context, instance_uuid, action_name, want_result=True):

    def action_finish(cls, context, instance_uuid, want_result=True):

    def finish(self, context):

class InstanceActionList(base.ObjectListBase, base.NovaObject):

    def get_by_instance_uuid(cls, context, instance_uuid):

OpenStack Index

Previous

Next