--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?>
+
+<pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+</pydev_project>
--- /dev/null
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira Neworks, Inc.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+# If ../quantum/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+
+import optparse
+import os
+import re
+import sys
+import time
+
+
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+ os.pardir,
+ os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'quantum', '__init__.py')):
+ sys.path.insert(0, possible_topdir)
+
+
+from quantum.common import wsgi
+from quantum.common import config
+
+def create_options(parser):
+ """
+ Sets up the CLI and config-file options that may be
+ parsed and program commands.
+ :param parser: The option parser
+ """
+ config.add_common_options(parser)
+ config.add_log_options(parser)
+
+
+if __name__ == '__main__':
+ oparser = optparse.OptionParser(version='%%prog VERSION')
+ create_options(oparser)
+ (options, args) = config.parse_options(oparser)
+
+ try:
+ conf, app = config.load_paste_app('quantum', options, args)
+
+ server = wsgi.Server()
+ server.start(app, int(conf['bind_port']), conf['bind_host'])
+ server.wait()
+ except RuntimeError, e:
+ sys.exit("ERROR: %s" % e)
+
--- /dev/null
+[DEFAULT]
+# Show more verbose log output (sets INFO log level output)
+verbose = True
+
+# Show debugging output in logs (sets DEBUG log level output)
+debug = False
+
+[app:quantum]
+paste.app_factory = quantum.service:app_factory
+
+# Address to bind the API server
+bind_host = 0.0.0.0
+
+# Port the bind the API server to
+bind_port = 9696
\ No newline at end of file
--- /dev/null
+[DEFAULT]
+# Show more verbose log output (sets INFO log level output)
+verbose = True
+
+# Show debugging output in logs (sets DEBUG log level output)
+debug = False
+
+[app:quantum]
+paste.app_factory = quantum.l2Network.service:app_factory
+
+# Address to bind the API server
+bind_host = 0.0.0.0
+
+# Port the bind the API server to
+bind_port = 9696
\ No newline at end of file
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+# Copyright 2011 Nicira Networks, Inc.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+# @author: Somik Behera, Nicira Networks, Inc.
\ No newline at end of file
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+# Copyright 2011 Nicira Networks, Inc.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+# @author: Somik Behera, Nicira Networks, Inc.
\ No newline at end of file
--- /dev/null
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira Networks, Inc.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+Routines for configuring Quantum
+"""
+
+import ConfigParser
+import logging
+import logging.config
+import logging.handlers
+import optparse
+import os
+import re
+import sys
+
+from paste import deploy
+
+import quantum.common.exception as exception
+
+DEFAULT_LOG_FORMAT = "%(asctime)s %(levelname)8s [%(name)s] %(message)s"
+DEFAULT_LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+def parse_options(parser, cli_args=None):
+ """
+ Returns the parsed CLI options, command to run and its arguments, merged
+ with any same-named options found in a configuration file.
+
+ The function returns a tuple of (options, args), where options is a
+ mapping of option key/str(value) pairs, and args is the set of arguments
+ (not options) supplied on the command-line.
+
+ The reason that the option values are returned as strings only is that
+ ConfigParser and paste.deploy only accept string values...
+
+ :param parser: The option parser
+ :param cli_args: (Optional) Set of arguments to process. If not present,
+ sys.argv[1:] is used.
+ :retval tuple of (options, args)
+ """
+
+ (options, args) = parser.parse_args(cli_args)
+
+ return (vars(options), args)
+
+
+def add_common_options(parser):
+ """
+ Given a supplied optparse.OptionParser, adds an OptionGroup that
+ represents all common configuration options.
+
+ :param parser: optparse.OptionParser
+ """
+ help_text = "The following configuration options are common to "\
+ "all quantum programs."
+
+ group = optparse.OptionGroup(parser, "Common Options", help_text)
+ group.add_option('-v', '--verbose', default=False, dest="verbose",
+ action="store_true",
+ help="Print more verbose output")
+ group.add_option('-d', '--debug', default=False, dest="debug",
+ action="store_true",
+ help="Print debugging output")
+ group.add_option('--config-file', default=None, metavar="PATH",
+ help="Path to the config file to use. When not specified "
+ "(the default), we generally look at the first "
+ "argument specified to be a config file, and if "
+ "that is also missing, we search standard "
+ "directories for a config file.")
+ parser.add_option_group(group)
+
+
+def add_log_options(parser):
+ """
+ Given a supplied optparse.OptionParser, adds an OptionGroup that
+ represents all the configuration options around logging.
+
+ :param parser: optparse.OptionParser
+ """
+ help_text = "The following configuration options are specific to logging "\
+ "functionality for this program."
+
+ group = optparse.OptionGroup(parser, "Logging Options", help_text)
+ group.add_option('--log-config', default=None, metavar="PATH",
+ help="If this option is specified, the logging "
+ "configuration file specified is used and overrides "
+ "any other logging options specified. Please see "
+ "the Python logging module documentation for "
+ "details on logging configuration files.")
+ group.add_option('--log-date-format', metavar="FORMAT",
+ default=DEFAULT_LOG_DATE_FORMAT,
+ help="Format string for %(asctime)s in log records. "
+ "Default: %default")
+ group.add_option('--log-file', default=None, metavar="PATH",
+ help="(Optional) Name of log file to output to. "
+ "If not set, logging will go to stdout.")
+ group.add_option("--log-dir", default=None,
+ help="(Optional) The directory to keep log files in "
+ "(will be prepended to --logfile)")
+ parser.add_option_group(group)
+
+
+def setup_logging(options, conf):
+ """
+ Sets up the logging options for a log with supplied name
+
+ :param options: Mapping of typed option key/values
+ :param conf: Mapping of untyped key/values from config file
+ """
+
+ if options.get('log_config', None):
+ # Use a logging configuration file for all settings...
+ if os.path.exists(options['log_config']):
+ logging.config.fileConfig(options['log_config'])
+ return
+ else:
+ raise RuntimeError("Unable to locate specified logging "
+ "config file: %s" % options['log_config'])
+
+ # If either the CLI option or the conf value
+ # is True, we set to True
+ debug = options.get('debug') or \
+ get_option(conf, 'debug', type='bool', default=False)
+ verbose = options.get('verbose') or \
+ get_option(conf, 'verbose', type='bool', default=False)
+ root_logger = logging.root
+ if debug:
+ root_logger.setLevel(logging.DEBUG)
+ elif verbose:
+ root_logger.setLevel(logging.INFO)
+ else:
+ root_logger.setLevel(logging.WARNING)
+
+ # Set log configuration from options...
+ # Note that we use a hard-coded log format in the options
+ # because of Paste.Deploy bug #379
+ # http://trac.pythonpaste.org/pythonpaste/ticket/379
+ log_format = options.get('log_format', DEFAULT_LOG_FORMAT)
+ log_date_format = options.get('log_date_format', DEFAULT_LOG_DATE_FORMAT)
+ formatter = logging.Formatter(log_format, log_date_format)
+
+ logfile = options.get('log_file')
+ if not logfile:
+ logfile = conf.get('log_file')
+
+ if logfile:
+ logdir = options.get('log_dir')
+ if not logdir:
+ logdir = conf.get('log_dir')
+ if logdir:
+ logfile = os.path.join(logdir, logfile)
+ logfile = logging.FileHandler(logfile)
+ logfile.setFormatter(formatter)
+ logfile.setFormatter(formatter)
+ root_logger.addHandler(logfile)
+ else:
+ handler = logging.StreamHandler(sys.stdout)
+ handler.setFormatter(formatter)
+ root_logger.addHandler(handler)
+
+
+def find_config_file(options, args):
+ """
+ Return the first config file found.
+
+ We search for the paste config file in the following order:
+ * If --config-file option is used, use that
+ * If args[0] is a file, use that
+ * Search for quantum.conf in standard directories:
+ * .
+ * ~.quantum/
+ * ~
+ * /etc/quantum
+ * /etc
+
+ :retval Full path to config file, or None if no config file found
+ """
+
+ fix_path = lambda p: os.path.abspath(os.path.expanduser(p))
+ if options.get('config_file'):
+ if os.path.exists(options['config_file']):
+ return fix_path(options['config_file'])
+ elif args:
+ if os.path.exists(args[0]):
+ return fix_path(args[0])
+
+ # Handle standard directory search for quantum.conf
+ config_file_dirs = [fix_path(os.getcwd()),
+ fix_path(os.path.join('~', '.quantum')),
+ fix_path('~'),
+ '/etc/quantum/',
+ '/etc']
+
+ for cfg_dir in config_file_dirs:
+ cfg_file = os.path.join(cfg_dir, 'quantum.conf')
+ if os.path.exists(cfg_file):
+ return cfg_file
+
+
+def load_paste_config(app_name, options, args):
+ """
+ Looks for a config file to use for an app and returns the
+ config file path and a configuration mapping from a paste config file.
+
+ We search for the paste config file in the following order:
+ * If --config-file option is used, use that
+ * If args[0] is a file, use that
+ * Search for quantum.conf in standard directories:
+ * .
+ * ~.quantum/
+ * ~
+ * /etc/quantum
+ * /etc
+
+ :param app_name: Name of the application to load config for, or None.
+ None signifies to only load the [DEFAULT] section of
+ the config file.
+ :param options: Set of typed options returned from parse_options()
+ :param args: Command line arguments from argv[1:]
+ :retval Tuple of (conf_file, conf)
+
+ :raises RuntimeError when config file cannot be located or there was a
+ problem loading the configuration file.
+ """
+ conf_file = find_config_file(options, args)
+ if not conf_file:
+ raise RuntimeError("Unable to locate any configuration file. "
+ "Cannot load application %s" % app_name)
+ try:
+ conf = deploy.appconfig("config:%s" % conf_file, name=app_name)
+ return conf_file, conf
+ except Exception, e:
+ raise RuntimeError("Error trying to load config %s: %s"
+ % (conf_file, e))
+
+
+def load_paste_app(app_name, options, args):
+ """
+ Builds and returns a WSGI app from a paste config file.
+
+ We search for the paste config file in the following order:
+ * If --config-file option is used, use that
+ * If args[0] is a file, use that
+ * Search for quantum.conf in standard directories:
+ * .
+ * ~.quantum/
+ * ~
+ * /etc/quantum
+ * /etc
+
+ :param app_name: Name of the application to load
+ :param options: Set of typed options returned from parse_options()
+ :param args: Command line arguments from argv[1:]
+
+ :raises RuntimeError when config file cannot be located or application
+ cannot be loaded from config file
+ """
+ conf_file, conf = load_paste_config(app_name, options, args)
+
+ try:
+ # Setup logging early, supplying both the CLI options and the
+ # configuration mapping from the config file
+ setup_logging(options, conf)
+
+ # We only update the conf dict for the verbose and debug
+ # flags. Everything else must be set up in the conf file...
+ debug = options.get('debug') or \
+ get_option(conf, 'debug', type='bool', default=False)
+ verbose = options.get('verbose') or \
+ get_option(conf, 'verbose', type='bool', default=False)
+ conf['debug'] = debug
+ conf['verbose'] = verbose
+
+ # Log the options used when starting if we're in debug mode...
+ if debug:
+ logger = logging.getLogger(app_name)
+ logger.debug("*" * 80)
+ logger.debug("Configuration options gathered from config file:")
+ logger.debug(conf_file)
+ logger.debug("================================================")
+ items = dict([(k, v) for k, v in conf.items()
+ if k not in ('__file__', 'here')])
+ for key, value in sorted(items.items()):
+ logger.debug("%(key)-30s %(value)s" % locals())
+ logger.debug("*" * 80)
+ app = deploy.loadapp("config:%s" % conf_file, name=app_name)
+ except (LookupError, ImportError), e:
+ raise RuntimeError("Unable to load %(app_name)s from "
+ "configuration file %(conf_file)s."
+ "\nGot: %(e)r" % locals())
+ return conf, app
+
+
+def get_option(options, option, **kwargs):
+ if option in options:
+ value = options[option]
+ type_ = kwargs.get('type', 'str')
+ if type_ == 'bool':
+ if hasattr(value, 'lower'):
+ return value.lower() == 'true'
+ else:
+ return value
+ elif type_ == 'int':
+ return int(value)
+ elif type_ == 'float':
+ return float(value)
+ else:
+ return value
+ elif 'default' in kwargs:
+ return kwargs['default']
+ else:
+ raise KeyError("option '%s' not found" % option)
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira Networks, Inc
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+Quantum base exception handling, including decorator for re-raising
+Quantum-type exceptions. SHOULD include dedicated exception logging.
+"""
+
+import logging
+import sys
+import traceback
+
+
+class ProcessExecutionError(IOError):
+ def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None,
+ description=None):
+ if description is None:
+ description = "Unexpected error while running command."
+ if exit_code is None:
+ exit_code = '-'
+ message = "%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r" % (
+ description, cmd, exit_code, stdout, stderr)
+ IOError.__init__(self, message)
+
+
+class Error(Exception):
+ def __init__(self, message=None):
+ super(Error, self).__init__(message)
+
+
+class ApiError(Error):
+ def __init__(self, message='Unknown', code='Unknown'):
+ self.message = message
+ self.code = code
+ super(ApiError, self).__init__('%s: %s' % (code, message))
+
+
+class NotFound(Error):
+ pass
+
+
+class Duplicate(Error):
+ pass
+
+
+class NotAuthorized(Error):
+ pass
+
+
+class NotEmpty(Error):
+ pass
+
+
+class Invalid(Error):
+ pass
+
+
+class BadInputError(Exception):
+ """Error resulting from a client sending bad input to a server"""
+ pass
+
+
+class MissingArgumentError(Error):
+ pass
+
+
+def wrap_exception(f):
+ def _wrap(*args, **kw):
+ try:
+ return f(*args, **kw)
+ except Exception, e:
+ if not isinstance(e, Error):
+ #exc_type, exc_value, exc_traceback = sys.exc_info()
+ logging.exception('Uncaught exception')
+ #logging.error(traceback.extract_stack(exc_traceback))
+ raise Error(str(e))
+ raise
+ _wrap.func_name = f.func_name
+ return _wrap
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira Networks, Inc
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+System-level utilities and helper functions.
+"""
+
+import datetime
+import inspect
+import logging
+import os
+import random
+import subprocess
+import socket
+import sys
+
+from quantum.common import exception
+from quantum.common.exception import ProcessExecutionError
+
+
+TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
+
+def int_from_bool_as_string(subject):
+ """
+ Interpret a string as a boolean and return either 1 or 0.
+
+ Any string value in:
+ ('True', 'true', 'On', 'on', '1')
+ is interpreted as a boolean True.
+
+ Useful for JSON-decoded stuff and config file parsing
+ """
+ return bool_from_string(subject) and 1 or 0
+
+
+def bool_from_string(subject):
+ """
+ Interpret a string as a boolean.
+
+ Any string value in:
+ ('True', 'true', 'On', 'on', '1')
+ is interpreted as a boolean True.
+
+ Useful for JSON-decoded stuff and config file parsing
+ """
+ if type(subject) == type(bool):
+ return subject
+ if hasattr(subject, 'startswith'): # str or unicode...
+ if subject.strip().lower() in ('true', 'on', '1'):
+ return True
+ return False
+
+
+def import_class(import_str):
+ """Returns a class from a string including module and class"""
+ mod_str, _sep, class_str = import_str.rpartition('.')
+ try:
+ __import__(mod_str)
+ return getattr(sys.modules[mod_str], class_str)
+ except (ImportError, ValueError, AttributeError):
+ raise exception.NotFound('Class %s cannot be found' % class_str)
+
+
+def import_object(import_str):
+ """Returns an object including a module or module and class"""
+ try:
+ __import__(import_str)
+ return sys.modules[import_str]
+ except ImportError:
+ cls = import_class(import_str)
+ return cls()
+
+
+def fetchfile(url, target):
+ logging.debug("Fetching %s" % url)
+# c = pycurl.Curl()
+# fp = open(target, "wb")
+# c.setopt(c.URL, url)
+# c.setopt(c.WRITEDATA, fp)
+# c.perform()
+# c.close()
+# fp.close()
+ execute("curl --fail %s -o %s" % (url, target))
+
+
+def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
+ logging.debug("Running cmd: %s", cmd)
+ env = os.environ.copy()
+ if addl_env:
+ env.update(addl_env)
+ obj = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
+ result = None
+ if process_input != None:
+ result = obj.communicate(process_input)
+ else:
+ result = obj.communicate()
+ obj.stdin.close()
+ if obj.returncode:
+ logging.debug("Result was %s" % (obj.returncode))
+ if check_exit_code and obj.returncode != 0:
+ (stdout, stderr) = result
+ raise ProcessExecutionError(exit_code=obj.returncode,
+ stdout=stdout,
+ stderr=stderr,
+ cmd=cmd)
+ return result
+
+
+def abspath(s):
+ return os.path.join(os.path.dirname(__file__), s)
+
+
+# TODO(sirp): when/if utils is extracted to common library, we should remove
+# the argument's default.
+#def default_flagfile(filename='nova.conf'):
+def default_flagfile(filename='quantum.conf'):
+ for arg in sys.argv:
+ if arg.find('flagfile') != -1:
+ break
+ else:
+ if not os.path.isabs(filename):
+ # turn relative filename into an absolute path
+ script_dir = os.path.dirname(inspect.stack()[-1][1])
+ filename = os.path.abspath(os.path.join(script_dir, filename))
+ if os.path.exists(filename):
+ sys.argv = \
+ sys.argv[:1] + ['--flagfile=%s' % filename] + sys.argv[1:]
+
+
+def debug(arg):
+ logging.debug('debug in callback: %s', arg)
+ return arg
+
+
+def runthis(prompt, cmd, check_exit_code=True):
+ logging.debug("Running %s" % (cmd))
+ exit_code = subprocess.call(cmd.split(" "))
+ logging.debug(prompt % (exit_code))
+ if check_exit_code and exit_code != 0:
+ raise ProcessExecutionError(exit_code=exit_code,
+ stdout=None,
+ stderr=None,
+ cmd=cmd)
+
+
+def generate_uid(topic, size=8):
+ return '%s-%s' % (topic, ''.join(
+ [random.choice('01234567890abcdefghijklmnopqrstuvwxyz')
+ for x in xrange(size)]))
+
+
+def generate_mac():
+ mac = [0x02, 0x16, 0x3e, random.randint(0x00, 0x7f),
+ random.randint(0x00, 0xff), random.randint(0x00, 0xff)]
+ return ':'.join(map(lambda x: "%02x" % x, mac))
+
+
+def last_octet(address):
+ return int(address.split(".")[-1])
+
+
+def isotime(at=None):
+ if not at:
+ at = datetime.datetime.utcnow()
+ return at.strftime(TIME_FORMAT)
+
+
+def parse_isotime(timestr):
+ return datetime.datetime.strptime(timestr, TIME_FORMAT)
+
+
+class LazyPluggable(object):
+ """A pluggable backend loaded lazily based on some value."""
+
+ def __init__(self, pivot, **backends):
+ self.__backends = backends
+ self.__pivot = pivot
+ self.__backend = None
+
+ def __get_backend(self):
+ if not self.__backend:
+ backend_name = self.__pivot.value
+ if backend_name not in self.__backends:
+ raise exception.Error('Invalid backend: %s' % backend_name)
+
+ backend = self.__backends[backend_name]
+ if type(backend) == type(tuple()):
+ name = backend[0]
+ fromlist = backend[1]
+ else:
+ name = backend
+ fromlist = backend
+
+ self.__backend = __import__(name, None, None, fromlist)
+ logging.info('backend %s', self.__backend)
+ return self.__backend
+
+ def __getattr__(self, key):
+ backend = self.__get_backend()
+ return getattr(backend, key)
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2011, Nicira Networks, Inc.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+Utility methods for working with WSGI servers
+"""
+
+import json
+import logging
+import sys
+import datetime
+
+import eventlet
+import eventlet.wsgi
+eventlet.patcher.monkey_patch(all=False, socket=True)
+import routes
+import routes.middleware
+import webob.dec
+import webob.exc
+
+
+class WritableLogger(object):
+ """A thin wrapper that responds to `write` and logs."""
+
+ def __init__(self, logger, level=logging.DEBUG):
+ self.logger = logger
+ self.level = level
+
+ def write(self, msg):
+ self.logger.log(self.level, msg.strip("\n"))
+
+
+def run_server(application, port):
+ """Run a WSGI server with the given application."""
+ sock = eventlet.listen(('0.0.0.0', port))
+ eventlet.wsgi.server(sock, application)
+
+
+class Server(object):
+ """Server class to manage multiple WSGI sockets and applications."""
+
+ def __init__(self, threads=1000):
+ self.pool = eventlet.GreenPool(threads)
+
+ def start(self, application, port, host='0.0.0.0', backlog=128):
+ """Run a WSGI server with the given application."""
+ socket = eventlet.listen((host, port), backlog=backlog)
+ self.pool.spawn_n(self._run, application, socket)
+
+ def wait(self):
+ """Wait until all servers have completed running."""
+ try:
+ self.pool.waitall()
+ except KeyboardInterrupt:
+ pass
+
+ def _run(self, application, socket):
+ """Start a WSGI server in a new green thread."""
+ logger = logging.getLogger('eventlet.wsgi.server')
+ eventlet.wsgi.server(socket, application, custom_pool=self.pool,
+ log=WritableLogger(logger))
+
+
+class Middleware(object):
+ """
+ Base WSGI middleware wrapper. These classes require an application to be
+ initialized that will be called next. By default the middleware will
+ simply call its wrapped app, or you can override __call__ to customize its
+ behavior.
+ """
+
+ def __init__(self, application):
+ self.application = application
+
+ def process_request(self, req):
+ """
+ Called on each request.
+
+ If this returns None, the next application down the stack will be
+ executed. If it returns a response then that response will be returned
+ and execution will stop here.
+
+ """
+ return None
+
+ def process_response(self, response):
+ """Do whatever you'd like to the response."""
+ return response
+
+ @webob.dec.wsgify
+ def __call__(self, req):
+ response = self.process_request(req)
+ if response:
+ return response
+ response = req.get_response(self.application)
+ return self.process_response(response)
+
+
+class Debug(Middleware):
+ """
+ Helper class that can be inserted into any WSGI application chain
+ to get information about the request and response.
+ """
+
+ @webob.dec.wsgify
+ def __call__(self, req):
+ print ("*" * 40) + " REQUEST ENVIRON"
+ for key, value in req.environ.items():
+ print key, "=", value
+ print
+ resp = req.get_response(self.application)
+
+ print ("*" * 40) + " RESPONSE HEADERS"
+ for (key, value) in resp.headers.iteritems():
+ print key, "=", value
+ print
+
+ resp.app_iter = self.print_generator(resp.app_iter)
+
+ return resp
+
+ @staticmethod
+ def print_generator(app_iter):
+ """
+ Iterator that prints the contents of a wrapper string iterator
+ when iterated.
+ """
+ print ("*" * 40) + " BODY"
+ for part in app_iter:
+ sys.stdout.write(part)
+ sys.stdout.flush()
+ yield part
+ print
+
+
+class Router(object):
+ """
+ WSGI middleware that maps incoming requests to WSGI apps.
+ """
+
+ def __init__(self, mapper):
+ """
+ Create a router for the given routes.Mapper.
+
+ Each route in `mapper` must specify a 'controller', which is a
+ WSGI app to call. You'll probably want to specify an 'action' as
+ well and have your controller be a wsgi.Controller, who will route
+ the request to the action method.
+
+ Examples:
+ mapper = routes.Mapper()
+ sc = ServerController()
+
+ # Explicit mapping of one route to a controller+action
+ mapper.connect(None, "/svrlist", controller=sc, action="list")
+
+ # Actions are all implicitly defined
+ mapper.resource("server", "servers", controller=sc)
+
+ # Pointing to an arbitrary WSGI app. You can specify the
+ # {path_info:.*} parameter so the target app can be handed just that
+ # section of the URL.
+ mapper.connect(None, "/v1.0/{path_info:.*}", controller=BlogApp())
+ """
+ self.map = mapper
+ self._router = routes.middleware.RoutesMiddleware(self._dispatch,
+ self.map)
+
+ @webob.dec.wsgify
+ def __call__(self, req):
+ """
+ Route the incoming request to a controller based on self.map.
+ If no match, return a 404.
+ """
+ return self._router
+
+ @staticmethod
+ @webob.dec.wsgify
+ def _dispatch(req):
+ """
+ Called by self._router after matching the incoming request to a route
+ and putting the information into req.environ. Either returns 404
+ or the routed WSGI app's response.
+ """
+ match = req.environ['wsgiorg.routing_args'][1]
+ if not match:
+ return webob.exc.HTTPNotFound()
+ app = match['controller']
+ return app
+
+
+class Controller(object):
+ """
+ WSGI app that reads routing information supplied by RoutesMiddleware
+ and calls the requested action method upon itself. All action methods
+ must, in addition to their normal parameters, accept a 'req' argument
+ which is the incoming webob.Request. They raise a webob.exc exception,
+ or return a dict which will be serialized by requested content type.
+ """
+
+ @webob.dec.wsgify
+ def __call__(self, req):
+ """
+ Call the method specified in req.environ by RoutesMiddleware.
+ """
+ arg_dict = req.environ['wsgiorg.routing_args'][1]
+ action = arg_dict['action']
+ method = getattr(self, action)
+ del arg_dict['controller']
+ del arg_dict['action']
+ arg_dict['request'] = req
+ result = method(**arg_dict)
+ if type(result) is dict:
+ return self._serialize(result, req)
+ else:
+ return result
+
+ def _serialize(self, data, request):
+ """
+ Serialize the given dict to the response type requested in request.
+ Uses self._serialization_metadata if it exists, which is a dict mapping
+ MIME types to information needed to serialize to that type.
+ """
+ _metadata = getattr(type(self), "_serialization_metadata", {})
+ serializer = Serializer(request.environ, _metadata)
+ return serializer.to_content_type(data)
+
+
+class Serializer(object):
+ """
+ Serializes a dictionary to a Content Type specified by a WSGI environment.
+ """
+
+ def __init__(self, environ, metadata=None):
+ """
+ Create a serializer based on the given WSGI environment.
+ 'metadata' is an optional dict mapping MIME types to information
+ needed to serialize a dictionary to that type.
+ """
+ self.environ = environ
+ self.metadata = metadata or {}
+ self._methods = {
+ 'application/json': self._to_json,
+ 'application/xml': self._to_xml}
+
+ def to_content_type(self, data):
+ """
+ Serialize a dictionary into a string. The format of the string
+ will be decided based on the Content Type requested in self.environ:
+ by Accept: header, or by URL suffix.
+ """
+ # FIXME(sirp): for now, supporting json only
+ #mimetype = 'application/xml'
+ mimetype = 'application/json'
+ # TODO(gundlach): determine mimetype from request
+ return self._methods.get(mimetype, repr)(data)
+
+ def _to_json(self, data):
+ def sanitizer(obj):
+ if isinstance(obj, datetime.datetime):
+ return obj.isoformat()
+ return obj
+
+ return json.dumps(data, default=sanitizer)
+
+ def _to_xml(self, data):
+ metadata = self.metadata.get('application/xml', {})
+ # We expect data to contain a single key which is the XML root.
+ root_key = data.keys()[0]
+ from xml.dom import minidom
+ doc = minidom.Document()
+ node = self._to_xml_node(doc, metadata, root_key, data[root_key])
+ return node.toprettyxml(indent=' ')
+
+ def _to_xml_node(self, doc, metadata, nodename, data):
+ """Recursive method to convert data members to XML nodes."""
+ result = doc.createElement(nodename)
+ if type(data) is list:
+ singular = metadata.get('plurals', {}).get(nodename, None)
+ if singular is None:
+ if nodename.endswith('s'):
+ singular = nodename[:-1]
+ else:
+ singular = 'item'
+ for item in data:
+ node = self._to_xml_node(doc, metadata, singular, item)
+ result.appendChild(node)
+ elif type(data) is dict:
+ attrs = metadata.get('attributes', {}).get(nodename, {})
+ for k, v in data.items():
+ if k in attrs:
+ result.setAttribute(k, str(v))
+ else:
+ node = self._to_xml_node(doc, metadata, k, v)
+ result.appendChild(node)
+ else: # atom
+ node = doc.createTextNode(str(data))
+ result.appendChild(node)
+ return result
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira Networks, Inc
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""
+Manager is responsible for parsing a config file and instantiating the correct
+set of plugins that concretely implement quantum_plugin_base class
+"""
\ No newline at end of file
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+# Copyright 2011 Nicira Networks, Inc.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+# @author: Somik Behera, Nicira Networks, Inc.
+
+"""
+Quantum Plug-in API specification.
+
+QuantumPluginBase provides the definition of minimum set of
+methods that needs to be implemented by a Quantum Plug-in.
+"""
+
+from abc import ABCMeta, abstractmethod
+
+class QuantumPluginBase(object):
+
+ __metaclass__ = ABCMeta
+
+ @abstractmethod
+ def get_all_networks(self, tenant_id):
+ """
+ Returns a dictionary containing all
+ <network_uuid, network_name> for
+ the specified tenant.
+ """
+ pass
+
+ @abstractmethod
+ def create_network(self, tenant_id, net_name):
+ """
+ Creates a new Virtual Network, and assigns it
+ a symbolic name.
+ """
+ pass
+
+ @abstractmethod
+ def delete_network(self, tenant_id, net_id):
+ """
+ Deletes the network with the specified network identifier
+ belonging to the specified tenant.
+ """
+ pass
+
+ @abstractmethod
+ def get_network_details(self, tenant_id, net_id):
+ """
+ Deletes the Virtual Network belonging to a the
+ spec
+ """
+ pass
+
+ @abstractmethod
+ def rename_network(self, tenant_id, net_id, new_name):
+ """
+ Updates the symbolic name belonging to a particular
+ Virtual Network.
+ """
+ pass
+
+ @abstractmethod
+ def get_all_ports(self, tenant_id, net_id):
+ """
+ Retrieves all port identifiers belonging to the
+ specified Virtual Network.
+ """
+ pass
+
+ @abstractmethod
+ def create_port(self, tenant_id, net_id):
+ """
+ Creates a port on the specified Virtual Network.
+ """
+ pass
+
+ @abstractmethod
+ def delete_port(self, tenant_id, net_id, port_id):
+ """
+ Deletes a port on a specified Virtual Network,
+ if the port contains a remote interface attachment,
+ the remote interface is first un-plugged and then the port
+ is deleted.
+ """
+ pass
+
+ @abstractmethod
+ def get_port_details(self, tenant_id, net_id, port_id):
+ """
+ This method allows the user to retrieve a remote interface
+ that is attached to this particular port.
+ """
+ pass
+
+ @abstractmethod
+ def plug_interface(self, tenant_id, net_id, port_id, remote_interface_id):
+ """
+ Attaches a remote interface to the specified port on the
+ specified Virtual Network.
+ """
+ pass
+
+ @abstractmethod
+ def unplug_interface(self, tenant_id, net_id, port_id):
+ """
+ Detaches a remote interface from the specified port on the
+ specified Virtual Network.
+ """
+ pass
+
+ @abstractmethod
+ def get_interface_details(self, tenant_id, net_id, port_id):
+ """
+ Retrieves the remote interface that is attached at this
+ particular port.
+ """
+ pass
+
+ @abstractmethod
+ def get_all_attached_interfaces(self, tenant_id, net_id):
+ """
+ Retrieves all remote interfaces that are attached to
+ a particular Virtual Network.
+ """
+ pass
\ No newline at end of file
--- /dev/null
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Nicira Networks, Inc
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import json
+import routes
+from webob import Response
+
+from common import wsgi
+
+class NetworkController(wsgi.Controller):
+
+ def version(self,request):
+ return "Quantum version 0.1"
+
+class API(wsgi.Router):
+ def __init__(self, options):
+ self.options = options
+ mapper = routes.Mapper()
+ network_controller = NetworkController()
+ mapper.resource("net_controller", "/network", controller=network_controller)
+ mapper.connect("/", controller=network_controller, action="version")
+ super(API, self).__init__(mapper)
+
+def app_factory(global_conf, **local_conf):
+ conf = global_conf.copy()
+ conf.update(local_conf)
+ return API(conf)
Code Review / openstack-build / neutron-build.git / commitdiff