def check_type(old_type, new_type):
if new_type == old_type:
return old_type
elif new_type == u.String():
if must_be_number:
raise exception.BananaTypeError(expected_type=u.Number,
found_type=new_type)
if old_type is None:
return new_type
elif u.can_to_str(old_type):
return new_type
else:
raise exception.BananaTypeError(expected_type=old_type,
found_type=new_type)
elif new_type == u.Number():
if old_type is None:
return new_type
elif old_type == u.String():
return old_type
elif not old_type == u.Number():
raise exception.BananaTypeError(expected_type=old_type,
found_type=new_type)
else:
raise exception.BananaTypeError(expected_type=old_type,
found_type=new_type)
def get_params():
return [
params.ParamDescriptor('host', type_util.String(), 'localhost'),
params.ParamDescriptor('port', type_util.Number(), 9092),
params.ParamDescriptor('topic', type_util.String(),
'transformed_alerts')
]
def get_params():
return [
params.ParamDescriptor('zk_host', type_util.String(), 'localhost'),
params.ParamDescriptor('zk_port', type_util.Number(), 2181),
params.ParamDescriptor('group_id', type_util.String(),
'my_group_id'),
params.ParamDescriptor('topics',
type_util.Object(strict_checking=False))
]
def get_params():
return [
params.ParamDescriptor('metric', type_util.String(),
'cpu.logcal_cores_actives'),
params.ParamDescriptor('period', type_util.Number(), 1),
params.ParamDescriptor('lambda', type_util.String(), 'a * b'),
params.ParamDescriptor('bindings', type_util.Any(), {
'a': 'cpu.ilde_perc',
'b': 'cpu.total_logical_cores'
})
]
def typeck_rhs(ast_value, type_table):
"""
Type-check the provided ast value. And returns its type.
This function does not support assignment,
:type ast_value: ast.ASTNode
:param ast_value: The ast_value to type check.
:type type_table: typetbl.TypeTable
:param type_table: The type table. Used for type lookup.
:rtype: u.Component | u.Object | u.Number | u.String
:return: Returns the computed type.
"""
if isinstance(ast_value, ast.Number):
return u.Number()
if isinstance(ast_value, ast.StringLit):
return u.String()
if isinstance(ast_value, ast.Ident):
return type_table.get_type(ast_value)
if isinstance(ast_value, ast.DotPath):
return type_table.get_type(ast_value)
if isinstance(ast_value, ast.Expr):
return typeck_expr(ast_value, type_table)
if isinstance(ast_value, ast.JsonObj):
return typeck_jsonobj(ast_value, type_table)
if isinstance(ast_value, ast.Component):
return typeck_component(ast_value, type_table)
raise Exception("Unhandled ast value type {}!!".format(ast_value))
def get_params():
return [
params.ParamDescriptor(
"db_name",
type_util.String(),
"sqlite_sink.db"
)
]
def get_params():
return [
params.ParamDescriptor('host', type_util.String(), 'localhost'),
params.ParamDescriptor('port', type_util.Number(), 1010),
params.ParamDescriptor(
'model',
type_util.Object({
'name':
type_util.String(),
'params':
type_util.Object({
'origin_types':
type_util.Object(strict_checking=False)
})
})),
params.ParamDescriptor('alert_per_burst', type_util.Number(), 1),
params.ParamDescriptor('idle_time_between_bursts',
type_util.Number(), 1.0),
]
def allowed_symbol(current_type):
if current_type == u.String():
return ['+']
else:
return ['+', '-', '*', '/']
def typeck_expr(expr, type_table):
"""
Type-check the given expression. If the typecheck
pass, the resulting type will be used for the strategy
to use when evaluating this expression.
:type expr: ast.Expr
:param expr: The expression to typecheck.
:type type_table: typetbl.TypeTable
:param type_table: Type of the table
:rtype: u.Number | u.String
:return: Returns the type of the expression if possible
:raise: Raise an exception
"""
# In the case where we are just wrapping around
# only one expression, the logic below
# needs to be skipped.
if len(expr.expr_tree) == 1:
return typeck_rhs(expr.expr_tree[0], type_table)
_type = None
must_be_number = False
def check_type(old_type, new_type):
if new_type == old_type:
return old_type
elif new_type == u.String():
if must_be_number:
raise exception.BananaTypeError(expected_type=u.Number,
found_type=new_type)
if old_type is None:
return new_type
elif u.can_to_str(old_type):
return new_type
else:
raise exception.BananaTypeError(expected_type=old_type,
found_type=new_type)
elif new_type == u.Number():
if old_type is None:
return new_type
elif old_type == u.String():
return old_type
elif not old_type == u.Number():
raise exception.BananaTypeError(expected_type=old_type,
found_type=new_type)
else:
raise exception.BananaTypeError(expected_type=old_type,
found_type=new_type)
def allowed_symbol(current_type):
if current_type == u.String():
return ['+']
else:
return ['+', '-', '*', '/']
for el in expr.expr_tree:
if isinstance(el, ast.StringLit):
_type = check_type(_type, u.String())
elif isinstance(el, ast.Number):
_type = check_type(_type, u.Number())
elif isinstance(el, ast.Ident):
ident_type = type_table.get_type(el)
_type = check_type(_type, ident_type)
elif isinstance(el, ast.DotPath):
dotpath_type = type_table.get_type(el)
_type = check_type(_type, dotpath_type)
elif isinstance(el, ast.Expr):
_type = check_type(_type, typeck_expr(el, type_table))
elif isinstance(el, basestring):
if el not in allowed_symbol(_type):
raise exception.BananaUnknownOperator(expr.span, el, _type)
if el in ['-', '*', '/']:
must_be_number = True
else:
raise exception.BananaTypeError(expected_type=[
u.Number.__name__, u.String.__name__, u.Object.__name__
], )
# The final type if we made until here!
return _type
def get_params():
return [
params.ParamDescriptor('db_name', type_util.String(),
'sqlite_sink.db')
]
def get_params():
return [params.ParamDescriptor('path', type_util.String())]
