def test_params_extract_garbage_suffix(self):
p = {'Parameters.member.1.ParameterKeysuffix': 'foo',
'Parameters.member.1.ParameterValue': 'bar'}
params = api_utils.extract_param_pairs(p, prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertFalse(params)
def handle_member_list_to_map(args):
correct = '''
{'Fn::MemberListToMap': ['Name', 'Value',
['.member.0.Name=key',
'.member.0.Value=door']]}
'''
if not isinstance(args, (list, tuple)):
raise TypeError(_('Wrong Arguments try: "%s"') % correct)
if len(args) != 3:
raise TypeError(_('Wrong Arguments try: "%s"') % correct)
if not isinstance(args[0], basestring):
raise TypeError(_('Wrong Arguments try: "%s"') % correct)
if not isinstance(args[1], basestring):
raise TypeError(_('Wrong Arguments try: "%s"') % correct)
if not isinstance(args[2], (list, tuple)):
raise TypeError(_('Wrong Arguments try: "%s"') % correct)
partial = {}
for item in args[2]:
sp = item.split('=')
partial[sp[0]] = sp[1]
return aws_utils.extract_param_pairs(partial,
prefix='',
keyname=args[0],
valuename=args[1])
def put_metric_data(self, req):
"""
Implements PutMetricData API action
"""
self._enforce(req, 'PutMetricData')
con = req.context
parms = dict(req.params)
namespace = api_utils.get_param_value(parms, 'Namespace')
# Extract data from the request so we can pass it to the engine
# We have to do this in two passes, because the AWS
# query format nests the dimensions within the MetricData
# query-parameter-list (see AWS PutMetricData docs)
# extract_param_list gives a list-of-dict, which we then
# need to process (each dict) for dimensions
metric_data = api_utils.extract_param_list(parms, prefix='MetricData')
if not len(metric_data):
logger.error("Request does not contain required MetricData")
return exception.HeatMissingParameterError("MetricData list")
watch_name = None
dimensions = []
for p in metric_data:
dimension = api_utils.extract_param_pairs(p,
prefix='Dimensions',
keyname='Name',
valuename='Value')
if 'AlarmName' in dimension:
watch_name = dimension['AlarmName']
else:
dimensions.append(dimension)
# We expect an AlarmName dimension as currently the engine
# implementation requires metric data to be associated
# with an alarm. When this is fixed, we can simply
# parse the user-defined dimensions and add the list to
# the metric data
if not watch_name:
logger.error("Request does not contain AlarmName dimension!")
return exception.HeatMissingParameterError("AlarmName dimension")
# Extract the required data from the metric_data
# and format dict to pass to engine
data = {'Namespace': namespace,
api_utils.get_param_value(metric_data[0], 'MetricName'): {
'Unit': api_utils.get_param_value(metric_data[0], 'Unit'),
'Value': api_utils.get_param_value(metric_data[0],
'Value'),
'Dimensions': dimensions}}
try:
self.engine_rpcapi.create_watch_data(con, watch_name, data)
except rpc_common.RemoteError as ex:
return exception.map_remote_error(ex)
result = {'ResponseMetadata': None}
return api_utils.format_response("PutMetricData", result)
def test_params_extract_dots(self):
p = {'Parameters.member.1.1.ParameterKey': 'foo',
'Parameters.member.1.1.ParameterValue': 'bar',
'Parameters.member.2.1.ParameterKey': 'blarg',
'Parameters.member.2.1.ParameterValue': 'wibble'}
params = api_utils.extract_param_pairs(p, prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertFalse(params)
def test_params_extract_garbage_prefix(self):
p = {
'prefixParameters.member.Foo.Bar.ParameterKey': 'foo',
'Parameters.member.Foo.Bar.ParameterValue': 'bar'
}
params = api_utils.extract_param_pairs(p,
prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertFalse(params)
def test_params_extract_garbage(self):
p = {'Parameters.member.1.ParameterKey': 'foo',
'Parameters.member.1.ParameterValue': 'bar',
'Foo.1.ParameterKey': 'blarg',
'Foo.1.ParameterValue': 'wibble'}
params = api_utils.extract_param_pairs(p, prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertEqual(len(params), 1)
self.assertTrue('foo' in params)
self.assertEqual(params['foo'], 'bar')
def test_params_extract_garbage(self):
p = {'Parameters.member.1.ParameterKey': 'foo',
'Parameters.member.1.ParameterValue': 'bar',
'Foo.1.ParameterKey': 'blarg',
'Foo.1.ParameterValue': 'wibble'}
params = api_utils.extract_param_pairs(p, prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertEqual(len(params), 1)
self.assertTrue('foo' in params)
self.assertEqual(params['foo'], 'bar')
def test_params_extract_dots(self):
p = {
"Parameters.member.1.1.ParameterKey": "foo",
"Parameters.member.1.1.ParameterValue": "bar",
"Parameters.member.2.1.ParameterKey": "blarg",
"Parameters.member.2.1.ParameterValue": "wibble",
}
params = api_utils.extract_param_pairs(
p, prefix="Parameters", keyname="ParameterKey", valuename="ParameterValue"
)
self.assertFalse(params)
def _extract_user_params(params):
"""Extract a dictionary of user input parameters for the stack.
In the AWS API parameters, each user parameter appears as two key-value
pairs with keys of the form below::
Parameters.member.1.ParameterKey
Parameters.member.1.ParameterValue
"""
return api_utils.extract_param_pairs(
params, prefix="Parameters", keyname="ParameterKey", valuename="ParameterValue"
)
def test_params_extract_dots(self):
p = {
'Parameters.member.1.1.ParameterKey': 'foo',
'Parameters.member.1.1.ParameterValue': 'bar',
'Parameters.member.2.1.ParameterKey': 'blarg',
'Parameters.member.2.1.ParameterValue': 'wibble'
}
params = api_utils.extract_param_pairs(p,
prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertFalse(params)
def result(self):
member_list = function.resolve(self._list)
if not isinstance(member_list, collections.Iterable):
raise TypeError(_("Member list must be a list"))
def item(s):
if not isinstance(s, six.string_types):
raise TypeError(_("Member list items must be strings"))
return s.split("=", 1)
partials = dict(item(s) for s in member_list)
return aws_utils.extract_param_pairs(partials, prefix="", keyname=self._keyname, valuename=self._valuename)
def test_params_extract_garbage(self):
p = {
"Parameters.member.1.ParameterKey": "foo",
"Parameters.member.1.ParameterValue": "bar",
"Foo.1.ParameterKey": "blarg",
"Foo.1.ParameterValue": "wibble",
}
params = api_utils.extract_param_pairs(
p, prefix="Parameters", keyname="ParameterKey", valuename="ParameterValue"
)
self.assertEqual(len(params), 1)
self.assertIn("foo", params)
self.assertEqual(params["foo"], "bar")
def test_params_extract(self):
p = {'Parameters.member.1.ParameterKey': 'foo',
'Parameters.member.1.ParameterValue': 'bar',
'Parameters.member.2.ParameterKey': 'blarg',
'Parameters.member.2.ParameterValue': 'wibble'}
params = api_utils.extract_param_pairs(p, prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertEqual(2, len(params))
self.assertIn('foo', params)
self.assertEqual('bar', params['foo'])
self.assertIn('blarg', params)
self.assertEqual('wibble', params['blarg'])
def _extract_user_params(params):
"""Extract a dictionary of user input parameters for the stack.
In the AWS API parameters, each user parameter appears as two key-value
pairs with keys of the form below::
Parameters.member.1.ParameterKey
Parameters.member.1.ParameterValue
"""
return api_utils.extract_param_pairs(params,
prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
def test_params_extract(self):
p = {'Parameters.member.1.ParameterKey': 'foo',
'Parameters.member.1.ParameterValue': 'bar',
'Parameters.member.2.ParameterKey': 'blarg',
'Parameters.member.2.ParameterValue': 'wibble'}
params = api_utils.extract_param_pairs(p, prefix='Parameters',
keyname='ParameterKey',
valuename='ParameterValue')
self.assertEqual(2, len(params))
self.assertIn('foo', params)
self.assertEqual('bar', params['foo'])
self.assertIn('blarg', params)
self.assertEqual('wibble', params['blarg'])
def put_metric_data(self, req):
"""
Implements PutMetricData API action
"""
self._enforce(req, 'PutMetricData')
con = req.context
parms = dict(req.params)
namespace = api_utils.get_param_value(parms, 'Namespace')
# Extract data from the request so we can pass it to the engine
# We have to do this in two passes, because the AWS
# query format nests the dimensions within the MetricData
# query-parameter-list (see AWS PutMetricData docs)
# extract_param_list gives a list-of-dict, which we then
# need to process (each dict) for dimensions
metric_data = api_utils.extract_param_list(parms, prefix='MetricData')
if not len(metric_data):
logger.error(_("Request does not contain required MetricData"))
return exception.HeatMissingParameterError("MetricData list")
watch_name = None
dimensions = []
for p in metric_data:
dimension = api_utils.extract_param_pairs(p,
prefix='Dimensions',
keyname='Name',
valuename='Value')
if 'AlarmName' in dimension:
watch_name = dimension['AlarmName']
else:
dimensions.append(dimension)
# Extract the required data from the metric_data
# and format dict to pass to engine
data = {
'Namespace': namespace,
api_utils.get_param_value(metric_data[0], 'MetricName'): {
'Unit': api_utils.get_param_value(metric_data[0], 'Unit'),
'Value': api_utils.get_param_value(metric_data[0], 'Value'),
'Dimensions': dimensions
}
}
try:
self.rpc_client.create_watch_data(con, watch_name, data)
except rpc_common.RemoteError as ex:
return exception.map_remote_error(ex)
result = {'ResponseMetadata': None}
return api_utils.format_response("PutMetricData", result)
def test_params_extract(self):
p = {
"Parameters.member.1.ParameterKey": "foo",
"Parameters.member.1.ParameterValue": "bar",
"Parameters.member.2.ParameterKey": "blarg",
"Parameters.member.2.ParameterValue": "wibble",
}
params = api_utils.extract_param_pairs(
p, prefix="Parameters", keyname="ParameterKey", valuename="ParameterValue"
)
self.assertEqual(2, len(params))
self.assertIn("foo", params)
self.assertEqual("bar", params["foo"])
self.assertIn("blarg", params)
self.assertEqual("wibble", params["blarg"])
def put_metric_data(self, req):
"""
Implements PutMetricData API action
"""
self._enforce(req, "PutMetricData")
con = req.context
parms = dict(req.params)
namespace = api_utils.get_param_value(parms, "Namespace")
# Extract data from the request so we can pass it to the engine
# We have to do this in two passes, because the AWS
# query format nests the dimensions within the MetricData
# query-parameter-list (see AWS PutMetricData docs)
# extract_param_list gives a list-of-dict, which we then
# need to process (each dict) for dimensions
metric_data = api_utils.extract_param_list(parms, prefix="MetricData")
if not len(metric_data):
logger.error(_("Request does not contain required MetricData"))
return exception.HeatMissingParameterError("MetricData list")
watch_name = None
dimensions = []
for p in metric_data:
dimension = api_utils.extract_param_pairs(p, prefix="Dimensions", keyname="Name", valuename="Value")
if "AlarmName" in dimension:
watch_name = dimension["AlarmName"]
else:
dimensions.append(dimension)
# Extract the required data from the metric_data
# and format dict to pass to engine
data = {
"Namespace": namespace,
api_utils.get_param_value(metric_data[0], "MetricName"): {
"Unit": api_utils.get_param_value(metric_data[0], "Unit"),
"Value": api_utils.get_param_value(metric_data[0], "Value"),
"Dimensions": dimensions,
},
}
try:
self.rpc_client.create_watch_data(con, watch_name, data)
except rpc_common.RemoteError as ex:
return exception.map_remote_error(ex)
result = {"ResponseMetadata": None}
return api_utils.format_response("PutMetricData", result)
def result(self):
member_list = function.resolve(self._list)
if not isinstance(member_list, collections.Iterable):
raise TypeError(_('Member list must be a list'))
def item(s):
if not isinstance(s, str):
raise TypeError(_("Member list items must be strings"))
return s.split('=', 1)
partials = dict(item(s) for s in member_list)
return aws_utils.extract_param_pairs(partials,
prefix='',
keyname=self._keyname,
valuename=self._valuename)
def result(self):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class MemberListToMap/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class MemberListToMap/ result "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class MemberListToMap/ result "))
member_list = function.resolve(self._list)
if not isinstance(member_list, collections.Iterable):
raise TypeError(_('Member list must be a list'))
def item(s):
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class MemberListToMap/ item "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class MemberListToMap/ item "))
LOG.info(_LI("soumiyajit:: /home/pankaj/python_program/logs/cfn/functions.py/Class MemberListToMap/ item "))
if not isinstance(s, six.string_types):
raise TypeError(_("Member list items must be strings"))
return s.split('=', 1)
partials = dict(item(s) for s in member_list)
return aws_utils.extract_param_pairs(partials,
prefix='',
keyname=self._keyname,
valuename=self._valuename)
def test_params_extract_garbage_suffix(self):
p = {"Parameters.member.1.ParameterKeysuffix": "foo", "Parameters.member.1.ParameterValue": "bar"}
params = api_utils.extract_param_pairs(
p, prefix="Parameters", keyname="ParameterKey", valuename="ParameterValue"
)
self.assertFalse(params)
