def stringToMessage(self, msg):
if (CATCH_BAD_MESSAGES):
try:
msg = nativizeObject(msg)
except:
logWarning(
"ERROR: Could not process message data received. Received:"
+ str(msg))
msg = None
else:
msg = nativizeObject(msg)
return msg
def matchOnPartial(self, current, timestampOperator):
if self.actor is not None and current.actor != self.actor:
return False
if self.verb is not None and current.verb != self.verb:
return False
if self.object is not None and current.object != self.object:
return False
if self.speechAct is not None and current.speechAct != current.speechAct:
return False
result = nativizeObject(self.result)
if result is not None and current.result != result:
return False
context = nativizeObject(self.context)
if context is not None:
if current.context is None:
return False
#Note: I am assuming that the context is a dictionary if that isn't true then I'll need to add a type check and handle all possible types
for filterContextKey in context.keys():
if filterContextKey not in current.context.keys():
return False
currentValue = current.context[filterContextKey]
filterValue = context[filterContextKey]
if filterValue is not None:
if isinstance(currentValue,
list) and filterValue not in currentValue:
return False
elif currentValue != filterValue:
return False
if self.timestamp is not None and current.timestamp != "timestamp":
parsedTimestamp = datetime.strptime(current.timestamp,
DATE_TIME_FORMAT)
parsedFilterTimestamp = datetime.strptime(self.timestamp,
DATE_TIME_FORMAT)
if timestampOperator == "<" and parsedTimestamp < parsedFilterTimestamp:
#print(current.timestamp + " < " + self.timestamp)
return False
if timestampOperator == ">" and parsedFilterTimestamp < parsedTimestamp:
return False
if timestampOperator == "==" and parsedFilterTimestamp != parsedTimestamp:
return False
return True
def processStorageRequest(self,
bucket,
verb,
key=None,
tags=None,
aType=None,
name=None):
if verb == self.HAS_ELEMENT_VERB:
return bucket.hasRef(key, name)
elif verb == self.CONTAINS_VERB:
keys = bucket.getMatchingKeys(tags, aType)
names = [bucket.getName(aKey) for aKey in keys]
return keys, names
elif verb == self.VALUE_VERB:
if isinstance(key, (tuple, list)):
values = []
for k in key:
value = bucket.getValue(key, None)
if bucket.getDataType(key, None) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
values.append(value)
return values
elif isinstance(name, (tuple, list)):
values = []
for n in name:
value = bucket.getValue(None, n)
if bucket.getDataType(None, n) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
values.append(value)
return values
else:
value = bucket.getValue(key, name)
if bucket.getDataType(key, name) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
return value
elif verb == INFORM_REF_ACT:
if key is not None:
return (key, bucket.getName(key))
elif name is not None:
return (bucket.resolveRef(None, name), name)
else:
return None
elif verb == self.ASSIGNED_TAGS:
return bucket.getObjectTags(key, name)
elif verb == self.ASSIGNED_URI_VERB:
return bucket.getLink(key, name)
else:
return False
def getValue(self, bucket, key=None, name=None):
if isinstance(bucket, basestring):
bucket = self.getBucket(bucket)
value = bucket.getValue(key, name)
if bucket.getDataType(key, name) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
return value
def _changeName(self, newName, data):
if newName is None:
newName = ""
if (data is not None) and (newName == "" or not self.hasName(newName)):
key = data.key
name = self.getName(key)
# Update any internal naming data
if data.data_type == SERIALIZABLE_DATA_TYPE:
value = data.value
value = nativizeObject(value, None, JSON_FORMAT)
if isinstance(value, NamedSerializable):
if newName == "":
value.setName(None)
else:
value.setName(newName)
value = serializeObject(value, JSON_FORMAT)
data.value = value
# Update the storage service data
data.name = newName
if name is not None:
del self.name_map[name]
if newName != "":
self.name_map[newName] = key
isChanged = True
else:
isChanged = False
return isChanged, data
def getValue(self, bucket, key=None, name=None):
if isinstance(bucket, basestring):
bucket = self.getBucket(bucket)
value = bucket.getValue(key, name)
if bucket.getDataType(key, name) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
return value
def _changeName(self, newName, data):
if newName is None:
newName = ''
if ((data is not None)
and (newName == '' or not self.hasName(newName))):
key = data.key
name = self.getName(key)
# Update any internal naming data
if data.data_type == SERIALIZABLE_DATA_TYPE:
value = data.value
value = nativizeObject(value, None, JSON_FORMAT)
if isinstance(value, NamedSerializable):
if newName == '':
value.setName(None)
else:
value.setName(newName)
value = serializeObject(value, JSON_FORMAT)
data.value = value
# Update the storage service data
data.name = newName
if (name is not None):
del self.name_map[name]
if newName != '':
self.name_map[newName] = key
isChanged = True
else:
isChanged = False
return isChanged, data
def testDataTransforms(self):
st_1 = StorageToken(10, "TestProp", {"Prop11": 1, "Prop12": "Hello!"})
st_2 = StorageToken(11, "TestClass3", {"Prop21": 1, "Prop22": st_1})
obj1 = TestProp({"Prop11": 1, "Prop12": "Hello!"})
obj2 = TestClass3({"Prop21": 1, "Prop22": obj1})
dataStructures = [None, 1, 5.0, range(5), {"S":1,"R":[1,3,4], "5": "S"}, obj1, obj2]
x = nativizeObject(serializeObject(obj1))
x = nativizeObject(serializeObject(obj2))
for aFormat in VALID_SERIAL_FORMATS:
for x in dataStructures:
self.assertEqual(x, x)
s = serializeObject(x, aFormat)
y = nativizeObject(s, None, aFormat)
if isinstance(x, dict):
self.assertItemsEqual(x, y)
else:
self.assertEqual(x, y)
def testDataTransforms(self):
st_1 = StorageToken(10, "TestProp", {"Prop11": 1, "Prop12": "Hello!"})
st_2 = StorageToken(11, "TestClass3", {"Prop21": 1, "Prop22": st_1})
obj1 = TestProp({"Prop11": 1, "Prop12": "Hello!"})
obj2 = TestClass3({"Prop21": 1, "Prop22": obj1})
dataStructures = [None, 1, 5.0, range(5), {"S":1,"R":[1,3,4], "5": "S"}, obj1, obj2]
x = nativizeObject(serializeObject(obj1))
x = nativizeObject(serializeObject(obj2))
for aFormat in VALID_SERIAL_FORMATS:
for x in dataStructures:
self.assertEqual(x, x)
s = serializeObject(x, aFormat)
y = nativizeObject(s, None, aFormat)
if isinstance(x, dict):
self.assertItemsEqual(x, y)
else:
self.assertEqual(x, y)
def readConfigurationFromFile(self, fileName, defaultFileName):
fileAsString = self.fileToString(fileName)
if fileAsString is None:
fileAsString = self.fileToString(defaultFileName)
result = nativizeObject(fileAsString, None,
Serialization.JSON_STANDARD_FORMAT)
return result
def processStorageRequest(self, bucket, verb, key=None,
tags=None, aType=None, name=None):
if verb == self.HAS_ELEMENT_VERB:
return bucket.hasRef(key, name)
elif verb == self.CONTAINS_VERB:
keys = bucket.getMatchingKeys(tags, aType)
names = [bucket.getName(aKey) for aKey in keys]
return keys, names
elif verb == self.VALUE_VERB:
if isinstance(key, (tuple, list)):
values = []
for k in key:
value = bucket.getValue(key, None)
if bucket.getDataType(key, None) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
values.append(value)
return values
elif isinstance(name, (tuple, list)):
values = []
for n in name:
value = bucket.getValue(None, n)
if bucket.getDataType(None, n) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
values.append(value)
return values
else:
value = bucket.getValue(key, name)
if bucket.getDataType(key, name) == SERIALIZABLE_DATA_TYPE:
value = nativizeObject(value, JSON_FORMAT)
return value
elif verb == INFORM_REF_ACT:
if key is not None:
return (key, bucket.getName(key))
elif name is not None:
return (bucket.resolveRef(None, name), name)
else:
return None
elif verb == self.ASSIGNED_TAGS:
return bucket.getObjectTags(key, name)
elif verb == self.ASSIGNED_URI_VERB:
return bucket.getLink(key, name)
else:
return False
def on_message(self, headers, msg):
msg = urllib.parse.unquote(msg)
msg = msg.replace("+", " ")
#Only handle superglu messages like this. for the moment we will ignore other message types until the ontology broker is ready
if self.MESSAGE_SYSTEM_NAME in headers:
if headers[self.MESSAGE_SYSTEM_NAME] == self.SUPERGLU:
try:
msg = nativizeObject(msg)
if isinstance(msg, Message):
if self._gateway is not None:
self._gateway.dispatchMessage(msg, self.getId())
self.distributeMessage(msg)
except Exception as err:
print("ActiveMQ message was unable to be parsed")
logError(err, stack=traceback.format_exc())
def nativizeReadObject(self, dbobj, context=None):
""" Helper for nativizing an object read from the DB. The main
work is removing anything added as part of the _save routine """
if not dbobj:
return None
#Remove mods done in _save... including the index names we add
#as top-level properties. Basically, remove everything but the
#classId key:
if MONGO_ID_KEY in dbobj:
del dbobj[MONGO_ID_KEY]
classId = dbobj.get(CLASS_ID_KEY, None)
if classId:
del dbobj[CLASS_ID_KEY]
keys = set(dbobj.keys())
keys.remove(classId) #the actual class id - not the literal
for k in keys:
del dbobj[k]
js = json.dumps(dbobj)
return nativizeObject(js)
def nativizeReadObject(self, dbobj, context=None):
""" Helper for nativizing an object read from the DB. The main
work is removing anything added as part of the _save routine """
if not dbobj:
return None
#Remove mods done in _save... including the index names we add
#as top-level properties. Basically, remove everything but the
#classId key:
if MONGO_ID_KEY in dbobj:
del dbobj[MONGO_ID_KEY]
classId = dbobj.get(CLASS_ID_KEY, None)
if classId:
del dbobj[CLASS_ID_KEY]
keys = set(dbobj.keys())
keys.remove(classId) #the actual class id - not the literal
for k in keys:
del dbobj[k]
js = json.dumps(dbobj)
return nativizeObject(js)
def toMessage(self):
return Message(self.actor, self.verb, self.object,
nativizeObject(self.result), self.speechAct,
nativizeObject(self.context), self.timestamp)
def userTaskIndex(self):
context = nativizeObject(self.context)
if USER_ID_CONTEXT_KEY in context and TASK_ID_CONTEXT_KEY in context:
return (context[USER_ID_CONTEXT_KEY], context[TASK_ID_CONTEXT_KEY])
else:
return None
