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():
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():
# 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():
# 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()
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()
# Use the system default key chain and certificate name to sign commands.
#print("key1")
#keyChain = KeyChain()
#print("key2")
identityStorage = MemoryIdentityStorage()
privateKeyStorage = MemoryPrivateKeyStorage()
keyChain = KeyChain(IdentityManager(identityStorage, privateKeyStorage),
NoVerifyPolicyManager())
identityName = Name("TestProducer")
certificateName = keyChain.createIdentityAndCertificate(identityName)
keyChain.getIdentityManager().setDefaultIdentity(identityName)
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
# Also use the default certificate name to sign data packets.
ubicdn = UbiCDN(keyChain, certificateName)
prefix = Name("/ubicdn/video")
dump("Register prefix", prefix.toUri())
face.registerPrefix(prefix, ubicdn.onInterest, ubicdn.onRegisterFailed)
while 1:
#while ubicdn._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():
"""
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("/localhost/repo1")
repoDataPrefix = Name("/NIST/library/mainroom/ESP32ID001")
nowMilliseconds = int(time.time() * 1000.0)
fetchPrefix = Name(repoDataPrefix).append(
Name.Component.fromNumber(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)
time.sleep(0.2)
def onInsertStarted():
dump("Insert started for", fetchPrefix.toUri())
def onFailed():
enabled[0] = False
requestInsert(face, repoCommandPrefix, fetchPrefix, onInsertStarted,
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)
face.shutdown()
class Consumer(object):
def __init__(self):
Prefix1 = '/umobile/notification/push'
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()
### Extract Data content from Interest name
interest_name_components = interestName.toUri().split("/")
Data_content = interest_name_components[interest_name_components.index("push") + 1]
print 'Received Data: %s' %Data_content
data = Data(interestName)
data.setContent("ACK")
hourMilliseconds = 600 * 1000
data.getMetaInfo().setFreshnessPeriod(hourMilliseconds)
self.keyChain.sign(data, self.keyChain.getDefaultCertificateName())
face.send(data.wireEncode().toBuffer())
print "Sending ACK"
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
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 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 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()
async def main():
# Set up face
async def face_loop():
nonlocal face, running
while running:
face.processEvents()
await asyncio.sleep(0.001)
face = Face()
running = True
face_event = event_loop.create_task(face_loop())
# register prefix in local NFD with it own name: /local_manager/building_1/camera_1
keychain = KeyChain()
face.setCommandSigningInfo(keychain, keychain.getDefaultCertificateName())
prefix_id = face.registerPrefix(Name(VIDEO_STREAM_NAME), None, on_register_failed)
filter_id = face.setInterestFilter(Name(VIDEO_STREAM_NAME), on_interest)
print('Registered prefix ID {}'.format(prefix_id))
print('Registered filter ID {}'.format(filter_id))
cap = cv2.VideoCapture(0)
# Capture a video every second
while True:
cur_time = await capture_video_chunk(duration=1, cap=cap)
prepare_packets(cur_time=cur_time, keychain=keychain)
remove_outdated_data(cur_time)
cap.release()
cv2.destroyAllWindows()
running = False
await face_event
def main():
face = Face()
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName())
prefix = Name("/test")
counter = Counter(keyChain, keyChain.getDefaultCertificateName())
face.registerPrefix(prefix, counter.onInterest, counter.onRegisterFailed)
while counter.rec == 1:
face.processEvents()
time.sleep(0.5)
face.shutdown()
def __init__(self, face: Face, prefix: Union[Name, str],
storage: IStorage):
self.face = face
self.prefix = prefix
self.storage = storage
self.register_id = face.registerPrefix(prefix, self.on_interest,
self.on_register_failed)
def run(self, namespace):
face = Face()
prefix = Name(namespace)
face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
face.registerPrefix(prefix, self.onInterest, self.onRegisterFailed)
print("Registering prefix", prefix.toUri())
while not self.isDone:
face.processEvents()
time.sleep(0.01)
pass
def main():
backboneFace = Face()
pibImpl = PibMemory()
keyChain = KeyChain(pibImpl, TpmBackEndMemory(),
SelfVerifyPolicyManager(pibImpl))
# This puts the public key in the pibImpl used by the SelfVerifyPolicyManager.
keyChain.importSafeBag(
SafeBag(Name("/testname/KEY/123"),
Blob(DEFAULT_RSA_PRIVATE_KEY_DER, False),
Blob(DEFAULT_RSA_PUBLIC_KEY_DER, False)))
backboneFace.setCommandSigningInfo(keyChain,
keyChain.getDefaultCertificateName())
prefix = Name("/farm1")
backboneFace.registerPrefix(prefix, onInterest, onRegisterFailed)
print("Ready to go...")
while 1:
try:
backboneFace.processEvents()
e.acquire()
frame = ieee.wait_read_frame(0.01)
e.release()
if frame is not None:
if frame['rf_data'][0] == b'\x06' or frame['rf_data'][
0] == b'\x05': #if Data or Interest
buffData[0] = frame['rf_data'][0]
buffData[1] = ord(frame['rf_data'][1]) + lCP
buffData[2] = frame['rf_data'][2]
buffData[3] = ord(frame['rf_data'][3]) + lCP
buffData[4:lCP + 4] = eCP
buffData[lCP + 4:] = frame['rf_data'][4:]
print(str(datetime.now().strftime('%X.%f')))
backboneFace.send(buffData)
else:
print(frame['rf_data'][:])
#time.sleep(0.1)
gc.collect()
except KeyboardInterrupt:
backboneFace.shutdown()
ser.close()
break
class Controller_Listener_CtrlInfo(object):
def __init__(self):
self.keyChain = KeyChain()
self.isDone = False
self.ofmsg = OFMSG()
self.nodeid = OSCommand.getnodeid()
self.face = Face()
self.featurereq = FeatureReq()
self.helloreq_name_list = []
self.new_CtrlInfo_data = "---Initial CtrlInfo data---" # used to get new ctrlinfo data and send to nodes.
self.CtrlInfo_data = "" # used to record used ctrlinfo data
def ctrl_info_run(self):
ControllerPrefixString = '/ndn/ie/tcd/controller01/ofndn/--/n1.0/36/0/0/'
ControllerPrefix = Name(ControllerPrefixString)
self.face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(ControllerPrefix, self.onInterest_CtrlInfo, self.onRegisterFailed) # run prefix
#
# # filters:
# CtrlInfo_msg_prefix = Name('/ndn/ie/tcd/controller01/ofndn/--/n1.0/36/0/0/')
# self.face.setInterestFilter(CtrlInfo_msg_prefix, self.onInterest_CtrlInfo) # for CtrlInfo msg
# Run the event loop forever. Use a short sleep to
# prevent the Producer from using 100% of the CPU.
while not self.isDone: # listen hello cannot stop
self.face.processEvents()
time.sleep(0.01)
def onInterest_CtrlInfo(self, mainPrefix, interest, transport, registeredPrefixId):
print("******** Received <<<CtrlInfoReq>>> Interest ******** \n {0} \n".format(interest.getName().toUri()))
while (self.new_CtrlInfo_data == self.CtrlInfo_data): # wait for new data.
time.sleep(15)
self.CtrlInfo_data = self.new_CtrlInfo_data
data = self.ofmsg.create_ctrlinfo_res_data(interest, self.CtrlInfo_data)
transport.send(data.wireEncode().toBuffer())
print("******** Sent <<<New CtrlInfo Res>>> Data ******** \n")
def onInterest_Mian(self, mainPrefix, interest, transport, registeredPrefixId):
pass
def onRegisterFailed(self, ControllerPrefix):
print("Register failed for prefix", ControllerPrefix.toUri())
self.isDone = True
def run(self, namespace):
# The default Face will connect using 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()
while True:
face.processEvents()
time.sleep(0.01)
def run(self):
# Create a connection to the local forwarder.
face = Face()
prefix = Name(namesp)
# 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: %s" % 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)
class Producer(object):
def __init__(self):
Prefix1 = '/umobile/polling/push'
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 Push Interest Polling 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 onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
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 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()
# 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()
class DLedger:
def __init__(self):
self.prefix = None
self.face = None
self.keychain = None
self.db = None
self.read_handle = None
self.sync_handle = None
self.notification_handle = None
def init_db(self):
import os
db_dir = os.path.expanduser('~/.dledger/')
if not os.path.exists(db_dir):
os.makedirs(db_dir)
self.db = plyvel.DB(db_dir, create_if_missing=True)
def init_network(self, prefix):
self.prefix = prefix
self.face = Face()
self.keychain = KeyChain()
self.face.setCommandSigningInfo(
self.keychain, self.keychain.getDefaultCertificateName())
self.face.registerPrefix(self.prefix, None, self.on_register_failed)
def init_handles(self):
self.read_handle = ReadHandle(self.face, self.prefix)
self.read_handle.listen()
self.sync_handle = SyncHandle(self.face, self.prefix)
self.sync_handle.listen()
self.notification_handle = NotificationHandle(self.face, self.prefix)
self.notification_handle.listen()
def gen_new_record(self):
pass
@staticmethod
def on_register_failed(prefix):
logging.error("Prefix registration failed: %s", prefix)
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 __init__(self, objects_db: IStorage, repo_name: str, face: Face):
self.repo_name = repo_name
self.repo_db = DBStorage(DATABASE_NAME, repo_name)
self.objects_db = objects_db
self.repo_prefix = Name(GIT_PREFIX).append(repo_name)
self.sync = Sync(face=face,
prefix=Name(self.repo_prefix).append("sync"),
on_update=self.on_sync_update)
self.producer = GitProducer(face=face,
prefix=Name(self.repo_prefix).append("objects"),
storage=objects_db)
self.face = face
self.branches = {}
self.load_refs()
face.registerPrefix(Name(self.repo_prefix).append("refs"),
self.on_refs_interest,
self.on_register_failed)
face.registerPrefix(Name(self.repo_prefix).append("ref-list"),
self.on_reflist_interest,
self.on_register_failed)
face.registerPrefix(Name(self.repo_prefix).append("branch-info"),
self.on_branchinfo_interest,
self.on_register_failed)
self.sync.run()
def main():
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
(keyChain, certificateName) = createKeyChain()
face.setCommandSigningInfo(keyChain, certificateName)
userKeyName = Name("/U/Key")
contentPrefix = Name("/Prefix/SAMPLE")
testProducer = TestProducer(
contentPrefix, userKeyName, keyChain, certificateName)
prefix = Name("/Prefix")
dump("Register prefix", prefix.toUri())
face.registerPrefix(
prefix, testProducer.onInterest, testProducer.onRegisterFailed)
while testProducer._enabled:
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():
# The default Face will connect using a Unix socket, or to "localhost".
face = Face()
(keyChain, certificateName) = createKeyChain()
face.setCommandSigningInfo(keyChain, certificateName)
userKeyName = Name("/U/Key")
contentPrefix = Name("/Prefix/SAMPLE")
testProducer = TestProducer(contentPrefix, userKeyName, keyChain,
certificateName)
prefix = Name("/Prefix")
dump("Register prefix", prefix.toUri())
face.registerPrefix(prefix, testProducer.onInterest,
testProducer.onRegisterFailed)
while testProducer._enabled:
face.processEvents()
# We need to sleep for a few milliseconds so we don't use 100% of the CPU.
time.sleep(0.01)
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.
'''Register prefix with the connected NDN hub and call onInterest when a
matching interest is received. To register a prefix with NFD, you must
first call setCommandSigningInfo.'''
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 run(self, namespace):
# Create a connection to the local forwarder over a Unix socket
# face = Face()
face = Face("127.0.0.1")
prefix = Name(namespace)
# Use the system default key chain and certificate name to sign commands.
cert_name = self.keyChain.getDefaultCertificateName()
face.setCommandSigningInfo(self.keyChain, cert_name)
# Also use the default certificate name to sign Data packets.
face.registerPrefix(prefix, self.onInterest, self.onRegisterFailed)
print "Registering prefix", prefix.toUri()
self.maxNdnPacketSize = face.getMaxNdnPacketSize()
# 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 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)
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
import time
from pyndn import Face, Name, Data, KeyLocator, Interest
from pyndn.security import KeyChain
#from pyndn.node import Node
def onRegisterSuccess(prefix, registeredPrefixId):
print "Registered: " + prefix.toUri()
def onRegisterFailed(prefix):
print "Prefix registration failed: " + prefix.toUri()
def onInterest(prefix, interest, face, interestFilterId, filter):
print "Got interest " + interest.getName().toUri()
face = Face("128.97.98.7", 6363)
print "Local face is: " + str(face.isLocal())
keyChain = KeyChain()
face.setCommandSigningInfo(keyChain, keyChain._identityManager.getDefaultCertificateNameForIdentity(Name("/ndn/edu/ucla/remap/%40GUEST/wangzhehao410305%40gmail.com")))
face.registerPrefix("/ndn/edu/ucla/remap/zhehao", onInterest, onRegisterFailed, onRegisterSuccess)
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)
done = False
# start publisher face
registerFail = Mock()
def publisher_loop(face):
global done
while not done:
face.processEvents()
if registerFail.call_count > 0:
logger.error("Registration failed!")
done = True
time.sleep(0.1)
face.shutdown()
publisher_face = Face("localhost")
publisher_face.setCommandSigningInfo(keychain, certName)
publisher_face.registerPrefix(data_prefix, onDataInterest, registerFail)
publisher = Thread(target=publisher_loop, name="Data publisher", args=(publisher_face,))
publisher.start()
# and the face that pokes the repo - these could have been separate programs instead
repo_face = Face("localhost")
repo_face.setCommandSigningInfo(keychain, certName)
success = Mock(side_effect=onCommandData)
failure = Mock()
try:
# sleep a second, then tell the repo we want to insert some data
time.sleep(1)
while not done:
#pick a random data name
data_part = suffix #str(randint(0,N))
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")
class Service_Execution_Main(object):
def __init__(self, producerName, namePrefix):
self.configPrefix = Name(namePrefix)
prefix_pullService = "/picasso/pull_Service/"
self.prefix_pullService = Name(prefix_pullService)
self.Datamessage_size = 2000000 #20MB --> Max Size from modified NDN
self.window = 1
self.producerName = producerName
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
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.num_deployedContainer = 0
self.lastChunk_window = 0
self.lastChunk_sent = 0
folder_name = "SEG_repository/"
self.repo_path = os.path.join(self.script_dir, folder_name)
if not os.path.exists(self.repo_path):
os.makedirs(self.repo_path)
folder_name = "Migration_cost/"
self.timestamp_path = os.path.join(self.script_dir, folder_name)
if not os.path.exists(self.timestamp_path):
os.makedirs(self.timestamp_path)
def run(self):
try:
self.face.setCommandSigningInfo(
self.keyChain, self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.configPrefix,
self.onInterest_pushService,
self.onRegisterFailed)
print "Registered prefix : " + self.configPrefix.toUri()
self.face.setCommandSigningInfo(
self.keyChain, self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.prefix_pullService,
self.onInterest_pullService,
self.onRegisterFailed)
print "Registered prefix : " + self.prefix_pullService.toUri()
while not self.isDone:
self.face.processEvents()
time.sleep(0.01)
except RuntimeError as e:
print "ERROR: %s" % e
def onInterest_pushService(self, prefix, interest, face, interestFilterId,
filter):
interestName = interest.getName()
### Delete image_file in SEG_Repe. This is just for migration cost experiment.
delete_service_command = 'rm ' + self.repo_path + '*'
os.system(delete_service_command)
print "Interest Name: %s" % interestName
interest_name_components = interestName.toUri().split("/")
if "service_deployment_push" in interest_name_components:
image_fileName = interest_name_components[
interest_name_components.index("service_deployment_push") + 2]
print 'Deploy service: %s' % image_fileName
print 'Start service deployment'
if dockerctl.has_ServiceInfo(image_fileName) == True:
print 'Has description for service deployment'
ExecutionType = dockerctl.get_ExecutionType(image_fileName)
if ExecutionType == 'singleWebContainer':
print 'Deployment uses dockerctl'
deployment_status = dockerctl.deployContainer(
image_fileName, self.num_deployedContainer)
if deployment_status == 'pull_image':
print 'Service: %s is not locally cached, pull from Repo' % image_fileName
prefix_pullImage = Name(
"/picasso/service_deployment_pull/" +
image_fileName)
print 'Sending Interest message: %s' % prefix_pullImage
self._sendNextInterest(prefix_pullImage,
self.interestLifetime, 'pull')
filename = image_fileName + '.txt'
self.StartTimeStamp_MigrationTime(filename)
elif deployment_status == 'done':
print 'Service:%s is successfully deployed' % image_fileName
self.num_deployedContainer += 1
elif deployment_status == 'error':
print 'Error in deployment process'
else:
print 'Code bug'
elif ExecutionType == 'DockerCompose':
print 'Deployment uses docker compose'
if dockerctl.has_imagefile(image_fileName) == True:
print 'Load image and run service'
dockerctl.run_DockerCompose_source(image_fileName)
else:
print 'Service: %s is not locally cached, pull from Repo' % image_fileName
prefix_pullImage = Name(
"/picasso/service_deployment_pull/" +
image_fileName)
print 'Sending Interest message: %s' % prefix_pullImage
self._sendNextInterest(prefix_pullImage,
self.interestLifetime, 'pull')
timestamp_file = image_fileName + '.txt'
self.StartTimeStamp_MigrationTime(timestamp_file)
else:
print 'Execution method is not yet implemented'
else:
print 'Deployment description is not available'
else:
print "Interest name mismatch"
def onInterest_pullService(self, prefix, interest, face, interestFilterId,
filter):
### This function is used in ACM ICN where the SEG receive the trigger message to pull the service
interestName = interest.getName()
print "Interest Name: %s" % interestName
interest_name_components = interestName.toUri().split("/")
image_fileName = interest_name_components[
interest_name_components.index("pull_Service") + 1]
if "pull_Service" in interest_name_components:
prefix_pullImage = Name("/picasso/service_deployment_pull/" +
image_fileName)
print 'Sending Interest message: %s' % prefix_pullImage
self._sendNextInterest(prefix_pullImage, self.interestLifetime,
'pull')
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
def _sendNextInterest(self, name, lifetime, mode):
interest = Interest(name)
uri = name.toUri()
interest.setInterestLifetimeMilliseconds(lifetime)
interest.setMustBeFresh(True)
if uri not in self.outstanding:
self.outstanding[uri] = 1
if mode == 'pull':
print "Sent Pull Interest for %s" % uri
self.face.expressInterest(interest, self._onData, self._onTimeout)
elif mode == 'push':
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
else:
print "send Interest mode mismatch"
def _onData(self, interest, data):
payload = data.getContent()
dataName = data.getName()
dataName_size = dataName.size()
print "Received data name: ", dataName.toUri()
data_name_components = dataName.toUri().split("/")
if "service_deployment_pull" in data_name_components:
fileName = data_name_components[
data_name_components.index("service_deployment_pull") + 1]
rel_path = "SEG_repository"
abs_path = os.path.join(self.script_dir, rel_path)
print "path of SEG_repository:%s" % abs_path
print "Service File name:%s" % fileName
file_path = os.path.join(abs_path, fileName)
dataSegmentNum = (dataName.get(dataName_size - 1)).toSegment()
lastSegmentNum = (data.getMetaInfo().getFinalBlockId()).toNumber()
print "dataSegmentNum" + str(dataSegmentNum)
print "lastSegmentNum" + str(lastSegmentNum)
if dataSegmentNum == 0:
print 'Start counting received chunks'
self.StartCountingReceivedChunks(dataSegmentNum,
lastSegmentNum + 1)
else:
self.UpdatingReceivedChunks(dataSegmentNum)
if self.request_SubsequenceDataChunk(abs_path, fileName, data,
self.window) == True:
timestamp_file = fileName + '.txt'
self.StopTimeStamp_MigrationTime(timestamp_file)
print 'Load image and run service'
if dockerctl.has_ServiceInfo(fileName) == True:
print 'Has description for service deployment'
ExecutionType = dockerctl.get_ExecutionType(fileName)
if ExecutionType == 'singleWebContainer':
print 'Deployment uses dockerctl'
if dockerctl.deployContainer(
fileName,
self.num_deployedContainer) == 'error':
print 'Image:%s cannot be deployed' % fileName
elif ExecutionType == 'DockerCompose':
dockerctl.run_DockerCompose_source(fileName)
else:
print 'Execution method is not yet implemented'
else:
print "function is not yet ready"
currentInterestName = interest.getName()
# Delete the Interest name from outstanding INTEREST dict as reply DATA has been received.
del self.outstanding[currentInterestName.toUri()]
#self.isDone = True
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, self.interestLifetime, 'pull')
else:
#self.isDone = True
print 'Cannot pull content for Interest: %s' % name
def request_SubsequenceDataChunk(self, path, fileName, data, window):
payload = data.getContent()
dataName = data.getName()
dataName_size = dataName.size()
timestamp_file = fileName + '.txt'
self.StartExtraction_TimeStamp(timestamp_file)
print "Extracting Data message name: ", dataName.toUri()
if not os.path.exists(path):
os.makedirs(path)
with open(os.path.join(path, fileName), 'ab') as temp_file:
temp_file.write(payload.toRawStr())
try:
dataSegmentNum = (dataName.get(dataName_size - 1)).toSegment()
lastSegmentNum = (data.getMetaInfo().getFinalBlockId()).toNumber()
self.FinishExtraction_TimeStamp(timestamp_file)
if dataSegmentNum == self.lastChunk_window:
print 'Send Interest of next window frame'
firstChunk_sent = self.lastChunk_window + 1
self.lastChunk_window = self.lastChunk_window + window
if self.lastChunk_window <= lastSegmentNum:
print 'This is NOT the last frame'
self.lastChunk_sent = self.lastChunk_window
else:
print 'This is the last frame'
self.lastChunk_sent = lastSegmentNum
for chunkID in range(firstChunk_sent, self.lastChunk_sent + 1):
interestName = dataName.getSubName(0, dataName_size - 1)
interestName = interestName.appendSegment(chunkID)
self._sendNextInterest(interestName, self.interestLifetime,
'pull')
else:
print 'Already sent window frame, Waiting for Data message'
if lastSegmentNum == dataSegmentNum:
print 'Received last chunk of content'
print 'Stop Sending Interest'
self.lastChunk_window = 0
self.lastChunk_sent = 0
TotalReceivedChunk = sum(list(self.receivedContentChunk))
if TotalReceivedChunk == lastSegmentNum + 1:
print "Received complete image: %s, EXECUTED !!!!" % fileName
return True
except RuntimeError as e:
print "ERROR: %s" % e
self.isDone = True
def StartCountingReceivedChunks(self, chunkID, TotalNumChunks):
self.receivedContentChunk = [0 for i in range(TotalNumChunks)]
self.receivedContentChunk[chunkID] = 1
print self.receivedContentChunk
def UpdatingReceivedChunks(self, chunkID):
self.receivedContentChunk[chunkID] = 1
print self.receivedContentChunk
def StartTimeStamp_MigrationTime(self, filename):
outputfile_path = os.path.join(self.timestamp_path, filename)
if os.path.exists(outputfile_path) == True:
print 'timestamp file is already existed'
else:
print 'create output file'
open(outputfile_path, 'a').close()
file = open(outputfile_path, 'a')
#file.write('Start Migration: ' + time.strftime("%a, %d %b %Y %X +0000", time.gmtime()) + '\n')
file.write('Service Migration Start: ' + time.ctime() + '\n')
file.write('Start: ' + str(time.time()) + '\n')
file.close()
def StartExtraction_TimeStamp(self, filename):
outputfile_path = os.path.join(self.timestamp_path, filename)
file = open(outputfile_path, 'a')
file.write('Extracting_Start: ' + str(time.time()) + '\n')
file.close()
def FinishExtraction_TimeStamp(self, filename):
outputfile_path = os.path.join(self.timestamp_path, filename)
file = open(outputfile_path, 'a')
file.write('Extracting_End: ' + str(time.time()) + '\n')
file.close()
def StopTimeStamp_MigrationTime(self, filename):
outputfile_path = os.path.join(self.timestamp_path, filename)
file = open(outputfile_path, 'a')
file.write('Service Migration Finish: ' + time.ctime() + '\n')
file.write('Finish: ' + str(time.time()) + '\n')
file.close()
rp.setStartBlockId(0)
interest = Interest(Name("/example/repo/1").append("insert").append(rp.wireEncode()))
identityStorage = MemoryIdentityStorage()
privateKeyStorage = MemoryPrivateKeyStorage()
keyChain = KeyChain(IdentityManager(identityStorage, privateKeyStorage),
SelfVerifyPolicyManager(identityStorage))
# 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)
# Make a Face just so that we can sign the interest.
face = Face("localhost")
face.setCommandSigningInfo(keyChain, certificateName)
face.makeCommandInterest(interest)
callbacks = Callbacks()
print interest.getName().toUri()
face.expressInterest(interest, callbacks.onData, callbacks.onTimeout)
face.registerPrefix(dataPrefix, callbacks.onInterest, callbacks.onRegisterFailed)
while True:
face.processEvents()
time.sleep(0.1)
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 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 Service_Execution_Main(object):
def __init__(self, producerName, namePrefix):
self.configPrefix = Name(namePrefix)
self.Datamessage_size = 8000 #8kB --> Max Size from NDN standard
self.producerName = producerName
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
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 = 12000
self.num_deployedContainer = 0
folder_name = "SEG_repository/"
rel_path = os.path.join(self.script_dir, folder_name)
if not os.path.exists(rel_path):
os.makedirs(rel_path)
def run(self):
try:
self.face.setCommandSigningInfo(
self.keyChain, self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.configPrefix, self.onInterest,
self.onRegisterFailed)
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
def onInterest(self, prefix, interest, face, interestFilterId, filter):
interestName = interest.getName()
print "Interest Name: %s" % interestName
interest_name_components = interestName.toUri().split("/")
if "service_deployment_push" in interest_name_components:
image_fileName = interest_name_components[
interest_name_components.index("service_deployment_push") + 2]
print 'Deploy service: %s' % image_fileName
print 'Start service deployment'
## check image is running or not
#Ger info from serviceInfo
#serviceName = 'web-uhttpd'
deployment_status = dockerctl.deployContainer(
image_fileName, self.num_deployedContainer)
if deployment_status == 'pull_image':
print 'Service: %s is not locally cached, pull from Repo' % image_fileName
prefix_pullImage = Name("/picasso/service_deployment_pull/" +
image_fileName)
print 'Sending Interest message: %s' % prefix_pullImage
self._sendNextInterest(prefix_pullImage, self.interestLifetime,
'pull')
elif deployment_status == 'done':
print 'Service:%s is successfully deployed' % image_fileName
self.num_deployedContainer += 1
elif deployment_status == 'error':
print 'Error in deployment process'
else:
print 'Code bug'
else:
print "Interest name mismatch"
def onRegisterFailed(self, prefix):
print "Register failed for prefix", prefix.toUri()
self.isDone = True
def _sendNextInterest(self, name, lifetime, mode):
interest = Interest(name)
uri = name.toUri()
interest.setInterestLifetimeMilliseconds(lifetime)
interest.setMustBeFresh(True)
if uri not in self.outstanding:
self.outstanding[uri] = 1
if mode == 'pull':
print "Sent Pull Interest for %s" % uri
self.face.expressInterest(interest, self._onData, self._onTimeout)
elif mode == 'push':
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
else:
print "send Interest mode mismatch"
def _onData(self, interest, data):
payload = data.getContent()
dataName = data.getName()
dataName_size = dataName.size()
print "Received data name: ", dataName.toUri()
data_name_components = dataName.toUri().split("/")
## Here is a received Data message /picasso/service_deployment_pull/fileName/%%01
if "service_deployment_pull" in data_name_components:
fileName = data_name_components[
data_name_components.index("service_deployment_pull") + 1]
rel_path = "SEG_repository"
abs_path = os.path.join(self.script_dir, rel_path)
print "path of SEG_repository:%s" % abs_path
print "Service File name:%s" % fileName
file_path = os.path.join(abs_path, fileName)
last_segment, interestName = ndnMessage_Helper.extractData_message(
abs_path, fileName, data)
if last_segment == True:
print 'Load image and run service'
if dockerctl.deployContainer(
fileName, self.num_deployedContainer) == 'error':
print 'Image:%s cannot be deployed' % fileName
else:
print 'This is not the last chunk, send subsequent Interest'
self._sendNextInterest(interestName, self.interestLifetime,
'pull')
else:
print "function is not yet ready"
currentInterestName = interest.getName()
# Delete the Interest name from outstanding INTEREST dict as reply DATA has been received.
del self.outstanding[currentInterestName.toUri()]
#self.isDone = True
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, self.interestLifetime, 'pull')
else:
#self.isDone = True
print 'Cannot pull content for Interest: %s' % name
class Monitoring_Agent_Main(object):
def __init__(self, namePrefix, producerName):
self.configPrefix = Name(namePrefix)
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
#self.DataStore = DS.readDataStore_json()
#self.DataStore = DS.table
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
self.producerName = producerName
#print "++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
#pprint(self.DataStore)
def run(self):
try:
self.face.setCommandSigningInfo(
self.keyChain, self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.configPrefix, self.onInterest,
self.onRegisterFailed)
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
def onInterest(self, prefix, interest, face, interestFilterId, filter):
interestName = interest.getName()
data = Data(interestName)
#print "++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
#pprint(self.DataStore)
print "Interest Name: %s" % interestName
interest_name_components = interestName.toUri().split("/")
if "monitoring" in interest_name_components:
print "Check Pi and Containers Status"
monitoring_agent = termopi()
## Print monitoring data
#monitoring_agent.prt_pi_resources()
print "Update json file"
filename = "piStatus" + self.producerName + ".json"
folder_name = "PIstatus/"
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)
monitoring_agent.create_jsonfile_with_pi_status(
abs_file_path, self.producerName)
freshness = 10 #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 Producer(object):
def __init__(self):
Prefix = '/umobile/push_PulblishData/pull'
self.configPrefix = Name(Prefix)
self.outstanding = dict()
self.isDone = False
self.keyChain = KeyChain()
self.face = Face("127.0.0.1")
self.Prefix_publish = '/umobile/push_PulblishData/publish'
self.Datamessage_size = 8000 # Data message size ~4kB
def run(self):
try:
self.face.setCommandSigningInfo(self.keyChain, \
self.keyChain.getDefaultCertificateName())
self.face.registerPrefix(self.configPrefix, self.onInterest_Pull,
self.onRegisterFailed)
print "Registering listening prefix : " + self.configPrefix.toUri()
self._sendInterest_Publish(Name(self.Prefix_publish))
while not self.isDone:
self.face.processEvents()
time.sleep(0.01)
except RuntimeError as e:
print "ERROR: %s" % e
def _sendInterest_Publish(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, None, None)
print "Sent Interest for %s" % uri
def onInterest_Pull(self, prefix, interest, face, interestFilterId,
filter):
script_path = os.path.abspath(__file__) # i.e. /path/to/dir/foobar.py
script_dir = os.path.split(script_path)[0] # i.e. /path/to/dir/
filename = 'testfile_original.docx'
abs_file_path = os.path.join(script_dir, filename)
freshness = 10000 # milli second, content will be deleted from the cache after freshness period
self.sendingFile(abs_file_path, interest, face, freshness)
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
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 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 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 = 800000
#self.Datamessage_size = 1999000
self.Datamessage_size = 19990000
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
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:
