cfg.IntOpt('backlog',

default=4096,

help="Number of backlog requests to configure the socket with"),

cfg.IntOpt('tcp_keepidle',

default=600,

help="Sets the value of TCP_KEEPIDLE in seconds for each "

"server socket. Not supported on OS X."),

"""

def __init__(self, application, port,

host='0.0.0.0', backlog=4096, threads=1000):

self.application = application

self._port = port

self._host = host

self._backlog = backlog if backlog else CONF.backlog

super(Service, self).__init__(threads)

def _get_socket(self, host, port, backlog):

# TODO(dims): eventlet's green dns/socket module does not actually

# support IPv6 in getaddrinfo(). We need to get around this in the

# future or monitor upstream for a fix

info = socket.getaddrinfo(host,

port,

socket.AF_UNSPEC,

socket.SOCK_STREAM)[0]

family = info[0]

bind_addr = info[-1]

sock = None

retry_until = time.time() + 30

while not sock and time.time() < retry_until:

try:

sock = eventlet.listen(bind_addr,

backlog=backlog,

family=family)

if sslutils.is_enabled():

sock = sslutils.wrap(sock)

except socket.error, err:

if err.args[0] != errno.EADDRINUSE:

raise

eventlet.sleep(0.1)

if not sock:

raise RuntimeError(_("Could not bind to %(host)s:%(port)s "

"after trying for 30 seconds") %

{'host': host, 'port': port})

sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# sockets can hang around forever without keepalive

sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)

# This option isn't available in the OS X version of eventlet

if hasattr(socket, 'TCP_KEEPIDLE'):

sock.setsockopt(socket.IPPROTO_TCP,

socket.TCP_KEEPIDLE,

CONF.tcp_keepidle)

return sock

def start(self):

"""Start serving this service using the provided server instance.

super(Service, self).start()

self._socket = self._get_socket(self._host, self._port, self._backlog)

self.tg.add_thread(self._run, self.application, self._socket)

@property

def backlog(self):

return self._backlog

@property

def host(self):

return self._socket.getsockname()[0] if self._socket else self._host

@property

def port(self):

return self._socket.getsockname()[1] if self._socket else self._port

def stop(self):

"""Stop serving this API.

super(Service, self).stop()

def _run(self, application, socket):

"""Start a WSGI server in a new green thread."""

logger = logging.getLogger('eventlet.wsgi')

eventlet.wsgi.server(socket,

application,

custom_pool=self.tg.pool,

"""

def __init__(self, application):

self.application = application

def process_request(self, req):

"""

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)

"""

@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):

"""

print ("*" * 40) + " BODY"

for part in app_iter:

sys.stdout.write(part)

sys.stdout.flush()

yield part

"""

def __init__(self, mapper):

"""

self.map = mapper

self._router = routes.middleware.RoutesMiddleware(self._dispatch,

self.map)

@webob.dec.wsgify

def __call__(self, req):

"""

return self._router

@staticmethod

@webob.dec.wsgify

def _dispatch(req):

"""

match = req.environ['wsgiorg.routing_args'][1]

if not match:

return webob.exc.HTTPNotFound()

app = match['controller']

"""Add some Openstack API-specific logic to the base webob.Request."""

default_request_content_types = ('application/json', 'application/xml')

default_accept_types = ('application/json', 'application/xml')

default_accept_type = 'application/json'

def best_match_content_type(self, supported_content_types=None):

"""Determine the requested response content-type.

supported_content_types = (supported_content_types or

self.default_accept_types)

parts = self.path.rsplit('.', 1)

if len(parts) > 1:

ctype = 'application/{0}'.format(parts[1])

if ctype in supported_content_types:

return ctype

bm = self.accept.best_match(supported_content_types)

return bm or self.default_accept_type

def get_content_type(self, allowed_content_types=None):

"""Determine content type of the request body.

if "Content-Type" not in self.headers:

return None

content_type = self.content_type

allowed_content_types = (allowed_content_types or

self.default_request_content_types)

if content_type not in allowed_content_types:

raise exception.InvalidContentType(content_type=content_type)

"""

def __init__(self, controller, deserializer=None, serializer=None):

"""

self.controller = controller

self.serializer = serializer or ResponseSerializer()

self.deserializer = deserializer or RequestDeserializer()

@webob.dec.wsgify(RequestClass=Request)

def __call__(self, request):

"""WSGI method that controls (de)serialization and method dispatch."""

try:

action, action_args, accept = self.deserialize_request(request)

except exception.InvalidContentType:

msg = _("Unsupported Content-Type")

return webob.exc.HTTPUnsupportedMediaType(explanation=msg)

except exception.MalformedRequestBody:

msg = _("Malformed request body")

return webob.exc.HTTPBadRequest(explanation=msg)

action_result = self.execute_action(action, request, **action_args)

try:

return self.serialize_response(action, action_result, accept)

# return unserializable result (typically a webob exc)

except Exception:

return action_result

def deserialize_request(self, request):

return self.deserializer.deserialize(request)

def serialize_response(self, action, action_result, accept):

return self.serializer.serialize(action_result, accept, action)

def execute_action(self, action, request, **action_args):

return self.dispatch(self.controller, action, request, **action_args)

def dispatch(self, obj, action, *args, **kwargs):

"""Find action-specific method on self and call it."""

try:

method = getattr(obj, action)

except AttributeError:

method = getattr(obj, 'default')

return method(*args, **kwargs)

def get_action_args(self, request_environment):

"""Parse dictionary created by routes library."""

try:

args = request_environment['wsgiorg.routing_args'][1].copy()

except Exception:

return {}

try:

del args['controller']

except KeyError:

pass

try:

del args['format']

except KeyError:

pass

"""Maps method name to local methods through action name."""

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

"""Find and call local method."""

action = kwargs.pop('action', 'default')

action_method = getattr(self, str(action), self.default)

return action_method(*args, **kwargs)

def default(self, data):

"""Default request body serialization"""

def serialize(self, data, action='default'):

return self.dispatch(data, action=action)

def default(self, data):

"""Default JSON request body serialization"""

def default(self, data):

def sanitizer(obj):

if isinstance(obj, datetime.datetime):

_dtime = obj - datetime.timedelta(microseconds=obj.microsecond)

return _dtime.isoformat()

return unicode(obj)

def __init__(self, metadata=None, xmlns=None):

"""

super(XMLDictSerializer, self).__init__()

self.metadata = metadata or {}

self.xmlns = xmlns

def default(self, data):

# We expect data to contain a single key which is the XML root.

root_key = data.keys()[0]

doc = minidom.Document()

node = self._to_xml_node(doc, self.metadata, root_key, data[root_key])

return self.to_xml_string(node)

def to_xml_string(self, node, has_atom=False):

self._add_xmlns(node, has_atom)

return node.toprettyxml(indent=' ', encoding='UTF-8')

#NOTE (ameade): the has_atom should be removed after all of the

# xml serializers and view builders have been updated to the current

# spec that required all responses include the xmlns:atom, the has_atom

# flag is to prevent current tests from breaking

def _add_xmlns(self, node, has_atom=False):

if self.xmlns is not None:

node.setAttribute('xmlns', self.xmlns)

if has_atom:

node.setAttribute('xmlns:atom', "http://www.w3.org/2005/Atom")

def _to_xml_node(self, doc, metadata, nodename, data):

"""Recursive method to convert data members to XML nodes."""

result = doc.createElement(nodename)

# Set the xml namespace if one is specified

# TODO(justinsb): We could also use prefixes on the keys

xmlns = metadata.get('xmlns', None)

if xmlns:

result.setAttribute('xmlns', xmlns)

#TODO(bcwaldon): accomplish this without a type-check

if type(data) is list:

collections = metadata.get('list_collections', {})

if nodename in collections:

metadata = collections[nodename]

for item in data:

node = doc.createElement(metadata['item_name'])

node.setAttribute(metadata['item_key'], str(item))

result.appendChild(node)

return result

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)

#TODO(bcwaldon): accomplish this without a type-check

elif type(data) is dict:

collections = metadata.get('dict_collections', {})

if nodename in collections:

metadata = collections[nodename]

for k, v in data.items():

node = doc.createElement(metadata['item_name'])

node.setAttribute(metadata['item_key'], str(k))

text = doc.createTextNode(str(v))

node.appendChild(text)

result.appendChild(node)

return result

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:

# Type is atom

node = doc.createTextNode(str(data))

result.appendChild(node)

return result

def _create_link_nodes(self, xml_doc, links):

link_nodes = []

for link in links:

link_node = xml_doc.createElement('atom:link')

link_node.setAttribute('rel', link['rel'])

link_node.setAttribute('href', link['href'])

if 'type' in link:

link_node.setAttribute('type', link['type'])

link_nodes.append(link_node)

"""Default response headers serialization"""

def serialize(self, response, data, action):

self.dispatch(response, data, action=action)

def default(self, response, data):

"""Encode the necessary pieces into a response object"""

def __init__(self, body_serializers=None, headers_serializer=None):

self.body_serializers = {

'application/xml': XMLDictSerializer(),

'application/json': JSONDictSerializer(),

}

self.body_serializers.update(body_serializers or {})

self.headers_serializer = (headers_serializer or

ResponseHeadersSerializer())

def serialize(self, response_data, content_type, action='default'):

"""Serialize a dict into a string and wrap in a wsgi.Request object.

response = webob.Response()

self.serialize_headers(response, response_data, action)

self.serialize_body(response, response_data, content_type, action)

return response

def serialize_headers(self, response, data, action):

self.headers_serializer.serialize(response, data, action)

def serialize_body(self, response, data, content_type, action):

response.headers['Content-Type'] = content_type

if data is not None:

serializer = self.get_body_serializer(content_type)

response.body = serializer.serialize(data, action)

def get_body_serializer(self, content_type):

try:

return self.body_serializers[content_type]

except (KeyError, TypeError):

"""Default request headers deserializer"""

def deserialize(self, request, action):

return self.dispatch(request, action=action)

def default(self, request):

"""Break up a Request object into more useful pieces."""

def __init__(self, body_deserializers=None, headers_deserializer=None,

supported_content_types=None):

self.supported_content_types = supported_content_types

self.body_deserializers = {

'application/xml': XMLDeserializer(),

'application/json': JSONDeserializer(),

}

self.body_deserializers.update(body_deserializers or {})

self.headers_deserializer = (headers_deserializer or

RequestHeadersDeserializer())

def deserialize(self, request):

"""Extract necessary pieces of the request.

action_args = self.get_action_args(request.environ)

action = action_args.pop('action', None)

action_args.update(self.deserialize_headers(request, action))

action_args.update(self.deserialize_body(request, action))

accept = self.get_expected_content_type(request)

return (action, action_args, accept)

def deserialize_headers(self, request, action):

return self.headers_deserializer.deserialize(request, action)

def deserialize_body(self, request, action):

if not len(request.body) > 0:

LOG.debug(_("Empty body provided in request"))

return {}

try:

content_type = request.get_content_type()

except exception.InvalidContentType:

LOG.debug(_("Unrecognized Content-Type provided in request"))

raise

if content_type is None:

LOG.debug(_("No Content-Type provided in request"))

return {}

try:

deserializer = self.get_body_deserializer(content_type)

except exception.InvalidContentType:

LOG.debug(_("Unable to deserialize body as provided Content-Type"))

raise

return deserializer.deserialize(request.body, action)

def get_body_deserializer(self, content_type):

try:

return self.body_deserializers[content_type]

except (KeyError, TypeError):

raise exception.InvalidContentType(content_type=content_type)

def get_expected_content_type(self, request):

return request.best_match_content_type(self.supported_content_types)

def get_action_args(self, request_environment):

"""Parse dictionary created by routes library."""

try:

args = request_environment['wsgiorg.routing_args'][1].copy()

except Exception:

return {}

try:

del args['controller']

except KeyError:

pass

try:

del args['format']

except KeyError:

pass

"""Default request body deserialization"""

def deserialize(self, datastring, action='default'):

return self.dispatch(datastring, action=action)

def default(self, datastring):

def _from_json(self, datastring):

try:

return jsonutils.loads(datastring)

except ValueError:

msg = _("cannot understand JSON")

raise exception.MalformedRequestBody(reason=msg)

def default(self, datastring):

def __init__(self, metadata=None):

"""

super(XMLDeserializer, self).__init__()

self.metadata = metadata or {}

def _from_xml(self, datastring):

plurals = set(self.metadata.get('plurals', {}))

try:

node = xmlutils.safe_minidom_parse_string(datastring).childNodes[0]

return {node.nodeName: self._from_xml_node(node, plurals)}

except expat.ExpatError:

msg = _("cannot understand XML")

raise exception.MalformedRequestBody(reason=msg)

def _from_xml_node(self, node, listnames):

"""Convert a minidom node to a simple Python type.

if len(node.childNodes) == 1 and node.childNodes[0].nodeType == 3:

return node.childNodes[0].nodeValue

elif node.nodeName in listnames:

return [self._from_xml_node(n, listnames) for n in node.childNodes]

else:

result = dict()

for attr in node.attributes.keys():

result[attr] = node.attributes[attr].nodeValue

for child in node.childNodes:

if child.nodeType != node.TEXT_NODE:

result[child.nodeName] = self._from_xml_node(child,

listnames)

return result

def find_first_child_named(self, parent, name):

"""Search a nodes children for the first child with a given name"""

for node in parent.childNodes:

if node.nodeName == name:

return node

return None

def find_children_named(self, parent, name):

"""Return all of a nodes children who have the given name"""

for node in parent.childNodes:

if node.nodeName == name:

yield node

def extract_text(self, node):

"""Get the text field contained by the given node"""

if len(node.childNodes) == 1:

child = node.childNodes[0]

if child.nodeType == child.TEXT_NODE:

return child.nodeValue

return ""

def default(self, datastring):