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)
