class TestRegistrationCallbacks(ut.TestCase): def setUp(self): self.face = Face() keyChain = KeyChain() self.face.setCommandSigningInfo( keyChain, keyChain.getDefaultCertificateName()) def tearDown(self): self.face.shutdown() def test_registration_callbacks(self): onRegisterFailed = Mock() onRegisterSuccess = Mock() self.face.registerPrefix( Name("/test/register/callbacks"), None, onRegisterFailed, onRegisterSuccess) while True: self.face.processEvents() time.sleep(0.01) if (onRegisterSuccess.call_count > 0 or onRegisterFailed.call_count > 0): break self.assertEqual( onRegisterSuccess.call_count, 1, "Expected 1 onRegisterSuccess callback, got " + str(onRegisterSuccess.call_count))
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(): face = Face("aleph.ndn.ucla.edu") counter = Counter() # Try to fetch anything. name1 = Name("/") dump("Express name ", name1.toUri()) face.expressInterest(name1, counter.onData, counter.onTimeout) # Try to fetch using a known name. name2 = Name("/ndn/edu/ucla/remap/demo/ndn-js-test/hello.txt/%FDU%8D%9DM") dump("Express name ", name2.toUri()) face.expressInterest(name2, counter.onData, counter.onTimeout) # Expect this to time out. name3 = Name("/test/timeout") dump("Express name ", name3.toUri()) face.expressInterest(name3, counter.onData, counter.onTimeout) while counter._callbackCount < 3: 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(): # Silence the warning from Interest wire encode. Interest.setDefaultCanBePrefix(True) # The default Face will connect using a Unix socket, or to "localhost". face = Face() counter = Counter() if sys.version_info[0] <= 2: word = raw_input("Enter a word to echo: ") else: word = input("Enter a word to echo: ") name = Name("/testecho") name.append(word) dump("Express name ", name.toUri()) face.expressInterest(name, counter.onData, counter.onTimeout) while counter._callbackCount < 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 main(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() identityStorage = MemoryIdentityStorage() privateKeyStorage = MemoryPrivateKeyStorage() keyChain = KeyChain( IdentityManager(identityStorage, privateKeyStorage), None) keyChain.setFace(face) # Initialize the storage. keyName = Name("/testname/DSK-123") certificateName = keyName.getSubName(0, keyName.size() - 1).append( "KEY").append(keyName[-1]).append("ID-CERT").append("0") identityStorage.addKey(keyName, KeyType.RSA, Blob(DEFAULT_RSA_PUBLIC_KEY_DER)) privateKeyStorage.setKeyPairForKeyName( keyName, KeyType.RSA, DEFAULT_RSA_PUBLIC_KEY_DER, DEFAULT_RSA_PRIVATE_KEY_DER) echo = Echo(keyChain, certificateName) 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 main(): face = Face("localhost") identityStorage = MemoryIdentityStorage() privateKeyStorage = MemoryPrivateKeyStorage() keyChain = KeyChain( IdentityManager(identityStorage, privateKeyStorage), None) keyChain.setFace(face) # Initialize the storage. keyName = Name("/testname/DSK-reposerver") certificateName = keyName.getSubName(0, keyName.size() - 1).append( "KEY").append(keyName[-1]).append("ID-CERT").append("0") identityStorage.addKey(keyName, KeyType.RSA, Blob(DEFAULT_PUBLIC_KEY_DER)) privateKeyStorage.setKeyPairForKeyName( keyName, DEFAULT_PUBLIC_KEY_DER, DEFAULT_PRIVATE_KEY_DER) echo = RepoServer(keyChain, certificateName) prefix = Name("/ndn/ucla.edu/bms") dump("Register prefix", prefix.toUri()) face.registerPrefix(prefix, echo.onInterest, echo.onRegisterFailed) 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 main(): if len(sys.argv) < 2: print("argv error: please input turnOn, turnOff or status") exit(1) else: cmd = sys.argv[1] loop = asyncio.get_event_loop() #face = ThreadsafeFace(loop, "localhost") face = Face("localhost") # Counter will stop the ioService after callbacks for all expressInterest. counter = Counter(loop, 3) seed = HMACKey(0,0,"seed","seedName") # Try to fetch anything. name1 = Name("/home/sensor/LED/0/"+cmd+"/0/0") commandTokenName = '/home/sensor/LED/0/'+cmd+'/token/0' commandTokenKey = hmac.new(seed.getKey(), commandTokenName, sha256).digest() accessTokenName = '/home/sensor/LED/0/'+cmd+'/token/0/user/Tom/token/0' accessTokenKey = hmac.new(commandTokenKey, accessTokenName, sha256).digest() accessToken = HMACKey(0,0,accessTokenKey,accessTokenName) dump("seed.getKey() :",seed.getKey()) dump("commandTokenName :",commandTokenName) dump("commandTokenKey :",base64.b64encode(commandTokenKey)) dump("accessTokenName :",accessTokenName) dump("accessTokenKey :",base64.b64encode(accessTokenKey)) interest = Interest(name1) interest.setInterestLifetimeMilliseconds(3000) a = AccessControlManager() a.signInterestWithHMACKey(interest,accessToken) dump("Express name ", interest.toUri()) face.expressInterest(interest, counter.onData, counter.onTimeout) """ name2 = Name("/home/sensor/LED/T0829374723/turnOff") dump("Express name ", name2.toUri()) face.expressInterest(name2, counter.onData, counter.onTimeout) """ while counter._callbackCount < 1: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(2) face.shutdown()
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()
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 main(): seg = 0 if len(sys.argv) < 3: print("argv error: please input capture or capture with #seg") exit(1) elif len(sys.argv) == 2: cmd = sys.argv[1] else: cmd = sys.argv[1] seg = sys.argv[2] loop = asyncio.get_event_loop() #face = ThreadsafeFace(loop, "localhost") face = Face("localhost") # Counter will stop the ioService after callbacks for all expressInterest. counter = Counter(loop, 3) seed = HMACKey(0,0,"seed","seedName") # Try to fetch anything. import time r = time.time() name1 = Name("/home/security/camera/0/"+cmd) name1.appendTimestamp(int(r)) name1.appendSegment(int(seg)) interest = Interest(name1) interest.setInterestLifetimeMilliseconds(3000) dump("Express name ", interest.toUri()) face.expressInterest(interest, counter.onData, counter.onTimeout) """ name2 = Name("/home/sensor/LED/T0829374723/turnOff") dump("Express name ", name2.toUri()) face.expressInterest(name2, counter.onData, counter.onTimeout) """ while counter._callbackCount < 1: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(2) face.shutdown()
def main(): face = Face("localhost") counter = Counter() ignored, name = argv name = "/ndn/ucla.edu/bms/" + name name1 = Name(name) dump("Express name ", name1.toUri()) face.expressInterest(name1, counter.onData, counter.onTimeout) while counter._callbackCount < 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 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 main(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() counter = Counter() if sys.version_info[0] <= 2: word = raw_input("Enter a word to echo: ") else: word = input("Enter a word to echo: ") name = Name("/testecho") name.append(word) dump("Express name ", name.toUri()) face.expressInterest(name, counter.onData, counter.onTimeout) while counter._callbackCount < 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 startPKG(): global EXIT # The default Face will connect using a Unix socket, or to "localhost". face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) pkg = PublicKeyGenerator(face, "/ndn/no/ntnu") while not EXIT: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01) isReady, _, _ = select.select([sys.stdin], [], [], 0) if len(isReady) != 0: input = promptAndInput("") if input == "r": sensorPull.requestData() if input == "leave" or input == "exit": EXIT = True break face.shutdown()
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. print("key1") keyChain = KeyChain() print("key2") 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 deviceListRequest(): loop = asyncio.get_event_loop() #face = ThreadsafeFace(loop, "localhost") face = Face("localhost") # Counter will stop the ioService after callbacks for all expressInterest. counter = Counter(loop, 3) while True: username = raw_input('Login username: '******'t be blank") continue else: break while True: password = raw_input("Login password: "******"Username can't be blank") continue else: break userHMACKey = HMACKey(0,0,password,"userHMACKey") interestName = Name("/home/controller/deviceList/user/"+username) interest = Interest(interestName) a = AccessControlManager() a.signInterestWithHMACKey(interest,userHMACKey) dump("Express interst :",interest.toUri()) face.expressInterest(interest,counter.onData,counter.onTimeout) while counter._callbackCount < 1: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(2) face.shutdown()
def startSensorPull(): global EXIT # The default Face will connect using a Unix socket, or to "localhost". face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) presharedKey = "gAJVrjM6R1RYT09MeE1XZXMxVzJiYWRuTXppaHIyamttRjNwdXJhTC9abnFKQTUrRU5DM1Z1eHB1YnpST1VBVTlVN2dvclZlT0ZmUDNPUkR1UkJaVldjNUh0dDVEOXcwNVJOUmFNV1YxeVFqTlUvNmo1Rk9LbU5RUmkrZWxORlNoRkxYbWtZZjdxS3ZWUlNGUU1najBoNkt1YW1IN1J4WWNYZ09wMlR4MUx4RnBXYlBFPXEALg==" sensorPull = Device(face, "/ndn/no/ntnu", "device1", presharedKey) sensorPull.requestIdentityBasedPrivateKey() while not EXIT: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01) isReady, _, _ = select.select([sys.stdin], [], [], 0) if len(isReady) != 0: input = promptAndInput("") if input == "r": sensorPull.requestData() if input == "leave" or input == "exit": EXIT = True break face.shutdown()
def startSensorData(): global EXIT # The default Face will connect using a Unix socket, or to "localhost". face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) presharedKey = "gAJVrjM6RjFCMGE3Y0VRaFh2RTdqSUZPT3R2ZFZEWFVubDVVRVlXMmlmbWVXczR3K0JTdG9TTlUxREk3TGQ1K1p0UkpkL0NVUG55c1M4ZzhXdDdKT2lKOWx4cUh3UVRtNDVWemlGWVdaQlV2cHMwZkpQWUNMc0RyeTFqUldMOEQ4YTcyaTZCTlhueXo3bitIa0ZFdm1wVzhFbE00UEtRc21KdTlTWmkybVRlVlZFaTNRPXEALg==" sensorData = Device(face, "/ndn/no/ntnu", "device2", presharedKey) sensorData.requestIdentityBasedPrivateKey() sensorData.registerPrefix() while not EXIT: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01) isReady, _, _ = select.select([sys.stdin], [], [], 0) if len(isReady) != 0: input = promptAndInput("") if input == "r": sensorPull.requestData() if input == "leave" or input == "exit": EXIT = True break face.shutdown()
def run_reqs(self, request): # silence the warning from interest wire encode Interest.setDefaultCanBePrefix(True) # set up a face that connects to the remote forwarder #udp_connection_info = UdpTransport.ConnectionInfo("10.10.1.1", 6363) #udp_connection_info = UdpTransport.ConnectionInfo("10.10.2.1", 6363) #udp_connection_info = UdpTransport.ConnectionInfo("10.10.3.1", 6363) #udp_connection_info = UdpTransport.ConnectionInfo("10.10.4.1", 6363) #udp_connection_info = UdpTransport.ConnectionInfo("10.10.5.1", 6363) udp_transport = UdpTransport() face = Face(udp_transport, udp_connection_info) counter = Counter() # try to fetch from provided name name = Name(request) dump("Express name", name.toUri()) interest = Interest(name) interest.setMustBeFresh(False) date = datetime.now() face.expressInterest(interest, counter.onData, counter.onTimeout, counter.onNetworkNack) dump(f">>{date}>>") with open('data_collection/out.dat', 'a') as outfile: outfile.write(f"{date}\n") while counter._callbackCount < 1: face.processEvents() # don't use 100% of the CPU time.sleep(0.01) face.shutdown()
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")) # 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): """Starts listening for interest packets in the given namespace.""" prefix = Name(namespace) # 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}...") # 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 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")
dump("Time out for interest", interest.getName().toUri()) if __name__ == "__main__": import sys arg = 1 filename = sys.argv[1] try: name = sys.argv[2] except: name = "/endless/testchunks" name += "/chunked/" face = Face() chunks = Chunks(face, filename) # Try to fetch. name1 = Name(name).appendSegment(0) dump("Express name:", name1.toUri()) face.expressInterest(name1, chunks.onData, chunks.onTimeout) while chunks._callbackCount < 3: 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 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 Server: def __init__(self, deeplab_manager, fst_manager, _root_path, storage): # type: (DeepLab, Fst, str, IStorage) -> None self.face = None self.keychain = KeyChain() # self.namespace = Namespace(Name(SERVER_PREFIX).append(RESULT_PREFIX), self.keychain) # self.namespace.addOnObjectNeeded(self.on_result_interest) self.segment_size = Face.getMaxNdnPacketSize() // 2 self.running = False self._restart = False self.deeplab_manager = deeplab_manager self.fst_manager = fst_manager self.storage = storage deeplab_manager.on_finished = self.on_process_finished fst_manager.on_finished = self.on_process_finished self.fetcher = Fetcher(self.keychain, self.on_payload, self.storage, self.on_fetch_fail) self.command_filter_id = 0 self.result_filter_id = 0 self.operations_set = self.fst_manager.get_models() | {"deeplab"} # Status set, one item per frame # TODO: Start with unfinished tasks # self.status_set = {} def save_status(self, name, status): # type: (Name, ResultStatus) -> None """Save status to database""" self.storage.put(Name(STATUS_PREFIX).append(name), status.to_bytes()) def load_status(self, name): """Load status from database""" # Get exact prefix to data if name[-1] == Name.Component("_meta") or name[-1].isSegment(): name = name[:-1] ret = self.storage.get(Name(STATUS_PREFIX).append(name)) if ret is not None: return ResultStatus.from_bytes(ret) else: return None async def _run(self): self.running = True while self.running: self.face = Face() self._restart = False try: self._network_start() logging.info("Starting...") while self.running and not self._restart: self.face.processEvents() await asyncio.sleep(0.01) except ConnectionRefusedError: logging.warning("Connection refused. Retry in %ss.", DISCONN_RETRY_TIME) finally: self.face.shutdown() self._network_stop() if self.running: time.sleep(DISCONN_RETRY_TIME) def run(self): event_loop = asyncio.get_event_loop() try: event_loop.run_until_complete(self._run()) finally: event_loop.close() def stop(self): self.running = False def _network_start(self): self.face.setCommandSigningInfo(self.keychain, self.keychain.getDefaultCertificateName()) # self.namespace.setFace(self.face, lambda prefix: print("Register failed for")) self.face.registerPrefix(Name(SERVER_PREFIX), None, self.on_register_failed) self.command_filter_id = self.face.setInterestFilter( Name(SERVER_PREFIX).append(COMMAND_PREFIX), self.on_command) self.result_filter_id = self.face.setInterestFilter( Name(SERVER_PREFIX).append(RESULT_PREFIX), self.on_result_interest) self.fetcher.network_start(self.face) def _network_stop(self): self.fetcher.network_stop() self.face.unsetInterestFilter(self.result_filter_id) self.face.unsetInterestFilter(self.command_filter_id) def on_register_failed(self, prefix): # type: (Name) -> None logging.error("Register failed for prefix: %s", prefix.toUri()) self._restart = True def on_command(self, _prefix, interest, _face, _interest_filter_id, _filter_obj): # type: (Name, Interest, Face, int, InterestFilter) -> None parameter_msg = SegmentParameterMessage() try: ProtobufTlv.decode(parameter_msg, interest.name[-1].getValue()) except ValueError: self.nodata_reply(interest.name, RET_MALFORMED_COMMAND) return parameter = parameter_msg.segment_parameter prefix = Name() for compo in parameter.name.component: prefix.append(compo.decode("utf-8")) # Check operations for op in parameter.operations.components: model_name = op.model.decode("utf-8") if model_name not in self.operations_set: self.nodata_reply(interest.name, RET_NOT_SUPPORTED) return # Fetch frames for frame_id in range(parameter.start_frame, parameter.end_frame + 1): frame_name = Name(prefix).append(str(frame_id)) for op in parameter.operations.components: model_name = op.model.decode("utf-8") data_name = Name(frame_name).append(model_name) logging.info("Request processed: %s", data_name) status = ResultStatus(prefix.toUri(), model_name, Common.getNowMilliseconds()) status.status = STATUS_FETCHING status.estimated_time = status.proecess_start_time + 10.0 self.save_status(data_name, status) # Check data existence and trigger fetching process for frame_id in range(parameter.start_frame, parameter.end_frame + 1): frame_name = Name(prefix).append(str(frame_id)) if self.storage.exists(frame_name): self.on_payload(frame_name) else: self.fetcher.fetch_data(frame_name) self.nodata_reply(interest.name, RET_OK, 10.0) # def on_result_interest(self, _namespace, needed_obj, _id): # # type: (Namespace, Namespace, int) -> bool def on_result_interest(self, _prefix, interest, face, _interest_filter_id, _filter_obj): # type: (Name, Interest, Face, int, InterestFilter) -> bool prefix = Name(SERVER_PREFIX).append(RESULT_PREFIX) if not prefix.isPrefixOf(interest.name): # Wrong prefix return False data_name = interest.name[prefix.size():] logging.info("On result interest: %s", data_name.toUri()) # key, stat = self._result_set_prefix_match(data_name) status = self.load_status(data_name) if status is None: # No such request self.nodata_reply(interest.name, RET_NO_REQUEST) return True if data_name[-1].isSegment(): # Segment no suffix seg_no = data_name[-1].toSegment() result = self.storage.get(data_name.getPrefix(-1)) elif data_name[-1] == Name("_meta")[0]: # MetaInfo suffix seg_no = -1 result = self.storage.get(data_name.getPrefix(-1)) else: # No suffix seg_no = None result = self.storage.get(data_name) if result is not None: # There are data segment_cnt = (len(result) + self.segment_size - 1) // self.segment_size # Note: I don't understand why namespace keep all data in memory metainfo = MetaInfo() # metainfo.setFinalBlockId(segment_cnt - 1) # WHY this doesn't work? metainfo.setFinalBlockId(Name().appendSegment(segment_cnt - 1)[0]) if segment_cnt > 1 and seg_no is None: # Fetch segmented data with no suffix will get only first segment seg_no = 0 data_name.appendSequenceNumber(seg_no) data = Data(Name(prefix).append(data_name)) data.setMetaInfo(metainfo) if seg_no == -1: # _meta data.content = self.storage.get(data_name) else: # data if segment_cnt > 1: # Segmented if seg_no < segment_cnt: start_offset = seg_no * self.segment_size end_offset = start_offset + self.segment_size data.content = Blob(bytearray(result[start_offset:end_offset])) else: data.content = None else: # No segmentation data.content = Blob(bytearray(result)) self.keychain.sign(data) face.putData(data) return True else: # Data are not ready if status.status == STATUS_NO_INPUT: self.nodata_reply(interest.name, RET_NO_INPUT) elif status.status == STATUS_FAILED: self.nodata_reply(interest.name, RET_EXECUTION_FAILED) else: self.nodata_reply(interest.name, RET_RETRY_AFTER, status.estimated_time - Common.getNowMilliseconds()) return True def nodata_reply(self, name, code, retry_after=0.0): # type: (Name, int, float) -> None logging.info("Reply with code: %s", code) data = Data(name) metainfo = MetaInfo() msg = ServerResponseMessage() msg.server_response.ret_code = code if code != RET_OK: metainfo.type = ContentType.NACK else: metainfo.type = ContentType.BLOB if retry_after > 0.1: metainfo.freshnessPeriod = int(retry_after / 10) msg.server_response.retry_after = int(retry_after) else: metainfo.freshnessPeriod = 600 data.setMetaInfo(metainfo) data.setContent(ProtobufTlv.encode(msg)) self.keychain.sign(data) self.face.putData(data) def on_payload(self, frame_name): # type: (Name) -> None for model in self.operations_set: data_name = Name(frame_name).append(model) status = self.load_status(data_name) if status is None: continue if self.storage.exists(data_name): logging.info("Result exists: %s", data_name.toUri()) continue logging.info("Ready to produce: %s", data_name.toUri()) status.proecess_start_time = Common.getNowMilliseconds() if model == "deeplab": ret = self.deeplab_manager.send(DeepLabRequest(frame_name.toUri()[1:], frame_name.toUri(), data_name)) else: ret = self.fst_manager.send(FstRequest(frame_name.toUri()[1:], model, frame_name.toUri(), data_name)) status.status = STATUS_PROCESSING if ret else STATUS_FAILED self.save_status(data_name, status) def on_process_finished(self, name_str, model_name): # type: (str, str) -> None data_name = Name(name_str).append(model_name) logging.info("Process finished: %s", data_name.toUri()) status = self.load_status(data_name) if status is None: logging.fatal("Database broken.") raise RuntimeError() status.end_time = Common.getNowMilliseconds() status.status = STATUS_SUCCEED meta_name = Name(data_name).append("_meta") content_metainfo = ContentMetaInfo() content_metainfo.setContentType("png") content_metainfo.setTimestamp(status.end_time) content_metainfo.setHasSegments(True) self.storage.put(meta_name, content_metainfo.wireEncode().toBytes()) def on_fetch_fail(self, frame_name): logging.error("Fail to fetch: {}".format(frame_name)) for model in self.operations_set: data_name = Name(frame_name).append(model) status = self.load_status(data_name) if status is None: continue status.status = STATUS_NO_INPUT self.save_status(data_name, status)
if shouldCollectStats: insertTable.append({'version':versionStr, 'insert_request':time.time()}) data = generateData(fullName) dataCache.add(data) if shouldCollectStats: info = getInfoForVersion(versionStr) if info is not None: info['insert_complete'] = time.time() time.sleep(0.1) print '.', sys.stdout.flush() except Exception as e: print e tb = traceback.format_exc() except KeyboardInterrupt: pass else: pass finally: done = True time.sleep(0.5) if tb is not None: print tb if shouldCollectStats: collectStats(insertTable) publisher_face.shutdown()
class TestConfigPolicyManager(ut.TestCase): def setUp(self): testCertDirectory = 'policy_config/certs' self.testCertFile = os.path.join(testCertDirectory, 'test.cert') self.identityStorage = MemoryIdentityStorage() self.privateKeyStorage = MemoryPrivateKeyStorage() self.identityManager = IdentityManager(self.identityStorage, self.privateKeyStorage) self.policyManager = ConfigPolicyManager('policy_config/simple_rules.conf') self.identityName = Name('/TestConfigPolicyManager/temp') # to match the anchor cert keyName = Name(self.identityName).append('ksk-1416010123') self.privateKeyStorage.setKeyPairForKeyName( keyName, KeyType.RSA, TEST_RSA_PUBLIC_KEY_DER, TEST_RSA_PRIVATE_KEY_DER) self.identityStorage.addKey( keyName, KeyType.RSA, Blob(TEST_RSA_PUBLIC_KEY_DER)) cert = self.identityManager.selfSign(keyName) self.identityStorage.setDefaultKeyNameForIdentity(keyName) self.identityManager.addCertificateAsDefault(cert) self.keyChain = KeyChain(self.identityManager, self.policyManager) self.keyName = keyName self.face = Face() def tearDown(self): self.privateKeyStorage.deleteKeyPair(self.keyName) self.face.shutdown() try: os.remove(self.testCertFile) except OSError: pass def test_no_verify(self): policyManager = NoVerifyPolicyManager() identityName = Name('TestValidator/Null').appendVersion(int(time.time())) keyChain = KeyChain(self.identityManager, policyManager) keyChain.createIdentityAndCertificate(identityName) data = Data(Name(identityName).append('data')) keyChain.signByIdentity(data, identityName) vr = doVerify(policyManager, data) self.assertFalse(vr.hasFurtherSteps, "NoVerifyPolicyManager returned a ValidationRequest") self.assertEqual(vr.failureCount, 0, "Verification failed with NoVerifyPolicyManager") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) def test_self_verification(self): policyManager = SelfVerifyPolicyManager(self.identityStorage) keyChain = KeyChain(self.identityManager, policyManager) identityName = Name('TestValidator/RsaSignatureVerification') keyChain.createIdentityAndCertificate(identityName) data = Data(Name('/TestData/1')) keyChain.signByIdentity(data, identityName) vr = doVerify(policyManager, data) self.assertFalse(vr.hasFurtherSteps, "SelfVerifyPolicyManager returned a ValidationRequest") self.assertEqual(vr.failureCount, 0, "Verification of identity-signed data failed") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) data2 = Data(Name('/TestData/2')) vr = doVerify(policyManager, data2) self.assertFalse(vr.hasFurtherSteps, "SelfVerifyPolicyManager returned a ValidationRequest") self.assertEqual(vr.successCount, 0, "Verification of unsigned data succeeded") self.assertEqual(vr.failureCount, 1, "Verification failure callback called {} times instead of 1".format( vr.failureCount)) def test_interest_timestamp(self): interestName = Name('/ndn/ucla/edu/something') certName = self.identityManager.getDefaultCertificateNameForIdentity( self.identityName) self.face.setCommandSigningInfo(self.keyChain, certName) oldInterest = Interest(interestName) self.face.makeCommandInterest(oldInterest) time.sleep(0.1) # make sure timestamps are different newInterest = Interest(interestName) self.face.makeCommandInterest(newInterest) vr = doVerify(self.policyManager, newInterest) self.assertFalse(vr.hasFurtherSteps, "ConfigPolicyManager returned ValidationRequest but certificate is known") self.assertEqual(vr.failureCount, 0, "Verification of valid interest failed") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) vr = doVerify(self.policyManager, oldInterest) self.assertFalse(vr.hasFurtherSteps, "ConfigPolicyManager returned ValidationRequest but certificate is known") self.assertEqual(vr.successCount, 0, "Verification of stale interest succeeded") self.assertEqual(vr.failureCount, 1, "Failure callback called {} times instead of 1".format( vr.failureCount)) def _removeFile(self, filename): try: os.remove(filename) except OSError: # no such file pass def test_refresh_10s(self): with open('policy_config/testData', 'r') as dataFile: encodedData = dataFile.read() data = Data() dataBlob = Blob(b64decode(encodedData)) data.wireDecode(dataBlob) # needed, since the KeyChain will express interests in unknown # certificates vr = doVerify(self.policyManager, data) self.assertTrue(vr.hasFurtherSteps, "ConfigPolicyManager did not create ValidationRequest for unknown certificate") self.assertEqual(vr.successCount, 0, "ConfigPolicyManager called success callback with pending ValidationRequest") self.assertEqual(vr.failureCount, 0, "ConfigPolicyManager called failure callback with pending ValidationRequest") # now save the cert data to our anchor directory, and wait # we have to sign it with the current identity or the # policy manager will create an interest for the signing certificate with open(self.testCertFile, 'w') as certFile: cert = IdentityCertificate() certData = b64decode(CERT_DUMP) cert.wireDecode(Blob(certData, False)) self.keyChain.signByIdentity(cert, self.identityName) encodedCert = b64encode(cert.wireEncode().toBytes()) certFile.write(Blob(encodedCert, False).toRawStr()) # still too early for refresh to pick it up vr = doVerify(self.policyManager, data) self.assertTrue(vr.hasFurtherSteps, "ConfigPolicyManager refresh occured sooner than specified") self.assertEqual(vr.successCount, 0, "ConfigPolicyManager called success callback with pending ValidationRequest") self.assertEqual(vr.failureCount, 0, "ConfigPolicyManager called failure callback with pending ValidationRequest") time.sleep(6) # now we should find it vr = doVerify(self.policyManager, data) self.assertFalse(vr.hasFurtherSteps, "ConfigPolicyManager did not refresh certificate store") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) self.assertEqual(vr.failureCount, 0, "ConfigPolicyManager did not verify valid signed data")
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')
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 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 TestFaceInterestMethods(ut.TestCase): def setUp(self): self.face = Face("localhost") def tearDown(self): self.face.shutdown() def run_express_name_test(self, interestName, timeout=12): # returns the dataCallback and timeoutCallback mock objects so we can test timeout behavior # as well as a bool for if we timed out without timeoutCallback being called name = Name(interestName) dataCallback = Mock() timeoutCallback = Mock() self.face.expressInterest(name, dataCallback, timeoutCallback) while True: self.face.processEvents() time.sleep(0.01) if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break return dataCallback, timeoutCallback def test_any_interest(self): uri = "/" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) self.assertTrue(timeoutCallback.call_count == 0 , 'Timeout on expressed interest') # check that the callback was correct self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count)) onDataArgs = dataCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onDataArgs[0] self.assertTrue(callbackInterest.getName() == (Name(uri)), 'Interest returned on callback had different name') # TODO: Replace this with a test that connects to a Face on localhost #def test_specific_interest(self): # uri = "/ndn/edu/ucla/remap/ndn-js-test/howdy.txt/%FD%052%A1%DF%5E%A4" # (dataCallback, timeoutCallback) = self.run_express_name_test(uri) # self.assertTrue(timeoutCallback.call_count == 0, 'Unexpected timeout on expressed interest') # # # check that the callback was correct # self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count)) # onDataArgs = dataCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) # #just check that the interest was returned correctly? # callbackInterest = onDataArgs[0] # self.assertTrue(callbackInterest.getName() == Name(uri), 'Interest returned on callback had different name') def test_timeout(self): uri = "/test/timeout" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) # we're expecting a timeout callback, and only 1 self.assertTrue(dataCallback.call_count == 0, 'Data callback called for invalid interest') self.assertTrue(timeoutCallback.call_count == 1, 'Expected 1 timeout call, got ' + str(timeoutCallback.call_count)) #check that the interest was returned correctly onTimeoutArgs = timeoutCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onTimeoutArgs[0] self.assertTrue(callbackInterest.getName() == (Name(uri)), 'Interest returned on callback had different name') def test_remove_pending(self): name = Name("/ndn/edu/ucla/remap/") dataCallback = Mock() timeoutCallback = Mock() interestID = self.face.expressInterest(name, dataCallback, timeoutCallback) self.face.removePendingInterest(interestID) timeout = 10000 startTime = getNowMilliseconds() while True: self.face.processEvents() time.sleep(0.01) if getNowMilliseconds() - startTime >= timeout: break if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break self.assertEqual(dataCallback.call_count, 0, 'Should not have called data callback after interest was removed') self.assertEqual(timeoutCallback.call_count, 0, 'Should not have called timeout callback after interest was removed') def test_max_ndn_packet_size(self): # Construct an interest whose encoding is one byte larger than getMaxNdnPacketSize. targetSize = Face.getMaxNdnPacketSize() + 1 # Start with an interest which is almost the right size. interest = Interest() interest.getName().append(bytearray(targetSize)) initialSize = interest.wireEncode().size() # Now replace the component with the desired size which trims off the extra encoding. interest.setName( (Name().append(bytearray(targetSize - (initialSize - targetSize))))) interestSize = interest.wireEncode().size() self.assertEqual(targetSize, interestSize, "Wrong interest size for MaxNdnPacketSize") with self.assertRaises(RuntimeError): # If no error is raised, then expressInterest didn't throw an # exception when the interest size exceeds getMaxNdnPacketSize() self.face.expressInterest(interest, Mock(), Mock())
class TestFaceInterestMethods(ut.TestCase): def setUp(self): self.face = Face("localhost") def tearDown(self): self.face.shutdown() def run_express_name_test(self, interestName, useOnNack = False): # returns the dataCallback and timeoutCallback mock objects so we can test timeout behavior # as well as a bool for if we timed out without timeoutCallback being called name = Name(interestName) dataCallback = Mock() timeoutCallback = Mock() onNackCallback = Mock() if useOnNack: self.face.expressInterest( name, dataCallback, timeoutCallback, onNackCallback) else: self.face.expressInterest(name, dataCallback, timeoutCallback) while True: self.face.processEvents() time.sleep(0.01) if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0 or onNackCallback.call_count > 0): break return dataCallback, timeoutCallback, onNackCallback def test_any_interest(self): uri = "/" (dataCallback, timeoutCallback, onNackCallback) = self.run_express_name_test(uri) self.assertTrue(timeoutCallback.call_count == 0 , 'Timeout on expressed interest') # check that the callback was correct self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count)) onDataArgs = dataCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onDataArgs[0] self.assertTrue(callbackInterest.getName() == (Name(uri)), 'Interest returned on callback had different name') # TODO: Replace this with a test that connects to a Face on localhost #def test_specific_interest(self): # uri = "/ndn/edu/ucla/remap/ndn-js-test/howdy.txt/%FD%052%A1%DF%5E%A4" # (dataCallback, timeoutCallback, onNackCallback) = self.run_express_name_test(uri) # self.assertTrue(timeoutCallback.call_count == 0, 'Unexpected timeout on expressed interest') # # # check that the callback was correct # self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count)) # onDataArgs = dataCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) # #just check that the interest was returned correctly? # callbackInterest = onDataArgs[0] # self.assertTrue(callbackInterest.getName() == Name(uri), 'Interest returned on callback had different name') def test_timeout(self): uri = "/test/timeout" (dataCallback, timeoutCallback, onNackCallback) = self.run_express_name_test(uri) # we're expecting a timeout callback, and only 1 self.assertTrue(dataCallback.call_count == 0, 'Data callback called for invalid interest') self.assertTrue(timeoutCallback.call_count == 1, 'Expected 1 timeout call, got ' + str(timeoutCallback.call_count)) #check that the interest was returned correctly onTimeoutArgs = timeoutCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onTimeoutArgs[0] self.assertTrue(callbackInterest.getName() == (Name(uri)), 'Interest returned on callback had different name') def test_remove_pending(self): name = Name("/ndn/edu/ucla/remap/") dataCallback = Mock() timeoutCallback = Mock() interestID = self.face.expressInterest(name, dataCallback, timeoutCallback) self.face.removePendingInterest(interestID) timeout = 10000 startTime = getNowMilliseconds() while True: if getNowMilliseconds() - startTime >= timeout: break self.face.processEvents() if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break time.sleep(0.01) self.assertEqual(dataCallback.call_count, 0, 'Should not have called data callback after interest was removed') self.assertEqual(timeoutCallback.call_count, 0, 'Should not have called timeout callback after interest was removed') def test_max_ndn_packet_size(self): # Construct an interest whose encoding is one byte larger than getMaxNdnPacketSize. targetSize = Face.getMaxNdnPacketSize() + 1 # Start with an interest which is almost the right size. interest = Interest() interest.getName().append(bytearray(targetSize)) initialSize = interest.wireEncode().size() # Now replace the component with the desired size which trims off the extra encoding. interest.setName( (Name().append(bytearray(targetSize - (initialSize - targetSize))))) interestSize = interest.wireEncode().size() self.assertEqual(targetSize, interestSize, "Wrong interest size for MaxNdnPacketSize") with self.assertRaises(RuntimeError): # If no error is raised, then expressInterest didn't throw an # exception when the interest size exceeds getMaxNdnPacketSize() self.face.expressInterest(interest, Mock(), Mock()) def test_network_nack(self): uri = "/noroute" + str(getNowMilliseconds()) (dataCallback, timeoutCallback, onNackCallback) = self.run_express_name_test( uri, True) # We're expecting a network Nack callback, and only 1. self.assertEqual(dataCallback.call_count, 0, "Data callback called for unroutable interest") self.assertEqual(timeoutCallback.call_count, 0, "Timeout callback called for unroutable interest") self.assertEqual(onNackCallback.call_count, 1, "Expected 1 network Nack call") # The args are returned as ([ordered arguments], [keyword arguments]) onNetworkNackArgs = onNackCallback.call_args[0] callbackNetworkNack = onNetworkNackArgs[1] self.assertEqual(callbackNetworkNack.getReason(), NetworkNack.Reason.NO_ROUTE, "Network Nack has unexpected reason")
class TestConfigPolicyManager(ut.TestCase): def setUp(self): testCertDirectory = 'policy_config/certs' self.testCertFile = os.path.join(testCertDirectory, 'test.cert') # Reuse the policy_config subdirectory for the temporary SQLite file. self.databaseFilePath = "policy_config/test-public-info.db" try: os.remove(self.databaseFilePath) except OSError: # no such file pass self.identityStorage = BasicIdentityStorage(self.databaseFilePath) self.privateKeyStorage = MemoryPrivateKeyStorage() self.identityManager = IdentityManager(self.identityStorage, self.privateKeyStorage) self.policyManager = ConfigPolicyManager('policy_config/simple_rules.conf') self.identityName = Name('/TestConfigPolicyManager/temp') # to match the anchor cert keyName = Name(self.identityName).append('ksk-1416010123') self.privateKeyStorage.setKeyPairForKeyName( keyName, KeyType.RSA, TEST_RSA_PUBLIC_KEY_DER, TEST_RSA_PRIVATE_KEY_DER) self.identityStorage.addKey( keyName, KeyType.RSA, Blob(TEST_RSA_PUBLIC_KEY_DER)) cert = self.identityManager.selfSign(keyName) self.identityStorage.setDefaultKeyNameForIdentity(keyName) self.identityManager.addCertificateAsDefault(cert) self.keyChain = KeyChain(self.identityManager, self.policyManager) self.keyName = keyName self.face = Face() def tearDown(self): try: os.remove(self.databaseFilePath) except OSError: pass self.privateKeyStorage.deleteKeyPair(self.keyName) self.face.shutdown() try: os.remove(self.testCertFile) except OSError: pass def test_no_verify(self): policyManager = NoVerifyPolicyManager() identityName = Name('TestValidator/Null').appendVersion(int(time.time())) keyChain = KeyChain(self.identityManager, policyManager) keyChain.createIdentityAndCertificate(identityName) data = Data(Name(identityName).append('data')) keyChain.signByIdentity(data, identityName) vr = doVerify(policyManager, data) self.assertFalse(vr.hasFurtherSteps, "NoVerifyPolicyManager returned a ValidationRequest") self.assertEqual(vr.failureCount, 0, "Verification failed with NoVerifyPolicyManager") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) def test_self_verification(self): policyManager = SelfVerifyPolicyManager(self.identityStorage) keyChain = KeyChain(self.identityManager, policyManager) identityName = Name('TestValidator/RsaSignatureVerification') keyChain.createIdentityAndCertificate(identityName) data = Data(Name('/TestData/1')) keyChain.signByIdentity(data, identityName) vr = doVerify(policyManager, data) self.assertFalse(vr.hasFurtherSteps, "SelfVerifyPolicyManager returned a ValidationRequest") self.assertEqual(vr.failureCount, 0, "Verification of identity-signed data failed") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) data2 = Data(Name('/TestData/2')) vr = doVerify(policyManager, data2) self.assertFalse(vr.hasFurtherSteps, "SelfVerifyPolicyManager returned a ValidationRequest") self.assertEqual(vr.successCount, 0, "Verification of unsigned data succeeded") self.assertEqual(vr.failureCount, 1, "Verification failure callback called {} times instead of 1".format( vr.failureCount)) def test_interest_timestamp(self): interestName = Name('/ndn/ucla/edu/something') certName = self.identityManager.getDefaultCertificateNameForIdentity( self.identityName) self.face.setCommandSigningInfo(self.keyChain, certName) oldInterest = Interest(interestName) self.face.makeCommandInterest(oldInterest) time.sleep(0.1) # make sure timestamps are different newInterest = Interest(interestName) self.face.makeCommandInterest(newInterest) vr = doVerify(self.policyManager, newInterest) self.assertFalse(vr.hasFurtherSteps, "ConfigPolicyManager returned ValidationRequest but certificate is known") self.assertEqual(vr.failureCount, 0, "Verification of valid interest failed") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) vr = doVerify(self.policyManager, oldInterest) self.assertFalse(vr.hasFurtherSteps, "ConfigPolicyManager returned ValidationRequest but certificate is known") self.assertEqual(vr.successCount, 0, "Verification of stale interest succeeded") self.assertEqual(vr.failureCount, 1, "Failure callback called {} times instead of 1".format( vr.failureCount)) def _removeFile(self, filename): try: os.remove(filename) except OSError: # no such file pass def test_refresh_10s(self): with open('policy_config/testData', 'r') as dataFile: encodedData = dataFile.read() data = Data() dataBlob = Blob(b64decode(encodedData)) data.wireDecode(dataBlob) # needed, since the KeyChain will express interests in unknown # certificates vr = doVerify(self.policyManager, data) self.assertTrue(vr.hasFurtherSteps, "ConfigPolicyManager did not create ValidationRequest for unknown certificate") self.assertEqual(vr.successCount, 0, "ConfigPolicyManager called success callback with pending ValidationRequest") self.assertEqual(vr.failureCount, 0, "ConfigPolicyManager called failure callback with pending ValidationRequest") # now save the cert data to our anchor directory, and wait # we have to sign it with the current identity or the # policy manager will create an interest for the signing certificate with open(self.testCertFile, 'w') as certFile: cert = IdentityCertificate() certData = b64decode(CERT_DUMP) cert.wireDecode(Blob(certData, False)) self.keyChain.signByIdentity(cert, self.identityName) encodedCert = b64encode(cert.wireEncode().toBuffer()) certFile.write(Blob(encodedCert, False).toRawStr()) # still too early for refresh to pick it up vr = doVerify(self.policyManager, data) self.assertTrue(vr.hasFurtherSteps, "ConfigPolicyManager refresh occured sooner than specified") self.assertEqual(vr.successCount, 0, "ConfigPolicyManager called success callback with pending ValidationRequest") self.assertEqual(vr.failureCount, 0, "ConfigPolicyManager called failure callback with pending ValidationRequest") time.sleep(6) # now we should find it vr = doVerify(self.policyManager, data) self.assertFalse(vr.hasFurtherSteps, "ConfigPolicyManager did not refresh certificate store") self.assertEqual(vr.successCount, 1, "Verification success called {} times instead of 1".format( vr.successCount)) self.assertEqual(vr.failureCount, 0, "ConfigPolicyManager did not verify valid signed data")
class TestFaceInterestMethods(ut.TestCase): def setUp(self): self.face = Face("aleph.ndn.ucla.edu") def tearDown(self): self.face.shutdown() def run_express_name_test(self, interestName, timeout=12): # returns the dataCallback and timeoutCallback mock objects so we can test timeout behavior # as well as a bool for if we timed out without timeoutCallback being called name = Name(interestName) dataCallback = Mock() timeoutCallback = Mock() self.face.expressInterest(name, dataCallback, timeoutCallback) def waitForCallbacks(): while 1: self.face.processEvents() gevent.sleep() if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break task = gevent.spawn(waitForCallbacks) task.join(timeout=10) return dataCallback, timeoutCallback def test_any_interest(self): uri = "/" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) self.assertTrue(timeoutCallback.call_count == 0 , 'Timeout on expressed interest') # check that the callback was correct self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count)) onDataArgs = dataCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onDataArgs[0] self.assertTrue(callbackInterest.getName().equals(Name(uri)), 'Interest returned on callback had different name') # TODO: Replace this with a test that connects to a Face on localhost #def test_specific_interest(self): # uri = "/ndn/edu/ucla/remap/ndn-js-test/howdy.txt/%FD%052%A1%DF%5E%A4" # (dataCallback, timeoutCallback) = self.run_express_name_test(uri) # self.assertTrue(timeoutCallback.call_count == 0, 'Unexpected timeout on expressed interest') # # # check that the callback was correct # self.assertEqual(dataCallback.call_count, 1, 'Expected 1 onData callback, got '+str(dataCallback.call_count)) # onDataArgs = dataCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) # #just check that the interest was returned correctly? # callbackInterest = onDataArgs[0] # self.assertTrue(callbackInterest.getName().equals(Name(uri)), 'Interest returned on callback had different name') def test_timeout(self): uri = "/test/timeout" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) # we're expecting a timeout callback, and only 1 self.assertTrue(dataCallback.call_count == 0, 'Data callback called for invalid interest') self.assertTrue(timeoutCallback.call_count == 1, 'Expected 1 timeout call, got ' + str(timeoutCallback.call_count)) #check that the interest was returned correctly onTimeoutArgs = timeoutCallback.call_args[0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onTimeoutArgs[0] self.assertTrue(callbackInterest.getName().equals(Name(uri)), 'Interest returned on callback had different name') def test_remove_pending(self): name = Name("/ndn/edu/ucla/remap/") dataCallback = Mock() timeoutCallback = Mock() interestID = self.face.expressInterest(name, dataCallback, timeoutCallback) def removeInterestAndWait(): self.face.removePendingInterest(interestID) while 1: self.face.processEvents() gevent.sleep() currentTime = time.clock() if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break task = gevent.spawn(removeInterestAndWait) task.join(timeout=10) self.assertEqual(dataCallback.call_count, 0, 'Should not have called data callback after interest was removed') self.assertEqual(timeoutCallback.call_count, 0, 'Should not have called timeout callback after interest was removed')
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("/unittest") 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') gevent.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.equals(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
else: timing.append(done-start) if __name__ == '__main__': face = Face() if shouldSign: face.setCommandSigningInfo(keychain, certName) input = None N = 0 try: while True: byteVal = (N)&0xff color = (0,0,0) selector = (N/256)%0x3 if selector == 1: color = (byteVal, 0, 0) elif selector == 2: color = (0, byteVal, 0) elif selector == 0: color = (0, 0, byteVal) interest = createCommandInterest(color=color) waitForResponse(face, interest, None) N += 10 except KeyboardInterrupt: pass face.shutdown() print "Response time: {:3.2f}/{:3.2f}/{:3.2f}s min/mean/max".format(min(timing), mean(timing), max(timing)) print str(timeouts) + " timeouts"
class TestFaceInterestMethods(ut.TestCase): def setUp(self): self.face = Face("aleph.ndn.ucla.edu") def tearDown(self): self.face.shutdown() def run_express_name_test(self, interestName, timeout=12): # returns the dataCallback and timeoutCallback mock objects so we can test timeout behavior # as well as a bool for if we timed out without timeoutCallback being called name = Name(interestName) dataCallback = Mock() timeoutCallback = Mock() self.face.expressInterest(name, dataCallback, timeoutCallback) def waitForCallbacks(): while 1: self.face.processEvents() gevent.sleep() if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break task = gevent.spawn(waitForCallbacks) task.join(timeout=10) return dataCallback, timeoutCallback def test_any_interest(self): uri = "/" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) self.assertTrue(timeoutCallback.call_count == 0, 'Timeout on expressed interest') # check that the callback was correct self.assertEqual( dataCallback.call_count, 1, 'Expected 1 onData callback, got ' + str(dataCallback.call_count)) onDataArgs = dataCallback.call_args[ 0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onDataArgs[0] self.assertTrue(callbackInterest.getName().equals(Name(uri)), 'Interest returned on callback had different name') def test_specific_interest(self): uri = "/ndn/edu/ucla/remap/ndn-js-test/howdy.txt/%FD%052%A1%DF%5E%A4" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) self.assertTrue(timeoutCallback.call_count == 0, 'Unexpected timeout on expressed interest') # check that the callback was correct self.assertEqual( dataCallback.call_count, 1, 'Expected 1 onData callback, got ' + str(dataCallback.call_count)) onDataArgs = dataCallback.call_args[ 0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onDataArgs[0] self.assertTrue(callbackInterest.getName().equals(Name(uri)), 'Interest returned on callback had different name') def test_timeout(self): uri = "/test/timeout" (dataCallback, timeoutCallback) = self.run_express_name_test(uri) # we're expecting a timeout callback, and only 1 self.assertTrue(dataCallback.call_count == 0, 'Data callback called for invalid interest') self.assertTrue( timeoutCallback.call_count == 1, 'Expected 1 timeout call, got ' + str(timeoutCallback.call_count)) #check that the interest was returned correctly onTimeoutArgs = timeoutCallback.call_args[ 0] # the args are returned as ([ordered arguments], [keyword arguments]) #just check that the interest was returned correctly? callbackInterest = onTimeoutArgs[0] self.assertTrue(callbackInterest.getName().equals(Name(uri)), 'Interest returned on callback had different name') def test_remove_pending(self): name = Name("/ndn/edu/ucla/remap/") dataCallback = Mock() timeoutCallback = Mock() interestID = self.face.expressInterest(name, dataCallback, timeoutCallback) def removeInterestAndWait(): self.face.removePendingInterest(interestID) while 1: self.face.processEvents() gevent.sleep() currentTime = time.clock() if (dataCallback.call_count > 0 or timeoutCallback.call_count > 0): break task = gevent.spawn(removeInterestAndWait) task.join(timeout=10) self.assertEqual( dataCallback.call_count, 0, 'Should not have called data callback after interest was removed') self.assertEqual( timeoutCallback.call_count, 0, 'Should not have called timeout callback after interest was removed' )
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 startRepoWatch. """ repoCommandPrefix = Name("/ndn/edu/ucla/remap/bms-repo/1") repoDataPrefix = Name("/ndn/edu/ucla/remap/bms") 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. from pyndn.security.identity import IdentityManager, FilePrivateKeyStorage, BasicIdentityStorage keyChain = KeyChain( IdentityManager(BasicIdentityStorage(), FilePrivateKeyStorage())) face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) # Register the prefix and start the repo watch at the same time. enabled = [True] sendSegments = SendSegments(keyChain, keyChain.getDefaultCertificateName(), enabled) dump("Register prefix", watchPrefix.toUri()) face.registerPrefix(watchPrefix, sendSegments.onInterest, sendSegments.onRegisterFailed) print("Here") def onRepoWatchStarted(): dump("Watch started for", watchPrefix.toUri()) def onFailed(): enabled[0] = False startRepoWatch(face, repoCommandPrefix, watchPrefix, onRepoWatchStarted, onFailed) # 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) def onRepoWatchStopped(): dump("Watch stopped for", watchPrefix.toUri()) enabled[0] = False stopRepoWatch(face, repoCommandPrefix, watchPrefix, onRepoWatchStopped, onFailed) # Run until stopRepoWatch finishes. 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()