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)