def __call__(self, req):
# Request lazy serialization
req.environ['engine.lazy_serialize'] = True
response = req.get_response(self.application)
# See if we're using the simple serialization driver
simple_serial = req.environ.get('engine.simple_serial')
if simple_serial is not None:
body_obj = utils.loads(response.body)
response.body = simple_serial.serialize(body_obj)
return response
# See if there's a serializer...
serializer = req.environ.get('engine.serializer')
if serializer is None:
return response
# OK, build up the arguments for the serialize() method
kwargs = dict(action=req.environ['engine.action'])
if 'engine.template' in req.environ:
kwargs['template'] = req.environ['engine.template']
# Re-serialize the body
response.body = serializer.serialize(utils.loads(response.body),
**kwargs)
return response
def test_create_server_detect_from_image(self):
"""If user doesn't pass in diskConfig for server, use image metadata
to specify AUTO or MANUAL.
"""
req = fakes.HTTPRequest.blank('/fake/servers')
req.method = 'POST'
req.content_type = 'application/json'
body = {'server': {
'name': 'server_test',
'imageRef': 'a440c04b-79fa-479c-bed1-0b816eaec379',
'flavorRef': '1',
}}
req.body = utils.dumps(body)
res = req.get_response(self.app)
server_dict = utils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'MANUAL')
req = fakes.HTTPRequest.blank('/fake/servers')
req.method = 'POST'
req.content_type = 'application/json'
body = {'server': {
'name': 'server_test',
'imageRef': '70a599e0-31e7-49b7-b260-868f441e862b',
'flavorRef': '1',
}}
req.body = utils.dumps(body)
res = req.get_response(self.app)
server_dict = utils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'AUTO')
def test_show_image(self):
req = fakes.HTTPRequest.blank(
'/fake/images/a440c04b-79fa-479c-bed1-0b816eaec379')
res = req.get_response(self.app)
image_dict = utils.loads(res.body)['image']
self.assertDiskConfig(image_dict, 'MANUAL')
req = fakes.HTTPRequest.blank(
'/fake/images/70a599e0-31e7-49b7-b260-868f441e862b')
res = req.get_response(self.app)
image_dict = utils.loads(res.body)['image']
self.assertDiskConfig(image_dict, 'AUTO')
def test_show_server(self):
req = fakes.HTTPRequest.blank(
'/fake/servers/%s' % MANUAL_INSTANCE_UUID)
res = req.get_response(self.app)
server_dict = utils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'MANUAL')
req = fakes.HTTPRequest.blank(
'/fake/servers/%s' % AUTO_INSTANCE_UUID)
res = req.get_response(self.app)
server_dict = utils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'AUTO')
def process(self, req, *args, **kwargs):
for pre_handler in self.pre_handlers:
pre_handler(req)
res = req.get_response(self.application)
# Don't call extensions if the main application returned an
# unsuccessful status
successful = 200 <= res.status_int < 400
if not successful:
return res
# Deserialize the response body, if any
body = None
if res.body:
body = utils.loads(res.body)
# currently request handlers are un-ordered
for handler in self.handlers:
res = handler(req, res, body)
# Reserialize the response body
if body is not None:
res.body = utils.dumps(body)
return res
def test_detail_servers(self):
req = fakes.HTTPRequest.blank('/fake/servers/detail')
res = req.get_response(self.app)
server_dicts = utils.loads(res.body)['servers']
expectations = ['MANUAL', 'AUTO']
for server_dict, expected in zip(server_dicts, expectations):
self.assertDiskConfig(server_dict, expected)
def __do_request(self, path, context, **kwargs):
req = wsgi.Request.blank(path)
req.method = 'POST'
req.body = urllib.urlencode({'json': utils.dumps(kwargs)})
req.environ['x7.context'] = context
resp = req.get_response(self.app)
try:
return utils.loads(resp.body)
except Exception:
return resp.body
def test_detail_image(self):
req = fakes.HTTPRequest.blank('/fake/images/detail')
res = req.get_response(self.app)
image_dicts = utils.loads(res.body)['images']
expectations = ['MANUAL', 'AUTO']
for image_dict, expected in zip(image_dicts, expectations):
# NOTE(sirp): image fixtures 6 and 7 are setup for
# auto_disk_config testing
if image_dict['id'] in (6, 7):
self.assertDiskConfig(image_dict, expected)
def __call__(self, req):
# Read request signature and access id.
try:
signature = req.params['Signature']
access = req.params['AWSAccessKeyId']
except KeyError:
raise webob.exc.HTTPBadRequest()
# Make a copy of args for authentication and signature verification.
auth_params = dict(req.params)
# Not part of authentication args
auth_params.pop('Signature')
# Authenticate the request.
creds = {'ec2Credentials': {'access': access,
'signature': signature,
'host': req.host,
'verb': req.method,
'path': req.path,
'params': auth_params,
}}
creds_json = utils.dumps(creds)
headers = {'Content-Type': 'application/json'}
# Disable "has no x member" pylint error
# for httplib and urlparse
# pylint: disable-msg=E1101
o = urlparse(FLAGS.keystone_ec2_url)
if o.scheme == "http":
conn = httplib.HTTPConnection(o.netloc)
else:
conn = httplib.HTTPSConnection(o.netloc)
conn.request('POST', o.path, body=creds_json, headers=headers)
response = conn.getresponse().read()
conn.close()
# NOTE(vish): We could save a call to keystone by
# having keystone return token, tenant,
# user, and roles from this call.
result = utils.loads(response)
try:
token_id = result['access']['token']['id']
except (AttributeError, KeyError):
raise webob.exc.HTTPBadRequest()
# Authenticated!
req.headers['X-Auth-Token'] = token_id
return self.application
def process_request(self, request):
if 'json' not in request.params:
return
params_json = request.params['json']
params_parsed = utils.loads(params_json)
params = {}
for k, v in params_parsed.iteritems():
if k in ('self', 'context'):
continue
if k.startswith('_'):
continue
params[k] = v
request.environ['x7.params'] = params
def test_create_server_override_manual(self):
req = fakes.HTTPRequest.blank('/fake/servers')
req.method = 'POST'
req.content_type = 'application/json'
body = {'server': {
'name': 'server_test',
'imageRef': 'cedef40a-ed67-4d10-800e-17455edce175',
'flavorRef': '1',
'RAX-DCF:diskConfig': 'MANUAL'
}}
req.body = utils.dumps(body)
res = req.get_response(self.app)
server_dict = utils.loads(res.body)['server']
self.assertDiskConfig(server_dict, 'MANUAL')
def _pre_POST_servers(self, req):
# NOTE(sirp): deserialization currently occurs *after* pre-processing
# extensions are called. Until extensions are refactored so that
# deserialization occurs earlier, we have to perform the
# deserialization ourselves.
content_type = req.content_type
if 'xml' in content_type:
node = minidom.parseString(req.body)
server = node.getElementsByTagName('server')[0]
api_value = server.getAttribute(self.API_DISK_CONFIG)
if api_value:
value = disk_config_from_api(api_value)
server.setAttribute(self.INTERNAL_DISK_CONFIG, str(value))
req.body = str(node.toxml())
else:
body = utils.loads(req.body)
server = body['server']
api_value = server.get(self.API_DISK_CONFIG)
if api_value:
value = disk_config_from_api(api_value)
server[self.INTERNAL_DISK_CONFIG] = value
req.body = utils.dumps(body)
def _from_json(self, datastring):
try:
return utils.loads(datastring)
except ValueError:
msg = _("cannot understand JSON")
raise exception.MalformedRequestBody(reason=msg)
