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 _init(self):
try:
onem2m_config = self.config["onem2m"]
except KeyError:
raise ConfigurationError("No onem2m config part!")
# cse id
try:
self.cse_id = "/" + onem2m_config["cse_id"]
except KeyError:
raise ConfigurationError("Missing configuration key: cse_id")
# 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, ))
self.cse_type = CSETypeIDE(cse_type)
self.cse_base = onem2m_config.get("cse_base", "onem2m")
self.labels = self.config.get("labels", [])
self.__registrations = []
self._initialized()
def _start(self):
servers = []
additional_hostnames = self.config["global"].get(
"additional_hostnames") or []
if not isinstance(additional_hostnames, list):
raise ConfigurationError("additional_hostnames is not a list")
for endpoint in self.config.get("connectors", []):
interface = endpoint["interface"]
port = endpoint["port"]
host = endpoint["host"]
keyfile = endpoint.get("key")
certfile = endpoint.get("crt")
is_wan = endpoint.get("is_wan")
if not host:
host = self._guess_host(interface)
self.logger.debug("No host specified for connector on '%s'. "
"Guessing %s", interface, host)
connectors = self._guess_alternatives(interface)
else:
connectors = []
is_coaps = keyfile and certfile
if is_coaps:
scheme = "coaps"
ssl_args = {"keyfile": keyfile, "certfile": certfile}
else:
scheme = "coap"
ssl_args = None
base_uri = "%s://%s:%s" % (scheme, host, port)
connectors = [base_uri] + ["%s://%s:%s" % (scheme, host, port)
for host in connectors]
for hostname in additional_hostnames:
alternative = "%s://%s" % (scheme, hostname, )
if urlparse(alternative).port in (None, ''):
alternative = "%s:%s" % (alternative, port)
connectors.append(alternative)
if endpoint.is_wan is None:
# TODO: guess if an interface is a WAN interface
raise NotImplementedError()
connector = Connector(base_uri, connectors, is_wan)
servers.append(CoapServer(self.api.handle_request,
connector=connector, address=interface,
server_port=port, ssl_args=ssl_args))
self.api.register_connector(connector)
rack = self.__rack = GEventServerRack(servers)
rack.start()
self._started()
def _handle_remote_cse_update_expiration_time(self,
remote_cse,
instance=None):
""" Sends a update request for the RemoteCSE resource.
Retrieves resource data afterwards.
@return: RemoteCSE instance representing the created resource.
"""
try:
remote_cse_id = "/" + remote_cse["cse_id"]
except KeyError:
raise ConfigurationError('Missing parameter (cse_id) in %s' %
remote_cse)
# cse type
remote_cse_type = remote_cse.get("cse_type")
try:
remote_cse_type = getattr(
CSETypeIDE,
str(remote_cse_type).replace("-", "_").upper())
except (AttributeError, TypeError, ValueError):
raise ConfigurationError("Invalid value for 'cse_type': %s" %
(remote_cse_type, ))
def _update_own_remote_cse_remotely():
cse = RemoteCSE(expirationTime=instance.expirationTime)
# todo: need to check format here?
to = remote_cse_id + "/" + instance.resourceID
request = OneM2MRequest(OneM2MOperation.update,
to,
fr=self.originator,
ty=RemoteCSE,
pc=cse)
return self.api.send_onem2m_request(request)
try:
_update_own_remote_cse_remotely().get()
except CSETargetNotReachable as e_not_reachable:
raise e_not_reachable
except OneM2MErrorResponse as error_response:
if error_response.response_status_code == STATUS_CONFLICT:
raise CSEConflict()
else:
pass
def __subscribe(remote_cse):
try:
remote_cse_id = "/" + remote_cse["cse_id"]
except KeyError:
raise ConfigurationError('Missing parameter (cse_id) in %s' %
remote_cse)
subs = Subscription(notificationURI=self.api.get_onem2m_endpoints())
to = remote_cse_id + "/" + remote_cse.get("cse_base", "onem2m")
request = OneM2MRequest(OneM2MOperation.create, to,
self.originator,
ty=Subscription,
pc=subs)
return self.api.send_onem2m_request(request)
def load_db_module(config, **override_params):
try:
dbconfig = config["database"]
except KeyError:
raise ConfigurationError("db configuration is missing")
try:
db_fq_name = dbconfig["driver"]
except KeyError:
raise ConfigurationError(
"db configuration is missing a 'driver' entry")
package, _, clsname = db_fq_name.rpartition(".")
if not package or not clsname:
raise ConfigurationError("Invalid DB driver string")
module = import_module(package)
cls = getattr(module, clsname)
dbconfig.update(override_params)
return cls(dbconfig)
def _handle_remote_cse_delete(self, remote_cse):
""" Sends a delete request for the RemoteCSE resource.
"""
try:
remote_cse_id = "/" + remote_cse["cse_id"]
except KeyError:
raise ConfigurationError('Missing parameter (cse_id) in %s' %
remote_cse)
remote_cse_base = remote_cse.get("cse_base", "onem2m")
def _delete_remote_cse_base():
to = remote_cse_id + '/' + remote_cse_base + self.cse_id
request = OneM2MRequest(OneM2MOperation.delete, to,
self.originator)
return self.api.send_onem2m_request(request)
_delete_remote_cse_base()
def __init__(self, *args, **kw):
super(GEventSQLDBAdapter, self).__init__(*args, **kw)
self._shelves = set()
self._mapped_column_names = {}
try:
driver = self.config["backend"]
connectionstring = self.config["connectionstring"]
except KeyError as e:
raise ConfigurationError("DB configuration key missing: %s" % (e,))
poolsize = self.config.get("concurrency", DEFAULT_CONCURRENCY)
if driver == "sqlite3" and poolsize != 1:
self.logger.warn(
"Limiting DB Connection pool size to 1 for sqlite DB")
poolsize = 1
try:
self._pool = DBPool(connectionstring=connectionstring,
poolsize=poolsize,
modulename=driver)
except Exception as e:
self.logger.debug("DB module loading failed", exc_info=True)
raise DBError("Failed to load database backend driver '%s': %s" %
(driver, e))
if driver == "sqlite3":
self.__sql_creator = SQLiteSQLCreator()
else:
self.__sql_creator = SQLCreator()
# this is necessary for generating inserts with mapped column names
# (that contain e.g. "-")
self.__sql_creator.mapped_column_names = self._mapped_column_names
self._map_types()
if self._pool.paramstyle not in ("qmark", "format", "quote"):
raise NotImplementedError("paramstyle", self._pool.paramstyle)
def prepare_config(config):
try:
global_config = config["global"]
except KeyError:
global_config = config["global"] = {}
try:
etsi_version = global_config["etsi_version"]
except KeyError:
etsi_version = global_config["etsi_version"] = LATEST_VERSION
try:
etsi_compatibility = global_config["etsi_compatibility"]
except KeyError:
global_config["etsi_compatibility"] = etsi_version
else:
if etsi_compatibility > etsi_version:
raise ConfigurationError("'etsi_version' (%s) must be greater or "
"equal to 'etsi_compatibility' (%s)" %
(etsi_version, etsi_compatibility))
global_config.setdefault("ignore_extra_attributes", False)
return config
def _handle_remote_cse(self, remote_cse):
""" Sends a create request for the RemoteCSE resource.
Retrieves resource data afterwards.
@return: RemoteCSE instance representing the created resource.
"""
try:
remote_cse_id = "/" + remote_cse["cse_id"]
except KeyError:
raise ConfigurationError('Missing parameter (cse_id) in %s' %
remote_cse)
# cse type
remote_cse_type = remote_cse.get("cse_type")
try:
remote_cse_type = getattr(
CSETypeIDE,
str(remote_cse_type).replace("-", "_").upper())
except (AttributeError, TypeError, ValueError):
raise ConfigurationError("Invalid value for 'cse_type': %s" %
(remote_cse_type, ))
remote_cse_type = CSETypeIDE(remote_cse_type)
remote_cse_base = remote_cse.get("cse_base", "onem2m")
remote_cse_uri = remote_cse_id + '/' + remote_cse_base
self.logger.info("registering %s at %s", self.cse_id, remote_cse_id)
def _create_own_remote_cse_remotely():
endpoints = self.api.get_onem2m_endpoints()
from openmtc.util import datetime_the_future
# init RemoteCSE object
cse = RemoteCSE(resourceName=self.cse_id[1:],
labels=self.labels,
cseType=self.cse_type,
pointOfAccess=endpoints,
CSEBase=self.cse_base,
CSE_ID=self.cse_id,
requestReachability=bool(len(endpoints)),
expirationTime=datetime_the_future(
self.get_offset))
if remote_cse.get('own_poa'):
cse.pointOfAccess = remote_cse.get('own_poa')
request = OneM2MRequest(OneM2MOperation.create,
remote_cse_uri,
self.originator,
ty=RemoteCSE,
pc=cse)
return self.api.send_onem2m_request(request)
def _retrieve_remote_cse_base():
request = OneM2MRequest(OneM2MOperation.retrieve,
remote_cse_uri,
self.originator,
ty=CSEBase)
return self.api.send_onem2m_request(request)
def _create_remote_cse_locally(cse_base):
cse = RemoteCSE(resourceName=remote_cse_id[1:],
CSEBase=remote_cse_base,
CSE_ID=remote_cse_id,
cseType=remote_cse_type,
pointOfAccess=cse_base.pointOfAccess)
cse.pointOfAccess = remote_cse.get('poa')
request = OneM2MRequest(OneM2MOperation.create,
self.cse_base,
self.originator,
ty=RemoteCSE,
pc=cse)
return self.api.handle_onem2m_request(request)
try:
instance = _create_own_remote_cse_remotely().get().content
def _update_function(updated_instance):
self._handle_remote_cse_update_expiration_time(
remote_cse, updated_instance)
self.refresher.start(instance, send_update=_update_function)
except CSETargetNotReachable as e_not_reachable:
# TODO(rst): print error message
raise e_not_reachable
except OneM2MErrorResponse as error_response:
if error_response.response_status_code == STATUS_CONFLICT:
# TODO(rst): handle conflict here
raise CSEConflict()
else:
retrieved_cse_base = _retrieve_remote_cse_base().get().content
if retrieved_cse_base is None:
raise CSENotFound()
_create_remote_cse_locally(retrieved_cse_base).get()
def __init__(self, issuer, request_dict, context, logger):
self.logger = logger
self.issuer = issuer
self.context = context
self.logger.info("request dict is " + str(request_dict))
if "method" in request_dict:
# if request_dict.has_key("method"):
self.method = request_dict[
"method"] # create, update, retrieve, update
else:
raise IntentError("Extra field method is not present")
return
try:
self.method = request_dict[
"method"] # create, update, retrieve, update
self.logger.info("method: %s", self.method)
except KeyError:
raise ConfigurationError("Extra field method is not present")
if request_dict.has_key("path"):
self.path = request_dict.get(
"path"
) # http://something, e.g. "http://some.host:1234/m2m/applications"
self.logger.info("path: " + str(self.path))
else:
raise IntentError("Extra field path is not present")
return
if request_dict.has_key("content_type"):
self.content_type = request_dict.get(
"content_type") # application/json
else:
self.logger.info(
"Extra field content_type not provided, default value application/json used"
)
self.content_type = "application/json"
self.logger.info("content_type: " + str(self.content_type))
if request_dict.has_key("requestId"):
self.intentRequestId = request_dict.get("requestId")
self.logger.info("requestId is " + self.intentRequestId)
else:
self.logger.info("Extra field requestId is not present")
if request_dict.has_key("replyAction"):
self.replyAction = request_dict.get("replyAction")
self.logger.info("replyAction: " + str(self.replyAction))
else:
raise IntentError("Extra field replyAction is not present")
return
if request_dict.has_key("searchStrings"):
self.searchStrings = request_dict.get("searchStrings")
self.logger.info("searchStrings: " + str(self.searchStrings))
else:
self.logger.info("no searchStrings present")
if request_dict.has_key("requestCategory"):
self.requestCategory = request_dict.get("requestCategory")
self.logger.info("requestCategory: " + str(self.requestCategory))
else:
self.logger.info("no requestCategory present, assuming default 7")
self.requestCategory = 7
if request_dict.has_key("tolerantDelay"):
self.tolerantDelay = request_dict.get("tolerantDelay")
self.logger.info("tolerantDelay: " + str(self.tolerantDelay))
else:
self.logger.info("no tolerantDelay present, assuming default 30s")
self.tolerantDelay = 30
if request_dict.has_key("contactURI"):
self.contactURI = request_dict.get("contactURI")
self.logger.info("contactURI: " + str(self.contactURI))
else:
self.logger.info("no contactURI present")
if request_dict.has_key("content"):
self.content = request_dict.get("content")
self.logger.info("content: " + str(self.content))
else:
self.logger.info("Extra field content was not provided")
if len(self.content) is 0:
self.logger.info("content is empty")
def _start(self):
servers = []
additional_hostnames = self.config["global"].get(
"additional_hostnames", [])
if not isinstance(additional_hostnames, list):
raise ConfigurationError("additional_hostnames is not a list")
require_auth = self.config["global"].get("require_auth", True)
for endpoint in self.config.get("connectors", []):
interface = endpoint["interface"]
port = endpoint["port"]
host = endpoint["host"]
keyfile = endpoint.get("key")
certfile = endpoint.get("crt")
if not host:
host = self._guess_host(interface)
self.logger.info(
"No host specified for connector on '%s'. "
"Guessing %s", interface, host)
connectors = self._guess_alternatives(interface)
else:
connectors = []
is_https = keyfile and certfile
scheme = "https" if is_https else "http"
base_uri = "%s://%s:%s" % (scheme, host, port)
connectors = [
"%s://%s:%s" % (scheme, host, port) for host in connectors
]
default_port = getservbyname(scheme)
if port == default_port:
connectors.append("%s://%s" % (scheme, host))
for hostname in additional_hostnames:
alternative = "%s://%s" % (scheme, hostname)
parsed_alternative = urlparse(alternative)
alternative_port = parsed_alternative.port
if alternative_port in (None, ''):
alternative_port = port
alternative = "%s:%s" % (alternative, port)
connectors.append(alternative)
if alternative_port == default_port:
connectors.append("%s://%s" %
(scheme, parsed_alternative.hostname))
if endpoint.is_wan is None:
# TODO: guess if an interface is a WAN interface
raise NotImplementedError()
connector = Connector(base_uri, connectors, endpoint.is_wan)
application = OpenMTCWSGIApplication(self.api.handle_request,
connector=connector,
server_address=interface,
require_auth=require_auth)
if is_https:
servers.append(
WSGIServer((interface, port),
application,
environ={'SERVER_NAME': 'openmtc.local'},
keyfile=keyfile,
certfile=certfile))
else:
servers.append(
WSGIServer((interface, port),
application,
environ={'SERVER_NAME': 'openmtc.local'}))
self.api.register_connector(connector)
rack = self.__rack = GEventServerRack(servers)
rack.start()
self._started()
def _start(self):
servers = []
prefer_xml = bool(self.config["global"].get("prefer_xml"))
additional_hostnames = self.config["global"].get(
"additional_hostnames") or []
if not isinstance(additional_hostnames, list):
raise ConfigurationError("additional_hostnames is not a list")
pretty = self.config.get("pretty_print", "auto")
if pretty and pretty is not True:
try:
pretty = pretty.lower()
except AttributeError:
pretty = True
else:
if pretty == "auto":
pretty = None
else:
pretty = True
require_auth = self.config["global"].get("require_auth", True)
for endpoint in self.config.get("endpoints") or []:
interface = endpoint.get("interface") or ""
port = endpoint["port"]
personality = endpoint["personality"]
host = endpoint.get("host")
keyfile = endpoint.get("key")
certfile = endpoint.get("crt")
if not host:
host = self._guess_host(interface)
self.logger.info(
"No host specified for %s endpoint on '%s'. Guessing %s",
personality, interface, host)
alternatives = self._guess_alternatives(interface)
else:
alternatives = []
application = SCLWSGIApplication(
self.api.handle_request_indication,
base_uri=None,
server_address=interface,
reference_point=personality,
prefer_xml=prefer_xml,
require_auth=require_auth,
etsi_version_v2=self.etsi_version_v2,
etsi_compatibility=self.etsi_compatibility_needed)
if keyfile and certfile:
scheme = "https"
base_uri = application.base_uri = "https://%s:%s" % (host,
port)
servers.append(
WSGIServer((interface, port),
application,
keyfile=keyfile,
certfile=certfile))
else:
scheme = "http"
base_uri = application.base_uri = "http://%s:%s" % (host, port)
servers.append(WSGIServer((interface, port), application))
self.api.register_endpoint(personality, base_uri)
alternatives = [
"%s://%s:%s" % (scheme, host, port) for host in alternatives
]
default_port = getservbyname(scheme)
if port == default_port:
alternatives.append("%s://%s" % (scheme, host))
if additional_hostnames:
for hostname in additional_hostnames:
alternative = "%s://%s" % (scheme, hostname)
parsed_alternative = urlparse(alternative)
alternative_port = parsed_alternative.port
if alternative_port in (None, ''):
alternative_port = port
alternative = "%s:%s" % (alternative, port)
alternatives.append(alternative)
if alternative_port == default_port:
alternatives.append(
"%s://%s" % (scheme, parsed_alternative.hostname))
if alternatives:
self.api.register_alternative_endpoints(
personality, alternatives)
rack = self.__rack = GEventServerRack(servers)
rack.start()
self._started()