OpenStack Study: neutron

OpenStack Index

class MoxStubout(fixtures.Fixture):

    def setUp(self):

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

def enable_lazy():

def _(msg):

def _log_translation(msg, level):

def install(domain, lazy=False):

class Message(six.text_type):

    def __new__(cls, msgid, msgtext=None, params=None, domain='neutron', *args):

    def translate(self, desired_locale=None):

    def _translate_msgid(msgid, domain, desired_locale=None):

    def __mod__(self, other):

    def _sanitize_mod_params(self, other):

    def _copy_param(self, param):

    def __add__(self, other):

    def __radd__(self, other):

    def __str__(self):

def get_available_languages(domain):

def translate(obj, desired_locale=None):

def _translate_args(args, desired_locale=None):

class TranslationHandler(handlers.MemoryHandler):

    def __init__(self, locale=None, target=None):

    def setFormatter(self, fmt):

    def emit(self, record):

    def _translate_and_log_record(self, record):

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

def import_class(import_str):

def import_object(import_str, *args, **kwargs):

def import_object_ns(name_space, import_str, *args, **kwargs):

def import_module(import_str):

def try_import(import_str, default=None):

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

def to_primitive(value, convert_instances=False, convert_datetime=True, level=0, max_depth=3):

def dumps(value, default=to_primitive, **kwargs):

def loads(s):

def load(s):

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

class WeakLocal(threading.local):

    def __getattribute__(self, attr):

    def __setattr__(self, attr, value):

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

def set_defaults(lock_path):

class _InterProcessLock(object):

    def __init__(self, name):

    def __enter__(self):

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

    def trylock(self):

    def unlock(self):

class _WindowsLock(_InterProcessLock):

    def trylock(self):

    def unlock(self):

class _PosixLock(_InterProcessLock):

    def trylock(self):

    def unlock(self):

        def foo(self, *args):

        def foo(self, *args):

        def bar(self, *args):

    def wrap(f):

        def inner(*args, **kwargs):

        def bar(self, *args):

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

def _dictify_context(context):

def _get_binary_name():

def _get_log_file_path(binary=None):

def mask_password(message, secret="***"):

class BaseLoggerAdapter(logging.LoggerAdapter):

    def audit(self, msg, *args, **kwargs):

class LazyAdapter(BaseLoggerAdapter):

    def __init__(self, name='unknown', version='unknown'):

    def logger(self):

class ContextAdapter(BaseLoggerAdapter):

    def __init__(self, logger, project_name, version_string):

    def handlers(self):

    def deprecated(self, msg, *args, **kwargs):

    def process(self, msg, kwargs):

class JSONFormatter(logging.Formatter):

    def __init__(self, fmt=None, datefmt=None):

    def formatException(self, ei, strip_newlines=True):

    def format(self, record):

def _create_logging_excepthook(product_name):

    def logging_excepthook(exc_type, value, tb):

class LogConfigError(Exception):

    def __init__(self, log_config, err_msg):

    def __str__(self):

def _load_log_config(log_config_append):

def setup(product_name):

def set_defaults(logging_context_format_string):

def _find_facility_from_conf():

def _setup_logging_from_conf():

def getLogger(name='unknown', version='unknown'):

def getLazyLogger(name='unknown', version='unknown'):

class WritableLogger(object):

    def __init__(self, logger, level=logging.INFO):

    def write(self, msg):

class ContextFormatter(logging.Formatter):

    def format(self, record):

    def formatException(self, exc_info, record=None):

class ColorHandler(logging.StreamHandler):

    def format(self, record):

class DeprecatedConfig(Exception):

    def __init__(self, msg):

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

class PublishErrorsHandler(logging.Handler):

    def emit(self, record):

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

class LoopingCallDone(Exception):

    def __init__(self, retvalue=True):

class LoopingCallBase(object):

    def __init__(self, f=None, *args, **kw):

    def stop(self):

    def wait(self):

class FixedIntervalLoopingCall(LoopingCallBase):

    def start(self, interval, initial_delay=None):

        def _inner():

class DynamicLoopingCall(LoopingCallBase):

    def start(self, initial_delay=None, periodic_interval_max=None):

        def _inner():

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\audit.py

class AuditMiddleware(notifier.RequestNotifier):

    def __init__(self, app, **conf):

    def process_request(self, request):

    def process_response(self, request, response, exception=None, traceback=None):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\base.py

class Middleware(object):

    def factory(cls, global_conf, **local_conf):

    def __init__(self, application):

    def process_request(self, req):

    def process_response(self, response):

    def __call__(self, req):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\catch_errors.py

class CatchErrorsMiddleware(base.Middleware):

    def __call__(self, req):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\correlation_id.py

class CorrelationIdMiddleware(base.Middleware):

    def process_request(self, req):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\debug.py

class Debug(base.Middleware):

    def __call__(self, req):

    def print_generator(app_iter):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\notifier.py

def log_and_ignore_error(fn):

 def wrapped(*args, **kwargs):

class RequestNotifier(base.Middleware):

    def factory(cls, global_conf, **local_conf):

        def _factory(app):

    def __init__(self, app, **conf):

    def environ_to_dict(environ):

    def process_request(self, request):

    def process_response(self, request, response, exception=None, traceback=None):

    def __call__(self, req):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\request_id.py

class RequestIdMiddleware(base.Middleware):

    def __call__(self, req):

\OpenStack\neutron-2014.1\neutron\openstack\common\middleware\sizelimit.py

class LimitingReader(object):

    def __init__(self, data, limit):

    def __iter__(self):

    def read(self, i=None):

class RequestBodySizeLimiter(base.Middleware):

    def __call__(self, req):

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

def parse_host_port(address, default_port=None):

def urlsplit(url, scheme='', allow_fragments=True):

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

class BadPriorityException(Exception):

    def wrapped_func(*args, **kwarg):

def publisher_id(service, host=None):

def notify(context, publisher_id, event_type, priority, payload):

def _get_drivers():

def add_driver(notification_driver):

def _reset_drivers():

\OpenStack\neutron-2014.1\neutron\openstack\common\notifier\log_notifier.py

def notify(_context, message):

\OpenStack\neutron-2014.1\neutron\openstack\common\notifier\no_op_notifier.py

def notify(_context, message):

\OpenStack\neutron-2014.1\neutron\openstack\common\notifier\rabbit_notifier.py

def notify(context, message):

\OpenStack\neutron-2014.1\neutron\openstack\common\notifier\rpc_notifier.py

def notify(context, message):

\OpenStack\neutron-2014.1\neutron\openstack\common\notifier\rpc_notifier2.py

def notify(context, message):

\OpenStack\neutron-2014.1\neutron\openstack\common\notifier\test_notifier.py

def notify(_context, message):

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

class InvalidPeriodicTaskArg(Exception):

    def decorator(f):

class _PeriodicTasksMeta(type):

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

class PeriodicTasks(object):

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

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

class Rules(dict):

    def load_json(cls, data, default_rule=None):

    def __init__(self, rules=None, default_rule=None):

    def __missing__(self, key):

    def __str__(self):

def set_rules(rules):

def reset():

def check(rule, target, creds, exc=None, *args, **kwargs):

class BaseCheck(object):

    def __str__(self):

    def __call__(self, target, cred):

class FalseCheck(BaseCheck):

    def __str__(self):

    def __call__(self, target, cred):

class TrueCheck(BaseCheck):

    def __str__(self):

    def __call__(self, target, cred):

class Check(BaseCheck):

    def __init__(self, kind, match):

    def __str__(self):

class NotCheck(BaseCheck):

    def __init__(self, rule):

    def __str__(self):

    def __call__(self, target, cred):

class AndCheck(BaseCheck):

    def __init__(self, rules):

    def __str__(self):

    def __call__(self, target, cred):

    def add_check(self, rule):

class OrCheck(BaseCheck):

    def __init__(self, rules):

    def __str__(self):

    def __call__(self, target, cred):

    def add_check(self, rule):

def _parse_check(rule):

def _parse_list_rule(rule):

def _parse_tokenize(rule):

class ParseStateMeta(type):

    def __new__(mcs, name, bases, cls_dict):

def reducer(*tokens):

    def decorator(func):

class ParseState(object):

    def __init__(self):

    def reduce(self):

    def shift(self, tok, value):

    def result(self):

    def _wrap_check(self, _p1, check, _p2):

    def _make_and_expr(self, check1, _and, check2):

    def _extend_and_expr(self, and_expr, _and, check):

    def _make_or_expr(self, check1, _or, check2):

    def _extend_or_expr(self, or_expr, _or, check):

    def _make_not_expr(self, _not, check):

def _parse_text_rule(rule):

def parse_rule(rule):

def register(name, func=None):

    def decorator(func):

class RuleCheck(Check):

    def __call__(self, target, creds):

class RoleCheck(Check):

    def __call__(self, target, creds):

class HttpCheck(Check):

    def __call__(self, target, creds):

class GenericCheck(Check):

    def __call__(self, target, creds):

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

class InvalidArgumentError(Exception):

    def __init__(self, message=None):

class UnknownArgumentError(Exception):

    def __init__(self, message=None):

class ProcessExecutionError(Exception):

    def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None, description=None):

class NoRootWrapSpecified(Exception):

    def __init__(self, message=None):

def _subprocess_setup():

def execute(*cmd, **kwargs):

def trycmd(*args, **kwargs):

def ssh_execute(ssh, cmd, process_input=None, addl_env=None, check_exit_code=True):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\amqp.py

class Pool(pools.Pool):

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

    def create(self):

    def empty(self):

def get_connection_pool(conf, connection_cls):

class ConnectionContext(rpc_common.Connection):

    def __init__(self, conf, connection_pool, pooled=True, server_params=None):

    def __enter__(self):

    def _done(self):

    def __exit__(self, exc_type, exc_value, tb):

    def __del__(self):

    def close(self):

    def create_consumer(self, topic, proxy, fanout=False):

    def create_worker(self, topic, proxy, pool_name):

    def join_consumer_pool(self, callback, pool_name, topic, exchange_name, ack_on_error=True):

    def consume_in_thread(self):

    def __getattr__(self, key):

class ReplyProxy(ConnectionContext):

    def __init__(self, conf, connection_pool):

    def _process_data(self, message_data):

    def add_call_waiter(self, waiter, msg_id):

    def del_call_waiter(self, msg_id):

    def get_reply_q(self):

def msg_reply(conf, msg_id, reply_q, connection_pool, reply=None, failure=None, ending=False, log_failure=True):

class RpcContext(rpc_common.CommonRpcContext):

    def __init__(self, **kwargs):

    def deepcopy(self):

    def reply(self, reply=None, failure=None, ending=False, connection_pool=None, log_failure=True):

def unpack_context(conf, msg):

def pack_context(msg, context):

class _MsgIdCache(object):

    def __init__(self, **kwargs):

    def check_duplicate_message(self, message_data):

def _add_unique_id(msg):

class _ThreadPoolWithWait(object):

    def __init__(self, conf, connection_pool):

    def wait(self):

class CallbackWrapper(_ThreadPoolWithWait):

    def __init__(self, conf, callback, connection_pool, wait_for_consumers=False):

    def _wrap(self, message_data, **kwargs):

    def __call__(self, message_data):

class ProxyCallback(_ThreadPoolWithWait):

    def __init__(self, conf, proxy, connection_pool):

    def __call__(self, message_data):

    def _process_data(self, ctxt, version, method, namespace, args):

class MulticallProxyWaiter(object):

    def __init__(self, conf, msg_id, timeout, connection_pool):

    def put(self, data):

    def done(self):

    def _process_data(self, data):

    def __iter__(self):

def create_connection(conf, new, connection_pool):

def multicall(conf, context, topic, msg, timeout, connection_pool):

def call(conf, context, topic, msg, timeout, connection_pool):

def cast(conf, context, topic, msg, connection_pool):

def fanout_cast(conf, context, topic, msg, connection_pool):

def cast_to_server(conf, context, server_params, topic, msg, connection_pool):

def fanout_cast_to_server(conf, context, server_params, topic, msg, connection_pool):

def notify(conf, context, topic, msg, connection_pool, envelope):

def cleanup(connection_pool):

def get_control_exchange(conf):

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

class RPCException(Exception):

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

class RemoteError(RPCException):

    def __init__(self, exc_type=None, value=None, traceback=None):

class Timeout(RPCException):

    def __init__(self, info=None, topic=None, method=None):

class DuplicateMessageError(RPCException):

class InvalidRPCConnectionReuse(RPCException):

class UnsupportedRpcVersion(RPCException):

class UnsupportedRpcEnvelopeVersion(RPCException):

class RpcVersionCapError(RPCException):

class Connection(object):

    def close(self):

    def create_consumer(self, topic, proxy, fanout=False):

    def create_worker(self, topic, proxy, pool_name):

    def join_consumer_pool(self, callback, pool_name, topic, exchange_name):

    def consume_in_thread(self):

def _safe_log(log_func, msg, msg_data):

    def _fix_passwords(d):

def serialize_remote_exception(failure_info, log_failure=True):

def deserialize_remote_exception(conf, data):

class CommonRpcContext(object):

    def __init__(self, **kwargs):

    def __getattr__(self, key):

    def to_dict(self):

    def from_dict(cls, values):

    def deepcopy(self):

    def update_store(self):

    def elevated(self, read_deleted=None, overwrite=False):

class ClientException(Exception):

    def __init__(self):

def catch_client_exception(exceptions, func, *args, **kwargs):

def client_exceptions(*exceptions):

    def outer(func):

        def inner(*args, **kwargs):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\dispatcher.py

class RpcDispatcher(object):

    def __init__(self, callbacks, serializer=None):

    def _deserialize_args(self, context, kwargs):

    def dispatch(self, ctxt, version, method, namespace, **kwargs):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\impl_fake.py

class RpcContext(rpc_common.CommonRpcContext):

    def __init__(self, **kwargs):

    def deepcopy(self):

    def reply(self, reply=None, failure=None, ending=False):

class Consumer(object):

    def __init__(self, topic, proxy):

    def call(self, context, version, method, namespace, args, timeout):

        def _inner():

class Connection(object):

    def __init__(self):

    def create_consumer(self, topic, proxy, fanout=False):

    def close(self):

    def consume_in_thread(self):

def create_connection(conf, new=True):

def check_serialize(msg):

def multicall(conf, context, topic, msg, timeout=None):

def call(conf, context, topic, msg, timeout=None):

def cast(conf, context, topic, msg):

def notify(conf, context, topic, msg, envelope):

def cleanup():

def fanout_cast(conf, context, topic, msg):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\impl_kombu.py

def _get_queue_arguments(conf):

class ConsumerBase(object):

    def __init__(self, channel, callback, tag, **kwargs):

    def reconnect(self, channel):

    def _callback_handler(self, message, callback):

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

        def _callback(raw_message):

    def cancel(self):

class DirectConsumer(ConsumerBase):

    def __init__(self, conf, channel, msg_id, callback, tag, **kwargs):

class TopicConsumer(ConsumerBase):

    def __init__(self, conf, channel, topic, callback, tag, name=None, exchange_name=None, **kwargs):

class FanoutConsumer(ConsumerBase):

    def __init__(self, conf, channel, topic, callback, tag, **kwargs):

class Publisher(object):

    def __init__(self, channel, exchange_name, routing_key, **kwargs):

    def reconnect(self, channel):

    def send(self, msg, timeout=None):

class DirectPublisher(Publisher):

    def __init__(self, conf, channel, msg_id, **kwargs):

class TopicPublisher(Publisher):

    def __init__(self, conf, channel, topic, **kwargs):

class FanoutPublisher(Publisher):

    def __init__(self, conf, channel, topic, **kwargs):

class NotifyPublisher(TopicPublisher):

    def __init__(self, conf, channel, topic, **kwargs):

    def reconnect(self, channel):

class Connection(object):

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

    def _fetch_ssl_params(self):

    def _connect(self, params):

    def reconnect(self):

    def ensure(self, error_callback, method, *args, **kwargs):

    def get_channel(self):

    def close(self):

    def reset(self):

    def declare_consumer(self, consumer_cls, topic, callback):

        def _connect_error(exc):

        def _declare_consumer():

    def iterconsume(self, limit=None, timeout=None):

        def _error_callback(exc):

        def _consume():

    def cancel_consumer_thread(self):

    def wait_on_proxy_callbacks(self):

    def publisher_send(self, cls, topic, msg, timeout=None, **kwargs):

        def _error_callback(exc):

        def _publish():

    def declare_direct_consumer(self, topic, callback):

    def declare_topic_consumer(self, topic, callback=None, queue_name=None, exchange_name=None, ack_on_error=True):

    def declare_fanout_consumer(self, topic, callback):

    def direct_send(self, msg_id, msg):

    def topic_send(self, topic, msg, timeout=None):

    def fanout_send(self, topic, msg):

    def notify_send(self, topic, msg, **kwargs):

    def consume(self, limit=None):

    def consume_in_thread(self):

        def _consumer_thread():

    def create_consumer(self, topic, proxy, fanout=False):

    def create_worker(self, topic, proxy, pool_name):

    def join_consumer_pool(self, callback, pool_name, topic, exchange_name=None, ack_on_error=True):

def create_connection(conf, new=True):

def multicall(conf, context, topic, msg, timeout=None):

def call(conf, context, topic, msg, timeout=None):

def cast(conf, context, topic, msg):

def fanout_cast(conf, context, topic, msg):

def cast_to_server(conf, context, server_params, topic, msg):

def fanout_cast_to_server(conf, context, server_params, topic, msg):

def notify(conf, context, topic, msg, envelope):

def cleanup():

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\impl_qpid.py

def raise_invalid_topology_version(conf):

class ConsumerBase(object):

    def __init__(self, conf, session, callback, node_name, node_opts, link_name, link_opts):

    def connect(self, session):

    def reconnect(self, session):

    def _declare_receiver(self, session):

    def _unpack_json_msg(self, msg):

    def consume(self):

    def get_receiver(self):

    def get_node_name(self):

class DirectConsumer(ConsumerBase):

    def __init__(self, conf, session, msg_id, callback):

class TopicConsumer(ConsumerBase):

    def __init__(self, conf, session, topic, callback, name=None, exchange_name=None):

class FanoutConsumer(ConsumerBase):

    def __init__(self, conf, session, topic, callback):

class Publisher(object):

    def __init__(self, conf, session, node_name, node_opts=None):

    def reconnect(self, session):

    def _pack_json_msg(self, msg):

    def send(self, msg):

class DirectPublisher(Publisher):

    def __init__(self, conf, session, msg_id):

class TopicPublisher(Publisher):

    def __init__(self, conf, session, topic):

class FanoutPublisher(Publisher):

    def __init__(self, conf, session, topic):

class NotifyPublisher(Publisher):

    def __init__(self, conf, session, topic):

class Connection(object):

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

    def connection_create(self, broker):

    def _register_consumer(self, consumer):

    def _lookup_consumer(self, receiver):

    def reconnect(self):

    def ensure(self, error_callback, method, *args, **kwargs):

    def close(self):

    def reset(self):

    def declare_consumer(self, consumer_cls, topic, callback):

        def _connect_error(exc):

        def _declare_consumer():

    def iterconsume(self, limit=None, timeout=None):

        def _error_callback(exc):

        def _consume():

    def cancel_consumer_thread(self):

    def wait_on_proxy_callbacks(self):

    def publisher_send(self, cls, topic, msg):

        def _connect_error(exc):

        def _publisher_send():

    def declare_direct_consumer(self, topic, callback):

    def declare_topic_consumer(self, topic, callback=None, queue_name=None, exchange_name=None):

    def declare_fanout_consumer(self, topic, callback):

    def direct_send(self, msg_id, msg):

    def topic_send(self, topic, msg, timeout=None):

    def fanout_send(self, topic, msg):

    def notify_send(self, topic, msg, **kwargs):

    def consume(self, limit=None):

    def consume_in_thread(self):

        def _consumer_thread():

    def create_consumer(self, topic, proxy, fanout=False):

    def create_worker(self, topic, proxy, pool_name):

    def join_consumer_pool(self, callback, pool_name, topic, exchange_name=None, ack_on_error=True):

def create_connection(conf, new=True):

def multicall(conf, context, topic, msg, timeout=None):

def call(conf, context, topic, msg, timeout=None):

def cast(conf, context, topic, msg):

def fanout_cast(conf, context, topic, msg):

def cast_to_server(conf, context, server_params, topic, msg):

def fanout_cast_to_server(conf, context, server_params, topic, msg):

def notify(conf, context, topic, msg, envelope):

def cleanup():

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\impl_zmq.py

def _serialize(data):

def _deserialize(data):

class ZmqSocket(object):

    def __init__(self, addr, zmq_type, bind=True, subscribe=None):

    def socket_s(self):

    def subscribe(self, msg_filter):

    def unsubscribe(self, msg_filter):

    def close(self):

    def recv(self, **kwargs):

    def send(self, data, **kwargs):

class ZmqClient(object):

    def __init__(self, addr):

    def cast(self, msg_id, topic, data, envelope):

    def close(self):

class RpcContext(rpc_common.CommonRpcContext):

    def __init__(self, **kwargs):

    def deepcopy(self):

    def reply(self, reply=None, failure=None, ending=False):

    def marshal(self, ctx):

    def unmarshal(self, data):

class InternalContext(object):

    def __init__(self, proxy):

    def _get_response(self, ctx, proxy, topic, data):

    def reply(self, ctx, proxy, msg_id=None, context=None, topic=None, msg=None):

class ConsumerBase(object):

    def __init__(self):

    def normalize_reply(self, result, replies):

    def process(self, proxy, ctx, data):

class ZmqBaseReactor(ConsumerBase):

    def __init__(self, conf):

    def register(self, proxy, in_addr, zmq_type_in, in_bind=True, subscribe=None):

    def consume_in_thread(self):

        def _consume(sock):

    def wait(self):

    def close(self):

class ZmqProxy(ZmqBaseReactor):

    def __init__(self, conf):

    def consume(self, sock):

    def consume_in_thread(self):

def unflatten_envelope(packenv):

class ZmqReactor(ZmqBaseReactor):

    def __init__(self, conf):

    def consume(self, sock):

class Connection(rpc_common.Connection):

    def __init__(self, conf):

    def create_consumer(self, topic, proxy, fanout=False):

    def close(self):

    def wait(self):

    def consume_in_thread(self):

def _cast(addr, context, topic, msg, timeout=None, envelope=False, _msg_id=None):

def _call(addr, context, topic, msg, timeout=None, envelope=False):

def _multi_send(method, context, topic, msg, timeout=None, envelope=False, _msg_id=None):

def create_connection(conf, new=True):

def multicall(conf, *args, **kwargs):

def call(conf, *args, **kwargs):

def cast(conf, *args, **kwargs):

def fanout_cast(conf, context, topic, msg, **kwargs):

def notify(conf, context, topic, msg, envelope):

def cleanup():

def _get_ctxt():

def _get_matchmaker(*args, **kwargs):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\matchmaker.py

class MatchMakerException(Exception):

class Exchange(object):

    def __init__(self):

    def run(self, key):

class Binding(object):

    def __init__(self):

    def test(self, key):

class MatchMakerBase(object):

    def __init__(self):

    def register(self, key, host):

    def ack_alive(self, key, host):

    def is_alive(self, topic, host):

    def expire(self, topic, host):

    def send_heartbeats(self):

    def unregister(self, key, host):

    def start_heartbeat(self):

    def stop_heartbeat(self):

    def add_binding(self, binding, rule, last=True):

    def queues(self, key):

class HeartbeatMatchMakerBase(MatchMakerBase):

    def __init__(self):

    def send_heartbeats(self):

    def ack_alive(self, key, host):

    def backend_register(self, key, host):

    def backend_unregister(self, key, key_host):

    def register(self, key, host):

    def unregister(self, key, host):

    def start_heartbeat(self):

        def do_heartbeat():

    def stop_heartbeat(self):

class DirectBinding(Binding):

    def test(self, key):

class TopicBinding(Binding):

    def test(self, key):

class FanoutBinding(Binding):

    def test(self, key):

class StubExchange(Exchange):

    def run(self, key):

class LocalhostExchange(Exchange):

    def __init__(self, host='localhost'):

    def run(self, key):

class DirectExchange(Exchange):

    def __init__(self):

    def run(self, key):

class MatchMakerLocalhost(MatchMakerBase):

    def __init__(self, host='localhost'):

class MatchMakerStub(MatchMakerBase):

    def __init__(self):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\matchmaker_redis.py

class RedisExchange(mm_common.Exchange):

    def __init__(self, matchmaker):

class RedisTopicExchange(RedisExchange):

    def run(self, topic):

class RedisFanoutExchange(RedisExchange):

    def run(self, topic):

class MatchMakerRedis(mm_common.HeartbeatMatchMakerBase):

    def __init__(self):

    def ack_alive(self, key, host):

    def is_alive(self, topic, host):

    def expire(self, topic, host):

    def backend_register(self, key, key_host):

    def backend_unregister(self, key, key_host):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\matchmaker_ring.py

class RingExchange(mm.Exchange):

    def __init__(self, ring=None):

    def _ring_has(self, key):

class RoundRobinRingExchange(RingExchange):

    def __init__(self, ring=None):

    def run(self, key):

class FanoutRingExchange(RingExchange):

    def __init__(self, ring=None):

    def run(self, key):

class MatchMakerRing(mm.MatchMakerBase):

    def __init__(self, ring=None):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\proxy.py

class RpcProxy(object):

    def __init__(self, topic, default_version, version_cap=None, serializer=None):

    def _set_version(self, msg, vers):

    def _get_topic(self, topic):

    def can_send_version(self, version):

    def make_namespaced_msg(method, namespace, **kwargs):

    def make_msg(self, method, **kwargs):

    def _serialize_msg_args(self, context, kwargs):

    def call(self, context, msg, topic=None, version=None, timeout=None):

    def multicall(self, context, msg, topic=None, version=None, timeout=None):

    def cast(self, context, msg, topic=None, version=None):

    def fanout_cast(self, context, msg, topic=None, version=None):

    def cast_to_server(self, context, server_params, msg, topic=None, version=None):

    def fanout_cast_to_server(self, context, server_params, msg, topic=None, version=None):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\serializer.py

class Serializer(object):

    def serialize_entity(self, context, entity):

    def deserialize_entity(self, context, entity):

class NoOpSerializer(Serializer):

    def serialize_entity(self, context, entity):

    def deserialize_entity(self, context, entity):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\service.py

class Service(service.Service):

    def __init__(self, host, topic, manager=None, serializer=None):

    def start(self):

    def stop(self):

\OpenStack\neutron-2014.1\neutron\openstack\common\rpc\zmq_receiver.py

def main():

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

def set_defaults(control_exchange):

def create_connection(new=True):

def call(context, topic, msg, timeout=None):

def cast(context, topic, msg):

def fanout_cast(context, topic, msg):

def multicall(context, topic, msg, timeout=None):

def notify(context, topic, msg, envelope=False):

def cleanup():

def cast_to_server(context, server_params, topic, msg):

def fanout_cast_to_server(context, server_params, topic, msg):

def queue_get_for(context, topic, host):

def _get_impl():

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

def _sighup_supported():

def _is_daemon():

def _is_sighup_and_daemon(signo):

def _signo_to_signame(signo):

def _set_signals_handler(handler):

class Launcher(object):

    def __init__(self):

    def launch_service(self, service):

    def stop(self):

    def wait(self):

    def restart(self):

class SignalExit(SystemExit):

    def __init__(self, signo, exccode=1):

class ServiceLauncher(Launcher):

    def _handle_signal(self, signo, frame):

    def handle_signal(self):

    def _wait_for_exit_or_signal(self, ready_callback=None):

    def wait(self, ready_callback=None):

class ServiceWrapper(object):

    def __init__(self, service, workers):

class ProcessLauncher(object):

    def __init__(self, wait_interval=0.01):

    def handle_signal(self):

    def _handle_signal(self, signo, frame):

    def _pipe_watcher(self):

    def _child_process_handle_signal(self):

        def _sigterm(*args):

        def _sighup(*args):

    def _child_wait_for_exit_or_signal(self, launcher):

    def _child_process(self, service):

    def _start_child(self, wrap):

    def launch_service(self, service, workers=1):

    def _wait_child(self):

    def _respawn_children(self):

    def wait(self):

class Service(object):

    def __init__(self, threads=1000):

    def reset(self):

    def start(self):

    def stop(self):

    def wait(self):

class Services(object):

    def __init__(self):

    def add(self, service):

    def stop(self):

    def wait(self):

    def restart(self):

    def run_service(service, done):

def launch(service, workers=None):

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

def is_enabled():

def wrap(sock):

def validate_ssl_version(version):

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

def _thread_done(gt, *args, **kwargs):

class Thread(object):

    def __init__(self, thread, group):

    def stop(self):

    def wait(self):

    def link(self, func, *args, **kwargs):

class ThreadGroup(object):

    def __init__(self, thread_pool_size=10):

    def add_dynamic_timer(self, callback, initial_delay=None, periodic_interval_max=None, *args, **kwargs):

    def add_timer(self, interval, callback, initial_delay=None, *args, **kwargs):

    def add_thread(self, callback, *args, **kwargs):

    def thread_done(self, thread):

    def stop(self):

    def wait(self):

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

def isotime(at=None, subsecond=False):

def parse_isotime(timestr):

def strtime(at=None, fmt=PERFECT_TIME_FORMAT):

def parse_strtime(timestr, fmt=PERFECT_TIME_FORMAT):

def normalize_time(timestamp):

def is_older_than(before, seconds):

def is_newer_than(after, seconds):

def utcnow_ts():

def utcnow():

def iso8601_from_timestamp(timestamp):

def set_time_override(override_time=None):

def advance_time_delta(timedelta):

def advance_time_seconds(seconds):

def clear_time_override():

def marshall_now(now=None):

def unmarshall_time(tyme):

def delta_seconds(before, after):

def total_seconds(delta):

def is_soon(dt, window):

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

def generate_uuid():

def is_uuid_like(val):

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

class deprecated(object):

    def __init__(self, as_of, in_favor_of=None, remove_in=2, what=None):

    def __call__(self, func):

        def wrapped(*args, **kwargs):

    def _get_safe_to_remove_release(self, release):

    def _build_message(self):

def is_compatible(requested_version, current_version, same_major=True):

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

class IVSBridge(ovs_lib.OVSBridge):

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

    def get_vif_port_set(self):

    def get_vif_port_by_id(self, port_id):

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

class SecurityGroupAgent(sg_rpc.SecurityGroupAgentRpcMixin):

    def __init__(self, context, plugin_rpc, root_helper):

class RestProxyAgent(sg_rpc.SecurityGroupAgentRpcCallbackMixin):

    def __init__(self, integ_br, polling_interval, root_helper, vs='ovs'):

    def _setup_rpc(self):

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

    def _update_ports(self, registered_ports):

    def _process_devices_filter(self, port_info):

    def daemon_loop(self):

def main():

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

def register_config():

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\db\consistency_db.py

class ConsistencyHash(model_base.BASEV2):

def get_consistency_hash(hash_id='1'):

def put_consistency_hash(hash, hash_id='1'):

\OpenStack\neutron-2014.1\neutron\plugins\bigswitch\db\porttracker_db.py

def get_port_hostid(context, port_id):

def put_port_hostid(context, port_id, host):

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

class InvalidRouterRules(qexception.InvalidInput):

class RulesExhausted(qexception.BadRequest):

def convert_to_valid_router_rules(data):

def _validate_nexthops(nexthops):

def _validate_action(action):

def _validate_uniquerules(rules):

class Routerrule(object):

    def get_name(cls):

    def get_alias(cls):

    def get_description(cls):

    def get_namespace(cls):

    def get_updated(cls):

    def get_extended_resources(self, version):

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

class AgentNotifierApi(rpc.proxy.RpcProxy, sg_rpc.SecurityGroupAgentRpcApiMixin):

    def __init__(self, topic):

    def port_update(self, context, port):

class RestProxyCallbacks(sg_rpc_base.SecurityGroupServerRpcCallbackMixin, dhcp_rpc_base.DhcpRpcCallbackMixin):

    def create_rpc_dispatcher(self):

    def get_port_from_device(self, device):

    def get_port_and_sgs(self, port_id):

class NeutronRestProxyV2Base(db_base_plugin_v2.NeutronDbPluginV2, external_net_db.External_net_db_mixin, routerrule_db.RouterRule_db_mixin):

    def __init__(self, server_timeout=None):

    def _get_all_data(self, get_ports=True, get_floating_ips=True, get_routers=True):

    def _send_all_data(self, send_ports=True, send_floating_ips=True, send_routers=True, timeout=None, triggered_by_tenant=None):

    def _get_network_with_floatingips(self, network, context=None):

    def _get_all_subnets_json_for_network(self, net_id, context=None):

    def _get_mapped_network_with_subnets(self, network, context=None):

    def _send_create_network(self, network, context=None):

    def _send_update_network(self, network, context=None):

    def _send_delete_network(self, network, context=None):

    def _map_state_and_status(self, resource):

    def _warn_on_state_status(self, resource):

    def _get_router_intf_details(self, context, intf_id, subnet_id):

    def _extend_port_dict_binding(self, context, port):

    def _check_hostvif_override(self, hostid):

    def _get_port_net_tenantid(self, context, port):

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

    def _set_port_status(self, port_id, status):

class NeutronRestProxyV2(NeutronRestProxyV2Base, addr_pair_db.AllowedAddressPairsMixin, extradhcpopt_db.ExtraDhcpOptMixin, agentschedulers_db.DhcpAgentSchedulerDbMixin, sg_rpc_base.SecurityGroupServerRpcMixin):

    def supported_extension_aliases(self):

    def __init__(self, server_timeout=None):

    def _setup_rpc(self):

    def create_network(self, context, network):

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

    def delete_network(self, context, net_id):

    def create_port(self, context, port):

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

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

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

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