def __init__(
self,
baseObject=None,
port=None
): # FIXME if no baseObject given, create a default base object
if port == None:
self._port = 5683 # IETF default port for coap://
else:
self._port = port
if baseObject == None:
from iottoolkit.core.SmartObject import SmartObject
self._baseObject = SmartObject()
else:
self._baseObject = baseObject
self.resources = self._baseObject.resources
self._host = gethostname()
self._baseObject.Properties.update(
{'coapService': 'coap://' + self._host + ':' + repr(self._port)})
self._coapHandler = CoapRequestHandler(self._baseObject)
self._coapServer = COAPServer(self._host, self._port,
self._coapHandler)
def __init__(self, baseObject=None, port=None):
if port == None:
self._port = 8000
else:
self._port = port # default port 8000
if baseObject == None:
from iottoolkit.core.SmartObject import SmartObject
self._baseObject = SmartObject()
else:
self._baseObject = baseObject
self.resources = self._baseObject.resources
self.start(self._port)
def __init__(self, systemConstructor):
self._service_metadata = systemConstructor["service_metadata"]
self._services = systemConstructor["services"]
self._object_metadata = systemConstructor["object_metadata"]
self._objects = systemConstructor["objects"]
self._baseObject = None
self._defaultResources = {
"SmartObject": ["Description", "Agent"],
"ObservableProperty": ["Description", "Observers"],
}
self._observerTypes = ["subscribesTo", "publishesTo", "bridgesTo", "handledBy"]
self._observerSchemes = ["http", "coap", "mqtt", "handler"]
self._mqttObserverTemplate = {
"resourceName": "mqttObserver",
"resourceClass": "mqttObserver",
"connection": "localhost",
"pubTopic": "",
"subTopic": "",
"keepAlive": 60,
"QoS": 0,
}
self._httpPublisherTemplate = {
"resourceName": "httpPublisher",
"resourceClass": "httpPublisher",
"targetURI": "http://localhost:8000/",
}
self._httpSubscriberTemplate = {
"resourceName": "httpSubscriber",
"resourceClass": "httpSubscriber",
"ObserverURI": "http://localhost:8000/",
}
self._coapPublisherTemplate = {
"resourceName": "coapPublisher",
"resourceClass": "coapPublisher",
"targetURI": "coap://localhost:5683/",
}
self._coapSubscriberTemplate = {
"resourceName": "coapSubscriber",
"resourceClass": "coapSubscriber",
"ObserverURI": "coap://localhost:5683/",
}
self._callbackNotifierTemplate = {
"resourceName": "callbackNotifier",
"resourceClass": "callbackNotifier",
"handlerURI": "handler://",
}
"""
make objects from object models first
make list sorted by path element count + length for import from graph,
could count a split list but this should be the same if we eat slashes somewhere
having the root object called '/' and '/' as the separator is extra work
"""
self._resourceList = sorted(self._objects.keys(), key=lambda s: s.count("/"))
self._resourceList = sorted(self._resourceList, key=lambda s: len(s))
for self._resourceLink in self._resourceList:
self._resourceDescriptor = self._objects[self._resourceLink]
# see if base object needs to be created.
if (
self._resourceLink is "/"
and self._resourceDescriptor["resourceClass"] is "SmartObject"
and self._baseObject is None
):
self._newResource = SmartObject()
self._baseObject = self._newResource
else:
self._parentLink = "/".join(self._resourceLink.split("/")[:-1])
if self._parentLink == "":
self._parentLink = "/"
self._parentObject = self._objectFromPath(self._parentLink, self._baseObject)
self._newResource = self._parentObject.create(self._resourceDescriptor)
if self._resourceDescriptor["resourceClass"] in self._defaultResources:
for self._defaultResource in self._defaultResources[self._resourceDescriptor["resourceClass"]]:
self._newChildResource = self._newResource.create(
{"resourceName": self._defaultResource, "resourceClass": self._defaultResource}
)
if self._defaultResource is "Description":
self._newChildResource.create(
self._graphFromModel(self._resourceLink, self._resourceDescriptor)
)
self._newResource.create({"resourceName": ".well-known", "resourceClass": "Agent"}).create(
{"resourceName": "core", "resourceClass": "LinkFormatProxy"}
)
# FIXME need to aggregate graphs upstream
# make observers from the list of URIs of each Observer type
for self._resourceProperty in self._resourceDescriptor:
if self._resourceProperty in self._observerTypes:
for self._observerURI in self._resourceDescriptor[self._resourceProperty]:
self._observerFromURI(self._newResource, self._resourceProperty, self._observerURI)
"""
make services
"""
# make this a service Object (RESTfulResource) with dict as constructor
self._serviceRegistry = self._objectFromPath("/services", self._baseObject)
self._serviceDescription = self._objectFromPath("/services/Description", self._baseObject)
for self._serviceName in self._services:
self._newService = ServiceObject(self._serviceName, self._services[self._serviceName], self._baseObject)
self._serviceRegistry.resources.update({self._serviceName: self._newService})
self._serviceDescription.set(self._graphFromModel(self._serviceName, self._services[self._serviceName]))
class SystemInstance(object):
"""
creates service instances and object instances from dictionary constructors
{
'service_metadata': {},
'services': {},
'object_metadata': {},
'objects': {}
}
"""
def __init__(self, systemConstructor):
self._service_metadata = systemConstructor["service_metadata"]
self._services = systemConstructor["services"]
self._object_metadata = systemConstructor["object_metadata"]
self._objects = systemConstructor["objects"]
self._baseObject = None
self._defaultResources = {
"SmartObject": ["Description", "Agent"],
"ObservableProperty": ["Description", "Observers"],
}
self._observerTypes = ["subscribesTo", "publishesTo", "bridgesTo", "handledBy"]
self._observerSchemes = ["http", "coap", "mqtt", "handler"]
self._mqttObserverTemplate = {
"resourceName": "mqttObserver",
"resourceClass": "mqttObserver",
"connection": "localhost",
"pubTopic": "",
"subTopic": "",
"keepAlive": 60,
"QoS": 0,
}
self._httpPublisherTemplate = {
"resourceName": "httpPublisher",
"resourceClass": "httpPublisher",
"targetURI": "http://localhost:8000/",
}
self._httpSubscriberTemplate = {
"resourceName": "httpSubscriber",
"resourceClass": "httpSubscriber",
"ObserverURI": "http://localhost:8000/",
}
self._coapPublisherTemplate = {
"resourceName": "coapPublisher",
"resourceClass": "coapPublisher",
"targetURI": "coap://localhost:5683/",
}
self._coapSubscriberTemplate = {
"resourceName": "coapSubscriber",
"resourceClass": "coapSubscriber",
"ObserverURI": "coap://localhost:5683/",
}
self._callbackNotifierTemplate = {
"resourceName": "callbackNotifier",
"resourceClass": "callbackNotifier",
"handlerURI": "handler://",
}
"""
make objects from object models first
make list sorted by path element count + length for import from graph,
could count a split list but this should be the same if we eat slashes somewhere
having the root object called '/' and '/' as the separator is extra work
"""
self._resourceList = sorted(self._objects.keys(), key=lambda s: s.count("/"))
self._resourceList = sorted(self._resourceList, key=lambda s: len(s))
for self._resourceLink in self._resourceList:
self._resourceDescriptor = self._objects[self._resourceLink]
# see if base object needs to be created.
if (
self._resourceLink is "/"
and self._resourceDescriptor["resourceClass"] is "SmartObject"
and self._baseObject is None
):
self._newResource = SmartObject()
self._baseObject = self._newResource
else:
self._parentLink = "/".join(self._resourceLink.split("/")[:-1])
if self._parentLink == "":
self._parentLink = "/"
self._parentObject = self._objectFromPath(self._parentLink, self._baseObject)
self._newResource = self._parentObject.create(self._resourceDescriptor)
if self._resourceDescriptor["resourceClass"] in self._defaultResources:
for self._defaultResource in self._defaultResources[self._resourceDescriptor["resourceClass"]]:
self._newChildResource = self._newResource.create(
{"resourceName": self._defaultResource, "resourceClass": self._defaultResource}
)
if self._defaultResource is "Description":
self._newChildResource.create(
self._graphFromModel(self._resourceLink, self._resourceDescriptor)
)
self._newResource.create({"resourceName": ".well-known", "resourceClass": "Agent"}).create(
{"resourceName": "core", "resourceClass": "LinkFormatProxy"}
)
# FIXME need to aggregate graphs upstream
# make observers from the list of URIs of each Observer type
for self._resourceProperty in self._resourceDescriptor:
if self._resourceProperty in self._observerTypes:
for self._observerURI in self._resourceDescriptor[self._resourceProperty]:
self._observerFromURI(self._newResource, self._resourceProperty, self._observerURI)
"""
make services
"""
# make this a service Object (RESTfulResource) with dict as constructor
self._serviceRegistry = self._objectFromPath("/services", self._baseObject)
self._serviceDescription = self._objectFromPath("/services/Description", self._baseObject)
for self._serviceName in self._services:
self._newService = ServiceObject(self._serviceName, self._services[self._serviceName], self._baseObject)
self._serviceRegistry.resources.update({self._serviceName: self._newService})
self._serviceDescription.set(self._graphFromModel(self._serviceName, self._services[self._serviceName]))
def _graphFromModel(self, link, meta):
# make rdf-json from the model and return RDF graph for loading into Description
g = rdflib.Graph()
subject = URIRef(link)
for relation in meta:
value = meta[relation]
g.add((subject, Literal(relation), Literal(value)))
return g
def _observerFromURI(self, currentResource, observerType, observerURI):
# split by scheme
URIObject = urlparse(observerURI)
# fill in constructor template
if URIObject.scheme == "http":
if observerType is "publishesTo":
resourceConstructor = self._httpPublisherTemplate.copy()
resourceConstructor["targetURI"] = observerURI
if observerType is "subscribesTo":
resourceConstructor = self._httpSubscriberTemplate.copy()
resourceConstructor["observerURI"] = observerURI
elif URIObject.scheme == "coap":
if observerType is "publishesTo":
resourceConstructor = self._coapPublisherTemplate.copy()
resourceConstructor["targetURI"] = observerURI
if observerType is "subscribesTo":
resourceConstructor = self._coapSubscriberTemplate.copy()
resourceConstructor["observerURI"] = observerURI
elif URIObject.scheme == "mqtt":
resourceConstructor = self._mqttObserverTemplate.copy()
resourceConstructor["connection"] = URIObject.netloc
if observerType is "publishesTo":
resourceConstructor["pubTopic"] = URIObject.path
if observerType is "subscribesTo":
resourceConstructor["subTopic"] = URIObject.path
if observerType is "bridgesTo":
resourceConstructor["pubTopic"] = URIObject.path
resourceConstructor["subTopic"] = URIObject.path
elif URIObject.scheme == "handler":
resourceConstructor = self._callbackNotifierTemplate.copy()
resourceConstructor["handlerURI"] = observerURI
else:
print "no scheme", URIObject.scheme
return
# create resource in currentResource.resources['Observers'] container
newObserver = currentResource.resources["Observers"].create(resourceConstructor)
def _objectFromPath(self, path, baseObject):
# fails if resource doesn't exist
currentObject = baseObject
pathList = path.split("/")[1:]
for pathElement in pathList:
if len(pathElement) > 0:
currentObject = currentObject.resources[pathElement]
return currentObject
def __init__(self, systemConstructor):
self._service_metadata = systemConstructor['service_metadata']
self._services = systemConstructor['services']
self._object_metadata = systemConstructor['object_metadata']
self._objects = systemConstructor['objects']
self._baseObject = None
self._defaultResources = {
'SmartObject': ['Description', 'Agent'],
'ObservableProperty': ['Description', 'Observers']
}
self._observerTypes = [
'subscribesTo', 'publishesTo', 'bridgesTo', 'handledBy'
]
self._observerSchemes = ['http', 'coap', 'mqtt', 'handler']
self._mqttObserverTemplate = {
'resourceName': 'mqttObserver',
'resourceClass': 'mqttObserver',
'connection': 'localhost',
'pubTopic': '',
'subTopic': '',
'keepAlive': 60,
'QoS': 0
}
self._httpPublisherTemplate = {
'resourceName': 'httpPublisher',
'resourceClass': 'httpPublisher',
'targetURI': 'http://localhost:8000/'
}
self._httpSubscriberTemplate = {
'resourceName': 'httpSubscriber',
'resourceClass': 'httpSubscriber',
'ObserverURI': 'http://localhost:8000/',
}
self._coapPublisherTemplate = {
'resourceName': 'coapPublisher',
'resourceClass': 'coapPublisher',
'targetURI': 'coap://localhost:5683/'
}
self._coapSubscriberTemplate = {
'resourceName': 'coapSubscriber',
'resourceClass': 'coapSubscriber',
'ObserverURI': 'coap://localhost:5683/'
}
self._callbackNotifierTemplate = {
'resourceName': 'callbackNotifier',
'resourceClass': 'callbackNotifier',
'handlerURI': 'handler://'
}
'''
make objects from object models first
make list sorted by path element count + length for import from graph,
could count a split list but this should be the same if we eat slashes somewhere
having the root object called '/' and '/' as the separator is extra work
'''
self._resourceList = sorted(self._objects.keys(),
key=lambda s: s.count('/'))
self._resourceList = sorted(self._resourceList, key=lambda s: len(s))
for self._resourceLink in self._resourceList:
self._resourceDescriptor = self._objects[self._resourceLink]
# see if base object needs to be created.
if self._resourceLink is '/' and self._resourceDescriptor[
'resourceClass'] is 'SmartObject' and self._baseObject is None:
self._newResource = SmartObject()
self._baseObject = self._newResource
else:
self._parentLink = '/'.join(self._resourceLink.split('/')[:-1])
if self._parentLink == '': self._parentLink = '/'
self._parentObject = self._objectFromPath(
self._parentLink, self._baseObject)
self._newResource = self._parentObject.create(
self._resourceDescriptor)
if self._resourceDescriptor[
'resourceClass'] in self._defaultResources:
for self._defaultResource in self._defaultResources[
self._resourceDescriptor['resourceClass']]:
self._newChildResource = self._newResource.create({
'resourceName':
self._defaultResource,
'resourceClass':
self._defaultResource
})
if self._defaultResource is 'Description':
self._newChildResource.create(
self._graphFromModel(self._resourceLink,
self._resourceDescriptor))
self._newResource.create({'resourceName':'.well-known', 'resourceClass':'Agent'})\
.create({'resourceName':'core', 'resourceClass':'LinkFormatProxy'})
# FIXME need to aggregate graphs upstream
# make observers from the list of URIs of each Observer type
for self._resourceProperty in self._resourceDescriptor:
if self._resourceProperty in self._observerTypes:
for self._observerURI in self._resourceDescriptor[
self._resourceProperty]:
self._observerFromURI(self._newResource,
self._resourceProperty,
self._observerURI)
'''
make services
'''
# make this a service Object (RESTfulResource) with dict as constructor
self._serviceRegistry = self._objectFromPath('/services',
self._baseObject)
self._serviceDescription = self._objectFromPath(
'/services/Description', self._baseObject)
for self._serviceName in self._services:
self._newService = ServiceObject(self._serviceName,
self._services[self._serviceName],
self._baseObject)
self._serviceRegistry.resources.update(
{self._serviceName: self._newService})
self._serviceDescription.set(
self._graphFromModel(self._serviceName,
self._services[self._serviceName]))
class SystemInstance(object):
'''
creates service instances and object instances from dictionary constructors
{
'service_metadata': {},
'services': {},
'object_metadata': {},
'objects': {}
}
'''
def __init__(self, systemConstructor):
self._service_metadata = systemConstructor['service_metadata']
self._services = systemConstructor['services']
self._object_metadata = systemConstructor['object_metadata']
self._objects = systemConstructor['objects']
self._baseObject = None
self._defaultResources = {
'SmartObject': ['Description', 'Agent'],
'ObservableProperty': ['Description', 'Observers']
}
self._observerTypes = [
'subscribesTo', 'publishesTo', 'bridgesTo', 'handledBy'
]
self._observerSchemes = ['http', 'coap', 'mqtt', 'handler']
self._mqttObserverTemplate = {
'resourceName': 'mqttObserver',
'resourceClass': 'mqttObserver',
'connection': 'localhost',
'pubTopic': '',
'subTopic': '',
'keepAlive': 60,
'QoS': 0
}
self._httpPublisherTemplate = {
'resourceName': 'httpPublisher',
'resourceClass': 'httpPublisher',
'targetURI': 'http://localhost:8000/'
}
self._httpSubscriberTemplate = {
'resourceName': 'httpSubscriber',
'resourceClass': 'httpSubscriber',
'ObserverURI': 'http://localhost:8000/',
}
self._coapPublisherTemplate = {
'resourceName': 'coapPublisher',
'resourceClass': 'coapPublisher',
'targetURI': 'coap://localhost:5683/'
}
self._coapSubscriberTemplate = {
'resourceName': 'coapSubscriber',
'resourceClass': 'coapSubscriber',
'ObserverURI': 'coap://localhost:5683/'
}
self._callbackNotifierTemplate = {
'resourceName': 'callbackNotifier',
'resourceClass': 'callbackNotifier',
'handlerURI': 'handler://'
}
'''
make objects from object models first
make list sorted by path element count + length for import from graph,
could count a split list but this should be the same if we eat slashes somewhere
having the root object called '/' and '/' as the separator is extra work
'''
self._resourceList = sorted(self._objects.keys(),
key=lambda s: s.count('/'))
self._resourceList = sorted(self._resourceList, key=lambda s: len(s))
for self._resourceLink in self._resourceList:
self._resourceDescriptor = self._objects[self._resourceLink]
# see if base object needs to be created.
if self._resourceLink is '/' and self._resourceDescriptor[
'resourceClass'] is 'SmartObject' and self._baseObject is None:
self._newResource = SmartObject()
self._baseObject = self._newResource
else:
self._parentLink = '/'.join(self._resourceLink.split('/')[:-1])
if self._parentLink == '': self._parentLink = '/'
self._parentObject = self._objectFromPath(
self._parentLink, self._baseObject)
self._newResource = self._parentObject.create(
self._resourceDescriptor)
if self._resourceDescriptor[
'resourceClass'] in self._defaultResources:
for self._defaultResource in self._defaultResources[
self._resourceDescriptor['resourceClass']]:
self._newChildResource = self._newResource.create({
'resourceName':
self._defaultResource,
'resourceClass':
self._defaultResource
})
if self._defaultResource is 'Description':
self._newChildResource.create(
self._graphFromModel(self._resourceLink,
self._resourceDescriptor))
self._newResource.create({'resourceName':'.well-known', 'resourceClass':'Agent'})\
.create({'resourceName':'core', 'resourceClass':'LinkFormatProxy'})
# FIXME need to aggregate graphs upstream
# make observers from the list of URIs of each Observer type
for self._resourceProperty in self._resourceDescriptor:
if self._resourceProperty in self._observerTypes:
for self._observerURI in self._resourceDescriptor[
self._resourceProperty]:
self._observerFromURI(self._newResource,
self._resourceProperty,
self._observerURI)
'''
make services
'''
# make this a service Object (RESTfulResource) with dict as constructor
self._serviceRegistry = self._objectFromPath('/services',
self._baseObject)
self._serviceDescription = self._objectFromPath(
'/services/Description', self._baseObject)
for self._serviceName in self._services:
self._newService = ServiceObject(self._serviceName,
self._services[self._serviceName],
self._baseObject)
self._serviceRegistry.resources.update(
{self._serviceName: self._newService})
self._serviceDescription.set(
self._graphFromModel(self._serviceName,
self._services[self._serviceName]))
def _graphFromModel(self, link, meta):
# make rdf-json from the model and return RDF graph for loading into Description
g = rdflib.Graph()
subject = URIRef(link)
for relation in meta:
value = meta[relation]
g.add((subject, Literal(relation), Literal(value)))
return g
def _observerFromURI(self, currentResource, observerType, observerURI):
# split by scheme
URIObject = urlparse(observerURI)
# fill in constructor template
if URIObject.scheme == 'http':
if observerType is 'publishesTo':
resourceConstructor = self._httpPublisherTemplate.copy()
resourceConstructor['targetURI'] = observerURI
if observerType is 'subscribesTo':
resourceConstructor = self._httpSubscriberTemplate.copy()
resourceConstructor['observerURI'] = observerURI
elif URIObject.scheme == 'coap':
if observerType is 'publishesTo':
resourceConstructor = self._coapPublisherTemplate.copy()
resourceConstructor['targetURI'] = observerURI
if observerType is 'subscribesTo':
resourceConstructor = self._coapSubscriberTemplate.copy()
resourceConstructor['observerURI'] = observerURI
elif URIObject.scheme == 'mqtt':
resourceConstructor = self._mqttObserverTemplate.copy()
resourceConstructor['connection'] = URIObject.netloc
if observerType is 'publishesTo':
resourceConstructor['pubTopic'] = URIObject.path
if observerType is 'subscribesTo':
resourceConstructor['subTopic'] = URIObject.path
if observerType is 'bridgesTo':
resourceConstructor['pubTopic'] = URIObject.path
resourceConstructor['subTopic'] = URIObject.path
elif URIObject.scheme == 'handler':
resourceConstructor = self._callbackNotifierTemplate.copy()
resourceConstructor['handlerURI'] = observerURI
else:
print 'no scheme', URIObject.scheme
return
#create resource in currentResource.resources['Observers'] container
newObserver = currentResource.resources['Observers'].create(
resourceConstructor)
def _objectFromPath(self, path, baseObject):
# fails if resource doesn't exist
currentObject = baseObject
pathList = path.split('/')[1:]
for pathElement in pathList:
if len(pathElement) > 0:
currentObject = currentObject.resources[pathElement]
return currentObject
