def test_consume(self):
contentData = self.createEncryptedContent()
cKeyData = self.createEncryptedCKey()
dKeyData = self.createEncryptedDKey()
contentCount = [0]
cKeyCount = [0]
dKeyCount = [0]
# Prepare a TestFace to instantly answer calls to expressInterest.
class TestFace(object):
def __init__(self, handleExpressInterest):
self.handleExpressInterest = handleExpressInterest
def expressInterest(self, interest, onData, onTimeout,
onNetworkNack):
return self.handleExpressInterest(interest, onData, onTimeout,
onNetworkNack)
def handleExpressInterest(interest, onData, onTimeout, onNetworkNack):
if interest.matchesName(contentData.getName()):
contentCount[0] = 1
onData(interest, contentData)
elif interest.matchesName(cKeyData.getName()):
cKeyCount[0] = 1
onData(interest, cKeyData)
elif interest.matchesName(dKeyData.getName()):
dKeyCount[0] = 1
onData(interest, dKeyData)
else:
onTimeout(interest)
return 0
face = TestFace(handleExpressInterest)
# Create the consumer.
consumer = Consumer(face, self.keyChain, self.groupName, self.uName,
Sqlite3ConsumerDb(self.databaseFilePath))
consumer.addDecryptionKey(self.uKeyName, self.fixtureUDKeyBlob)
finalCount = [0]
def onConsumeComplete(data, result):
finalCount[0] = 1
self.assertTrue("consumeComplete",
result.equals(Blob(DATA_CONTENT, False)))
consumer.consume(
self.contentName, onConsumeComplete, lambda code, message: self.
fail("consume error " + repr(code) + ": " + message))
self.assertEqual(1, contentCount[0], "contentCount")
self.assertEqual(1, cKeyCount[0], "cKeyCount")
self.assertEqual(1, dKeyCount[0], "dKeyCount")
self.assertEqual(1, finalCount[0], "finalCount")
def test_consume(self):
contentData = self.createEncryptedContent()
cKeyData = self.createEncryptedCKey()
dKeyData = self.createEncryptedDKey()
contentCount = [0]
cKeyCount = [0]
dKeyCount = [0]
# Prepare a TestFace to instantly answer calls to expressInterest.
class TestFace(object):
def __init__(self, handleExpressInterest):
self.handleExpressInterest = handleExpressInterest
def expressInterest(self, interest, onData, onTimeout, onNetworkNack):
return self.handleExpressInterest(
interest, onData, onTimeout, onNetworkNack)
def handleExpressInterest(interest, onData, onTimeout, onNetworkNack):
if interest.matchesName(contentData.getName()):
contentCount[0] = 1
onData(interest, contentData)
elif interest.matchesName(cKeyData.getName()):
cKeyCount[0] = 1
onData(interest, cKeyData)
elif interest.matchesName(dKeyData.getName()):
dKeyCount[0] = 1
onData(interest, dKeyData)
else:
onTimeout(interest)
return 0
face = TestFace(handleExpressInterest)
# Create the consumer.
consumer = Consumer(
face, self.keyChain, self.groupName, self.uName,
Sqlite3ConsumerDb(self.databaseFilePath))
consumer.addDecryptionKey(self.uKeyName, self.fixtureUDKeyBlob)
finalCount = [0]
def onConsumeComplete(data, result):
finalCount[0] = 1
self.assertTrue("consumeComplete",
result.equals(Blob(DATA_CONTENT, False)))
consumer.consume(
self.contentName, onConsumeComplete,
lambda code, message:
self.fail("consume error " + repr(code) + ": " + message))
self.assertEqual(1, contentCount[0], "contentCount")
self.assertEqual(1, cKeyCount[0], "cKeyCount")
self.assertEqual(1, dKeyCount[0], "dKeyCount")
self.assertEqual(1, finalCount[0], "finalCount")
class TestConsumer(object):
def __init__(self, face):
# Set up face
self.face = face
self.databaseFilePath = "policy_config/test_consumer.db"
try:
os.remove(self.databaseFilePath)
except OSError:
# no such file
pass
self.groupName = Name("/org/openmhealth/haitao")
# Set up the keyChain.
identityStorage = BasicIdentityStorage()
privateKeyStorage = FilePrivateKeyStorage()
self.keyChain = KeyChain(
IdentityManager(identityStorage, privateKeyStorage),
NoVerifyPolicyManager())
# Authorized identity
identityName = Name("/org/openmhealth/dvu-python-3")
# Unauthorized identity
#identityName = Name("/org/openmhealth/dvu-python-1")
self.certificateName = self.keyChain.createIdentityAndCertificate(
identityName)
self.face.setCommandSigningInfo(self.keyChain, self.certificateName)
consumerKeyName = IdentityCertificate.certificateNameToPublicKeyName(
self.certificateName)
consumerCertificate = identityStorage.getCertificate(
self.certificateName)
self.consumer = Consumer(face, self.keyChain, self.groupName,
identityName,
Sqlite3ConsumerDb(self.databaseFilePath))
# TODO: Read the private key to decrypt d-key...this may or may not be ideal
base64Content = None
with open(
privateKeyStorage.nameTransform(consumerKeyName.toUri(),
".pri")) as keyFile:
print privateKeyStorage.nameTransform(consumerKeyName.toUri(),
".pri")
base64Content = keyFile.read()
#print base64Content
der = Blob(base64.b64decode(base64Content), False)
self.consumer.addDecryptionKey(consumerKeyName, der)
self.memoryContentCache = MemoryContentCache(self.face)
self.memoryContentCache.registerPrefix(identityName,
self.onRegisterFailed,
self.onDataNotFound)
self.memoryContentCache.add(consumerCertificate)
accessRequestInterest = Interest(
Name(self.groupName).append("read_access_request").append(
self.certificateName).appendVersion(int(time.time())))
self.face.expressInterest(accessRequestInterest,
self.onAccessRequestData,
self.onAccessRequestTimeout)
print "Access request interest name: " + accessRequestInterest.getName(
).toUri()
self.consumeCatalog = True
return
def onAccessRequestData(self, interest, data):
print "Access request data: " + data.getName().toUri()
print "Start consuming"
self.startConsuming()
return
def onAccessRequestTimeout(self, interest):
print "Access request times out: " + interest.getName().toUri()
print "Assuming certificate sent and D-key generated, start consuming"
self.startConsuming()
return
def startConsuming(self):
if self.consumeCatalog:
contentName = Name(
"/org/openmhealth/haitao/SAMPLE/fitness/physical_activity/time_location/catalog/20161024T213400"
)
catalogInterest = Interest(contentName)
self.face.expressInterest(catalogInterest,
self.onCatalogConsumeComplete,
self.onCatalogConsumeFailed)
# self.consumer.consume(contentName, self.onCatalogConsumeComplete, self.onConsumeFailed)
print "Trying to consume: " + contentName.toUri()
else:
contentName = Name(
"/org/openmhealth/haitao/SAMPLE/fitness/physical_activity/time_location/"
)
dataNum = 60
baseZFill = 3
basetimeString = "20160620T080"
for i in range(0, dataNum):
timeString = basetimeString + str(i).zfill(baseZFill)
timeFloat = Schedule.fromIsoString(timeString)
self.consumer.consume(
Name(contentName).append(timeString),
self.onConsumeComplete, self.onConsumeFailed)
print "Trying to consume: " + Name(contentName).append(
timeString).toUri()
def onDataNotFound(self, prefix, interest, face, interestFilterId, filter):
print "Data not found for interest: " + interest.getName().toUri()
return
def onRegisterFailed(self, prefix):
print "Prefix registration failed: " + prefix.toUri()
return
def onCatalogConsumeComplete(self, interest, data):
print "Consume complete for catalog: " + data.getName().toUri()
resultObject = json.loads(data.getContent().toRawStr())
print data.getContent().toRawStr()
contentName = Name(
"/org/openmhealth/haitao/SAMPLE/fitness/physical_activity/time_location/"
)
for i in range(0, len(resultObject)):
# timeString = Schedule.toIsoString(int(resultObject[i]) * 1000)
timeString = resultObject[i]
self.consumer.consume(
Name(contentName).append(timeString), self.onConsumeComplete,
self.onConsumeFailed)
print "Trying to consume: " + Name(contentName).append(
timeString).toUri()
def onCatalogConsumeFailed(self, interest):
print "Data request times out: " + interest.getName().toUri()
return
def onConsumeComplete(self, data, result):
print "Consume complete for data name: " + data.getName().toUri()
print result
# Test the length of encrypted data
# dataBlob = data.getContent()
# dataContent = EncryptedContent()
# dataContent.wireDecode(dataBlob)
# encryptedData = dataContent.getPayload()
# print len(encryptedData)
# TODO: shouldn't this indicate the consumption of what has failed though
def onConsumeFailed(self, code, message):
print "Consume error " + str(code) + ": " + message
class DPU(object):
def __init__(self,
face,
identityName,
groupName,
catalogPrefix,
rawDataPrefix,
producerDbFilePath,
consumerDbFilePath,
encrypted=False):
self.face = face
# Set up the keyChain.
identityStorage = BasicIdentityStorage()
privateKeyStorage = FilePrivateKeyStorage()
self.keyChain = KeyChain(
IdentityManager(identityStorage, privateKeyStorage),
NoVerifyPolicyManager())
self.identityName = Name(identityName)
self.groupName = Name(groupName)
self.rawDataPrefix = rawDataPrefix
self.catalogPrefix = catalogPrefix
self.certificateName = self.keyChain.createIdentityAndCertificate(
self.identityName)
self.face.setCommandSigningInfo(self.keyChain, self.certificateName)
# Set up the memoryContentCache
self.memoryContentCache = MemoryContentCache(self.face)
self.memoryContentCache.registerPrefix(self.identityName,
self.onRegisterFailed,
self.onDataNotFound)
self.producerPrefix = Name(identityName)
self.producerSuffix = Name()
self.producer = DPUProducer(face, self.memoryContentCache,
self.producerPrefix, self.producerSuffix,
self.keyChain, self.certificateName,
producerDbFilePath)
# Put own (consumer) certificate in memoryContentCache
consumerKeyName = IdentityCertificate.certificateNameToPublicKeyName(
self.certificateName)
consumerCertificate = identityStorage.getCertificate(
self.certificateName, True)
# TODO: request that this DPU be added as a trusted group member
self.remainingTasks = dict()
try:
os.remove(consumerDbFilePath)
except OSError:
# no such file
pass
self.consumer = Consumer(face, self.keyChain, self.groupName,
consumerKeyName,
Sqlite3ConsumerDb(consumerDbFilePath))
# TODO: Read the private key to decrypt d-key...this may or may not be ideal
base64Content = None
with open(
privateKeyStorage.nameTransform(consumerKeyName.toUri(),
".pri")) as keyFile:
base64Content = keyFile.read()
der = Blob(base64.b64decode(base64Content), False)
self.consumer.addDecryptionKey(consumerKeyName, der)
self.memoryContentCache.add(consumerCertificate)
self.encrypted = encrypted
self.rawData = []
self.catalogFetchFinished = False
self.remainingData = 0
return
def onDataNotFound(self, prefix, interest, face, interestFilterId, filter):
print "Data not found for interest: " + interest.getName().toUri()
if interest.getName().get(
-3).toEscapedString() == "bout" or interest.getName().get(
-3).toEscapedString() == "genericfunctions":
if interest.getName().toUri() in self.remainingTasks:
# We are already trying to process this task, so we don't add it to the list of tasks
pass
else:
self.remainingTasks[interest.getName().toUri()] = "in-progress"
else:
print "Got unexpected interest: " + interest.getName().toUri()
# .../SAMPLE/<timestamp>
timestamp = interest.getName().get(-1)
catalogInterest = Interest(self.catalogPrefix)
# Traverse catalogs in range from leftmost child
catalogInterest.setChildSelector(0)
catalogInterest.setMustBeFresh(True)
catalogInterest.setInterestLifetimeMilliseconds(4000)
exclude = Exclude()
exclude.appendAny()
exclude.appendComponent(timestamp)
catalogInterest.setExclude(catalogInterest)
self.face.expressInterest(catalogInterest, self.onCatalogData,
self.onCatalogTimeout)
print "Expressed catalog interest " + catalogInterest.getName().toUri()
return
def onRegisterFailed(self, prefix):
print "Prefix registration failed"
return
def onCatalogData(self, interest, data):
# Find the next catalog
print "Received catalog data " + data.getName().toUri()
catalogTimestamp = data.getName().get(-2)
exclude = Exclude()
exclude.appendAny()
exclude.appendComponent(catalogTimestamp)
nextCatalogInterest = Interest(interest.getName())
nextCatalogInterest.setExclude(exclude)
nextCatalogInterest.setChildSelector(0)
nextCatalogInterest.setMustBeFresh(True)
nextCatalogInterest.setInterestLifetimeMilliseconds(2000)
self.face.expressInterest(nextCatalogInterest, self.onCatalogData,
self.onCatalogTimeout)
print "Expressed catalog interest " + nextCatalogInterest.getName(
).toUri()
# We ignore the version in the catalog
if self.encrypted:
self.consumer.consume(contentName, self.onCatalogConsumeComplete,
self.onConsumeFailed)
else:
self.onCatalogConsumeComplete(data, data.getContent())
def onCatalogConsumeComplete(self, data, result):
print "Consume complete for catalog name: " + data.getName().toUri()
catalog = json.loads(result.toRawStr())
for timestamp in catalog:
# For encrypted data, timestamp format will have to change
rawDataName = Name(self.rawDataPrefix).append(
Schedule.toIsoString(timestamp * 1000))
dataInterest = Interest(rawDataName)
dataInterest.setInterestLifetimeMilliseconds(2000)
dataInterest.setMustBeFresh(True)
self.face.expressInterest(dataInterest, self.onRawData,
self.onRawDataTimeout)
self.remainingData += 1
return
# TODO: This logic for checking 'if I have everything, and should proceed with all pending tasks' is not correct for the long run
def onRawDataConsumeComplete(self, data, result):
resultObject = json.loads(result.toRawStr())
# TODO: the original data for timestamp should be an array
self.rawData.append(resultObject)
self.remainingData -= 1
print "Remaing data number: " + str(self.remainingData)
if self.remainingData == 0 and self.catalogFetchFinished:
self.produce()
# TODO: Unideal distanceTo production
for item in self.remainingTasks:
username = data.getName().get(2)
timestamp = Name(item).get(-1).toEscapedString()
if "distanceTo" in item and username in item and timestamp in data.getName(
).toUri():
# We want this distanceTo
destCoordinate = Name(item).get(-2).toEscapedString()
coordinates = destCoordinate[1:-1].split(",").strip()
x = int(coordinates[0])
y = int(coordinates[1])
dataObject = json.dumps({
"distanceTo":
math.sqrt((x - resultObject["lat"]) *
(x - resultObject["lat"]) +
(y - resultObject["lng"]) *
(y - resultObject["lng"]))
})
data = Data(data)
data.getMetaInfo().setFreshnessPeriod(40000000000)
data.setContent(dataObject)
self.keyChain.sign(data)
# If the interest's still within lifetime, this will satisfy the interest
self.memoryContentCache.add(data)
return
def onConsumeFailed(self, code, message):
print "Consume error " + str(code) + ": " + message
def onRawData(self, interest, data):
print "Raw data received: " + data.getName().toUri()
# TODO: Quick hack for deciding if the data is encrypted
if "zhehao" in data.getName().toUri():
self.consumer.consume(data.getName(),
self.onRawDataConsumeComplete,
self.onConsumeFailed)
else:
print "raw data consume complete"
self.onRawDataConsumeComplete(data, data.getContent())
# if self.encrypted:
# self.consumer.consume(data.getName(), self.onRawDataConsumeComplete, self.onConsumeFailed)
# else:
# self.onRawDataConsumeComplete(data, data.getContent())
def onCatalogTimeout(self, interest):
print "Catalog times out: " + interest.getName().toUri()
# TODO: 1 timeout would result in this dpu thinking that catalog fetching's done!
self.catalogFetchFinished = True
if self.remainingData == 0:
self.produce()
return
def onRawDataTimeout(self, interest):
print "Raw data times out: " + interest.getName().toUri()
return
# TODO: This logic for checking 'if I have everything, and should proceed with all pending tasks' is not correct for the long run
def produce(self):
# Produce the bounding box
print "ready to produce"
maxLong = -3600
minLong = 3600
maxLat = -3600
minLat = 3600
if len(self.rawData) == 0:
print "No raw data as producer input"
for item in self.rawData:
print item
if item["lng"] > maxLong:
maxLong = item["lng"]
if item["lng"] < minLong:
minLong = item["lng"]
if item["lat"] > maxLat:
maxLat = item["lat"]
if item["lat"] < minLat:
minLat = item["lat"]
result = json.dumps({
"maxlng": maxLong,
"minlng": minLong,
"maxlat": maxLat,
"minlat": minLat,
"size": len(self.rawData)
})
if self.encrypted:
# TODO: replace fixed timestamp for now for produced data, createContentKey as needed
testTime1 = Schedule.fromIsoString("20160320T080000")
self.producer.createContentKey(testTime1)
self.producer.produce(testTime1, result)
else:
# Arbitrary produced data lifetime
data = Data(Name(self.identityName).append("20160320T080000"))
data.getMetaInfo().setFreshnessPeriod(400000)
data.setContent(result)
# If the interest's still within lifetime, this will satisfy the interest
self.memoryContentCache.add(data)
print "Produced data with name " + data.getName().toUri()
class TestConsumer(object):
def __init__(self, face):
# Set up face
self.face = face
self.databaseFilePath = "policy_config/test_consumer.db"
try:
os.remove(self.databaseFilePath)
except OSError:
# no such file
pass
self.groupName = Name("/org/openmhealth/zhehao")
# Set up the keyChain.
identityStorage = BasicIdentityStorage()
privateKeyStorage = FilePrivateKeyStorage()
self.keyChain = KeyChain(
IdentityManager(identityStorage, privateKeyStorage),
NoVerifyPolicyManager())
# Authorized identity
identityName = Name("/org/openmhealth/dvu-python-3")
# Unauthorized identity
#identityName = Name("/org/openmhealth/dvu-python-1")
self.certificateName = self.keyChain.createIdentityAndCertificate(identityName)
self.face.setCommandSigningInfo(self.keyChain, self.certificateName)
consumerKeyName = IdentityCertificate.certificateNameToPublicKeyName(self.certificateName)
consumerCertificate = identityStorage.getCertificate(self.certificateName)
self.consumer = Consumer(
face, self.keyChain, self.groupName, identityName,
Sqlite3ConsumerDb(self.databaseFilePath))
# TODO: Read the private key to decrypt d-key...this may or may not be ideal
base64Content = None
with open(privateKeyStorage.nameTransform(consumerKeyName.toUri(), ".pri")) as keyFile:
print privateKeyStorage.nameTransform(consumerKeyName.toUri(), ".pri")
base64Content = keyFile.read()
#print base64Content
der = Blob(base64.b64decode(base64Content), False)
self.consumer.addDecryptionKey(consumerKeyName, der)
self.memoryContentCache = MemoryContentCache(self.face)
self.memoryContentCache.registerPrefix(identityName, self.onRegisterFailed, self.onDataNotFound)
self.memoryContentCache.add(consumerCertificate)
accessRequestInterest = Interest(Name(self.groupName).append("read_access_request").append(self.certificateName).appendVersion(int(time.time())))
self.face.expressInterest(accessRequestInterest, self.onAccessRequestData, self.onAccessRequestTimeout)
print "Access request interest name: " + accessRequestInterest.getName().toUri()
self.consumeCatalog = True
return
def onAccessRequestData(self, interest, data):
print "Access request data: " + data.getName().toUri()
print "Start consuming"
self.startConsuming()
return
def onAccessRequestTimeout(self, interest):
print "Access request times out: " + interest.getName().toUri()
print "Assuming certificate sent and D-key generated, start consuming"
self.startConsuming()
return
def startConsuming(self):
if self.consumeCatalog:
contentName = Name("/org/openmhealth/zhehao/SAMPLE/fitness/physical_activity/time_location/catalog/20160620T080000")
self.consumer.consume(contentName, self.onCatalogConsumeComplete, self.onConsumeFailed)
print "Trying to consume: " + contentName.toUri()
else:
contentName = Name("/org/openmhealth/zhehao/SAMPLE/fitness/physical_activity/time_location/")
dataNum = 60
baseZFill = 3
basetimeString = "20160620T080"
for i in range(0, dataNum):
timeString = basetimeString + str(i).zfill(baseZFill)
timeFloat = Schedule.fromIsoString(timeString)
self.consumer.consume(Name(contentName).append(timeString), self.onConsumeComplete, self.onConsumeFailed)
print "Trying to consume: " + Name(contentName).append(timeString).toUri()
def onDataNotFound(self, prefix, interest, face, interestFilterId, filter):
print "Data not found for interest: " + interest.getName().toUri()
return
def onRegisterFailed(self, prefix):
print "Prefix registration failed: " + prefix.toUri()
return
def onCatalogConsumeComplete(self, data, result):
print "Consume complete for catalog: " + data.getName().toUri()
resultObject = json.loads(result.toRawStr())
contentName = Name("/org/openmhealth/zhehao/SAMPLE/fitness/physical_activity/time_location/")
for i in range(0, len(resultObject)):
timeString = Schedule.toIsoString(int(resultObject[i]) * 1000)
self.consumer.consume(Name(contentName).append(timeString), self.onConsumeComplete, self.onConsumeFailed)
print "Trying to consume: " + Name(contentName).append(timeString).toUri()
def onConsumeComplete(self, data, result):
print "Consume complete for data name: " + data.getName().toUri()
print result
# Test the length of encrypted data
# dataBlob = data.getContent()
# dataContent = EncryptedContent()
# dataContent.wireDecode(dataBlob)
# encryptedData = dataContent.getPayload()
# print len(encryptedData)
# TODO: shouldn't this indicate the consumption of what has failed though
def onConsumeFailed(self, code, message):
print "Consume error " + str(code) + ": " + message
class TestDPU(object):
def __init__(self, face, encryptResult, link = None):
# Set up face
self.face = face
self._encryptResult = encryptResult
self._link = link
self.databaseFilePath = "policy_config/test_consumer_dpu.db"
try:
os.remove(self.databaseFilePath)
except OSError:
# no such file
pass
self.groupName = Name("/org/openmhealth/haitao")
# Set up the keyChain.
identityStorage = BasicIdentityStorage()
privateKeyStorage = FilePrivateKeyStorage()
self.keyChain = KeyChain(
IdentityManager(identityStorage, privateKeyStorage),
NoVerifyPolicyManager())
# Authorized identity
identityName = Name("/ndn/edu/basel/dpu")
# Function name: the function that this DPU provides
self._functionName = "bounding_box"
self._identityName = identityName
self.certificateName = self.keyChain.createIdentityAndCertificate(identityName)
# TODO: if using BasicIdentityStorage and FilePrivateKeyStorage
# For some reason this newly generated cert is not installed by default, calling keyChain sign later would result in error
#self.keyChain.installIdentityCertificate()
self.face.setCommandSigningInfo(self.keyChain, self.certificateName)
consumerKeyName = IdentityCertificate.certificateNameToPublicKeyName(self.certificateName)
consumerCertificate = identityStorage.getCertificate(self.certificateName)
self.consumer = Consumer(
face, self.keyChain, self.groupName, identityName,
Sqlite3ConsumerDb(self.databaseFilePath))
# TODO: Read the private key to decrypt d-key...this may or may not be ideal
base64Content = None
with open(privateKeyStorage.nameTransform(consumerKeyName.toUri(), ".pri")) as keyFile:
print privateKeyStorage.nameTransform(consumerKeyName.toUri(), ".pri")
base64Content = keyFile.read()
#print base64Content
der = Blob(base64.b64decode(base64Content), False)
self.consumer.addDecryptionKey(consumerKeyName, der)
self.memoryContentCache = MemoryContentCache(self.face)
self.memoryContentCache.registerPrefix(identityName, self.onRegisterFailed, self.onDataNotFound)
self.memoryContentCache.add(consumerCertificate)
accessRequestInterest = Interest(Name(self.groupName).append("read_access_request").append(self.certificateName).appendVersion(int(time.time())))
self.face.expressInterest(accessRequestInterest, self.onAccessRequestData, self.onAccessRequestTimeout)
print "Access request interest name: " + accessRequestInterest.getName().toUri()
self._tasks = dict()
return
def onAccessRequestData(self, interest, data):
print "Access request data: " + data.getName().toUri()
return
def onAccessRequestTimeout(self, interest):
print "Access request times out: " + interest.getName().toUri()
print "Assuming certificate sent and D-key generated"
return
def startConsuming(self, userId, basetimeString, producedDataName, dataNum, outerDataName):
contentName = Name(userId).append(Name("/SAMPLE/fitness/physical_activity/time_location/"))
baseZFill = 2
for i in range(0, dataNum):
timeString = basetimeString + str(i).zfill(baseZFill) + '00'
timeFloat = Schedule.fromIsoString(timeString)
self.consume(Name(contentName).append(timeString), producedDataName, outerDataName)
print "Trying to consume: " + Name(contentName).append(timeString).toUri()
def onDataNotFound(self, prefix, interest, face, interestFilterId, filter):
print "Data not found for interest: " + interest.getName().toUri()
functionComponentIdx = len(self._identityName)
if interest.getName().get(functionComponentIdx).toEscapedString() == self._functionName:
try:
parameters = interest.getName().get(functionComponentIdx + 1).toEscapedString()
pattern = re.compile('([^,]*),([^,]*),([^,]*)')
matching = pattern.match(str(Name.fromEscapedString(parameters)))
#print parameters
#print str(Name.fromEscapedString(parameters))
userId = matching.group(1)
basetimeString = matching.group(2)
producedDataName = matching.group(3)
dataNum = 2
self._tasks[producedDataName] = {"cap_num": dataNum, "current_num": 0, "dataset": []}
self.startConsuming(userId, basetimeString, producedDataName, dataNum, interest.getName().toUri())
except Exception as e:
print "Exception in processing function arguments: " + str(e)
else:
print "function name mismatch: expected " + self._functionName + " ; got " + interest.getName().get(functionComponentIdx).toEscapedString()
return
def onRegisterFailed(self, prefix):
print "Prefix registration failed: " + prefix.toUri()
return
def consume(self, contentName, producedDataName, outerDataName):
self.consumer.consume(contentName, lambda data, result: self.onConsumeComplete(data, result, producedDataName, outerDataName), lambda code, message : self.onConsumeFailed(code, message, producedDataName, outerDataName))
def onConsumeComplete(self, data, result, producedDataName, outerDataName):
print "Consume complete for data name: " + data.getName().toUri()
if producedDataName in self._tasks:
self._tasks[producedDataName]["current_num"] += 1
resultObject = json.loads(str(result))
for i in range(0, len(resultObject)):
self._tasks[producedDataName]["dataset"].append(resultObject[i])
if self._tasks[producedDataName]["current_num"] == self._tasks[producedDataName]["cap_num"]:
self.onGetAllData(producedDataName, outerDataName)
def onConsumeFailed(self, code, message, producedDataName, outerDataName):
print "Consume error " + str(code) + ": " + message
if producedDataName in self._tasks:
self._tasks[producedDataName]["current_num"] += 1
if self._tasks[producedDataName]["current_num"] == self._tasks[producedDataName]["cap_num"]:
self.onGetAllData(producedDataName, outerDataName)
def onGetAllData(self, producedDataName, outerDataName):
maxLng = -1000
minLng = 1000
maxLat = -1000
minLat = 1000
for item in self._tasks[producedDataName]["dataset"]:
dataObject = json.loads(str(item))
if dataObject["lat"] > maxLat:
maxLat = dataObject["lat"]
if dataObject["lat"] < minLat:
minLat = dataObject["lat"]
if dataObject["lng"] > maxLng:
maxLng = dataObject["lng"]
if dataObject["lng"] < minLng:
minLng = dataObject["lng"]
if not self._encryptResult:
innerData = Data(Name(str(producedDataName)))
innerData.setContent(json.dumps({"minLat": minLat, "maxLat": maxLat, "minLng": minLng, "maxLng": maxLng}))
#self.keyChain.sign(innerData)
outerData = Data(Name(str(outerDataName)))
outerData.setContent(innerData.wireEncode())
#self.keyChain.sign(outerData)
self.memoryContentCache.add(outerData)
self.initiateContentStoreInsertion("/ndn/edu/ucla/remap/ndnfit/repo", outerData)
print "Calculation completed, put data to repo"
else:
print "Encrypt result is not implemented"
def initiateContentStoreInsertion(self, repoCommandPrefix, data):
fetchName = data.getName()
parameter = repo_command_parameter_pb2.RepoCommandParameterMessage()
# Add the Name.
for i in range(fetchName.size()):
parameter.repo_command_parameter.name.component.append(
fetchName[i].getValue().toBytes())
# Create the command interest.
interest = Interest(Name(repoCommandPrefix).append("insert")
.append(Name.Component(ProtobufTlv.encode(parameter))))
self.face.makeCommandInterest(interest)
self.face.expressInterest(interest, self.onRepoData, self.onRepoTimeout)
def onRepoData(self, interest, data):
#print "received repo data: " + interest.getName().toUri()
return
def onRepoTimeout(self, interest):
#print "repo command times out: " + interest.getName().getPrefix(-1).toUri()
return
class TestDPU(object):
def __init__(self, face, encryptResult, defaultPrefix, link = None):
# Set up face
self.face = face
self._encryptResult = encryptResult
self._link = link
self.databaseFilePath = "policy_config/test_consumer_dpu.db"
try:
os.remove(self.databaseFilePath)
except OSError:
# no such file
pass
self.groupName = Name(defaultPrefix)
# Set up the keyChain.
identityStorage = BasicIdentityStorage()
privateKeyStorage = FilePrivateKeyStorage()
self.keyChain = KeyChain(
IdentityManager(identityStorage, privateKeyStorage),
NoVerifyPolicyManager())
# Authorized identity
identityName = Name("/ndn/edu/basel/dpu")
# Function name: the function that this DPU provides
self._functionName = "bounding_box"
self._identityName = identityName
self.certificateName = self.keyChain.createIdentityAndCertificate(identityName)
# TODO: if using BasicIdentityStorage and FilePrivateKeyStorage
# For some reason this newly generated cert is not installed by default, calling keyChain sign later would result in error
#self.keyChain.installIdentityCertificate()
self.memoryContentCache = MemoryContentCache(self.face)
try:
commandSigningKeyChain = KeyChain()
print "Default certificate name is: " + self.keyChain.getDefaultCertificateName().toUri()
self.face.setCommandSigningInfo(commandSigningKeyChain, commandSigningKeyChain.getDefaultCertificateName())
self.memoryContentCache.registerPrefix(identityName, self.onRegisterFailed, self.onDataNotFound)
except SecurityException as e:
print str(e)
print "Cannot use default certificate, use created certificate in FilePrivateKeyStorage"
self.face.setCommandSigningInfo(self.keyChain, self.certificateName)
self.memoryContentCache.registerPrefix(identityName, self.onRegisterFailed, self.onDataNotFound)
consumerKeyName = IdentityCertificate.certificateNameToPublicKeyName(self.certificateName)
consumerCertificate = identityStorage.getCertificate(self.certificateName)
self.consumer = Consumer(
face, self.keyChain, self.groupName, identityName,
Sqlite3ConsumerDb(self.databaseFilePath))
# TODO: Read the private key to decrypt d-key...this may or may not be ideal
base64Content = None
with open(privateKeyStorage.nameTransform(consumerKeyName.toUri(), ".pri")) as keyFile:
print privateKeyStorage.nameTransform(consumerKeyName.toUri(), ".pri")
base64Content = keyFile.read()
#print base64Content
der = Blob(base64.b64decode(base64Content), False)
self.consumer.addDecryptionKey(consumerKeyName, der)
self.memoryContentCache.add(consumerCertificate)
accessRequestInterest = Interest(Name(self.groupName).append("read_access_request").append(self.certificateName).appendVersion(int(time.time())))
self.face.expressInterest(accessRequestInterest, self.onAccessRequestData, self.onAccessRequestTimeout)
print "Access request interest name: " + accessRequestInterest.getName().toUri()
self._tasks = dict()
return
def onAccessRequestData(self, interest, data):
print "Access request data: " + data.getName().toUri()
return
def onAccessRequestTimeout(self, interest):
print "Access request times out: " + interest.getName().toUri()
print "Assuming certificate sent and D-key generated"
return
def startConsuming(self, userId, basetimeString, producedDataName, dataNum, outerDataName):
contentName = Name(userId).append(Name("/SAMPLE/fitness/physical_activity/time_location/"))
baseZFill = 3
for i in range(0, dataNum):
timeString = basetimeString + str(i).zfill(baseZFill)
timeFloat = Schedule.fromIsoString(timeString)
self.consume(Name(contentName).append(timeString), producedDataName, outerDataName)
print "Trying to consume: " + Name(contentName).append(timeString).toUri()
def onDataNotFound(self, prefix, interest, face, interestFilterId, filter):
print "Data not found for interest: " + interest.getName().toUri()
functionComponentIdx = len(self._identityName)
if interest.getName().get(functionComponentIdx).toEscapedString() == self._functionName:
try:
parameters = interest.getName().get(functionComponentIdx + 1).toEscapedString()
pattern = re.compile('([^,]*),([^,]*),([^,]*)')
matching = pattern.match(str(Name.fromEscapedString(parameters)))
userId = matching.group(1)
basetimeString = matching.group(2)
producedDataName = matching.group(3)
dataNum = 60
self._tasks[producedDataName] = {"cap_num": dataNum, "current_num": 0, "dataset": []}
self.startConsuming(userId, basetimeString, producedDataName, dataNum, interest.getName().toUri())
except Exception as e:
print "Exception in processing function arguments: " + str(e)
else:
print "function name mismatch: expected " + self._functionName + " ; got " + interest.getName().get(functionComponentIdx).toEscapedString()
return
def onRegisterFailed(self, prefix):
print "Prefix registration failed: " + prefix.toUri()
return
def consume(self, contentName, producedDataName, outerDataName):
self.consumer.consume(contentName, lambda data, result: self.onConsumeComplete(data, result, producedDataName, outerDataName), self.onConsumeFailed)
def onConsumeComplete(self, data, result, producedDataName, outerDataName):
print "Consume complete for data name: " + data.getName().toUri()
if producedDataName in self._tasks:
self._tasks[producedDataName]["current_num"] += 1
self._tasks[producedDataName]["dataset"].append(result)
if self._tasks[producedDataName]["current_num"] == self._tasks[producedDataName]["cap_num"]:
maxLng = -1000
minLng = 1000
maxLat = -1000
minLat = 1000
for item in self._tasks[producedDataName]["dataset"]:
dataObject = json.loads(str(item))
if dataObject["lat"] > maxLat:
maxLat = dataObject["lat"]
if dataObject["lat"] < minLat:
minLat = dataObject["lat"]
if dataObject["lng"] > maxLng:
maxLng = dataObject["lng"]
if dataObject["lng"] < minLng:
minLng = dataObject["lng"]
if not self._encryptResult:
innerData = Data(Name(str(producedDataName)))
innerData.setContent(json.dumps({"minLat": minLat, "maxLat": maxLat, "minLng": minLng, "maxLng": maxLng}))
#self.keyChain.sign(innerData)
outerData = Data(Name(str(outerDataName)))
outerData.setContent(innerData.wireEncode())
#self.keyChain.sign(outerData)
self.memoryContentCache.add(outerData)
self.initiateContentStoreInsertion("/ndn/edu/ucla/remap/ndnfit/repo", outerData)
print "Calculation completed, put data to repo"
else:
print "Encrypt result is not implemented"
def onConsumeFailed(self, code, message):
print "Consume error " + str(code) + ": " + message
def initiateContentStoreInsertion(self, repoCommandPrefix, data):
fetchName = data.getName()
parameter = repo_command_parameter_pb2.RepoCommandParameterMessage()
# Add the Name.
for i in range(fetchName.size()):
parameter.repo_command_parameter.name.component.append(
fetchName[i].getValue().toBytes())
# Create the command interest.
interest = Interest(Name(repoCommandPrefix).append("insert")
.append(Name.Component(ProtobufTlv.encode(parameter))))
self.face.makeCommandInterest(interest)
self.face.expressInterest(interest, self.onRepoData, self.onRepoTimeout)
def onRepoData(self, interest, data):
#print "received repo data: " + interest.getName().toUri()
return
def onRepoTimeout(self, interest):
#print "repo command times out: " + interest.getName().getPrefix(-1).toUri()
return
