def _build_ops(self, protocmds, cmdname, *args):
toargs = {}
if not "Parameters" in protocmds[cmdname]:
logger.debug("no parameters")
elif len(protocmds[cmdname]["Parameters"]) != len(args):
logger.debug("Too many args")
return { 'Status' : 'Failed', 'Message' : 'Client Side: Too many arguments' }
else:
counter = 0
for (var, arg, field, val, dest) in protocmds[cmdname]["Parameters"]:
if (args[counter] is None):
myval = ""
else:
args_fixed = args[counter]
if PY2 and (val == str and type(args_fixed) == unicode):
args_fixed = args_fixed.encode('ascii', 'ignore')
if not TypeHelper.belongs_to(val, args_fixed):
return { 'Status' : 'Failed', 'Message' : 'Client Side: Argument ' + str(counter) + " got " + str(type(args_fixed))+ "! Must be: " + val.__name__ }
try :
if (val == datetime) and args_fixed.year == 1970:
myval = "TIME_NOW"
elif (val == datetime):
myval = datetime.strftime(args_fixed, "%Y%m%d%H%M%S")
else:
myval = TypeHelper.resolve(args_fixed.value)
except Exception as ex:
myval = args_fixed
toargs[var] = myval
if dest != None:
toargs[var] = dest(toargs[var])
logger.debug(var + "<=>" + str(toargs[var]))
counter = counter + 1
return { 'Status' : 'Success', 'retval' : toargs }
def operation(self, cmdname, **kwargs):
argvals = {}
counter = 1
fcmd = self.cmds[cmdname]
for name, value in kwargs.items():
logger.debug(str(counter) + ":"+ str(name) + "=" + str(value))
counter = counter + 1
if not name in fcmd["Args"]:
str_err = name + " argument is invalid!"
logger.debug(str_err)
return { 'Status' : 'Failed', 'Message' : str_err }
argtype = fcmd["Args"][name]
if not TypeHelper.belongs_to(argtype, value):
str_err = name + " argument is invalid type! "
str_err = str_err + "Expected "+ str(argtype) + ". "
str_err = str_err + "But got "+ str(type(value))
str_err = str_err + "But got "+ str(value)
logger.debug(str_err)
return { 'Status' : 'Failed', 'Message' : str_err }
argvals[name] = value
for name in fcmd["Args"]:
if not name in argvals:
str_err = name + " argument is empty!"
logger.debug(str_err)
return { 'Status' : 'Failed', 'Message' : str_err }
paramlist = []
for (pname, argname, field, ftype, dest) in fcmd["Parameters"]:
if field is None:
argval = argvals[argname]
else:
argval = getattr(argvals[argname], field)
paramlist.append(argval)
logger.debug(PrettyPrint.prettify_json(paramlist))
if Simulator.is_simulating():
str_out = cmdname + "("
comma = ""
for i in paramlist:
str_out = str_out + comma + type(i).__name__ + str(i)
comma = ","
str_out = str_out + ")"
logger.debug(str_out)
rjson= { 'Status' : 'Success' }
else:
rjson = self.proto.operation(self.cmds, cmdname, *paramlist)
rjson['retval' ] = True
if not 'Message' in rjson:
rjson['Message'] = 'none'
return rjson
def check(self, scopeEnum):
return TypeHelper.belongs_to(MonitorScope, scopeEnum)
def check(self, scopeEnum):
return TypeHelper.belongs_to(DiffScope, scopeEnum)
def __setattr__(self, name, value):
# Do not allow access to internal variables
if name in ['_orig_value', '_state']:
raise AttributeError('Invalid attribute ' + name)
# Freeze mode: No sets allowed
if '_freeze' in self.__dict__ and self._freeze:
raise ValueError('object in freeze mode')
# allow updates to other fields except _value
# should we allow updates to '_type', '_alias', '_fname'?
if name not in ['_value']:
self.__dict__[name] = value
return
# Create-only attribute : No updates allowed
if not self._modifyAllowed and \
self._state in [TypeState.Committed, TypeState.Changing]:
raise ValueError('updates not allowed to this object')
# CompositeField : sets not allowed in composite fields
if self._composite:
raise AttributeError('composite objects cannot be modified')
# value is None, object was committed; ==> no change
if value is None and \
self._state in [TypeState.Committed, TypeState.Precommit, TypeState.Changing]:
return
# Validate value and convert it if needed
valid = False
msg = None
if value is None or TypeHelper.belongs_to(self._type, value):
valid = True
elif type(self) == type(value):
value = value._value
valid = True
elif isinstance(value, str):
# expected value is int
if self._type == int:
value = int(value)
valid = True
# expected value is bool
elif self._type == bool:
value = bool(value)
valid = True
# expected value is enumeration
elif TypeHelper.is_enum(self._type):
newvalue = TypeHelper.convert_to_enum(value, self._type)
if newvalue is not None:
value = newvalue
valid = True
else:
msg = str(value) + " is not " + str(self._type)
else:
msg = str(value) + " cannot be converted to " + str(self._type)
else:
msg = "No type conversion found for '" + str(value) + "'. "\
"Expected " + str(self._type.__name__) + ". Got " +\
type(value).__name__
if valid and not self.my_accept_value(value):
msg = type(self).__name__ + " returned failure for " + str(value)
valid = False
# if invalid, raise ValueError exception
if not valid:
raise ValueError(msg)
# same value - no change
if name in self.__dict__ and self._value == value:
return
# List fields, simply append the new entry!
if self._list and name in self.__dict__ and self.__dict__[name]:
value = self.__dict__[name] + "," + value
# modify the value
self.__dict__[name] = value
if self._state in [
TypeState.UnInitialized, TypeState.Precommit,
TypeState.Initializing
]:
self.__dict__['_state'] = TypeState.Initializing
elif self._state in [TypeState.Committed, TypeState.Changing]:
if self._orig_value == self._value:
self.__dict__['_state'] = TypeState.Committed
else:
self.__dict__['_state'] = TypeState.Changing
else:
print("Should not come here")
if self.is_changed() and self._parent:
self._parent.child_state_changed(self, self._state)
