def init_cse_base(self): # get config values onem2m_config = self.config["onem2m"] self._cse_base = cse_base_name = onem2m_config.get( "cse_base", "onem2m") # TODO(rst): check later # node_link = 'dummy' # cse type cse_type = onem2m_config.get("cse_type") try: cse_type = getattr(CSETypeIDE, str(cse_type).replace("-", "_").upper()) except (AttributeError, TypeError, ValueError): raise ConfigurationError("Invalid value for 'cse_type': %s" % (cse_type, )) cse_type = CSETypeIDE(cse_type) # cse id try: self._rel_cse_id = "/" + onem2m_config["cse_id"] except KeyError: raise ConfigurationError("Missing configuration key: cse_id") # sp id try: self._abs_cse_id = "//" + onem2m_config["sp_id"] + self._rel_cse_id except KeyError: raise ConfigurationError("Missing configuration key: sp_id") # time now = datetime_now() # resource cse_base = CSEBase(resourceName=cse_base_name, resourceID='cb0', parentID=None, resourceType=model.ResourceTypeE['CSEBase'], creationTime=now, lastModifiedTime=now, cseType=cse_type, CSE_ID=self._rel_cse_id, supportedResourceType=[ model.ResourceTypeE[x.typename] for x in self.controller_classes.keys() ], pointOfAccess=[], path=cse_base_name) db_session = self._api.start_onem2m_session() try: result = db_session.store(cse_base) except Exception as error: self.logger.exception("Initialization error") db_session.rollback() raise error else: db_session.commit() return result
def rerun_discovery(o): try: func(self.discover(fc)) except SCLError: pass o['createdAfter'] = datetime_now() spawn_later(interval, rerun_discovery, o)
def _handle_update(self): self.now = datetime_now() self.fields = [] self._check_authorization() self._check_update_representation() self._update_resource() self._finalize_update() return self._send_update_response()
def run_discovery(o): try: cb(self.discover(path, o)) except OneM2MErrorResponse as error_response: if err_cb: return err_cb(error_response) else: o['createdAfter'] = datetime_now() spawn_later(interval, run_discovery, o)
def _handle_create(self): self.parent = self.resource del self.resource self.now = datetime_now() self.fields = [] self._check_authorization() self._check_create_representation() self._create_resource() self._finalize_create() return self._send_create_response()
def __init__(self, name=None, cse_base=None, expiration_time=None, announce_to=None, poas=None, originator_pre=None, ca_certs=None, cert_file=None, key_file=None, *args, **kw): super(XAE, self).__init__(*args, **kw) self.__subscriptions = [] self.name = name or type(self).__name__ self.cse_base = cse_base or "onem2m" ae_id = "C" + self.name self.originator = (originator_pre + '/' + ae_id) if originator_pre else ae_id self.ca_certs = ca_certs self.cert_file = cert_file self.key_file = key_file if expiration_time is not None: if isinstance(expiration_time, (str, unicode)): expiration_time = parse_date(expiration_time) elif isinstance(expiration_time, (int, float)): expiration_time = datetime.fromtimestamp(expiration_time, UTC) if not isinstance(expiration_time, datetime): raise ValueError(expiration_time) self.default_lifetime = (expiration_time - datetime_now()).total_seconds() self.announceTo = announce_to self.__resumed_registration = False self.__known_containers = set() self.__shutdown = False self.allow_duplicate = None self.runner = None self.poas = poas or [] self.fmt_json_regex = re.compile(r'^application/(?:[^+]+\+)?json$', re.IGNORECASE) self.fmt_xml_regex = re.compile(r'^application/(?:[^+]+\+)?xml$', re.IGNORECASE)
def run_discovery(o): while True: try: cb(self.discover(path, o)) except OneM2MErrorResponse as error_response: if err_cb: return err_cb(error_response) else: if auto_cra: o['createdAfter'] = datetime_now() sleep(interval)
def main(): """ Testing code """ def update_function(instance): pass e = ExpTimeUpdater(send_update=update_function, interval=5, offset=1) from openmtc_onem2m.model import Container from openmtc.util import datetime_now from time import sleep instance = Container(expirationTime=datetime_now(), path="/test/path") e.start(instance) sleep(10)
def __init__(self, name=None, cse_base=None, expiration_time=None, announce_to=None, *args, **kw): super(XAE, self).__init__(*args, **kw) self.__app = None self.__subscriptions = [] if name: self.name = name elif not self.name: self.name = type(self).__name__ if cse_base: self.cse_base = cse_base self.ae_id = "C" + self.name if expiration_time is not None: if isinstance(expiration_time, basestring): expiration_time = parse_date(expiration_time) elif isinstance(expiration_time, (int, float)): expiration_time = datetime.fromtimestamp(expiration_time, UTC) if not isinstance(expiration_time, datetime): raise ValueError(expiration_time) self.default_lifetime = (expiration_time - datetime_now()).total_seconds() self.announceTo = announce_to self.__resumed_registration = False self.__known_containers = set() self.__shutdown = False self.mapper = None self.allow_duplicate = None self.runner = None self.fmt_json_regex = re.compile(r'application/([\w]+\+)?json') self.fmt_xml_regex = re.compile(r'application/([\w]+\+)?xml')
def periodic_discover(self, fc, interval, func): try: func(self.discover(fc)) except SCLError: pass now = datetime_now() try: fc['createdAfter'] = now except AttributeError: fc = {'createdAfter': now} def rerun_discovery(o): try: func(self.discover(fc)) except SCLError: pass o['createdAfter'] = datetime_now() spawn_later(interval, rerun_discovery, o) return spawn_later(interval, rerun_discovery, fc)
def _check_timetable(self): if not self._running: return now = datetime_now() sleeptime = self.timeout while len(self._timetable) > 0 and now >= self._timetable[0][0]: expired_path = self._timetable.pop(0)[1] # self._resources.pop(expired_path) self.logger.info("Resource has expired: %s", expired_path) self._purge(expired_path) try: td = self._timetable[0][0] - now try: td = td.total_seconds() except AttributeError: # Jython does not have timedelta.total_seconds() td = td.seconds + (td.days * 24 * 60 * 60) sleeptime = min(td, sleeptime) except IndexError: pass self._timer = self.api.set_timer(sleeptime, self._check_timetable)