class Producer(object):
def __init__(self, delay=None):
self.delay = delay
self.nDataServed = 0
self.isDone = False
def run(self, prefix):
self.keyChain = KeyChain()
self.consoleThread = ConsoleThread()
self.consoleThread.start()
# The default Face will connect using a Unix socket
face = Face()
prefix = Name(prefix)
# Use the system default key chain and certificate name to sign commands.
face.setCommandSigningInfo(self.keyChain, self.keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign data packets.
face.registerPrefix(prefix, self.onInterest, self.onRegisterFailed)
print "Registering prefix", prefix.toUri()
while not self.isDone:
face.processEvents()
time.sleep(0.01)
def onInterest(self, prefix, interest, transport, registeredPrefixId):
global stopServing
if stopServing:
print "refusing to serve " + interest.getName().toUri()
self.consoleThread.join()
print "join'd thread"
return
if self.delay is not None:
time.sleep(self.delay)
interestName = interest.getName()
data = Data(interestName)
data.setContent("Hello " + interestName.toUri())
data.getMetaInfo().setFreshnessPeriod(3600 * 1000)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
transport.send(data.wireEncode().toBuffer())
self.nDataServed += 1
print "Replied to: %s (#%d)" % (interestName.toUri(), self.nDataServed)
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
def status_put(name, data):
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign data packets.
echo = Echo(keyChain, keyChain.getDefaultCertificateName(), data)
prefix = Name(name)
dump("Register prefix", prefix.toUri())
logging.debug('Register prefix ' + prefix.toUri())
face.registerPrefix(prefix, echo.onInterest, echo.onRegisterFailed)
face.processEvents()
def main():
"""
Call requestInsert and register a prefix so that ProduceSegments will answer
interests from the repo to send the data packets. This assumes that repo-ng
is already running (e.g. `sudo ndn-repo-ng`).
"""
repoCommandPrefix = Name("/example/repo/1")
repoDataPrefix = Name("/example/data/1")
nowMilliseconds = int(time.time() * 1000.0)
fetchPrefix = Name(repoDataPrefix).append("testinsert").appendVersion(nowMilliseconds)
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Register the prefix and send the repo insert command at the same time.
startBlockId = 0
endBlockId = 1
enabled = [True]
def onFinished():
dump("All data was inserted.")
enabled[0] = False
produceSegments = ProduceSegments(
keyChain, keyChain.getDefaultCertificateName(), startBlockId, endBlockId,
onFinished)
dump("Register prefix", fetchPrefix.toUri())
def onRegisterFailed(prefix):
dump("Register failed for prefix", prefix.toUri())
enabled[0] = False
face.registerPrefix(
fetchPrefix, produceSegments.onInterest, onRegisterFailed)
def onInsertStarted():
dump("Insert started for", fetchPrefix.toUri())
def onFailed():
enabled[0] = False
requestInsert(
face, repoCommandPrefix, fetchPrefix, onInsertStarted, onFailed,
startBlockId, endBlockId)
# Run until all the data is sent.
while enabled[0]:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
face.shutdown()
def main():
"""
Call startRepoWatch and register a prefix so that SendSegments will answer
interests from the repo to send data packets for the watched prefix. When
all the data is sent (or an error), call stopRepoWatch. This assumes that
repo-ng is already running (e.g. `sudo ndn-repo-ng`).
"""
repoCommandPrefix = Name("/example/repo/1")
repoDataPrefix = Name("/example/data/1")
nowMilliseconds = int(time.time() * 1000.0)
watchPrefix = Name(repoDataPrefix).append("testwatch").appendVersion(
nowMilliseconds)
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Register the prefix and start the repo watch at the same time.
enabled = [True]
def onFinishedSending():
stopRepoWatchAndQuit(face, repoCommandPrefix, watchPrefix, enabled)
sendSegments = SendSegments(
keyChain, keyChain.getDefaultCertificateName(), onFinishedSending)
def onRegisterFailed(prefix):
dump("Register failed for prefix", prefix.toUri())
enabled[0] = False
dump("Register prefix", watchPrefix.toUri())
face.registerPrefix(watchPrefix, sendSegments.onInterest, onRegisterFailed)
def onRepoWatchStarted():
dump("Watch started for", watchPrefix.toUri())
def onStartFailed():
dump("startRepoWatch failed.")
stopRepoWatchAndQuit(face, repoCommandPrefix, watchPrefix, enabled)
startRepoWatch(
face, repoCommandPrefix, watchPrefix, onRepoWatchStarted, onStartFailed)
# Run until someone sets enabled[0] = False.
enabled[0] = True
while enabled[0]:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
face.shutdown()
class Producer(object):
def __init__(self):
self.keyChain = KeyChain()
self.isDone = False
def run(self, namespace):
# Create a connection to the local forwarder over a Unix socket
face = Face()
prefix = Name(namespace)
# Use the system default key chain and certificate name to sign commands.
face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign Data packets.
face.registerPrefix(prefix, self.onInterest, self.onRegisterFailed)
print "Registering prefix", prefix.toUri()
# Run the event loop forever. Use a short sleep to
# prevent the Producer from using 100% of the CPU.
while not self.isDone:
face.processEvents()
time.sleep(0.01)
def onInterest(self, prefix, interest, transport, registeredPrefixId):
interestName = interest.getName()
data = Data(interestName)
data.setContent("Hello, " + interestName.toUri())
hourMilliseconds = 3600 * 1000
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
transport.send(data.wireEncode().toBuffer())
print "Replied to: %s" % interestName.toUri()
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
class ThreadsafeFaceWrapper(object):
def __init__(self):
self._loop = asyncio.get_event_loop()
self._face = ThreadsafeFace(self._loop, "")
self._keyChain = KeyChain()
self._certificateName = self._keyChain.getDefaultCertificateName()
self._face.setCommandSigningInfo(self._keyChain, self._certificateName)
def startProcessing(self):
try:
self._loop.run_forever()
finally:
self.stop()
def stopProcessing(self):
self._loop.close()
self._face.shutdown()
self._face = None
sys.exit(1)
def getFace(self):
return self._face
def getLoop(self):
return self._loop
def main():
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
dataPrefix = "/home/test1/data"
repoDataPrefix = "/home/test1/data"
# Set up repo-ng, register prefix for repo-ng's fetch prefix
# Per configuration file in /usr/local/etc/ndn/repo-ng.conf
# memCache is not used for now; repo is hoping that the piece of data in question is still being held at nfd
#memCache = MemoryContentCache(face, 100000)
#memCache.registerPrefix(Name(repoDataPrefix), onRegisterFailed, onDataNotFound)
counter = Counter(face, repoDataPrefix)
interest = Interest(Name(dataPrefix))
interest.setChildSelector(1)
interest.setInterestLifetimeMilliseconds(defaultInterestLifetime)
face.expressInterest(interest, counter.onData, counter.onTimeout)
while True:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(1)
face.shutdown()
def main():
# Silence the warning from Interest wire encode.
Interest.setDefaultCanBePrefix(True)
interest = Interest()
interest.wireDecode(TlvInterest)
dump("Interest:")
dumpInterest(interest)
# Set the name again to clear the cached encoding so we encode again.
interest.setName(interest.getName())
encoding = interest.wireEncode()
dump("")
dump("Re-encoded interest", encoding.toHex())
reDecodedInterest = Interest()
reDecodedInterest.wireDecode(encoding)
dump("Re-decoded Interest:")
dumpInterest(reDecodedInterest)
freshInterest = (Interest(Name("/ndn/abc"))
.setMustBeFresh(False)
.setMinSuffixComponents(4)
.setMaxSuffixComponents(6)
.setInterestLifetimeMilliseconds(30000)
.setChildSelector(1)
.setMustBeFresh(True))
freshInterest.getKeyLocator().setType(KeyLocatorType.KEY_LOCATOR_DIGEST)
freshInterest.getKeyLocator().setKeyData(bytearray(
[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F]))
freshInterest.getExclude().appendComponent(Name("abc")[0]).appendAny()
freshInterest.getForwardingHint().add(1, Name("/A"))
dump(freshInterest.toUri())
# Set up the KeyChain.
keyChain = KeyChain("pib-memory:", "tpm-memory:")
keyChain.importSafeBag(SafeBag
(Name("/testname/KEY/123"),
Blob(DEFAULT_RSA_PRIVATE_KEY_DER, False),
Blob(DEFAULT_RSA_PUBLIC_KEY_DER, False)))
validator = Validator(ValidationPolicyFromPib(keyChain.getPib()))
# Make a Face just so that we can sign the interest.
face = Face("localhost")
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
face.makeCommandInterest(freshInterest)
reDecodedFreshInterest = Interest()
reDecodedFreshInterest.wireDecode(freshInterest.wireEncode())
dump("")
dump("Re-decoded fresh Interest:")
dumpInterest(reDecodedFreshInterest)
validator.validate(
reDecodedFreshInterest, makeSuccessCallback("Freshly-signed Interest"),
makeFailureCallback("Freshly-signed Interest"))
def onSetupFailed(msg):
print(msg)
print("In this test, try start publishing with default keychain certificate anyway")
keyChain = KeyChain()
try:
defaultCertificateName = keyChain.getDefaultCertificateName()
startProducers(defaultCertificateName, keyChain)
except SecurityException as e:
print str(e)
def main():
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign data packets.
echo = Echo(keyChain, keyChain.getDefaultCertificateName())
prefix = Name("/testecho")
dump("Register prefix", prefix.toUri())
face.registerPrefix(prefix, echo.onInterest, echo.onRegisterFailed)
while echo._responseCount < 1:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
face.shutdown()
def start(self):
self.isStopped = False
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.face = ThreadsafeFace(self.loop, '')
k = KeyChain()
self.face.setCommandSigningInfo(k, k.getDefaultCertificateName())
self.face.stopWhen(lambda:self.isStopped)
try:
self.loop.run_until_complete(self.sendNextInsertRequest())
finally:
self.face.shutdown()
def main():
# Params parsing
parser = argparse.ArgumentParser(description='bms gateway node to Parse or follow Cascade Datahub log and publish to MiniNdn.')
parser.add_argument('filename', help='datahub log file')
parser.add_argument('-f', dest='follow', action='store_true', help='follow (tail -f) the log file')
parser.add_argument('--namespace', default='/ndn/edu/ucla/remap/bms', help='root of ndn name, no trailing slash')
args = parser.parse_args()
# Setup logging
logger = Logger()
logger.prepareLogging()
# Face, KeyChain, memoryContentCache and asio event loop initialization
loop = asyncio.get_event_loop()
face = ThreadsafeFace(loop, "128.97.98.7")
keyChain = KeyChain(IdentityManager(BasicIdentityStorage(), FilePrivateKeyStorage()))
# For the gateway publisher, we create one identity for it to sign nfd command interests
#certificateName = keyChain.createIdentityAndCertificate(Name("/ndn/bms/gateway-publisher"))
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
print "Using certificate name " + keyChain.getDefaultCertificateName().toUri()
cache = MemoryContentCache(face)
dataPublisher = DataPublisher(face, keyChain, loop, cache, args.namespace)
cache.registerPrefix(Name(args.namespace), dataPublisher.onRegisterFailed, dataPublisher.onDataNotFound)
# Parse csv to decide the mapping between sensor JSON -> <NDN name, data type>
dataPublisher.populateSensorNDNDictFromCSV('bms-sensor-data-types-sanitized.csv')
loop.call_later(dataPublisher._restartInterval, dataPublisher.checkAlive)
if args.follow:
#asyncio.async(loop.run_in_executor(executor, followfile, args.filename, args.namespace, cache))
loop.run_until_complete(dataPublisher.followfile(args.filename))
else:
loop.run_until_complete(dataPublisher.readfile(args.filename))
loop.run_forever()
face.shutdown()
def main():
loop = asyncio.get_event_loop()
face = ThreadsafeFace(loop, "localhost")
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# TODO: NFD hack: uncomment once NFD forwarding fixed
# discoveree = Discoveree(loop, face, keyChain)
# TODO: NFD hack: remove once NFD forwarding fixed
discoveree = LocalDiscoveree(loop, face, keyChain)
cecTv = CecTv(loop, face, keyChain, discoveree)
loop.run_forever()
face.shutdown()
def main():
face = Face()
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
certificateName = keyChain.getDefaultCertificateName()
face.setCommandSigningInfo(keyChain, certificateName)
test = DiscoveryTest(face, keyChain, certificateName)
test.start()
while True:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
face.shutdown()
def start(self):
self.isStopped = False
self.loop = asyncio.get_event_loop()
self.face = ThreadsafeFace(self.loop, '')
self.keyFace = ThreadsafeFace(self.loop, 'borges.metwi.ucla.edu')
self.face.stopWhen(lambda:self.isStopped)
self.keyFace.stopWhen(lambda:self.isStopped)
k = KeyChain()
self.face.setCommandSigningInfo(k, k.getDefaultCertificateName())
try:
self.loop.run_until_complete(self.parseDataRequest())
except (EOFError, KeyboardInterrupt):
pass
finally:
self.face.shutdown()
def main():
prefix = Name("/nfd/edu/ucla/remap/test")
# Route to aleph.ndn.ucla.edu. Have to use the canonical name with an IP
# address and port.
uri = "udp4://128.97.98.7:6363"
# The default Face connects to the local NFD.
face = Face()
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Create the /localhost/nfd/faces/query command interest, including the
# FaceQueryFilter. Construct the FaceQueryFilter using the structure in
# face_query_filter_pb2 which was produced by protoc.
message = face_query_filter_pb2.FaceQueryFilterMessage()
filter = message.face_query_filter.add()
filter.uri = uri
encodedFilter = ProtobufTlv.encode(message)
interest = Interest(Name("/localhost/nfd/faces/query"))
interest.getName().append(encodedFilter)
enabled = [True]
def onComplete(content):
processFaceStatus(content, prefix, uri, face, enabled)
def onError(errorCode, message):
enabled[0] = False
dump(message)
SegmentFetcher.fetch(
face, interest, SegmentFetcher.DontVerifySegment, onComplete, onError)
# Loop calling processEvents until a callback sets enabled[0] = False.
while enabled[0]:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
def main():
# Silence the warning from Interest wire encode.
Interest.setDefaultCanBePrefix(True)
if sys.version_info[0] <= 2:
userPrefixUri = raw_input("Enter your user prefix (e.g. /a): ")
else:
userPrefixUri = input("Enter your user prefix (e.g. /a): ")
if userPrefixUri == "":
dump("You must enter a user prefix")
return
syncPrefixUri = "/sync"
nUserPrefixes = 2
maxPublishedSequenceNo = 3
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
# Set up the KeyChain.
keyChain = KeyChain("pib-memory:", "tpm-memory:")
keyChain.importSafeBag(SafeBag
(Name("/testname/KEY/123"),
Blob(DEFAULT_RSA_PRIVATE_KEY_DER, False),
Blob(DEFAULT_RSA_PUBLIC_KEY_DER, False)))
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
producer = Producer(
face, keyChain, Name(syncPrefixUri), userPrefixUri, nUserPrefixes,
maxPublishedSequenceNo)
# The main event loop.
while True:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
class LightController():
shouldSign = False
COLORS_PER_LIGHT = 3
STRAND_SIZE = 50
def __init__(self, nStrands=1, myIP="192.168.1.1", lightIP="192.168.1.50", prefix="/testlight"):
self.log = logging.getLogger("LightController")
self.log.setLevel(logging.DEBUG)
sh = logging.StreamHandler()
sh.setLevel(logging.WARNING)
self.log.addHandler(sh)
fh = logging.FileHandler("LightController.log")
fh.setLevel(logging.INFO)
self.log.addHandler(fh)
self.payloadBuffer = [[0]*self.STRAND_SIZE*self.COLORS_PER_LIGHT for n in range(nStrands)]
self.kinetsender = KinetSender(myIP, lightIP, nStrands, self.STRAND_SIZE*self.COLORS_PER_LIGHT)
self.registerFailed = False
self.done = False
self.prefix = Name(prefix)
self.keychain = KeyChain()
self.certificateName = self.keychain.getDefaultCertificateName()
# XXX: we should get a thread for this or something!
def start(self):
self.face = Face()
self.face.setCommandSigningInfo(self.keychain, self.certificateName)
self.face.registerPrefix(self.prefix, self.onLightingCommand, self.onRegisterFailed)
while self.face is not None:
self.face.processEvents()
if self.registerFailed:
self.stop()
break
#time.sleep(0.001)
def stop(self):
self.kinetsender.stop = True
self.kinetsender.complete.wait()
self.face.shutdown()
self.face = None
def signData(self, data):
if LightController.shouldSign:
self.keychain.sign(data, self.certificateName)
else:
data.setSignature(Sha256WithRsaSignature())
def setPayloadColor(self, strand, color):
# will expand this to allow the repeats, etc
self.payloadBuffer[strand] = [int(color.r)&0xff, int(color.g)&0xff, int(color.b)&0xff]*self.STRAND_SIZE
def onLightingCommand(self, prefix, interest, transport, prefixId):
interestName = Name(interest.getName())
#d = Data(interest.getName().getPrefix(prefix.size()+1))
d = Data(interest.getName())
# get the command parameters from the name
try:
commandComponent = interest.getName().get(prefix.size())
commandParams = interest.getName().get(prefix.size()+1)
lightingCommand = LightCommandMessage()
ProtobufTlv.decode(lightingCommand, commandParams.getValue())
self.log.info("Command: " + commandComponent.toEscapedString())
requestedColor = lightingCommand.command.pattern.colors[0]
colorStr = str((requestedColor.r, requestedColor.g, requestedColor.b))
self.log.info("Requested color: " + colorStr)
self.setPayloadColor(0, requestedColor)
self.sendLightPayload(1)
d.setContent("Gotcha: " + colorStr+ "\n")
except Exception as e:
print e
d.setContent("Bad command\n")
finally:
d.getMetaInfo().setFinalBlockID(0)
self.signData(d)
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
def onRegisterFailed(self, prefix):
self.log.error("Could not register " + prefix.toUri())
print "Register failed!"
self.registerFailed = True
def sendLightPayload(self, port):
self.kinetsender.setPayload(port, self.payloadBuffer[port-1])
class StatusServer(object):
def __init__(self):
self._face = Face()
self._keyChain = KeyChain()
#print(dir(self._keyChain))
self._certificateName = self._keyChain.getDefaultCertificateName()
self.registerWithNfd()
#self.nfdCheck()
def registerWithNfd(self):
#self._face = Face()
# Use the system default key chain and certificate name to sign commands.
self._face.setCommandSigningInfo(self._keyChain, self._certificateName)
logging.debug('Register prefix ' + LINK_STATUS_NAME.toUri())
self._face.registerPrefix(LINK_STATUS_NAME, self.onLinkInterest, self.onRegisterFailed)
logging.debug('Register prefix ' + METADATA_STATUS_NAME.toUri())
self._face.registerPrefix(METADATA_STATUS_NAME, self.onMetaDataInterest, self.onRegisterFailed)
logging.debug('Register prefix ' + PREFIX_STATUS_NAME.toUri())
self._face.registerPrefix(PREFIX_STATUS_NAME, self.onPrefixInterest, self.onRegisterFailed)
def onLinkInterest(self, prefix, interest, face, registeredPrefixId, filter):
self._linkData = getLinkData()
logging.debug('Received interest for Link')
self.sendData(prefix, interest, face, registeredPrefixId, self._linkData)
def onMetaDataInterest(self, prefix, interest, face, registeredPrefixId, filter):
print("on meta interest")
print("interest rcvd for: ", interest.getName().toUri())
print("interest must be fresh value: ", interest.getMustBeFresh())
processFiles()
self._metaData = processAndGetMetaData()
logging.debug('Received interest for Metadata')
self.sendData(prefix, interest, face, registeredPrefixId, self._metaData)
print("Data send")
def onPrefixInterest(self, prefix, interest, transport, registeredPrefixId, filter):
self._prefixData = getPrefixData()
logging.debug('Received interest for Prefix')
self.sendData(prefix, interest, transport, registeredPrefixId, self._prefixData)
def sendData(self, prefix, interest, face, registeredPrefixId, content): #onInterest
#transport.send(encodedData.toBuffer())
#print(prefix)
# Publish segments
dataSize = len(content)
print("Dat size: ",dataSize)
segmentBegin = 0
segmentNo = 0
print "Start"
while segmentBegin < dataSize:
segmentEnd = segmentBegin + 2000 #Common.MAX_NDN_PACKET_SIZE
if segmentEnd > dataSize:
segmentEnd = dataSize
# Make and sign a Data packet.
print("Prefix: ")
print(prefix)
if not "%" in str(prefix)[-7:]:
segmentName = prefix
#print("NO % in name: ", segmentName)
segmentName.appendSegment(segmentNo)
else:
segmentName = str(prefix)[:-1]
#print("% in name: ",segmentName)
segmentName += str(segmentNo)
segmentName = Name(segmentName)
print("Segment Name: ")
print(segmentName)
print("Segment Name appended: ", segmentName)
print "Segmenting data from %d to %d" % (segmentBegin, segmentEnd)
print("COntent: ")
print(content[segmentBegin:segmentEnd])
data = Data(segmentName)
data.setContent(content[segmentBegin:segmentEnd])
data.getMetaInfo().setFreshnessPeriod(2000)
self._keyChain.sign(data, self._certificateName)
if segmentEnd >= dataSize:
print("yes")
data.getMetaInfo().setFinalBlockId(segmentName[-1])
#encodedData = data.wireEncode()
segmentBegin = segmentEnd
print "Sending data " + segmentName.toUri()
#transport.send(encodedData.toBuffer())
face.putData(data)
segmentNo += 1
time.sleep(0.5)
print "Finish"
def onRegisterFailed(self, prefix):
dump("Register failed for prefix", prefix.toUri())
def nfdCheck(self):
try:
try:
output=subprocess.check_output('nfd-status | grep memphis.edu/internal', shell=True)
except subprocess.CalledProcessError,e:
output=e.output
print("output", output)
if "memphis.edu/internal" not in output:
try:
self.registerWithNfd()
threading.Timer(1, self.nfdCheck).start()
self.run()
except:
pass
else:
pass
except:
def main(index_f, weight_f, consumerMode, k, query_interval, fetchPrefix,
publishPrefix):
# The default Face will connect using a Unix socket, or to "localhost".
instance_prefix = fetchPrefix.split("/")[-1]
pd = PlayDetect(index_f, weight_f, instance_prefix, k, query_interval)
face = Face()
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# sceneConsumer = Namespace("/ndn/eb/stream/run/28/annotation")
engine = str(Name(fetchPrefix)[-1])
sceneFetchPrefix = Name('/eb/seglab').append(engine)
print(' > Will fetch annotations from ' + fetchPrefix)
print(' > Will fetch scenes from ' + sceneFetchPrefix.toUri())
sceneConsumer = Namespace(sceneFetchPrefix)
sceneConsumer.setFace(face)
annotationsConsumer = Namespace(fetchPrefix)
#if consumerMode == "test":
# annotationsConsumer = Namespace("/ndn/eb/stream/run/28/annotations")
#elif consumerMode == "default":
# annotationsConsumer = Namespace('/eb/proto/test/ml_processing/yolo_default')
annotationsConsumer.setFace(face)
log_f = open(str("playdetect_log") + ".txt", "w")
log_f.close()
playdetectProducer = Namespace(
Name(publishPrefix).append(engine), keyChain)
print(' > Will publish playdetect data under ' +
playdetectProducer.getName().toUri())
playdSegmentsHandler = GeneralizedObjectStreamHandler()
# set freshness to 30
# playdSegmentsHandler.setLatestPacketFreshnessPeriod(30)
playdetectProducer.setHandler(playdSegmentsHandler)
playdetectProducer.setFace(
face,
lambda prefixName: dump("Register failed for prefix", prefixName),
lambda prefixName, whatever: dump("Register success for prefix",
prefixName))
def onNewScene(sequenceNumber, contentMetaInfo, objectNamespace):
dump("Got scene (segment) :", str(objectNamespace.getName()))
if str(objectNamespace.obj):
# Store scene segment AND scene segment NAME into a database
sceneSegmentName = objectNamespace.getName()
sceneSegment = json.loads(str(objectNamespace.obj))
pd.storeToDatabase(sceneSegmentName, sceneSegment)
def onNewAnnotation(sequenceNumber, contentMetaInfo, objectNamespace):
# dump("Got new annotation")
stringObj = str(objectNamespace.obj)
# print(stringObj)
now = Common.getNowMilliseconds()
if stringObj and pd.itIsTimeToQueryDatabase():
# TBD
# query interval configurable
itIsTimeToQueryDatabase = True
if itIsTimeToQueryDatabase:
# TBD
# run query against the databse, using recevied annotation
# the result should be a list that contains scene segment names (see above)
# FOR NOW: let's have startFrame end endFrame in the results
# most likely -- parameterize query, i.e. give argument maxResultNum
result = pd.pickTops(json.loads(stringObj), k)
if result:
playdSegmentsHandler.addObject(Blob(json.dumps(result)),
"application/json")
print(
"PUBLISH SIMILAR SCENES: %s" %
str(playdSegmentsHandler.getProducedSequenceNumber()))
#logging the result
with open(str("playdetect_log") + ".txt", "w+") as f:
f.write("PUBLISHED SCENE: %s" % str(
playdSegmentsHandler.getProducedSequenceNumber()))
f.write("%s\r\n" % result)
pipelineSize_segConsume = 3
sceneConsumer.setHandler(
GeneralizedObjectStreamHandler(pipelineSize_segConsume,
onNewScene)).objectNeeded()
pipelineSize_annoConsume = 3
annotationsConsumer.setHandler(
GeneralizedObjectStreamHandler(pipelineSize_annoConsume,
onNewAnnotation)).objectNeeded()
while True:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
class TestFaceRegisterMethods(ut.TestCase):
def setUp(self):
self.face_in = Face()
self.face_out = Face()
self.keyChain = KeyChain()
def tearDown(self):
self.face_in.shutdown()
self.face_out.shutdown()
def onInterestEffect(self, prefix, interest, transport, prefixID):
data = Data(interest.getName())
data.setContent("SUCCESS")
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
encodedData = data.wireEncode()
transport.send(encodedData.toBuffer())
def test_register_prefix_response(self):
# gotta sign it (WAT)
prefixName = Name("/test")
self.face_in.setCommandSigningInfo(self.keyChain,
self.keyChain.getDefaultCertificateName())
failedCallback = Mock()
interestCallback = Mock(side_effect=self.onInterestEffect)
self.face_in.registerPrefix(prefixName, interestCallback, failedCallback)
server = gevent.spawn(self.face_process_events, self.face_in, [interestCallback, failedCallback], 'h')
time.sleep(1) # give the 'server' time to register the interest
# express an interest on another face
dataCallback = Mock()
timeoutCallback = Mock()
# now express an interest on this new face, and see if onInterest is called
interestName = prefixName.append("hello")
self.face_out.expressInterest(interestName, dataCallback, timeoutCallback)
client = gevent.spawn(self.face_process_events, self.face_out, [dataCallback, timeoutCallback], 'c')
gevent.joinall([server, client], timeout=10)
self.assertEqual(failedCallback.call_count, 0, 'Failed to register prefix at all')
self.assertEqual(interestCallback.call_count, 1, 'Expected 1 onInterest callback, got '+str(interestCallback.call_count))
self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count))
onDataArgs = dataCallback.call_args[0]
# check the message content
data = onDataArgs[1]
expectedBlob = Blob(bytearray("SUCCESS"))
self.assertTrue(expectedBlob == data.getContent(), 'Data received on face does not match expected format')
def face_process_events(self, face, callbacks, name=None):
# implemented as a 'greenlet': something like a thread, but semi-synchronous
# callbacks should be a list
done = False
while not done:
face.processEvents()
gevent.sleep()
for c in callbacks:
if (c.call_count > 0):
done = True
class Producer(object):
def __init__(self):
# Initialize our keychain
self.keyChain = KeyChain()
self.isDone = False
pass
def run(self, namespace):
# Create a connection to the local forwarder over a Unix socket
face = Face()
prefix = Name(namespace)
# Use the system default key chain and certificate name to sign commands.
face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign Data packets.
face.registerPrefix(prefix, self.onInterest, self.onRegisterFailed)
print("Registering prefix: ", prefix.toUri())
# Run the event loop forever. Use a short sleep to
# prevent the Producer from using 100% of the CPU.
while not self.isDone:
face.processEvents()
time.sleep(0.01)
pass
def onInterest(self, prefix, interest, transport, registeredPrefixId):
interestName = interest.getName()
data = Data(interestName)
dt = datetime.now()
f = open("keluaran.txt", "r")
outiklan0 = f.readline()
outiklan1 = f.readline()
outiklan2 = f.readline()
outiklan3 = f.readline()
if (interestName.toUri() == "/vanet-ndn-rasp1/iklanpertama"):
data.setContent(
outiklan1
) #("\nLakukan Pengisian Pulsa Telkomsel sekarang juga \nDapatkan pulsa 5000 dan kelipatan untuk setiap pembelian pulsa 10000 dan kelipatannya\n" ) #bagian ini bisa diganti dengan informasi dari sensor
elif (interestName.toUri() == "/vanet-ndn-rasp1/iklankedua"):
data.setContent(
outiklan2
) #("\nLakukan Pengisian Kuota Indosat sekarang juga! \nDapatkan kemudahan dalam berinternet digenggamanmu\n" ) #bagian ini bisa diganti dengan informasi dari sensor
elif (interestName.toUri() == "/vanet-ndn-rasp1/iklanketiga"):
data.setContent(
outiklan3
) #("\nIngin memiliki Smartphone baru? \nDapatkan smartphone impian mu dengan XL\nCek xl.co.id untuk penawaran menarik\n" ) #bagian ini bisa diganti dengan informasi dari sensor
#else:
# data.setContent("\nJarak kendaraan: \n") #bagian ini bisa diganti dengan informasi dari sensor
hourMilliseconds = 100000 #3600 * 1000 #1000 jam
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
transport.send(data.wireEncode().toBuffer())
print("Replied to: %s - Time: %s " % (interestName.toUri(), dt))
print(
"==================================================================\n"
)
pass
def onRegisterFailed(self, prefix):
# Print an error message and signal the event loop to terminate
print("Register failed for prefix", prefix.toUri())
self.isDone = True
pass
class Flask():
def __init__(self, host):
self.__name__ = __name__
self.keyChain = KeyChain()
self.isDone = False
self.counter = 0
loop = asyncio.get_event_loop()
self.face = ThreadsafeFace(loop, host)
self.a = {}
self.methods = {}
def route(self, uri, methods):
prefix = uri
if bool(re.search('<(.*)>', prefix)):
self.baseName = ndn.Name(
re.sub('<(.*)>', methods[0] + '/<data>', prefix))
else:
self.baseName = ndn.Name(prefix + "/" + methods[0])
self.methods[self.baseName.toUri()] = methods[0]
return self.dec
def onInterest(self, prefix, interest, *k):
print >> sys.stderr, "<< PyNDN %s" % interest.name
intrestUri = interest.name.toUri()
prefixUri = prefix.toUri()
parameters = ''
if intrestUri != prefixUri:
parameters = intrestUri[len(prefixUri) + 1:]
print
prefixUri += "/%3Cdata%3E"
d = self.a[prefixUri]
if self.methods[prefixUri] == "POST":
content = json.dumps(
d(interest.getContent().toRawStr().decode('string_escape')))
else:
if parameters:
content = json.dumps(d(parameters))
else:
content = json.dumps(d())
self.counter += 1
data = ndn.Data(interest.getName())
meta = ndn.MetaInfo()
meta.setFreshnessPeriod(5000)
data.setMetaInfo(meta)
data.setContent(content)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
self.face.putData(data)
def _onRegisterFailed(self, prefix):
print >> sys.stderr, "<< PyNDN: failed to register prefix"
def run(self):
root = logging.getLogger()
root.setLevel(logging.DEBUG)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
root.addHandler(ch)
loop = asyncio.get_event_loop()
server = Server(self.face)
loop.run_forever()
self.face.shutdown()
def dec(self, func):
self.a[self.baseName.toUri()] = func
self.face.registerPrefix(
self.baseName,
self.onInterest,
self._onRegisterFailed,
)
class SongHandler:
def __init__(self):
self._device = "PC1"
self._playPrefix = Name("/ndn/edu/ucla/remap/music/play")
self.prefix = self._playPrefix.append(self._device)
self._face = None
self._loop = None
self.thread = None
self._keyChain = KeyChain()
self._certificateName = self._keyChain.getDefaultCertificateName()
self._repoCommandPrefix = "/example/repo/1"
self.song = ""
self.ftxt = ""
self.ffreq = ""
self.songList = ""
self.mp = MusicPlayer()
self.config = RawConfigParser()
self.config.read('config.cfg')
self.s = LightMessenger(self.config)
self.q = Queue.Queue()
def start(self):
self._loop = asyncio.get_event_loop()
self._face = ThreadsafeFace(self._loop,"")
self._face.setCommandSigningInfo(self._keyChain, self._certificateName)
self._face.registerPrefix(self.prefix, self.onPlayingCommand, self.onRegisterFailed)
print "after register prefix"
try:
self._loop.run_forever()
except KeyboardInterrupt:
sys.exit()
finally:
self.stop()
def stop(self):
self._loop.close()
self._face.shutdown()
sys.exit(1)
def playFunction(self):
txt = open(self.ftxt)
print "open txt successfully",self.ftxt
#collect the onset duration
osDur = [0.0]
freq = []
data = [float(line.split()[0])for line in txt]
for i in data:
osDur.append(i)
txt.close()
txt = open(self.ffreq)
print "open txt successfully",self.ffreq
data = [float(line.split()[1])for line in txt]
print "dasfdaaaa"
for j in data:
freq.append(j)
avefq = int(sum(freq)/len(freq))
print avefq
txt.close()
g=(avefq-100)/10
r=avefq/30
b=(100-avefq)/10
startingColors = [int((15+r)/1.5),int((10+g)/1.5), int((10+b)/1.5)]
for i in range(0,3):
if startingColors[i]<0:
startingColors[i]=6
#startingColors = [5,5,5]
self.q.put(self.song+str("-music.mp3") )
print "MusicPlayer.isPlaying",MusicPlayer.isPlaying
if not MusicPlayer.isPlaying:
self.thread.start()
#MusicPlayer.isPlaying = True
self.s.start(osDur,startingColors)
def getOnset(self):
print "getonset"
otxt = self.song+str("-o")
print otxt
g = GetFile(self._repoCommandPrefix, otxt, self._face, self.getFreq)
g.oStream = open(self.song+str("-os.txt"),'wb')
g.start()
def getFreq(self):
print "getfreq"
ftxt = self.song+str("-f")
g = GetFile(self._repoCommandPrefix, ftxt, self._face, self.playFunction)
g.oStream = open(self.song+str("-freq.txt"),'wb')
g.start()
def signData(self, data):
data.setSignature(Sha256WithRsaSignature())
def onPlayingCommand(self, prefix, interest, transport, prefixId):
print "receive interest"
interestName = Name(interest.getName())
commandComponent = interest.getName().get(self.prefix.size())
if commandComponent == Name.Component("stop"):
pass
if commandComponent == Name.Component("play"):
pass
else:
songName = commandComponent.toEscapedString()
print songName
songList = []
songList = songName.split('%2C')
print "songlist and its len",songList,len(songList)
for i in songList:
self.song = i
fmusic = i+str("-music.mp3")
self.ftxt = i + str("-os.txt")
self.ffreq = i + str("-freq.txt")
print "FMUSIC:",fmusic
self.thread = threading.Thread(target = self.mp.play_music, args = (fmusic,songList,self.q,))
self.thread.daemon = True
g = GetFile(self._repoCommandPrefix, i, self._face, self.getOnset)
#g = GetFile(self._repoCommandPrefix, ftxt, self._face, self.lightFunction)
g.oStream = open(fmusic,'wb')
g.start()
d = Data(interest.getName())
d.setContent("start to play: " + songName + "\n")
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
def onRegisterFailed(self, prefix):
self.log.error("Could not register " + prefix.toUri())
self.stop()
class Producer():
"""Hosts data under a certain namespace"""
def __init__(self, data_size, verbose=False):
# create a KeyChain for signing data packets
self._key_chain = KeyChain()
self._is_done = False
self._num_interests = 0
# self._keyChain.createIdentityV2(Name("/ndn/identity"))
# the number of interests to satisfy before shutdown of server
self._max_interests = 0
# host data at the local forwarder
self._face = Face()
# immutable byte array to use as data
self._byte_array = bytes(data_size)
# the number of bytes contained in each data packet
self._data_size = data_size
# the verbosity of diagnostic information
self._verbose = verbose
# keep track of if the first interest has been recieved (for timing)
self._is_first_interst = True
# keep track of various performance metrics:
self._interests_satisfied = 0
self._interests_recieved = 0
self._data_sent = 0
self._elapsed_time = {}
self._initial_time = {}
self._final_time = {}
print("Producer instance created.")
def run(self, namespace, max_interests):
"""Starts listening for interest packets in the given namespace"""
prefix = Name(namespace)
self._max_interests = max_interests
# Use the system default key chain and certificate name to sign commands.
self._face.setCommandSigningInfo(
self._key_chain, self._key_chain.getDefaultCertificateName())
# Also use the default certificate name to sign Data packets.
self._face.registerPrefix(prefix, self.onInterest,
self.onRegisterFailed)
dump("Registering prefix", prefix.toUri())
print(f"Listening for interests under {namespace}...")
print(f"Will satisfy {max_interests} before termination.")
# Run the event loop forever. Use a short sleep to
# prevent the Producer from using 100% of the CPU.
while not self._is_done:
self._face.processEvents()
time.sleep(0.01)
# shutdown this face - TODO: figure out why this can't be done in the self.shutdown() method
self._face.shutdown()
def onInterest(self, prefix, interest, transport, registeredPrefixId):
"""Called when an interest for the specified name is recieved"""
# keep track of when first interest was recieved
self._initial_time['download_time'] = time.time()
# set data to a byte array of a specified size
interestName = interest.getName()
data = Data(interestName)
data.setContent(self._byte_array)
# sign and send data
data.getMetaInfo().setFreshnessPeriod(3600 * 1000)
self._key_chain.sign(data, self._key_chain.getDefaultCertificateName())
transport.send(data.wireEncode().toBuffer())
# print additional information if verobse flag is set
if self._verbose:
dump("Replied to:", interestName.toUri())
# increment appropriate variables
self._interests_recieved += 1
self._interests_satisfied += 1
self._num_interests += 1
# stop loop if the required number of interests have been satisified
if self._num_interests >= self._max_interests:
self.shutdown()
def onRegisterFailed(self, prefix):
"""Called when forwarder can't register prefix."""
dump("Register failed for prefix", prefix.toUri())
self.shutdown()
def shutdown(self):
self._final_time['download_time'] = time.time()
self._is_done = True
self.print_status_report()
def print_status_report(self):
"""Prints performance metrics for this producer."""
# compute total data sent (in bytes)
self._data_sent = self._interests_satisfied * self._data_size
# compute timing
for key, value in self._initial_time.items():
self._elapsed_time[
key] = self._final_time[key] - self._initial_time[key]
# calculate bitrate of interests sent
download_kbps = (
(self._data_sent * 8) / 1000) / self._elapsed_time['download_time']
print("\n----------------------------------")
print(f"Number of interests recieved: {self._interests_recieved}")
print(f"Number of interests satisfied: {self._interests_satisfied}")
print("----------------------------------")
# this probably isn't a useful metric, as the output interface will throttle this
# print(f"{self._data_sent / 1000} kilobytes sent for a bitrate of {download_kbps} kbps")
print(
f"{self._data_size * self._interests_satisfied} bytes of data sent."
)
print("----------------------------------\n")
class Producer(object):
def __init__(self, prefix, maxCount=1):
self.keyChain = KeyChain()
self.prefix = Name(prefix)
self.isDone = False
# Initialize list for Data packet storage.
# We'll treat the indices as equivalent to the sequence
# number requested by Interests.
self.data = []
finalBlock = Name.Component.fromNumberWithMarker(maxCount - 1, 0x00)
hourMilliseconds = 3600 * 1000
# Pre-generate and sign all of Data we can serve.
# We can also set the FinalBlockID in each packet
# ahead of time because we know the entire sequence.
for i in range(maxCount):
dataName = Name(prefix).appendSegment(i)
data = Data(dataName)
data.setContent("Hello, " + dataName.toUri())
data.getMetaInfo().setFinalBlockID(finalBlock)
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
self.data.append(data)
def run(self):
face = Face()
# Use the system default key chain and certificate name to sign commands.
face.setCommandSigningInfo(self.keyChain, self.keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign data packets.
face.registerPrefix(self.prefix, self.onInterest, self.onRegisterFailed)
print "Registering prefix %s" % self.prefix.toUri()
while not self.isDone:
face.processEvents()
time.sleep(0.01)
def onInterest(self, prefix, interest, transport, registeredPrefixId):
interestName = interest.getName()
sequence = interestName[-1].toNumber()
if 0 <= sequence and sequence < len(self.data):
transport.send(self.data[sequence].wireEncode().toBuffer())
print "Replied to: %s" % interestName.toUri()
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
def main():
# Uncomment these lines to print ChronoSync debug messages.
# logging.getLogger('').addHandler(logging.StreamHandler(sys.stdout))
# logging.getLogger('').setLevel(logging.INFO)
# Silence the warning from Interest wire encode.
Interest.setDefaultCanBePrefix(True)
screenName = promptAndInput("Enter your chat username: "******"ndn/edu/ucla/remap"
hubPrefix = promptAndInput("Enter your hub prefix [" + defaultHubPrefix +
"]: ")
if hubPrefix == "":
hubPrefix = defaultHubPrefix
defaultChatRoom = "ndnchat"
chatRoom = promptAndInput("Enter the chatroom name [" + defaultChatRoom +
"]: ")
if chatRoom == "":
chatRoom = defaultChatRoom
host = "localhost"
print("Connecting to " + host + ", Chatroom: " + chatRoom +
", Username: "******"")
face = Face(host)
# Set up the key chain.
keyChain = KeyChain("pib-memory:", "tpm-memory:")
keyChain.importSafeBag(
SafeBag(Name("/testname/KEY/123"),
Blob(DEFAULT_RSA_PRIVATE_KEY_DER, False),
Blob(DEFAULT_RSA_PUBLIC_KEY_DER, False)))
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
chat = Chat(screenName, chatRoom, Name(hubPrefix), face, keyChain,
keyChain.getDefaultCertificateName())
# The main loop to process Chat while checking stdin to send a message.
print("Enter your chat message. To quit, enter \"leave\" or \"exit\".")
while True:
# Set timeout to 0 for an immediate check.
isReady, _, _ = select.select([sys.stdin], [], [], 0)
if len(isReady) != 0:
input = promptAndInput("")
if input == "leave" or input == "exit":
# We will send the leave message below.
break
chat.sendMessage(input)
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
# The user entered the command to leave.
chat.leave()
# Wait a little bit to allow other applications to fetch the leave message.
startTime = Chat.getNowMilliseconds()
while True:
if Chat.getNowMilliseconds() - startTime >= 1000.0:
break
face.processEvents()
time.sleep(0.01)
class TestFaceRegisterMethods(ut.TestCase):
def setUp(self):
self.face_in = Face()
self.face_out = Face()
self.keyChain = KeyChain()
def tearDown(self):
self.face_in.shutdown()
self.face_out.shutdown()
def onInterestEffect(self, prefix, interest, transport, prefixID):
data = Data(interest.getName())
data.setContent("SUCCESS")
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
encodedData = data.wireEncode()
transport.send(encodedData.toBuffer())
def test_register_prefix_response(self):
# gotta sign it (WAT)
prefixName = Name("/test")
self.face_in.setCommandSigningInfo(
self.keyChain, self.keyChain.getDefaultCertificateName())
failedCallback = Mock()
interestCallback = Mock(side_effect=self.onInterestEffect)
self.face_in.registerPrefix(prefixName, interestCallback,
failedCallback)
server = gevent.spawn(self.face_process_events, self.face_in,
[interestCallback, failedCallback], 'h')
time.sleep(1) # give the 'server' time to register the interest
# express an interest on another face
dataCallback = Mock()
timeoutCallback = Mock()
# now express an interest on this new face, and see if onInterest is called
interestName = prefixName.append("hello")
self.face_out.expressInterest(interestName, dataCallback,
timeoutCallback)
client = gevent.spawn(self.face_process_events, self.face_out,
[dataCallback, timeoutCallback], 'c')
gevent.joinall([server, client], timeout=10)
self.assertEqual(failedCallback.call_count, 0,
'Failed to register prefix at all')
self.assertEqual(
interestCallback.call_count, 1,
'Expected 1 onInterest callback, got ' +
str(interestCallback.call_count))
self.assertEqual(
dataCallback.call_count, 1,
'Expected 1 onData callback, got ' + str(dataCallback.call_count))
onDataArgs = dataCallback.call_args[0]
# check the message content
data = onDataArgs[1]
expectedBlob = Blob(bytearray("SUCCESS"))
self.assertTrue(
expectedBlob == data.getContent(),
'Data received on face does not match expected format')
def face_process_events(self, face, callbacks, name=None):
# implemented as a 'greenlet': something like a thread, but semi-synchronous
# callbacks should be a list
done = False
while not done:
face.processEvents()
gevent.sleep()
for c in callbacks:
if (c.call_count > 0):
done = True
class Producer(object):
def __init__(self):
Prefix1 = '/umobile/pull'
self.configPrefix = Name(Prefix1)
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
def run(self):
try:
self.face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.configPrefix, self.onInterest,
self.onRegisterFailed)
print "Registering listening prefix : " + self.configPrefix.toUri()
while not self.isDone:
self.face.processEvents()
time.sleep(0.01)
except RuntimeError as e:
print "ERROR: %s" % e
def onInterest(self, prefix, interest, face, interestFilterId, filter):
interestName = interest.getName()
data = Data(interestName)
data.setContent("Test Pull based model")
hourMilliseconds = 600 * 1000
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
face.send(data.wireEncode().toBuffer())
print "Replied to Interest name: %s" % interestName.toUri()
print "Replied with Data name: %s" % interestName.toUri()
def _sendNextInterest(self, name):
interest = Interest(name)
uri = name.toUri()
interest.setInterestLifetimeMilliseconds(4000)
interest.setMustBeFresh(True)
if uri not in self.outstanding:
self.outstanding[uri] = 1
self.face.expressInterest(interest, self._onData, self._onTimeout)
print "Sent Interest for %s" % uri
def _onData(self, interest, data):
payload = data.getContent()
dataName = data.getName()
dataName_size = dataName.size()
print "Received data name: ", dataName.toUri()
print "Received data: ", payload.toRawStr()
def _onTimeout(self, interest):
name = interest.getName()
uri = name.toUri()
print "TIMEOUT #%d: %s" % (self.outstanding[uri], uri)
self.outstanding[uri] += 1
if self.outstanding[uri] <= 3:
self._sendNextInterest(name)
else:
self.isDone = True
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
class Flask():
def __init__(self, host):
self.__name__ = __name__
self.keyChain = KeyChain()
self.isDone = False
self.counter = 0
loop = asyncio.get_event_loop()
self.face = ThreadsafeFace(loop, host)
self.a = {}
self.methods = {}
def route(self, uri, methods):
self.baseName = ndn.Name(uri)
self.methods[self.baseName] = methods[0]
return self.dec
def onInterest(self, prefix, interest, *k):
print >> sys.stderr, "<< PyNDN %s" % interest.name
print prefix
d = self.a[prefix]
if self.methods[prefix] == "POST":
content = json.dumps(
d(interest.getContent().toRawStr().decode('string_escape')))
else:
content = json.dumps(d())
self.counter += 1
#print interest.getContent().toRawStr().decode('string_escape')
data = ndn.Data(interest.getName())
meta = ndn.MetaInfo()
meta.setFreshnessPeriod(5000)
data.setMetaInfo(meta)
data.setContent(content)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
self.face.putData(data)
def _onRegisterFailed(self, prefix):
print >> sys.stderr, "<< PyNDN: failed to register prefix"
def run(self):
root = logging.getLogger()
root.setLevel(logging.DEBUG)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
root.addHandler(ch)
loop = asyncio.get_event_loop()
#face = ThreadsafeFace(loop, "172.17.0.1")
#face = ndn.Face("172.17.0.1","6363")
server = Server(self.face)
loop.run_forever()
face.shutdown()
def dec(self, func):
self.a[self.baseName] = func
print self.a
self.face.registerPrefix(
self.baseName,
self.onInterest,
self._onRegisterFailed,
)
class trigger(object):
def __init__(self):
self.script_path = os.path.abspath(
__file__) # i.e. /path/to/dir/foobar.py
self.script_dir = os.path.split(
self.script_path)[0] #i.e. /path/to/dir/
self.Datamessage_size = 8000 #8kB --> Max Size from NDN standard
prefix_serviceDiscovery = "/sm/service_discovery"
self.prefix_serviceDiscovery = Name(prefix_serviceDiscovery)
prefix_serviceRegistration = "/sm/service_registration"
self.prefix_serviceRegistration = Name(prefix_serviceRegistration)
prefix_serviceMigration = "/sm/service_migration"
self.prefix_serviceMigration = Name(prefix_serviceMigration)
prefix_serviceMigrationPush = "/sm/service_migration/push"
self.prefix_serviceMigrationPush = Name(prefix_serviceMigrationPush)
prefix_trigger = "/trigger"
self.prefix_trigger = Name(prefix_trigger)
prefix_start_DTN_demo = "/sm/start_DTN_demo"
self.prefix_start_DTN_demo = Name(prefix_start_DTN_demo)
prefix_serviceMigration_KEBAPP = "/kebapp/maps/routefinder/"
self.prefix_serviceMigration_KEBAPP = Name(
prefix_serviceMigration_KEBAPP)
prefix_DE = "/picasso/start_de/"
self.prefix_DE = Name(prefix_DE)
#prefix_deployment_pull = "/picasso/service_deployment_pull/"
#self.prefix_deployment_pull = Name(prefix_deployment_pull)
# Default configuration of NDN
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
self.face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
#self.face.registerPrefix(self.prefix_deployment_pull, self.onInterest_PullService, self.onRegisterFailed)
#print "Registering prefix : " + self.prefix_deployment_pull.toUri()
def run(self):
try:
# send Interest message to retrieve data
#self.sendNextInterest(self.prefix_serviceMigration)
demo_name = raw_input(
'Enter name of the Demo (DTN or KEBAPP or DE) ')
if demo_name == 'DTN':
print 'Start SM-DTN Demo'
name_prefix = self.prefix_start_DTN_demo
if demo_name == 'KEBAPP':
print 'Start SM-KEBAPP demo'
name_prefix = self.prefix_serviceMigration_KEBAPP
if demo_name == 'DE':
print 'Start DE test'
name_prefix = self.prefix_DE
else:
print 'Try Again'
self.sendPushInterest(name_prefix)
# while not self.isDone:
# self.face.processEvents()
# time.sleep(0.01)
except RuntimeError as e:
print "ERROR: %s" % e
def sendPushInterest(self, name):
interest = Interest(name)
uri = name.toUri()
interest.setInterestLifetimeMilliseconds(4000)
interest.setMustBeFresh(True)
if uri not in self.outstanding:
self.outstanding[uri] = 1
# self.face.expressInterest(interest, self.onData, self._onTimeout)
self.face.expressInterest(
interest, None, None
) ## set None --> sent out only, don't wait for Data and Timeout
print "Sent Push-Interest for %s" % uri
def onTimeout(self, interest):
name = interest.getName()
uri = name.toUri()
print "TIMEOUT #%d: %s" % (self.outstanding[uri], uri)
self.outstanding[uri] += 1
if self.outstanding[uri] <= 3:
self.sendNextInterest(name)
else:
self.isDone = True
def onInterest_PullService(self, prefix, interest, face, interestFilterId,
filter):
interestName = interest.getName()
data = Data(interestName)
print "Interest Name: %s" % interestName
interest_name_components = interestName.toUri().split("/")
if "service_deployment_pull" in interest_name_components:
filename = "uhttpd.tar"
folder_name = "SC_repository/"
rel_path = os.path.join(self.script_dir, folder_name)
if not os.path.exists(rel_path):
os.makedirs(rel_path)
abs_file_path = os.path.join(rel_path, filename)
freshness = 10000 #milli second, content will be deleted from the cache after freshness period
self.sendingFile(abs_file_path, interest, face, freshness)
else:
print "Interest name mismatch"
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
def sendingFile(self, file_path, interest, face, freshness):
print "Sending File Function"
interestName = interest.getName()
interestNameSize = interestName.size()
try:
SegmentNum = (interestName.get(interestNameSize - 1)).toSegment()
dataName = interestName.getSubName(0, interestNameSize - 1)
# If no segment number is included in the INTEREST, set the segment number as 0 and set the file name to configuration script to be sent
except RuntimeError as e:
SegmentNum = 0
dataName = interestName
# Put file to the Data message
try:
# due to overhead of NDN name and other header values; NDN header overhead + Data packet content = < maxNdnPacketSize
# So Here segment size is hard coded to 5000 KB.
# Class Enumerate publisher is used to split large files into segments and get a required segment ( segment numbers started from 0)
dataSegment, last_segment_num = EnumeratePublisher(
file_path, self.Datamessage_size, SegmentNum).getFileSegment()
# create the DATA name appending the segment number
dataName = dataName.appendSegment(SegmentNum)
data = Data(dataName)
data.setContent(dataSegment)
# set the final block ID to the last segment number
last_segment = (Name.Component()).fromNumber(last_segment_num)
data.getMetaInfo().setFinalBlockId(last_segment)
#hourMilliseconds = 600 * 1000
data.getMetaInfo().setFreshnessPeriod(freshness)
# currently Data is signed from the Default Identitiy certificate
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
# Sending Data message
face.send(data.wireEncode().toBuffer())
print "Replied to Interest name: %s" % interestName.toUri()
print "Replied with Data name: %s" % dataName.toUri()
except ValueError as err:
print "ERROR: %s" % err
class TestFaceRegisterMethods(ut.TestCase):
def setUp(self):
self.face_in = Face()
self.face_out = Face()
self.keyChain = KeyChain()
def tearDown(self):
self.face_in.shutdown()
self.face_out.shutdown()
def test_register_prefix_response(self):
prefixName = Name("/test")
self.face_in.setCommandSigningInfo(self.keyChain,
self.keyChain.getDefaultCertificateName())
interestCallbackCount = [0]
def onInterest(prefix, interest, transport, prefixID):
interestCallbackCount[0] += 1
data = Data(interest.getName())
data.setContent("SUCCESS")
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
encodedData = data.wireEncode()
transport.send(encodedData.toBuffer())
failedCallback = Mock()
self.face_in.registerPrefix(prefixName, onInterest, failedCallback)
# Give the 'server' time to register the interest.
time.sleep(1)
# express an interest on another face
dataCallback = Mock()
timeoutCallback = Mock()
# now express an interest on this new face, and see if onInterest is called
# Add the timestamp so it is unique and we don't get a cached response.
interestName = prefixName.append("hello" + repr(time.time()))
self.face_out.expressInterest(interestName, dataCallback, timeoutCallback)
# Process events for the in and out faces.
timeout = 10000
startTime = getNowMilliseconds()
while True:
if getNowMilliseconds() - startTime >= timeout:
break
self.face_in.processEvents()
self.face_out.processEvents()
done = True
if interestCallbackCount[0] == 0 and failedCallback.call_count == 0:
# Still processing face_in.
done = False
if dataCallback.call_count == 0 and timeoutCallback.call_count == 0:
# Still processing face_out.
done = False
if done:
break
time.sleep(0.01)
self.assertEqual(failedCallback.call_count, 0, 'Failed to register prefix at all')
self.assertEqual(interestCallbackCount[0], 1, 'Expected 1 onInterest callback, got '+str(interestCallbackCount[0]))
self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count))
onDataArgs = dataCallback.call_args[0]
# check the message content
data = onDataArgs[1]
expectedBlob = Blob("SUCCESS")
self.assertTrue(expectedBlob == data.getContent(), 'Data received on face does not match expected format')
class trigger(object):
def __init__(self):
self.script_path = os.path.abspath(
__file__) # i.e. /path/to/dir/foobar.py
self.script_dir = os.path.split(
self.script_path)[0] #i.e. /path/to/dir/
self.prefix_DE = "/picasso/start_de/"
self.prefix_pushService = "/picasso/service_deployment_push/SEG_1/"
# Default configuration of NDN
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
self.face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
def run(self):
try:
# send Interest message to retrieve data
#self.sendNextInterest(self.prefix_serviceMigration)
print 'Select Service '
print ' (1) umobilestore'
print ' (2) cloudrone'
print ' (3) kebapp'
service = raw_input(
'Choose service to be deployed (type number, e.g., 1): ')
if service == '1':
print 'Start migrating umobilestore'
service_name = 'umobilestore'
elif service == '2':
print 'Start migrating cloudrone'
service_name = 'cloudrone'
elif service == '3':
print 'Start migrating kebapp'
service_name = 'kebapp'
else:
print 'Chosen service is not available'
print 'Select Migration Method'
print ' (a) push @Service Manager'
print ' (b) pull @SEG'
method = raw_input(
'Choose method to migrate service (type code, e.g., a): ')
if method == 'a':
print 'Migrate by PUSH'
input_node = raw_input(
'Select node to migrate service (e.g., SEG_1): ')
name_prefix = self.prefix_DE + service_name + '.tar.xz' + '/' + input_node
elif method == 'b':
print 'Migrate by PULL'
name_prefix = self.prefix_pushService + service_name + '.tar.xz'
else:
print 'Chosen type is not available'
print 'name prefix: %s' % name_prefix
self.sendInterest(Name(name_prefix))
except RuntimeError as e:
print "ERROR: %s" % e
def sendInterest(self, name):
interest = Interest(name)
interestName = interest.getName()
interest.setInterestLifetimeMilliseconds(4000)
interest.setMustBeFresh(True)
self.face.expressInterest(
interest, None, None
) ## set None --> sent out only, don't wait for Data and Timeout
print "Sent Interest for %s" % interestName
class SongHandler:
def __init__(self):
self._device = "PC1"
self._playPrefix = Name("/ndn/edu/ucla/remap/music/play")
self.prefix = self._playPrefix.append(self._device)
self._face = None
self._loop = None
self._keyChain = KeyChain()
self._certificateName = self._keyChain.getDefaultCertificateName()
self._repoCommandPrefix = "/example/repo/1"
self.mp = MusicPlayer()
#self._getFiles = []
def start(self):
self._loop = asyncio.get_event_loop()
self._face = ThreadsafeFace(self._loop,"")
self._face.setCommandSigningInfo(self._keyChain, self._certificateName)
self._face.registerPrefix(self.prefix, self.onPlayingCommand, self.onRegisterFailed)
try:
self._loop.run_forever()
except KeyboardInterrupt:
sys.exit()
finally:
self.stop()
def stop(self):
self._loop.close()
self._face.shutdown()
sys.exit(1)
def getOnset(self, musicName):
otxt = musicName + str("-o")
print otxt
g = GetFile(self._repoCommandPrefix, otxt, self._face, self.getFreq, musicName)
g.oStream = open(musicName + str("-os.txt"), 'wb')
g.start()
#self._getFiles.append(g)
def getFreq(self, musicName):
ftxt = musicName + str("-f")
print musicName, " get Freq called"
g = GetFile(self._repoCommandPrefix, ftxt, self._face, self.mp.play_music, musicName, False)
g.oStream = open(musicName + str("-freq.txt"),'wb')
g.start()
#self._getFiles.append(g)
def signData(self, data):
data.setSignature(Sha256WithRsaSignature())
def onPlayingCommand(self, prefix, interest, transport, prefixId):
interestName = Name(interest.getName())
commandComponent = interest.getName().get(self.prefix.size())
if commandComponent == Name.Component("stop"):
pass
if commandComponent == Name.Component("play"):
pass
else:
songName = commandComponent.toEscapedString()
songList = []
songList = songName.split('%2C')
for i in songList:
fmusic = i + str("-music.mp3")
print "started getting music file", i
g = GetFile(self._repoCommandPrefix, i, self._face, self.getOnset, i)
g.oStream = open(fmusic,'wb')
g.start()
#self._getFiles.append(g)
d = Data(interest.getName())
d.setContent("start to play: " + songName + "\n")
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
def onRegisterFailed(self, prefix):
self.log.error("Could not register " + prefix.toUri())
self.stop()
class SongHandler:
def __init__(self):
self._device = "PC1"
self._playPrefix = Name("/ndn/edu/ucla/remap/music/play")
self.prefix = self._playPrefix.append(self._device)
self._face = None
self._loop = None
self._keyChain = KeyChain()
self._certificateName = self._keyChain.getDefaultCertificateName()
self._repoCommandPrefix = "/example/repo/1"
self.mp = MusicPlayer()
#self._getFiles = []
def start(self):
self._loop = asyncio.get_event_loop()
self._face = ThreadsafeFace(self._loop, "")
self._face.setCommandSigningInfo(self._keyChain, self._certificateName)
self._face.registerPrefix(self.prefix, self.onPlayingCommand,
self.onRegisterFailed)
try:
self._loop.run_forever()
except KeyboardInterrupt:
sys.exit()
finally:
self.stop()
def stop(self):
self._loop.close()
self._face.shutdown()
sys.exit(1)
def getOnset(self, musicName):
otxt = musicName + str("-o")
print otxt
g = GetFile(self._repoCommandPrefix, otxt, self._face, self.getFreq,
musicName)
g.oStream = open(musicName + str("-os.txt"), 'wb')
g.start()
#self._getFiles.append(g)
def getFreq(self, musicName):
ftxt = musicName + str("-f")
print musicName, " get Freq called"
g = GetFile(self._repoCommandPrefix, ftxt, self._face,
self.mp.play_music, musicName, False)
g.oStream = open(musicName + str("-freq.txt"), 'wb')
g.start()
#self._getFiles.append(g)
def signData(self, data):
data.setSignature(Sha256WithRsaSignature())
def onPlayingCommand(self, prefix, interest, transport, prefixId):
interestName = Name(interest.getName())
commandComponent = interest.getName().get(self.prefix.size())
if commandComponent == Name.Component("stop"):
pass
if commandComponent == Name.Component("play"):
pass
else:
songName = commandComponent.toEscapedString()
songList = []
songList = songName.split('%2C')
for i in songList:
fmusic = i + str("-music.mp3")
print "started getting music file", i
g = GetFile(self._repoCommandPrefix, i, self._face, self.getOnset,
i)
g.oStream = open(fmusic, 'wb')
g.start()
#self._getFiles.append(g)
d = Data(interest.getName())
d.setContent("start to play: " + songName + "\n")
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
def onRegisterFailed(self, prefix):
self.log.error("Could not register " + prefix.toUri())
self.stop()
async def run(local_repo_path: str, repo_prefix: str):
async def face_loop():
nonlocal face, running
while running:
face.processEvents()
await asyncio.sleep(0.01)
options = {'cloning': False}
running = True
face = Face()
keychain = KeyChain()
face.setCommandSigningInfo(keychain, keychain.getDefaultCertificateName())
event_loop = asyncio.get_event_loop()
face_task = event_loop.create_task(face_loop())
storage = FileStorage(local_repo_path)
producer = GitProducer(face, Name(repo_prefix).append("objects"), storage)
refs = []
empty_cnt = 0
while empty_cnt < 2 and running:
cmd = sys.stdin.readline().rstrip("\n\r")
# print("<<", cmd, file=sys.stderr)
if cmd == "capabilities":
print("push")
print("fetch")
print("option")
print("")
sys.stdout.flush()
elif cmd.startswith("option"):
opt_name, opt_val = cmd.split()[1:]
if opt_name == "cloning":
options['cloning'] = (opt_val == 'true')
print("ok")
else:
print("unsupported")
sys.stdout.flush()
elif cmd == "list" or cmd == "list for-push":
interest = Interest(Name(repo_prefix).append("ref-list"))
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
reflist = data.content.toBytes().decode("utf-8")
print(reflist)
if reflist.strip() == "":
refs = {}
else:
refs = [
item.split(" ")[1]
for item in reflist.strip().split("\n")
]
refs = {name.split("/")[-1] for name in refs}
else:
print("error: Couldn't connect to",
repo_prefix,
file=sys.stderr)
running = False
print("")
sys.stdout.flush()
elif cmd.startswith("fetch"):
fetcher = GitFetcher(face,
Name(repo_prefix).append("objects"), storage)
while True:
# Fetch files
hash_name, ref_name = cmd.split()[1:]
fetcher.fetch(hash_name, "commit")
await fetcher.wait_until_finish()
# Set refs file
ref_file_path = os.path.join(local_repo_path, ref_name)
with open(ref_file_path, 'w') as f:
f.write(hash_name)
# Read commands for next fetch
cmd = sys.stdin.readline().rstrip("\n\r")
if not cmd.startswith("fetch"):
break
print("")
sys.stdout.flush()
elif cmd.startswith("push"):
while True:
# Push commands
# TODO: DELETE ALL HARDCODED THINGS
# TODO: MAKE DATA AND INTEREST REAL
branch, commit, _ = parse_push(cmd, local_repo_path)
repo_name = repo_prefix.split("/")[-1]
# Create Branch if not exist
if branch not in refs:
print("Non-existing branch. Try to create...",
file=sys.stderr)
interest = Interest(
Name(LOCAL_CMD_PREFIX).append("create-branch").append(
repo_name).append(branch))
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
result = struct.unpack("i", data.content.toBytes())[0]
if result == 1:
print("Creation succeeded", file=sys.stderr)
elif result == 2:
print("Creation is FAILED", file=sys.stderr)
print("error refs/heads/{} FAILED".format(branch))
break
else:
print("Creation is PENDING", file=sys.stderr)
print("error refs/heads/{} PENDING".format(branch))
break
else:
print("error: Couldn't connect to",
interest.name.toUri(),
file=sys.stderr)
break
# BranchInfo Interest
interest = Interest(
Name(repo_prefix).append("branch-info").append(branch))
data = await fetch_data_packet(face, interest)
branchinfo = None
if isinstance(data, Data):
branchinfo = pickle.loads(data.content.toBytes())
if branchinfo is None or 'custodian' not in branchinfo.__dict__:
print("ERROR Interest got no response: ",
interest.name,
file=sys.stderr)
print("error refs/heads/{} DISCONNECTED".format(branch))
break
# Push Interest
interest = Interest(
Name(branchinfo.custodian).append("push").append(
repo_name).append(branch))
interest.applicationParameters = commit.encode("utf-8")
interest.appendParametersDigestToName()
interest.interestLifetimeMilliseconds = 20000
interest.mustBeFresh = True
data = await fetch_data_packet(face, interest)
if isinstance(data, Data):
result = struct.unpack("i", data.content.toBytes())[0]
if result == 1:
print("OK push succeeded",
interest.name,
file=sys.stderr)
print("ok refs/heads/{}".format(branch))
elif result == 2:
print("ERROR push failed",
interest.name,
file=sys.stderr)
print("error refs/heads/{} FAILED".format(branch))
else:
print("PROCESSING push is not finished yet",
interest.name,
file=sys.stderr)
print("error refs/heads/{} PENDING".format(branch))
else:
print("ERROR Interest got no response: ",
interest.name,
file=sys.stderr)
print("error refs/heads/{} DISCONNECTED".format(branch))
break
# Read commands for next fetch
cmd = sys.stdin.readline().rstrip("\n\r")
if not cmd.startswith("push"):
break
print("")
sys.stdout.flush()
elif cmd == "":
empty_cnt += 1
else:
pass
producer.cancel()
running = False
await face_task
class TestFaceRegisterMethods(ut.TestCase):
def setUp(self):
self.face_in = Face()
self.face_out = Face()
self.keyChain = KeyChain()
def tearDown(self):
self.face_in.shutdown()
self.face_out.shutdown()
def test_register_prefix_response(self):
prefixName = Name("/test")
self.face_in.setCommandSigningInfo(
self.keyChain, self.keyChain.getDefaultCertificateName())
interestCallbackCount = [0]
def onInterest(prefix, interest, face, interestFilterId, filter):
interestCallbackCount[0] += 1
data = Data(interest.getName())
data.setContent("SUCCESS")
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
face.putData(data)
failedCallback = Mock()
self.face_in.registerPrefix(prefixName, onInterest, failedCallback)
# Give the 'server' time to register the interest.
timeout = 1000
startTime = getNowMilliseconds()
while True:
if getNowMilliseconds() - startTime >= timeout:
break
self.face_in.processEvents()
time.sleep(0.01)
# express an interest on another face
dataCallback = Mock()
timeoutCallback = Mock()
# now express an interest on this new face, and see if onInterest is called
# Add the timestamp so it is unique and we don't get a cached response.
interestName = prefixName.append("hello" + repr(time.time()))
self.face_out.expressInterest(interestName, dataCallback,
timeoutCallback)
# Process events for the in and out faces.
timeout = 10000
startTime = getNowMilliseconds()
while True:
if getNowMilliseconds() - startTime >= timeout:
break
self.face_in.processEvents()
self.face_out.processEvents()
done = True
if interestCallbackCount[0] == 0 and failedCallback.call_count == 0:
# Still processing face_in.
done = False
if dataCallback.call_count == 0 and timeoutCallback.call_count == 0:
# Still processing face_out.
done = False
if done:
break
time.sleep(0.01)
self.assertEqual(failedCallback.call_count, 0,
'Failed to register prefix at all')
self.assertEqual(
interestCallbackCount[0], 1,
'Expected 1 onInterest callback, got ' +
str(interestCallbackCount[0]))
self.assertEqual(
dataCallback.call_count, 1,
'Expected 1 onData callback, got ' + str(dataCallback.call_count))
onDataArgs = dataCallback.call_args[0]
# check the message content
data = onDataArgs[1]
expectedBlob = Blob("SUCCESS")
self.assertTrue(
expectedBlob == data.getContent(),
'Data received on face does not match expected format')
from pyndn import Data
from pyndn.security import KeyChain
import sys
from RepoSocketPublisher import RepoSocketPublisher
publisher = RepoSocketPublisher(12345)
keyChain = KeyChain()
max_packets = 50000
total_size = 0
n = Name("/test").append(str(0))
d = Data(n)
d.setContent("this is a test.")
d.getMetaInfo().setFreshnessPeriod(4000)
keyChain.sign(d, keyChain.getDefaultCertificateName())
for i in range(0, max_packets + 1):
n = Name("/test").append(str(i))
d.setName(n)
if i % 100000 == 0:
print str(i)
if i == max_packets:
print str(total_size)
total_size = total_size + d.wireEncode().size()
publisher.put(d)
def benchmarkEncodeDataSeconds(nIterations, useComplex, useCrypto, keyType):
"""
Loop to encode a data packet nIterations times.
:param int nIterations: The number of iterations.
:param bool useComplex: If true, use a large name, large content and all
fields. If false, use a small name, small content and only required
fields.
:param bool useCrypto: If true, sign the data packet. If false, use a blank
signature.
:param KeyType keyType: KeyType.RSA or EC, used if useCrypto is True.
:return: A tuple (duration, encoding) where duration is the number of
seconds for all iterations and encoding is the wire encoding.
:rtype: (float, Blob)
"""
if useComplex:
# Use a large name and content.
name = Name(
"/ndn/ucla.edu/apps/lwndn-test/numbers.txt/%FD%05%05%E8%0C%CE%1D/%00"
)
contentString = ""
count = 1
contentString += "%d" % count
count += 1
while len(contentString) < 1115:
contentString += " %d" % count
count += 1
content = Name.fromEscapedString(contentString)
else:
# Use a small name and content.
name = Name("/test")
content = Name.fromEscapedString("abc")
finalBlockId = Name("/%00")[0]
# Initialize the private key storage in case useCrypto is true.
pibImpl = PibMemory()
keyChain = KeyChain(pibImpl, TpmBackEndMemory(),
SelfVerifyPolicyManager(pibImpl))
keyChain.importSafeBag(
SafeBag(
Name("/testname/KEY/123"),
Blob(
DEFAULT_EC_PRIVATE_KEY_DER if keyType == KeyType.ECDSA else
DEFAULT_RSA_PRIVATE_KEY_DER, False),
Blob(
DEFAULT_EC_PUBLIC_KEY_DER if keyType == KeyType.ECDSA else
DEFAULT_RSA_PUBLIC_KEY_DER, False)))
certificateName = keyChain.getDefaultCertificateName()
# Set up signatureBits in case useCrypto is false.
signatureBits = Blob(bytearray(256))
start = getNowSeconds()
for i in range(nIterations):
data = Data(name)
data.setContent(content)
if useComplex:
data.getMetaInfo().setFreshnessPeriod(1000)
data.getMetaInfo().setFinalBlockId(finalBlockId)
if useCrypto:
# This sets the signature fields.
keyChain.sign(data)
else:
# Imitate IdentityManager.signByCertificate to set up the signature
# fields, but don't sign.
sha256Signature = data.getSignature()
keyLocator = sha256Signature.getKeyLocator()
keyLocator.setType(KeyLocatorType.KEYNAME)
keyLocator.setKeyName(certificateName)
sha256Signature.setSignature(signatureBits)
encoding = data.wireEncode()
finish = getNowSeconds()
return (finish - start, encoding)
messageColor.r = color[0]
messageColor.g = color[1]
messageColor.b = color[2]
commandName = interestName.append(ProtobufTlv.encode(commandParams))
interest = Interest(commandName)
interest.setInterestLifetimeMilliseconds(2000)
return interest
timing = []
timeouts = 0
shouldSign = False
keychain = KeyChain()
certName = keychain.getDefaultCertificateName()
def waitForResponse(face, interest, timeout=None):
global timeouts
onData = Mock()
onTimeout = Mock()
if shouldSign:
face.makeCommandInterest(interest)
face.expressInterest(interest, onData, onTimeout)
start = time.time()
while (onData.call_count == 0 and onTimeout.call_count == 0):
face.processEvents()
#time.sleep(0.001)
if timeout is not None and time.time() >= start+timeout:
break
class MCCPublisher:
def __init__(self, dataPrefix, dataSuffix, keychain=None):
self.currentInsertion = -1
self.currentStatus = -1
self.face = None
self.loop = None
self.dataName = Name(dataPrefix).append(dataSuffix)
self.dataPrefix = Name(dataPrefix)
if keychain is not None:
self.keychain = keychain
else:
self.keychain = KeyChain()
self.certificateName = self.keychain.getDefaultCertificateName()
self.fakeSignature = Sha256WithRsaSignature()
self.failureCount = 0
self.successCount = 0
self.dataCache = None
def onRegisterFailed(self):
logger.error("Could not register data publishing face!")
self.stop()
def stop(self):
self.loop.close()
self.face.shutdown()
def generateVersionedName(self):
fullName = Name(self.dataName)
# currently we need to provide the version ourselves when we
# poke the repo
ts = int(time.time()*1000)
fullName.appendVersion(int(ts))
return fullName
def generateData(self, baseName):
'''
This appends the segment number to the data name, since repo-ng tends to expect it
'''
# just make up some data and return it
ts = (time.time())
segmentId = 0 # compatible with repo-ng test: may change to test segmented data
versionStr = baseName.get(-1).toEscapedString()
dataName = Name(baseName)
dataName.appendSegment(segmentId)
d = Data(dataName)
content = "(" + str(ts) + ") Data named " + dataName.toUri()
d.setContent(content)
d.getMetaInfo().setFinalBlockID(segmentId)
d.getMetaInfo().setFreshnessPeriod(-1)
if shouldSign:
self.keychain.sign(d, self.certificateName)
else:
d.setSignature(self.fakeSignature)
stats.insertDataForVersion(versionStr, {'publish_time':time.time()})
logger.debug('Publishing: '+d.getName().toUri())
return d
def onTimeout(self, prefix):
logger.warn('Timeout waiting for '+prefix.toUri())
@asyncio.coroutine
def insertNewVersion(self, interval=20):
#while True:
newVersion = self.generateVersionedName()
versionStr = newVersion.get(-1).toEscapedString()
logger.info('Inserting: '+versionStr)
stats.insertDataForVersion(versionStr, {'insert_request':time.time()})
newData = self.generateData(newVersion)
self.dataCache.add(newData)
stats.insertDataForVersion(versionStr, {'insert_complete':time.time()})
yield From (self.insertNewVersion())
def start(self):
self.loop = asyncio.new_event_loop()
self.face = ThreadsafeFace(self.loop, "")
self.dataCache = MemoryContentCache(self.face, 100)
asyncio.set_event_loop(self.loop)
self.face.setCommandSigningInfo(self.keychain, self.certificateName)
self.dataCache.registerPrefix(self.dataPrefix, self.onRegisterFailed)
self.loop.run_until_complete(self.insertNewVersion())
class FeatureRes(object):
def __init__(self):
self.keyChain = KeyChain()
self.isDone = False
self.nodeid = OSCommand.getnodeid()
self.face = Face()
self.featurereq = FeatureReq()
def run(self):
NodePrefixString = '/ndn/{}-site/{}/ofndn'.format(
self.nodeid, self.nodeid)
NodePrefix = Name(NodePrefixString)
self.face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
# self.face.registerPrefix(NodePrefix, self.onInterest, self.onRegisterFailed) #run prefix
self.face.registerPrefix(NodePrefix, self.onInterest_Mian,
self.onRegisterFailed) # run prefix
# filters:
feature_msg_prefix = Name('/ndn/{}-site/{}/ofndn/feature'.format(
self.nodeid, self.nodeid))
self.face.setInterestFilter(feature_msg_prefix,
self.onInterest_Feature) # for FeatureReq
packetout_msg_prefix = Name(
'/ndn/{}-site/{}/ofndn/--/n1.0/13/0/0'.format(
self.nodeid, self.nodeid))
self.face.setInterestFilter(
packetout_msg_prefix,
self.onInterest_PacketOut) # for PacketOut msg
facemod_msg_prefix = Name(
'/ndn/{}-site/{}/ofndn/--/n1.0/16/0/0'.format(
self.nodeid, self.nodeid))
self.face.setInterestFilter(facemod_msg_prefix,
self.onInterest_FaceMod) # for FaceMod msg
print(NodePrefix.toUri())
# # Run the event loop forever. Use a short sleep to
# # prevent the Producer from using 100% of the CPU.
# while not self.isDone:
# self.face.processEvents()
# time.sleep(0.01)
countnumber = 0
while countnumber < 200000000:
self.face.processEvents()
time.sleep(0.01)
countnumber += 1
# print("10s feature response listening stop")
def onInterest_PacketOut(self, mainPrefix, interest, transport,
registeredPrefixId):
print("--------Received <<<PacketOut>>> interest ----------")
PacketOut_suffix = NdnFlowTable.parse_PacketOut_Interest(interest)
NdnFlowTable.derectly_updatendnflowtable(PacketOut_suffix, self.nodeid)
print("--------Updated the NdnFlowTable")
self.isDone = True #
def onInterest_FaceMod(self, mainPrefix, interest, transport,
registeredPrefixId):
print("--------Received <<<FaceMod>>> interest Msg")
FaceMod_suffix_list = NdnFlowTable.parse_FaceMod_Interest(interest)
# FaceMod_suffix_list pattern:[faceid, action]
print(OSCommand.facemod(FaceMod_suffix_list)
) # modify the face and print the command output
self.isDone = True #
def onInterest_Feature(self, mainPrefix, interest, transport,
registeredPrefixId):
print("++++++++ Received <<<FeatureReq>>> interest ++++++++ \n")
feature_face = OSCommand.getface()
feature_FIB = OSCommand.getFIB()
nodeid = bytes(self.nodeid, 'utf-8')
feature_data = nodeid + b'----' + feature_face + b'----' + feature_FIB
data = OFMSG().create_feature_res_data(interest, feature_data)
transport.send(data.wireEncode().toBuffer())
print("++++++++ Sent <<<FeatureRes>>> Data ++++++++ \n")
self.isDone = True #
def onInterest_Mian(self, mainPrefix, interest, transport,
registeredPrefixId):
pass
#print("--------received Main interest:" + interest.getName().toUri())
def onRegisterFailed(self, ControllerPrefix):
print("Register failed for prefix", ControllerPrefix.toUri())
self.isDone = True
class LightController():
shouldSign = False
COLORS_PER_LIGHT = 3
STRAND_SIZE = 50
#mengchen: let's make the lighting lits only a half every time
#HALF_STRAND_SIZE = 25
def __init__(self, nStrands=1, myIP="192.168.1.1", lightIP="192.168.1.50", prefix="/testlight"):
self.log = logging.getLogger("LightController")
self.log.setLevel(logging.DEBUG)
sh = logging.StreamHandler()
sh.setLevel(logging.DEBUG)
self.log.addHandler(sh)
fh = logging.FileHandler("LightController.log")
fh.setLevel(logging.INFO)
self.log.addHandler(fh)
self.payloadBuffer = [[0]*self.STRAND_SIZE*self.COLORS_PER_LIGHT for n in range(nStrands)]
self.kinetsender = KinetSender(myIP, lightIP, nStrands, self.STRAND_SIZE*self.COLORS_PER_LIGHT)
self.prefix = Name(prefix)
self.keychain = KeyChain()
self.address = ""
self._isStopped = True
self.lightState = False
#mengchen: let's make the lighting lits only a half every time
#self.uphalf = True
self.HALF_STRAND_SIZE = 25
self.certificateName = self.keychain.getDefaultCertificateName()
self.receiveFile = open('interestReceiveFile', 'w')
def unix_time_now(self):
epoch = datetime.datetime.utcfromtimestamp(0)
delta = datetime.datetime.utcnow() - epoch
return delta.total_seconds() * 1000.0
# XXX: we should get a thread for this or something!
def start(self):
self.loop = asyncio.get_event_loop()
self.face = ThreadsafeFace(self.loop, self.address)
self.face.setCommandSigningInfo(self.keychain, self.certificateName)
self.face.registerPrefix(self.prefix, self.onLightingCommand, self.onRegisterFailed)
self._isStopped = False
self.face.stopWhen(lambda:self._isStopped)
try:
self.loop.run_forever()
except KeyboardInterrupt:
#self.stop()
#print "key interrupt in run_forever"
sys.exit()
finally:
#print "executing finally"
self.stop()
def stop(self):
self.loop.close()
self.kinetsender.stop = True
#print "before wait"
#self.kinetsender.complete.set
#self.kinetsender.complete.wait()
self.face.shutdown()
self.face = None
#print "sys exit"
self.receiveFile.close()
sys.exit(1)
def signData(self, data):
if LightController.shouldSign:
self.keychain.sign(data, self.certificateName)
else:
data.setSignature(Sha256WithRsaSignature())
def setPayloadColor(self, strand, color):
# will expand this to allow the repeats, etc
# if self.uphalf and not self.lightState:
# self.uphalf = False
# self.payloadBuffer[strand] = [int(color.r)&0xff, int(color.g)&0xff, int(color.b)&0xff]*self.HALF_STRAND_SIZE+[int(0)&0xff, int(0)&0xff, int(0)&0xff]*self.HALF_STRAND_SIZE
#if not self.uphalf and self.lightState :
# self.uphalf = True
self.payloadBuffer[strand] = [int(color.r)&0xff, int(color.g)&0xff, int(color.b)&0xff]*self.STRAND_SIZE
def onLightingCommand(self, prefix, interest, transport, prefixId):
#print datetime.datetime.now()
self.receiveFile.write('{0:f}'.format(self.unix_time_now()) + '\n')
interestName = Name(interest.getName())
#interstname: /ndn/ucla.edu/sculptures/ai_bus/lights/setRGB/%83%0D%84%0B%87%09%89%01%04%8A%01%01%8B%01%01
#d: <pyndn.data.Data object at 0xb64825d0>
print "interstname", interestName.toUri()
d = Data(interest.getName())
# get the command parameters from the name
try:
commandComponent = interest.getName().get(prefix.size())
#print commandComponent.toEscapedString():setRGB
#print "prefix ",prefix.toUri():/ndn/ucla.edu/sculpture/ai_bus/lights
#print "get name",interest.getName().toUri()
commandParams = interest.getName().get(prefix.size()+1)
#print "commandParams ",commandParams:%83%0D%84%0B%87%09%89%01%04%8A%01%01%8B%01%01
lightingCommand = LightCommandMessage()
ProtobufTlv.decode(lightingCommand, commandParams.getValue())
#self.log.info("Command: " + commandComponent.toEscapedString())
requestedColor = lightingCommand.command.pattern.colors[0]
colorStr = str((requestedColor.r, requestedColor.g, requestedColor.b))
#self.log.info("Requested color: " + colorStr)
self.setPayloadColor(0, requestedColor)
self.lightState = not self.lightState
if self.lightState:
print "Off"
else:
print "On"
#print requestedColor
self.sendLightPayload(1)
d.setContent("Gotcha: " + colorStr+ "\n")
except KeyboardInterrupt:
print "key interrupt"
sys.exit(1)
except Exception as e:
print e
d.setContent("Bad command\n")
finally:
d.getMetaInfo().setFinalBlockID(0)
self.signData(d)
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
def onRegisterFailed(self, prefix):
self.log.error("Could not register " + prefix.toUri())
self.stop()
def sendLightPayload(self, port):
# print port
# print self.payloadBuffer[port-1]
self.kinetsender.setPayload(port, self.payloadBuffer[port-1])
class RegisterSongList(object):
def __init__(self, prefix="/ndn/edu/ucla/remap/music/list"):
logging.basicConfig()
'''#这些log是干嘛的myIP="192.168.1.1",lightIP="192.168.1.50",
self.log = logging.getLogger("RegisterSongList")
self.log.setLevel(logging.DEBUG)
sh = logging.StreamHandler()
sh.setLevel(logging.DEBUG)
self.log.addHandler(sh)
fh = logging.FileHandler("RegisterSongList.log")
fh.setLevel(logging.INFO)
self.log.addHandler(fh)'''
self.device = "PC3"
self.deviceComponent = Name.Component(self.device)
self.excludeDevice = None
#self.songList = originalList
#security?
self.prefix = Name(prefix)
self.changePrefix = Name("/ndn/edu/ucla/remap/music/storage")
self.keychain = KeyChain()
self.certificateName = self.keychain.getDefaultCertificateName()
self.address = ""
self._isStopped = True
#self.payloadBuffer = []
#self.kinetsender = KinetSender(myIP, playerIP,self.STRAND_SIZE*self.COLORS_PER_LIGHT)
def start(self):
print "reg start"
self.loop = asyncio.get_event_loop()
self.face = ThreadsafeFace(self.loop,self.address)
self.face.setCommandSigningInfo(self.keychain,self.certificateName)
self.face.registerPrefix(self.prefix,self.onInterest,self.onRegisterFailed)
self._isStopped = False
self.face.stopWhen(lambda:self._isStopped)
try:
self.loop.run_forever()
except KeyboardInterrupt:
sys.exit()
finally:
self.stop()
def stop(self):
self.loop.close()
#self.kinetsender.stop = True
#self.kinetsender.complete.wait()
self.face.shutdown()
self.face = None
sys.exit(1)
def signData(self,data):
data.setSignature(Sha256WithRsaSignature())
#self.keychain.sign(data,self.certificateName)
def onInterest(self, prefix, interest, transport, registeredPrefixId):
print "received interest"
initInterest = Name(interest.getName())
print "interest name:",initInterest.toUri()
#d = Data(interest.getName().getPrefix(prefix.size()+1))
#self.excludeDevice = interest.getName().get(prefix.size())
#initInterest = interest.getName()
d = Data(interest.getName().append(self.deviceComponent))
try:
print "start to set data's content"
currentString = ','.join(currentList)
d.setContent("songList of " +self.device+":"+currentString+ "\n")
self.face.registerPrefix(self.changePrefix,self.onInterest,self.onRegisterFailed)
except KeyboardInterrupt:
print "key interrupt"
sys.exit(1)
except Exception as e:
print e
d.setContent("Bad command\n")
finally:
self.keychain.sign(d,self.certificateName)
encodedData = d.wireEncode()
transport.send(encodedData.toBuffer())
print d.getName().toUri()
print d.getContent()
self.stop()
'''print"remove register"
self.face.removeRegisteredPrefix(registeredPrefixId)
time.sleep(30)
#sleep 30s which means user cannot update the song list twice within 1 minutes
print"register again"
self.face.registerPrefix(self.prefix, self.onInterest, self.onRegisterFailed)'''
def onRegisterFailed(self, prefix):
self.log.error("Could not register " + prefix.toUri())
self.stop()
# Use a hard-wired secret for testing. In a real application the signer
# ensures that the verifier knows the shared key and its keyName.
key = Blob(
bytearray([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
]))
global face
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
global keychain
# Use the system default key chain and certificate name to sign commands.
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
global repoCommandPrefix
repoCommandPrefix = Name("/localhost/repo1")
global repoDataPrefix
repoDataPrefix = Name("/NIST/library/mainroom/repo1")
global lastDeviceIDList
lastDeviceIDList = []
global deviceIDListName
deviceIDListName = "proxy-py/deviceInfo/DeviceIDList.txt"
global first_repo_insert_after_startup
first_repo_insert_after_startup = True
def setUp(self):
self.face = Face()
keyChain = KeyChain()
self.face.setCommandSigningInfo(
keyChain, keyChain.getDefaultCertificateName())
def main(index_f, weight_f):
sl = SegmentLabel(index_f, weight_f)
# The default Face will connect using a Unix socket, or to "localhost".
face_producer = Face()
# Create an in-memory key chain with default keys.
keyChain = KeyChain("pib-memory:", "tpm-memory:")
keyChain.importSafeBag(SafeBag
(Name("/testname/KEY/123"),
Blob(DEFAULT_RSA_PRIVATE_KEY_DER, False),
Blob(DEFAULT_RSA_PUBLIC_KEY_DER, False)))
face_producer.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Use default keys
# keyChain = KeyChain()
# face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
publishIntervalMs = 1000.0 / 10
# stream_producer = Namespace("/ndn/eb/stream/run/28/annotation", keyChain)
stream_producer = Namespace("/eb/proto/test/ml_processing/yolo/seglab", keyChain)
handler = GeneralizedObjectStreamHandler()
stream_producer.setHandler(handler)
dump("Register prefix", stream_producer.name)
# Set the face and register to receive Interests.
stream_producer.setFace(face_producer,
lambda prefixName: dump("Register failed for prefix", prefixName))
# Loop, producing a new object every previousPublishMs milliseconds (and
# also calling processEvents()).
previousPublishMs = 0
#test with publishing existing jason file by json string input
jsonString = "data/faith.json"
curr = []
for line in open(jsonString, 'r'):
curr.append(json.loads(line))
# curr_list = []
# for ann in curr:
# temp = []
# frameName = ann['frameName']
# # print(frameName)
# for k in ann["annotations"]:
# # temp.append({"label": ''.join([i for i in k["label"] if not i.isdigit()]), "prob": k["prob"]})
# temp.append({"label": ''.join([i for i in k["label"] if not i.isdigit()]), "ytop": k["ytop"],
# "ybottom": k["ybottom"], "xleft": k["xleft"], "xright": k["xright"], "prob": k["prob"],
# "frameName": frameName})
#
# curr_list.append(temp)
cnt = 0
total_cnt = len(curr)
# while True:
while cnt < total_cnt:
now = Common.getNowMilliseconds()
if now >= previousPublishMs + publishIntervalMs:
dump("Preparing data for sequence",
handler.getProducedSequenceNumber() + 1)
seg_result = sl.processAnnotation(curr[cnt])
if seg_result:
print(seg_result)
handler.addObject(
Blob(json.dumps(seg_result)),
"application/json")
# handler.addObject(
# Blob(json.dumps() + str(handler.getProducedSequenceNumber() + 1)),
# "application/json")
cnt+= 1
previousPublishMs = now
face_producer.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
class BaseNode(object):
"""
This class contains methods/attributes common to both node and controller.
"""
def __init__(self):
"""
Initialize the network and security classes for the node
"""
super(BaseNode, self).__init__()
self._identityStorage = IotIdentityStorage()
self._identityManager = IotIdentityManager(self._identityStorage)
self._policyManager = IotPolicyManager(self._identityStorage)
# hopefully there is some private/public key pair available
self._keyChain = KeyChain(self._identityManager, self._policyManager)
self._registrationFailures = 0
self._prepareLogging()
self._setupComplete = False
self._instanceSerial = None
# waiting devices register this prefix and respond to discovery
# or configuration interest
self._hubPrefix = Name('/localhop/configure')
def getSerial(self):
"""
Since you may wish to run two nodes on a Raspberry Pi, each
node will generate a unique serial number each time it starts up.
"""
if self._instanceSerial is None:
prefixLen = 4
prefix = ''
for i in range(prefixLen):
prefix += (chr(random.randint(0,0xff)))
suffix = self.getDeviceSerial().lstrip('0')
self._instanceSerial = '-'.join([prefix.encode('hex'), suffix])
return self._instanceSerial
##
# Logging
##
def _prepareLogging(self):
self.log = logging.getLogger(str(self.__class__))
self.log.setLevel(logging.DEBUG)
logFormat = "%(asctime)-15s %(name)-20s %(funcName)-20s (%(levelname)-8s):\n\t%(message)s"
self._console = logging.StreamHandler()
self._console.setFormatter(logging.Formatter(logFormat))
self._console.setLevel(logging.INFO)
# without this, a lot of ThreadsafeFace errors get swallowed up
logging.getLogger("trollius").addHandler(self._console)
self.log.addHandler(self._console)
def setLogLevel(self, level):
"""
Set the log level that will be output to standard error
:param level: A log level constant defined in the logging module (e.g. logging.INFO)
"""
self._console.setLevel(level)
def getLogger(self):
"""
:return: The logger associated with this node
:rtype: logging.Logger
"""
return self.log
###
# Startup and shutdown
###
def beforeLoopStart(self):
"""
Called before the event loop starts.
"""
pass
def getDefaultCertificateName(self):
try:
certName = self._identityStorage.getDefaultCertificateNameForIdentity(
self._policyManager.getDeviceIdentity())
except SecurityException:
certName = self._keyChain.getDefaultCertificateName()
return certName
def start(self):
"""
Begins the event loop. After this, the node's Face is set up and it can
send/receive interests+data
"""
self.log.info("Starting up")
self.loop = asyncio.get_event_loop()
self.face = ThreadsafeFace(self.loop, '')
self.face.setCommandSigningInfo(self._keyChain, self.getDefaultCertificateName())
self._keyChain.setFace(self.face)
self._isStopped = False
self.face.stopWhen(lambda:self._isStopped)
self.beforeLoopStart()
try:
self.loop.run_forever()
except KeyboardInterrupt:
pass
except Exception as e:
self.log.exception(e, exc_info=True)
finally:
self._isStopped = True
def stop(self):
"""
Stops the node, taking it off the network
"""
self.log.info("Shutting down")
self._isStopped = True
###
# Data handling
###
def signData(self, data):
"""
Sign the data with our network certificate
:param pyndn.Data data: The data to sign
"""
self._keyChain.sign(data, self.getDefaultCertificateName())
def sendData(self, data, transport, sign=True):
"""
Reply to an interest with a data packet, optionally signing it.
:param pyndn.Data data: The response data packet
:param pyndn.Transport transport: The transport to send the data through. This is
obtained from an incoming interest handler
:param boolean sign: (optional, default=True) Whether the response must be signed.
"""
if sign:
self.signData(data)
transport.send(data.wireEncode().buf())
###
#
#
##
def onRegisterFailed(self, prefix):
"""
Called when the node cannot register its name with the forwarder
:param pyndn.Name prefix: The network name that failed registration
"""
if self._registrationFailures < 5:
self._registrationFailures += 1
self.log.warn("Could not register {}, retry: {}/{}".format(prefix.toUri(), self._registrationFailures, 5))
self.face.registerPrefix(self.prefix, self._onCommandReceived, self.onRegisterFailed)
else:
self.log.critical("Could not register device prefix, ABORTING")
self._isStopped = True
def verificationFailed(self, dataOrInterest):
"""
Called when verification of a data packet or command interest fails.
:param pyndn.Data or pyndn.Interest: The packet that could not be verified
"""
self.log.info("Received invalid" + dataOrInterest.getName().toUri())
@staticmethod
def getDeviceSerial():
"""
Find and return the serial number of the Raspberry Pi. Provided in case
you wish to distinguish data from nodes with the same name by serial.
:return: The serial number extracted from device information in /proc/cpuinfo
:rtype: str
"""
with open('/proc/cpuinfo') as f:
for line in f:
if line.startswith('Serial'):
return line.split(':')[1].strip()
class Decision_Engine_Main(object):
def __init__(self, namePrefix):
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
self.configPrefix = Name(namePrefix)
self.script_path = os.path.abspath(__file__) # i.e. /path/to/dir/foobar.py
self.script_dir = os.path.split(self.script_path)[0] #i.e. /path/to/dir/
self.interestLifetime = 12000000
#self.Datamessage_size = 1999000
self.Datamessage_size = 1999000
folder_name = "SC_repository/"
rel_path = os.path.join(self.script_dir, folder_name)
prefix_startDE = "/picasso/start_de/"
self.prefix_startDE = Name(prefix_startDE)
self.prefix_deployService = '/picasso/service_deployment_push/'
self.json_server_Spec_default= { # This is only an skeleton
'par':{ # service parameters
'serviceName': 'nameOfService',
'imageName': 'NameOfImageToIstantiateService',
'imageSize': 'sizeOfImage',
'maxConReq': 'maxNumConcurrentRequestsThatAnIntanceCanHandle',
'startUpTime': 'timeToInstatiateService'
},
'QoS':{ #QoS parameters expected from the service
'responseTime': 'resposeTimeExpectedFromService',
'availability': 'availabilityExpectedFromService',
'numConReq': 'numConcurrentRequestsToBeHandledByService'
}
}
if not os.path.exists(rel_path):
os.makedirs(rel_path)
def run(self):
try:
### This face is used to send an image to the SEG
self.face.setCommandSigningInfo(self.keyChain, self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.configPrefix, self.onInterest_PullService, self.onRegisterFailed)
#### This face is used to start the algorithm of decision engine. The Interest is sent by trigger module
#### This face is for testing propose
self.face.setCommandSigningInfo(self.keyChain, self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.prefix_startDE, self.onInterest_StartDE, self.onRegisterFailed)
Max = self.face.getMaxNdnPacketSize()
print 'Maxsize: ', Max
print "Registered prefix : " + self.configPrefix.toUri()
while not self.isDone:
self.face.processEvents()
time.sleep(0.01)
except RuntimeError as e:
print "ERROR: %s" % e
return True
def onInterest_StartDE(self, prefix, interest, face, interestFilterId, filter):
interestName = interest.getName()
print "Interest Name: %s" %interestName
interest_name_components = interestName.toUri().split("/")
if "start_de" in interest_name_components:
#print 'Query database'
#print 'Call decision engine algorithm'
#parent_dir = os.path.split(self.script_dir)[0]
#monitor_path = os.path.join(self.script_dir, parent_dir, 'Monitoring', 'Monitoring_DB')
#print monitor_path
#myDE = de(monitor_path)
#json_lst_dict = myDE.get_lst_of_dictionaries()
#json_server_Spec = self.json_server_Spec_default
#node_name = myDE.selectHost_to_deploy_firstInstance(json_lst_dict, json_server_Spec)
node_name = interest_name_components[interest_name_components.index("start_de") + 2]
print 'Selected Host Name %s' %node_name
service_name = interest_name_components[interest_name_components.index("start_de") + 1]
print 'service name %s' % service_name
print 'Start service deployment'
deployService = self.prefix_deployService + node_name + '/' + service_name
config_prefix_deployService = Name(deployService)
interest = Interest(config_prefix_deployService)
interest.setInterestLifetimeMilliseconds(self.interestLifetime)
interest.setMustBeFresh(True)
self.face.expressInterest(interest, None, None) ## set None --> sent out only, don't wait for Data and Timeout
print "Sent Push Interest to SEG %s" % config_prefix_deployService
else:
print "Interest name mismatch"
def onInterest_PullService(self, prefix, interest, face, interestFilterId, filter):
interestName = interest.getName()
data = Data(interestName)
print "Interest Name: %s" %interestName
interest_name_components = interestName.toUri().split("/")
if "service_deployment_pull" in interest_name_components:
## Extract filename from Interest name
#filename = "uhttpd.tar"
filename = interest_name_components[interest_name_components.index("service_deployment_pull") + 1]
folder_name = "ServiceRepo/SC_repository/"
parent_dir = os.path.split(self.script_dir)[0]
rel_path = os.path.join(parent_dir, folder_name)
if not os.path.exists(rel_path):
os.makedirs(rel_path)
abs_file_path = os.path.join(rel_path, filename)
freshness = 6000000 #milli second, content will be deleted from the cache after freshness period
self.sendingFile(abs_file_path, interest, face, freshness)
else:
print "Interest name mismatch"
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
def sendingFile(self, file_path, interest, face, freshness):
print "Sending File Function"
interestName = interest.getName()
interestNameSize = interestName.size()
try:
SegmentNum = (interestName.get(interestNameSize - 1)).toSegment()
dataName = interestName.getSubName(0, interestNameSize - 1)
# If no segment number is included in the INTEREST, set the segment number as 0 and set the file name to configuration script to be sent
except RuntimeError as e:
SegmentNum = 0
dataName = interestName
# Put file to the Data message
try:
# due to overhead of NDN name and other header values; NDN header overhead + Data packet content = < maxNdnPacketSize
# So Here segment size is hard coded to 5000 KB.
# Class Enumerate publisher is used to split large files into segments and get a required segment ( segment numbers started from 0)
dataSegment, last_segment_num = EnumeratePublisher(file_path, self.Datamessage_size, SegmentNum).getFileSegment()
print 'SegmentNum:%s last_segment_num: %s' % (SegmentNum, last_segment_num)
# create the DATA name appending the segment number
dataName = dataName.appendSegment(SegmentNum)
data = Data(dataName)
data.setContent(dataSegment)
# set the final block ID to the last segment number
last_segment = (Name.Component()).fromNumber(last_segment_num)
data.getMetaInfo().setFinalBlockId(last_segment)
#hourMilliseconds = 600 * 1000
data.getMetaInfo().setFreshnessPeriod(freshness)
# currently Data is signed from the Default Identitiy certificate
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
# Sending Data message
face.send(data.wireEncode().toBuffer())
print "Replied to Interest name: %s" % interestName.toUri()
print "Replied with Data name: %s" % dataName.toUri()
except ValueError as err:
print "ERROR: %s" % err
