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