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_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 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)