def parse_array_of_strings(strlist, separators=[","]):
"""Convert comma-separated string list into an ArrayOfStrings
Accepts the following string representations.
['a', 'b', 'c']
["a", "b", "c"]
'a', 'b', 'c'
"a", "b", "c"
a, b, c
@param strlist: list to be converted
@param separators: list of allowed separators
@return: None if strlist is empty, else return a JsonArray of strings
@raise TypeError if element_type is specified and conversion of any element fails
"""
if strlist is None:
return None
if not strlist:
return ArrayOfStrings()
strlist = strlist.strip()
# Remove surrounding square brackets
if strlist[0] == "[" and strlist[-1] == "]":
strlist = strlist[1:-1]
if not strlist:
return ArrayOfStrings()
# Extract elements, removing any surrounding quotes (Single-quotes are illegal JSON. Double quotes will be added).
elems = []
split_regex = "["
for delim in separators:
if delim is None:
split_regex += r"\s+" # None means "split by any whitespace"
else:
split_regex += delim
split_regex += "]"
items = re.split(split_regex, strlist)
for elem in items:
elem = elem.strip()
if len(elem) == 0:
continue
if elem[0] == r"'" or elem[0] == r'"' and elem[-1] == elem[0]:
elem = elem[1:-1]
if len(elem) == 0:
continue
elems.append(elem)
return ArrayOfStrings(elems)
def test_str_conversion(self):
self.assertEquals(self.get(1, convert_to=str), '1')
self.assertEquals(self.get('ah', convert_to=str), 'ah')
self.assertEquals(self.get(False, convert_to=str), 'False')
self.assertEquals(self.get(1.3, convert_to=str), '1.3')
self.assertEquals(self.get(1L, convert_to=str), '1')
test_array = ["a", "b", "c"]
# str -> ArrayOfStrings (must support different variations)
arr = ArrayOfStrings(*test_array)
self.assertEquals(self.get('a,b,c', convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get('a,b, c', convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get('"a", "b", "c"', convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get("'a', 'b', 'c'", convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get("[a, b, c]" , convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get("['a', \"b\", c]" , convert_to=ArrayOfStrings), arr)
# str -> JsonArray
self.assertEquals(self.get(serialize(test_array), convert_to=JsonArray), JsonArray(*test_array))
with self.assertRaises(BadMonitorConfiguration):
# single quotes are invalid JSON
self.assertEquals(self.get(str(test_array), convert_to=JsonArray), JsonArray(*test_array))
# str -> JsonObject
test_obj = {'a': 1, 'b': 'two', 'c': [1, 2, 3]}
self.assertEquals(self.get(serialize(test_obj), convert_to=JsonObject), json_lib_parse(serialize(test_obj)))
def test_arrayofstrings_conversion(self):
# JsonArray -> list not supported
test_array = ["a", "b", "c"]
json_arr = ArrayOfStrings(*test_array)
with self.assertRaises(BadMonitorConfiguration):
self.get(json_arr, convert_to=list)
# ArrayOfStrings -> JsonArray supported
test_array = ["a", "b", "c"]
json_arr = JsonArray(*test_array)
self.assertEquals(self.get(json_arr, convert_to=JsonArray), JsonArray(*test_array))
def test_list_conversion(self):
# list -> JsonArray supported
test_array = ["a", 1, False]
json_arr = JsonArray(*test_array)
self.assertEquals(
self.get(list(json_arr), convert_to=JsonArray),
JsonArray(*test_array),
)
# list -> ArrayOfStrings not supported
test_array = ["a", "b", "c"]
self.assertEquals(self.get(test_array, convert_to=ArrayOfStrings),
ArrayOfStrings(test_array))
def test_empty_environment_value(self):
# Test empty string results in empty list
self.assertEquals(
self.define_and_get_from_env("", "default value", convert_to=six.text_type),
"",
)
# Test empty string results in empty list
self.assertEquals(
self.define_and_get_from_env(
"", "default value", convert_to=ArrayOfStrings
),
ArrayOfStrings(),
)
def test_jsonarray_conversion(self):
# JsonArray -> list not supported
test_array = ["a", "b", "c"]
json_arr = JsonArray(*test_array)
with self.assertRaises(BadMonitorConfiguration):
self.get(json_arr, convert_to=list)
# JsonArray -> ArrayOfStrings supported
test_array = ["a", "b", "c"]
json_arr = JsonArray(*test_array)
self.assertEquals(self.get(json_arr, convert_to=ArrayOfStrings), ArrayOfStrings(*test_array))
# JsonArray -> invalid ArrayOfStrings
test_array = ["a", "b", 3]
json_arr = JsonArray(*test_array)
with self.assertRaises(BadMonitorConfiguration):
self.get(json_arr, convert_to=ArrayOfStrings)
def test_str_conversion(self):
self.assertEquals(self.get(1, convert_to=six.text_type), "1")
self.assertEquals(self.get("ah", convert_to=six.text_type), "ah")
self.assertEquals(self.get(False, convert_to=six.text_type), "False")
self.assertEquals(self.get(1.3, convert_to=six.text_type), "1.3")
self.assertEquals(self.get(1, convert_to=six.text_type), "1")
test_array = ["a", "b", "c"]
# str -> ArrayOfStrings (must support different variations)
arr = ArrayOfStrings(test_array)
self.assertEquals(self.get("a,b,c", convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get("a,b, c", convert_to=ArrayOfStrings), arr)
self.assertEquals(self.get('"a", "b", "c"', convert_to=ArrayOfStrings),
arr)
self.assertEquals(self.get("'a', 'b', 'c'", convert_to=ArrayOfStrings),
arr)
self.assertEquals(self.get("[a, b, c]", convert_to=ArrayOfStrings),
arr)
self.assertEquals(
self.get("['a', \"b\", c]", convert_to=ArrayOfStrings), arr)
# str -> JsonArray
self.assertEquals(
self.get(scalyr_util.json_encode(test_array),
convert_to=JsonArray),
JsonArray(*test_array),
)
self.assertRaises(
BadMonitorConfiguration,
# single quotes are invalid JSON
lambda: self.assertEquals(
self.get(six.text_type(test_array), convert_to=JsonArray),
JsonArray(*test_array),
),
)
# str -> JsonObject
test_obj = {"a": 1, "b": "two", "c": [1, 2, 3]}
self.assertEquals(
self.get(scalyr_util.json_encode(test_obj), convert_to=JsonObject),
scalyr_util.json_scalyr_config_decode(
scalyr_util.json_encode(test_obj)),
)
def parse_array_of_strings(strlist):
"""Convert comma-separated string list into an ArrayOfStrings
Accepts the following string representations.
['a', 'b', 'c']
["a", "b", "c"]
'a', 'b', 'c'
"a", "b", "c"
a, b, c
@param strlist: list to be converted
@return: None if strlist is empty, else return a JsonArray of strings
@raise TypeError if element_type is specified and conversion of any element fails
"""
if not strlist:
return None
strlist = strlist.strip()
# Remove surrounding square brackets
if strlist[0] == '[' and strlist[-1] == ']':
strlist = strlist[1:-1]
if not strlist:
return None
# Extract elements, removing any surrounding quotes (Single-quotes are illegal JSON. Double quotes will be added).
elems = []
items = strlist.split(',')
for elem in items:
elem = elem.strip()
if len(elem) == 0:
continue
if elem[0] == r"'" or elem[0] == r'"' and elem[-1] == elem[0]:
elem = elem[1:-1]
if len(elem) == 0:
continue
elems.append(elem)
return ArrayOfStrings(*elems)
def test_environment_based_options(self):
# Basic case
self.assertEquals(
self.define_and_get_from_env(
"value in env", default_value="default value", convert_to=six.text_type
),
"value in env",
)
# Test uses default value when no environment is set
self.assertEquals(
self.define_and_get_from_env(
None, "default value", convert_to=six.text_type
),
"default value",
)
# Test works with no default provided (note, testing conversions also happen because this was previous a bug)
self.assertEquals(
self.define_and_get_from_env("1,2,3", convert_to=ArrayOfStrings),
ArrayOfStrings(["1", "2", "3"]),
)
# Required field
self.assertEquals(
self.define_and_get_from_env(
"value in env",
default_value="default value",
convert_to=six.text_type,
required_field=True,
),
"value in env",
)
self.assertRaises(
Exception,
lambda: self.define_and_get_from_env(
None, convert_to=six.text_type, required_field=True
),
None,
)
# Test min/max
self.assertEquals(
self.define_and_get_from_env(
"16", convert_to=float, min_value=10, max_value=20
),
16,
)
self.assertRaises(
Exception,
lambda: self.define_and_get_from_env(
"23", convert_to=float, min_value=10, max_value=20
),
None,
)
self.assertRaises(
Exception,
lambda: self.define_and_get_from_env(
"5", convert_to=float, min_value=10, max_value=20
),
None,
)
# Test option with non-standard environment name
self.assertEquals(
self.define_and_get_from_env(
"value in env",
default_value="default value",
env_name="non-std-env-name",
convert_to=six.text_type,
),
"value in env",
)
# Test other convert to formats
self.assertEquals(
self.define_and_get_from_env(
"1,2,3", default_value="a,b,c", convert_to=ArrayOfStrings
),
ArrayOfStrings(["1", "2", "3"]),
)
self.assertEquals(
self.define_and_get_from_env(
"True", default_value="False", convert_to=bool
),
True,
)
def convert_config_param(field_name,
value,
convert_to,
is_environment_variable=False):
"""Convert monitor config values to a different type according to the ALLOWED_CONVERSIONS matrix"""
convert_from = type(value)
kind = 'config param' if not is_environment_variable else 'environment variable'
conversion_allowed = False
if convert_from in ALLOWED_CONVERSIONS:
if convert_to in set([convert_from
]) | ALLOWED_CONVERSIONS[convert_from]:
conversion_allowed = True
if not conversion_allowed:
raise BadConfiguration(
'Prohibited conversion of %s "%s" from %s to %s' %
(kind, field_name, convert_from, convert_to), field_name,
'illegalConversion')
# If no type change, simply return unconverted value
if convert_from == convert_to:
return value
# Anything is allowed to go to str/unicode
if convert_to in STRING_TYPES:
return convert_to(value)
if convert_from == list and convert_to == JsonArray:
try:
return JsonArray(*value)
except JsonConversionException:
raise BadConfiguration(
'Could not convert value %s for field "%s" from %s to %s' %
(value, field_name, convert_from, convert_to), field_name,
'notJsonArray')
if convert_from in (list, JsonArray) and convert_to == ArrayOfStrings:
list_of_strings = []
for item in value:
if type(item) not in STRING_TYPES:
raise BadConfiguration(
'Non-string element found in value %s for field "%s"' %
(value, field_name), field_name, 'notArrayOfStrings')
list_of_strings.append(item)
return ArrayOfStrings(*list_of_strings)
# Anything is allowed to go from string/unicode to the conversion type, as long as it can be parsed.
# Special-case handle bool and JsonArray
if convert_from in STRING_TYPES:
if convert_to == bool:
return str(value).lower() == 'true'
elif convert_to in (JsonArray, JsonObject):
try:
return json_lib.parse(value)
except JsonParseException:
raise BadConfiguration(
'Could not parse value %s for field "%s" as %s' %
(value, field_name, convert_to), field_name,
'notJsonObject')
elif convert_to == ArrayOfStrings:
try:
return parse_array_of_strings(value)
except TypeError:
raise BadConfiguration(
'Could not parse value %s for field "%s" as %s' %
(value, field_name, convert_to), field_name,
'notArrayOfStrings')
elif convert_to in NUMERIC_TYPES:
try:
return convert_to(value)
except ValueError:
raise BadConfiguration(
'Could not parse value %s for field "%s" as numeric type %s'
% (value, field_name, convert_to), field_name, 'notNumber')
if convert_from not in NUMERIC_TYPES:
raise BadConfiguration(
'Type conversion for field "%s" from %s to %s not implemented.' %
(field_name, convert_from, convert_to), field_name, 'notNumber')
if convert_to == bool:
raise BadConfiguration(
'A numeric value %s was given for boolean field "%s"' %
(value, field_name), field_name, 'notBoolean')
if convert_to not in NUMERIC_TYPES:
raise BadConfiguration(
'Type conversion for field "%s" from %s to %s not implemented.' %
(field_name, convert_from, convert_to), field_name,
'unsupportedConversion')
# At this point, we are trying to convert a number to another number type. We only allow int to long
# and long, int to float.
if convert_to == float and convert_from in (long, int):
return float(value)
if convert_to == long and convert_from == int:
return long(value)
raise BadConfiguration(
'A numeric value of %s was given for field "%s" but a %s is required.'
% (value, field_name, convert_to), field_name, 'wrongType')