def express_interest(self):
if self.chunkinfo == None:#a new chunk requested
self.chunkinfo = ChunkInfo(self.mydata.next_seg)
self.chunkinfo.begin_byte = self.mydata.next_byte
self.chunkinfo.expected_chunk_size = self.mydata.estimated_optimal_size or self.default_block_size
self.chunkinfo.beginT = datetime.datetime.now()
self.mydata.add_chunk_info(self.chunkinfo)
self.chunkinfo.retxN += 1
selector = pyndn.Interest()
selector.answerOriginKind = True
name = self.name
chunkid = self.mydata.next_seg
if self.mod == "adaptive": #byte index as chunkid
name = self.name.append(ADAPTIVE_MOD_FLAG).append(str(self.chunkinfo.expected_chunk_size))
chunkid = self.mydata.next_byte
if self.interest_schema == "exclusion": #do not use this
selector = pyndn.Interest(exclude = self.exclusions)
selector.answerOriginKind = True
elif self.interest_schema == "id":#the default one
name = pyndn.Name(name.components)
name = name.append(chunkid)
elif self.interest_schema == "segment":
name = pyndn.Name(name.components)
name = name.appendSegment(chunkid)
self.handle.expressInterest(name, self, selector)
#log.info("express interest %s, exclusions: %s" %(str(self.name), self.exclusions));
log.debug("interest=%s " %name)
def get_certificate():
client = request.args.get('client')
name = request.args.get('name')
isView = request.args.get('view')
token = request.args.get('token')
if client == nfd_android_client:
cert = current_app.mongo.db.certs.find_one({'token': token})
ndn_name = ndn.Name(str(cert['name']))
else:
ndn_name = ndn.Name(str(name))
cert = current_app.mongo.db.certs.find_one({'name': str(name)})
if cert == None:
abort(404)
if not isView:
response = make_response(cert['cert'])
response.headers['Content-Type'] = 'application/octet-stream'
response.headers['Content-Disposition'] = 'attachment; filename=%s.ndncert' % str(ndn_name[-3])
return response
else:
d = ndn.security.certificate.IdentityCertificate()
d.wireDecode(bytearray(base64.b64decode(cert['cert'])))
notBefore = datetime.utcfromtimestamp(d.getNotBefore() / 1000)
notAfter = datetime.utcfromtimestamp(d.getNotAfter() / 1000)
cert['from'] = notBefore
cert['to'] = notAfter
now = datetime.now()
cert['isValid'] = (notBefore <= now and now <= notAfter)
cert['info'] = d
return render_template('cert-show.html',
cert=cert, title=cert['name'])
def get_candidates():
commandInterestName = ndn.Name()
commandInterestName.wireDecode(
# ndn.Blob(buffer(base64.b64decode(request.form['commandInterest']))))
ndn.Blob(base64.b64decode(request.form['commandInterest'])))
site_prefix = ndn.Name()
site_prefix.wireDecode(commandInterestName[-1].getValue().toBuffer())
timestamp = commandInterestName[-2]
# TODO: haitao remove this hack after test
#signature = ndn.WireFormat.getDefaultWireFormat().decodeSignatureInfoAndValue(commandInterestName[-2].getValue().toBuffer(),
# commandInterestName[-1].getValue().toBuffer())
#keyLocator = signature.getKeyLocator().getKeyName()
#operator = mongo.db.operators.find_one({'site_prefix': site_prefix.toUri()})
operator = {
'_id': 1,
'site_name': 'UCLA',
'email': '*****@*****.**',
'doNotSendOpRequests': False,
'name': 'haitao'
}
if operator == None:
abort(403)
# @todo Command Interest verificateion
requests = mongo.db.requests.find({'operator_id': str(operator['_id'])})
output = []
for req in requests:
output.append(req)
# return json.dumps (output)
return json.dumps(output, default=json_util.default)
def test_ndn_sign(self):
data = pyndn.Data()
data.setName(pyndn.Name("/foo/bar"))
data.setContent("Hello, world!")
self.signer.sign(data, [b'Monday', b'Tuesday'])
self.assertEqual(data.getSignature().getTypeCode(), 42)
self.assertEqual(data.getSignature().getKeyLocator().getKeyName().toUri(),
pyndn.Name("/test/authority/ABS/%FD%5C%CC%C8%C3/Monday%26Tuesday").toUri())
def request(self,req,callback,content= None, mustbefresh= False):
baseName = ndn.Name(req)
interest = ndn.Interest(ndn.Name(baseName))
interest.setMustBeFresh(mustbefresh)
self.callback = callback
if content != None:
interest.setContent(content)
self.face.expressInterest(interest, self._onData, self._onTimeout)
self.loop.run_forever()
def route(self, uri, methods):
prefix = uri
if bool(re.search('<(.*)>', prefix)):
self.baseName = ndn.Name(
re.sub('<(.*)>', methods[0] + '/<data>', prefix))
else:
self.baseName = ndn.Name(prefix + "/" + methods[0])
self.methods[self.baseName.toUri()] = methods[0]
return self.dec
def __init__(self, context):
self.context = context
self.context.face.registerPrefix(
pyndn.Name(self.context.broadcast_name).append('join'),
self.on_join_interest, utils.on_registration_failed,
utils.on_registration_success)
self.context.face.registerPrefix(
pyndn.Name(self.context.broadcast_name).append('leave'),
self.on_leave_interest, utils.on_registration_failed,
utils.on_registration_success)
def start(ctx):
global context
context = ctx
context.face.registerPrefix(pyndn.Name(context.local_name), None,
utils.on_registration_failed,
utils.on_registration_success)
context.face.registerPrefix(pyndn.Name(context.broadcast_name), None,
utils.on_registration_failed,
utils.on_registration_success)
set_interest_filter()
def upcall(self, kind, upcallInfo):
if kind == pyndn.UPCALL_FINAL:#handler is about to be deregistered
log.info("handler is about to be deregistered")
if self.mydata.final_block_id == None:
self.handle.setRunTimeout(DEFAULT_RUN_TIMEOUT*10)
return pyndn.RESULT_OK
if kind == pyndn.UPCALL_INTEREST_TIMED_OUT:
self.do_meet_accident(kind, upcallInfo)
return pyndn.RESULT_OK
if kind in [pyndn.UPCALL_CONTENT_UNVERIFIED, pyndn.UPCALL_CONTENT_BAD]:
self.do_meet_accident(kind, upcallInfo)
return pyndn.RESULT_OK
if kind in [pyndn.UPCALL_INTEREST, pyndn.UPCALL_CONSUMED_INTEREST]:
log.warn("unexpected kind: %s" %kind)
assert kind == pyndn.UPCALL_CONTENT, "kind: "+str(kind)
if self.interest_schema == "exclusion":
matched_comps = upcallInfo.matchedComps
response_name = upcallInfo.ContentObject.name
org_prefix = response_name[:matched_comps]
assert org_prefix == self.name, "org_prefix: "+ str(org_prefix)+" , self.name: "+str(self.name)
if matched_comps == len(response_name):
comp = pyndn.Name([upcallInfo.ContentObject.digest()])
disp_name = pyndn.Name(response_name)
else:
comp = response_name[matched_comps:matched_comps + 1]
disp_name = response_name[:matched_comps + 1]
log.info("disp_name: %s, comp: %s" %(disp_name, comp))
self.exclusions.add_name(comp)
self.do_receive_content(kind, upcallInfo)
#if matched_comps + 1 < len(response_name):
# new = Consumer(response_name[:matched_comps+1])
# new.express_interest()
return pyndn.RESULT_OK
def sign(self, data, attributes, selfSign=False):
if not isinstance(data, pyndn.Data):
raise RuntimeError("ndnabs.Signer can only sign data packets")
signatureInfo = Sha256WithAbsSignature()
locator = pyndn.Name()
if selfSign:
locator.append(data.getName())
else:
if not isinstance(self.publicParams, pyndn.Data):
raise RuntimeError(
"Public parameters must be installed before signing")
locator.append(self.publicParams.getName())
locator.append(b'&'.join(attributes))
keyLocator = pyndn.KeyLocator()
keyLocator.setType(pyndn.KeyLocatorType.KEYNAME)
keyLocator.setKeyName(locator)
data.setSignature(signatureInfo)
data.getSignature().setKeyLocator(keyLocator)
data.getSignature().wireEncode()
toSign = data.wireEncode()
signatureBytes = self._sign(toSign.toSignedBytes(), attributes)
data.getSignature().setSignature(signatureBytes)
data.wireEncode()
def send_enter_chunk_interest(entity):
uid = entity.uid
chunk_x, chunk_y = int(entity.x // 15), int(entity.y // 15)
chunk_uid = entities.MapChunk.gen_uid(mngt.context.game_id, chunk_x,
chunk_y)
chunk_peer = mngt.context.peer_store.get_closest_peer(chunk_uid)
if chunk_peer.uid == mngt.context.peer_id:
# NOTE: Workaround to send update after coordinator transfert
# TODO: Maybe need to be more robust
mngt.load_chunk(chunk_x,
chunk_y,
callback=functools.partial(
mngt.emit_enter_chunk_update, chunk_x, chunk_y,
entity))
return
name = pyndn.Name(chunk_peer.prefix) \
.append('chunk') \
.append(str(chunk_x)) \
.append(str(chunk_y)) \
.append('enter') \
.append(str(uid))
logger.debug(
'Sending EnterChunkInterest for entity %d '
'and chunk %d (%d, %d), %s', uid, chunk_uid, chunk_x, chunk_y, entity)
mngt.context.face.expressInterest(name, utils.on_dummy_data)
def send_chunk_update_interest(chunk_x, chunk_y, uid, interest=None):
# Chunk not watched anymore, stop here
if (chunk_x, chunk_y) not in mngt.watched_chunks:
return
# Neep to check peer actively to be aware of coordinator changes
# TODO: See if possible to use leave event to be more lazy
peer = mngt.context.peer_store.get_closest_peer(uid)
# No need to subscribe for updates if the local peer is coordinator
if peer.uid == mngt.context.peer_id:
# mngt.watched_chunks.remove((chunk_x, chunk_y))
return
name = pyndn.Name(peer.prefix) \
.append('chunk') \
.append(str(chunk_x)) \
.append(str(chunk_y)) \
.append('updates')
if (chunk_x, chunk_y) in mngt.player_watch:
name.append('touch')
logger.debug('Sending ChunkUpdateInterest for chunk %d (%d, %d) to %d',
uid, chunk_x, chunk_y, peer.uid)
mngt.context.face.expressInterest(
name, mngt.on_chunk_update_data,
functools.partial(mngt.send_chunk_update_interest, chunk_x, chunk_y,
uid))
def build_interest(self, latest):
if self.start_with_latest:
latest = True
self.start_with_latest = False
excl = pyndn.ExclusionFilter()
excl.add_any()
excl.add_name(pyndn.Name([self.latest_version]))
# expected result should be between those two names
excl.add_name(pyndn.Name([self.last_version_marker]))
excl.add_any()
interest = pyndn.Interest(name=self.base_name, exclude=excl, \
minSuffixComponents=3, maxSuffixComponents=3)
interest.childSelector = 1 if latest else 0
return interest
def __init__(self, face, prefix, interval):
self.face = face
self.prefix = ndn.Name(prefix)
self.interval = interval
self.lastTime = 0
self.nSent = 0
self.nRecv = 0
def __init__(self, host, game_id, pseudo, peer_id, graphics=True):
global context
context = self
self.game_id = game_id
self.pseudo = pseudo
self.peer_id = peer_id
self.graphics = graphics
self.keychain = pyndn.security.KeyChain()
self.face = pyndn.Face(host)
self.face.setCommandSigningInfo(
self.keychain, self.keychain.getDefaultCertificateName())
self.broadcast_name = pyndn.Name(utils.broadcast_name_uri) \
.append(str(self.game_id))
self.peers_mngt = peers.PeerManagement(self)
# self.entities_mngt = entities.EntityManagement(self)
self.peer_store = peers.PeerStore()
self.object_store = entities.ObjectStore(self)
self.clock = pygame.time.Clock()
self.game = game.Game(self)
self.prefix_discovered = False
self.send_prefix_discovery_interest()
while not self.prefix_discovered:
self.face.processEvents()
time.sleep(0.01)
def __init__(self, face, filename):
self.face = face
self.baseName = ndn.Name("/my-local-prefix/simple-fetch/file").append(
filename)
self.currentSeqNo = 0
self._requestNext()
def __init__(self, prefix, handle):
self.prefix = pyndn.Name(prefix)
self.handle = handle
self.content_objects = []
self.cleanup_time = 15 * 60 # keep responses for 15 min
handle.setInterestFilter(self.prefix, self)
def get_operator_for_email(email):
# very basic pre-validation
user, domain = email.split('@', 2)
operator = mongo.db.operators.find_one({'site_emails': {'$in': [domain]}})
if (operator == None):
operator = mongo.db.operators.find_one(
{'site_emails': {
'$in': ['guest']
}})
# TODO: haitao remove this hack after testing
operator = {
'_id': 1,
'site_name': 'UCLA',
'email': '*****@*****.**',
'doNotSendOpRequests': False,
'name': 'haitao'
}
if (operator == None):
raise Exception("Unknown site for domain [%s]" % domain)
# Special handling for guests
ndn_domain = ndn.Name("/ndn/guest")
assigned_namespace = ndn.Name('/ndn/guest')
assigned_namespace.append(str(email))
else:
if domain == "operators.named-data.net":
ndn_domain = ndn.Name(str(user))
assigned_namespace = ndn.Name(str(user))
else:
ndn_domain = ndnify(domain)
assigned_namespace = ndn.Name('/ndn')
assigned_namespace \
.append(ndn_domain) \
.append(str(user))
# return various things
return {
'operator': operator,
'user': user,
'domain': domain,
'requestDetails': True,
'ndn_domain': ndn_domain,
'assigned_namespace': assigned_namespace
}
def sendInterest(self):
self.lastTime = time.time()
name = ndn.Name(self.prefix)
name.appendTimestamp(int(self.lastTime * 1000))
self.lastName = name
print('<I %s' % (name, ))
self.face.expressInterest(name, self.processData)
self.nSent += 1
def test_setup(self):
fd, tmpDbPath = tempfile.mkstemp()
os.close(fd)
os.remove(tmpDbPath)
print(tmpDbPath)
db = ndnabs.PickleDb(tmpDbPath)
self.aa = ndnabs.AttributeAuthority(db)
self.aa.setup(pyndn.Name("/test/name"))
def send_join_interest(self):
join_name = pyndn.Name(self.context.broadcast_name) \
.append('join') \
.append(self.context.local_name)
self.context.face.expressInterest(join_name,
self.on_peer_info_list_data,
self.on_peer_info_list_timeout)
def send_find_coordinator_interest(uid):
name = pyndn.Name(mngt.context.broadcast_name) \
.append('coordinator') \
.append(str(uid)) \
.append(str(mngt.context.peer_id))
logger.debug('Sending FindCoordinatorInterest to %s', name.toUri())
mngt.context.face.expressInterest(name, mngt.on_find_coordinator_data,
mngt.on_find_coordinator_timeout)
def send_find_entity_interest(uid):
logger.debug('Sending FindEntityInterest for entity %d', uid)
name = pyndn.Name(mngt.context.broadcast_name) \
.append('entity') \
.append(str(uid)) \
.append(str(mngt.context.peer_id))
mngt.context.face.expressInterest(name, utils.on_dummy_data,
mngt.on_find_entity_timeout)
def requestSegment(self, segmentNumber):
# if self.pendingSegmentCount < self.pendingSegmentMax:
self.pendingSegments.add(segmentNumber)
segmentName = pyndn.Name(self.redirect.getName())
segmentName.appendSegment(segmentNumber)
interest = pyndn.Interest(segmentName)
print("Sent segment interest '{}'".format(interestToString(interest)))
self.face.expressInterest(interest, self.receiveSegment, self.timeoutSegment)
def upcall(self, kind, upcallInfo):
if kind == pyndn.UPCALL_FINAL:
# any cleanup code here (so far I never had need for
# this call type)
return pyndn.RESULT_OK
if kind == pyndn.UPCALL_INTEREST_TIMED_OUT:
print("Got timeout!")
return pyndn.RESULT_OK
# make sure we're getting sane responses
if not kind in [
pyndn.UPCALL_CONTENT, pyndn.UPCALL_CONTENT_UNVERIFIED,
pyndn.UPCALL_CONTENT_BAD
]:
print("Received invalid kind type: %d" % kind)
sys.exit(100)
matched_comps = upcallInfo.matchedComps
response_name = upcallInfo.ContentObject.name
org_prefix = response_name[:matched_comps]
assert (org_prefix == self.root)
if matched_comps == len(response_name):
comp = pyndn.Name([upcallInfo.ContentObject.digest()])
disp_name = pyndn.Name(response_name)
else:
comp = response_name[matched_comps:matched_comps + 1]
disp_name = response_name[:matched_comps + 1]
if kind == pyndn.UPCALL_CONTENT_BAD:
print("*** VERIFICATION FAILURE *** %s" % response_name)
print("%s [%s]" % (disp_name, \
"verified" if kind == pyndn.UPCALL_CONTENT else "unverified"))
self.exclusions.add_name(comp)
self.express_my_interest()
# explore next level
if matched_comps + 1 < len(response_name):
new = Slurp(response_name[:matched_comps + 1], self.handle)
new.express_my_interest()
return pyndn.RESULT_OK
def get_candidates():
commandInterestName = ndn.Name()
commandInterestName.wireDecode(
# ndn.Blob(buffer(base64.b64decode(request.form['commandInterest']))))
ndn.Blob(base64.b64decode(request.form['commandInterest'])))
site_prefix = ndn.Name()
site_prefix.wireDecode(commandInterestName[-3].getValue().toBuffer())
timestamp = commandInterestName[-4]
signature = ndn.WireFormat.getDefaultWireFormat(
).decodeSignatureInfoAndValue(
commandInterestName[-2].getValue().toBuffer(),
commandInterestName[-1].getValue().toBuffer())
keyLocator = signature.getKeyLocator().getKeyName()
operator = mongo.db.operators.find_one(
{'site_prefix': site_prefix.toUri()})
if operator == None:
abort(403)
try:
keyChain = KeyChain(
policyManager=OperatorVerifyPolicyManager(operator))
def onVerified(interest):
pass
def onVerifyFailed(interest):
raise RuntimeError("Operator verification failed")
keyChain.verifyInterest(ndn.Interest(commandInterestName),
onVerified,
onVerifyFailed,
stepCount=1)
except Exception as e:
print("ERROR: %s" % e)
abort(403)
# Will get here if verification succeeds
requests = mongo.db.requests.find({'operator_id': str(operator['_id'])})
output = []
for req in requests:
output.append(req)
return json.dumps(output, default=json_util.default)
def send_entity_update_interest(uid, version=None, interest=None):
entity = mngt.context.object_store.get(uid)
pending_info = mngt.pending_update_interest.setdefault(
entity.uid, [0, entity.version])
if version is None:
version = pending_info[1]
# Called after timeout
if interest is not None:
pending_info[0] -= 1
peer = mngt.context.peer_store.get_closest_peer(uid)
chunk_coord = (entity.x // 15, entity.y // 15)
# No need to subscribe for updates if the local peer is coordinator
if peer.uid == mngt.context.peer_id:
# TODO: active check when coordinator leave the game
# (prevent entity freeze)
mngt.context.object_store.set_local_coordinator(entity.uid, True)
logger.debug(
'Skipping send EntityUpdateInterest for entity %s: '
'entity coordinated by local peer', uid)
return
# Entity not watch anymore
if chunk_coord not in mngt.watched_chunks:
logger.debug(
'Skipping send EntityUpdateInterest for entity %s: '
'chunk not watched, chunk=(%d, %d) watched_chunks=%s', uid,
entity.x // 15, entity.y // 15, mngt.watched_chunks)
entity.active = False
return
entity.active = True
name = pyndn.Name(peer.prefix) \
.append('entity') \
.append(str(uid)) \
.append('updates') \
.append(str(version))
if chunk_coord in mngt.player_watch:
name.append('touch')
logger.trace('Sending EntityUpdateInterest for entity %d to %d, %s', uid,
peer.uid, name)
mngt.context.face.expressInterest(
name, mngt.on_entity_update_data,
functools.partial(mngt.send_entity_update_interest, uid, version))
pending_info[0] += 1
pending_info[1] = max(pending_info[1], version + 1)
if pending_info[0] <= const.MAX_PENDING_UPDATE_INTEREST:
mngt.send_entity_update_interest(uid)
def send_entity_found_interest(peer, entity):
logger.debug('Sending EntityFoundInterest for entity %d to peer %d',
entity.uid, peer.uid)
name = pyndn.Name(peer.prefix) \
.append('entity_found') \
.append(str(entity.uid)) \
.append(str(mngt.context.peer_id)) \
.append(str(getattr(entity, 'timestamp', 0)))
mngt.context.face.expressInterest(name, utils.on_dummy_data)
def registerPrefixes(self, prefixes):
self.rem = len(prefixes)
for prefix in prefixes:
self.face.registerPrefix(ndn.Name(prefix), None,
self.onRegisterFailed,
self.onRegisterSuccess)
while self.rem > 0:
self.face.processEvents()
time.sleep(0.1)
return self.rem == 0
def extract_cert_name(name):
# remove two (or 3 in case of rejection) last components and remove "KEY" keyword at any position
newname = ndn.Name()
last = -2
if name[-1] == 'REVOKED':
last = -3
for component in name[:last]:
if str(component) != 'KEY':
newname.append(component)
return newname
