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/',
'username': '******',
'password': '******'
}
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 __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/',
'username': '******',
'password': '******'
}
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/',
'username': '******',
'password': '******'
}
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
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/',
'username': '******',
'password': '******'
}
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
