def ooo00Ooo(referral, delete_list):
if 93 - 93: i11iIiiIii - I1IiiI * I1ii11iIi11i * I11i % O0 + OoooooooOO
if (referral.expires == 0): return ([True, delete_list])
if 25 - 25: IiII + Ii1I / ooOoO0o.o0oOOo0O0Ooo % O0 * OoO0O00
o0O0oo0OO0O = lisp.lisp_get_timestamp()
if (referral.uptime + referral.referral_ttl > o0O0oo0OO0O):
return ([True, delete_list])
if 68 - 68: oO0o.I11i % OoooooooOO.I11i
if 64 - 64: iIii1I11I1II1 / I1IiiI.II111iiii + OoooooooOO.OoO0O00
if 56 - 56: Oo0Ooo.I1ii11iIi11i.I1IiiI
if 39 - 39: O0 + I1Ii111
if 91 - 91:
OoooooooOO - iIii1I11I1II1 + OoOoOO00 / OoO0O00.OoOoOO00 + O0
iIiii1iI1 = lisp.lisp_print_elapsed(referral.uptime)
i11ii1ii11i = referral.print_eid_tuple()
lisp.lprint(
"Referral for EID-prefix {} has timed out, had uptime of {}".format(
lisp.green(i11ii1ii11i, False), iIiii1iI1))
if 70 - 70: i1IIi - iII111i + Oo0Ooo
if 12 - 12: o0oOOo0O0Ooo - I1ii11iIi11i % OoOoOO00 * I11i
if 44 - 44: iII111i % Ii1I
if 41 - 41: i1IIi - I11i - Ii1I
if 8 - 8: OoO0O00 + I1Ii111 - o0oOOo0O0Ooo % Oo0Ooo % o0oOOo0O0Ooo * oO0o
delete_list.append(referral)
return ([True, delete_list])
if 9 - 9: Oo0Ooo - i11iIiiIii - OOooOOo * Ii1I + ooOoO0o
if 44 - 44: II111iiii
if 52 - 52: I1ii11iIi11i - Oo0Ooo + I1ii11iIi11i % o0oOOo0O0Ooo
if 35 - 35: iIii1I11I1II1
if 42 - 42: I1Ii111.I1IiiI.i1IIi + OoOoOO00 + OOooOOo + I1IiiI
if 31 - 31: iII111i.OOooOOo - ooOoO0o.OoooooooOO / OoooooooOO
if 56 - 56: OoO0O00 / oO0o / i11iIiiIii + OoooooooOO - Oo0Ooo - I11i
if 21 - 21: O0 % IiII.I1IiiI / II111iiii + IiII
def lisp_timeout_site_eid(site_eid, delete_list):
now = lisp.lisp_get_timestamp()
if (site_eid.registered == False): return (delete_list)
if (site_eid.last_registered + site_eid.register_ttl > now):
return (delete_list)
#endif
#
# Timed out.
#
m_or_r = "merge" if site_eid.merge_register_requested else "replacement"
dynamic = "dynamic " if site_eid.dynamic else ""
site_eid.registered = False
lisp.lisp_registered_count -= 1
elapsed = lisp.lisp_print_elapsed(site_eid.first_registered)
prefix_str = site_eid.print_eid_tuple()
registerer = site_eid.last_registerer.print_address_no_iid()
lisp.lprint(("Registration timeout for {}EID-prefix {} site '{}' " + \
"from {}, was registered for {}, {}-semantics").format(dynamic,
lisp.green(prefix_str, False), site_eid.site.site_name, registerer,
elapsed, m_or_r))
if (delete_list == None): return (None)
#
# Remove entries from site-cache for dynamic entries. For individual
# registrations, we put on the delete-list just to tell the caller if
# anything change so we can recommpute the merged set..
#
delete_list.append(site_eid)
return (delete_list)
def OooooO0oOOOO(referral, delete_list):
if 100 - 100: iII111i % OOooOOo
if (referral.expires == 0): return ([True, delete_list])
if 86 - 86: Oo0Ooo.O0 - OoooooooOO.OoO0O00 + Ii1I
OOo = lisp.lisp_get_timestamp()
if (referral.uptime + referral.referral_ttl > OOo):
return ([True, delete_list])
if 22 - 22: OoOoOO00 * O0.IiII * i11iIiiIii - I1IiiI * ooOoO0o
if 59 - 59: Oo0Ooo % OoooooooOO.iII111i / IiII + I1IiiI
if 76 - 76: ooOoO0o
if 73 - 73: O0 * iII111i + Ii1I + ooOoO0o
if 40 - 40: II111iiii.OoOoOO00 * I1Ii111 + OOooOOo + OOooOOo
I1ii1I1iiii = lisp.lisp_print_elapsed(referral.uptime)
iiI = referral.print_eid_tuple()
lisp.lprint(
"Referral for EID-prefix {} has timed out, had uptime of {}".format(
lisp.green(iiI, False), I1ii1I1iiii))
if 56 - 56: Oo0Ooo.I1ii11iIi11i.I1IiiI
if 39 - 39: O0 + I1Ii111
if 91 - 91: OoooooooOO - iIii1I11I1II1 + OoOoOO00 / OoO0O00.OoOoOO00 + O0
if 26 - 26: I1ii11iIi11i - OoooooooOO
if 11 - 11: I1IiiI * oO0o
delete_list.append(referral)
return ([True, delete_list])
if 81 - 81: iII111i + IiII
if 98 - 98: I1IiiI
if 95 - 95: ooOoO0o / ooOoO0o
if 30 - 30: I1ii11iIi11i + Oo0Ooo / Oo0Ooo % I1ii11iIi11i.I1ii11iIi11i
if 55 - 55: ooOoO0o - I11i + II111iiii + iII111i % Ii1I
if 41 - 41: i1IIi - I11i - Ii1I
if 8 - 8: OoO0O00 + I1Ii111 - o0oOOo0O0Ooo % Oo0Ooo % o0oOOo0O0Ooo * oO0o
if 9 - 9: Oo0Ooo - i11iIiiIii - OOooOOo * Ii1I + ooOoO0o
def lisp_itr_process_nonce_ipc(ipc):
x, opcode, rloc_str, nonce = ipc.split("%")
nonce = int(nonce, 16)
echo_nonce = lisp.lisp_get_echo_nonce(None, rloc_str)
if (echo_nonce == None): echo_nonce = lisp.lisp_echo_nonce(rloc_str)
#
# If we are in request-nonce mode, exit it, so we can echo the nonce the
# other side is requesting.
#
if (opcode == "R"):
echo_nonce.request_nonce_rcvd = nonce
echo_nonce.last_request_nonce_rcvd = lisp.lisp_get_timestamp()
echo_nonce.echo_nonce_sent = nonce
echo_nonce.last_new_echo_nonce_sent = lisp.lisp_get_timestamp()
lisp.lprint("Start echo-nonce mode for {}, nonce 0x{}".format( \
lisp.red(echo_nonce.rloc_str, False), lisp.lisp_hex_string(nonce)))
#endif
if (opcode == "E"):
echo_nonce.echo_nonce_rcvd = nonce
echo_nonce.last_echo_nonce_rcvd = lisp.lisp_get_timestamp()
if (echo_nonce.request_nonce_sent == nonce):
en = lisp.bold("echoed nonce", False)
lisp.lprint("Received {} {} from {}".format(en,
lisp.lisp_hex_string(nonce),
lisp.red(echo_nonce.rloc_str, False)))
echo_nonce.request_nonce_sent = None
lisp.lprint("Stop request-nonce mode for {}".format( \
lisp.red(echo_nonce.rloc_str, False)))
echo_nonce.last_good_echo_nonce_rcvd = lisp.lisp_get_timestamp()
else:
rns = "none"
if (echo_nonce.request_nonce_sent):
rns = lisp.lisp_hex_string(echo_nonce.request_nonce_sent)
#endif
lisp.lprint(("Received echo-nonce 0x{} from {}, but request-" + \
"nonce is {}").format(lisp.lisp_hex_string(nonce),
lisp.red(echo_nonce.rloc_str, False), rns))
#endif
#endif
return
def lisp_itr_timeout_dynamic_eids(lisp_socket):
lisp.lisp_set_exception()
now = lisp.lisp_get_timestamp()
for db in lisp.lisp_db_list:
if (db.dynamic_eid_configured() == False): continue
delete_list = []
for dyn_eid in db.dynamic_eids.values():
ts = dyn_eid.last_packet
if (ts == None): continue
if (ts + dyn_eid.timeout > now): continue
#
# Check hardware if dyn-EID has had packets SENT to. We want the
# opposite but this is all we get from Arista.
#
if (lisp.lisp_program_hardware):
prefix = dyn_eid.dynamic_eid.print_prefix_no_iid()
if (lisp.lisp_arista_is_alive(prefix)):
lisp.lprint(("Hardware indicates dynamic-EID {} " + \
"still active").format(lisp.green(prefix, False)))
continue
#endif
#endif
#
# Tell ETR process so it can register dynamic-EID.
#
eid_str = dyn_eid.dynamic_eid.print_address()
ipc = "learn%{}%None".format(eid_str)
ipc = lisp.lisp_command_ipc(ipc, "lisp-itr")
lisp.lisp_ipc(ipc, lisp_socket, "lisp-etr")
lisp.lprint("Dynamic-EID {}".format( \
lisp.bold(lisp.green(eid_str, False) + " activity timeout",
False)))
delete_list.append(eid_str)
#endfor
#
# Remove the timed out entries from db.dynamic_eids{}.
#
for eid_str in delete_list:
db.dynamic_eids.pop(eid_str)
#endfor
#
# Restart periodic timer.
#
threading.Timer(lisp.LISP_DEFAULT_DYN_EID_TIMEOUT,
lisp_itr_timeout_dynamic_eids, [lisp_socket]).start()
return
def lisp_timeout_pubsub():
lisp.lisp_set_exception()
#
# Return quickly if inject mode is not enabled.
#
lisp_ms_scale_inject()
now = lisp.lisp_get_timestamp()
delete_list = []
for e in lisp.lisp_pubsub_cache:
for pubsub in lisp.lisp_pubsub_cache[e].values():
ttl = pubsub.ttl * 60
if (pubsub.uptime + ttl > now): continue
delete_list.append([e, pubsub.xtr_id])
#endfor
#endfor
#
# Remove entries from delete queue.
#
for e, xtr_id in delete_list:
eid = lisp.green(e, False)
lisp.lprint("Pubsub state {} for xtr-id 0x{} has {}".format(
eid, lisp.lisp_hex_string(xtr_id), lisp.bold("timed out", False)))
#
# Remove entry from dictionary array. And explictly free memory.
#
entry = lisp.lisp_pubsub_cache[e][xtr_id]
lisp.lisp_pubsub_cache[e].pop(xtr_id)
del (entry)
#
# If not more subscriptions for this EID-prefix, remove EID-prefix
# from parent dictionary array.
#
if (len(lisp.lisp_pubsub_cache[e]) == 0):
lisp.lisp_pubsub_cache.pop(e)
#endif
#endfor
#
# Restart periodic timer.
#
lisp_pubsub_timer = threading.Timer( \
lisp.LISP_PUBSUB_TIMEOUT_CHECK_INTERVAL, lisp_timeout_pubsub, [])
lisp_pubsub_timer.start()
return
def lisp_timeout_referral_entry(referral, delete_list):
if (referral.expires == 0): return ([True, delete_list])
now = lisp.lisp_get_timestamp()
if (referral.uptime + referral.referral_ttl > now):
return ([True, delete_list])
#endif
#
# Timed out.
#
elapsed = lisp.lisp_print_elapsed(referral.uptime)
prefix_str = referral.print_eid_tuple()
lisp.lprint("Referral for EID-prefix {} has timed out, had uptime of {}". \
format(lisp.green(prefix_str, False), elapsed))
#
# Add to delete-list to remove after this loop.
#
delete_list.append(referral)
return ([True, delete_list])
def lisp_ms_scale_inject():
global lisp_inject_mode_count
#
# Only do it once or never.
#
if (lisp_inject_mode_count == 0): return
count = lisp_inject_mode_count
i = lisp.bold("Injecting", False)
lisp.fprint("{} {} entries into mapping system for scale testing". \
format(i, count))
#
# Create EID-record info.
#
iid = 1300
phone = 9990000000
eid = lisp.lisp_address(lisp.LISP_AFI_NAME, "ct", 0, iid)
group = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0)
parent_site = lisp.lisp_site_eid_lookup(eid, group, False)
if (parent_site == None):
lisp.fprint("No site found for instance-ID {}".format(iid))
return
#endif
if (parent_site.accept_more_specifics == False):
lisp.fprint("Site must be configured with accept-more-specifics")
return
#endif
#
# Create RLOC-record info.
#
rloc = lisp.lisp_rloc()
gps_record = ' "phone" : "{}", "text-interval" : "10", ' + \
'"gps" : "(37.623322,-122.384974579)" '
hs_record = ' "phone" : "{}", "health-state" : "not-tested" '
#
# Now loop.
#
ts = lisp.lisp_get_timestamp()
mem = 0
for i in range(1, count + 1):
site_eid = lisp.lisp_site_eid(parent_site.site)
site_eid.eid = copy.deepcopy(eid)
site_eid.eid.address = hmac.new("ct", str(phone),
hashlib.sha256).hexdigest()
site_eid.dynamic = True
site_eid.parent_for_more_specifics = parent_site
site_eid.add_cache()
site_eid.inherit_from_ams_parent()
parent_site.more_specific_registrations.append(site_eid)
#
# Add GPS and HS RLOC records for EID entry.
#
gr = copy.deepcopy(rloc)
json_string = "{" + gps_record.format(phone) + "}"
gr.json = lisp.lisp_json(site_eid.eid.address, json_string)
hr = copy.deepcopy(rloc)
json_string = "{" + hs_record.format(phone) + "}"
hr.json = lisp.lisp_json(site_eid.eid.address, json_string)
site_eid.registered_rlocs = [gr, hr]
mem += sys.getsizeof(site_eid)
#
# Print every 100 added.
#
if (i % 100 == 0):
lisp.fprint("Added {} site-eid entries".format(i))
#endif
#
# Pause after 10000.
#
if (i % 10000 == 0 and i != count):
lisp.fprint("Sleeping for 100ms ...")
time.sleep(.1)
#endif
phone += 1
#endfor
#
# Compute and print elapsed time.
#
ts = time.time() - ts
if (ts < 60):
lisp.fprint("Finished in {} secs, memory {}".format(round(ts, 3), mem))
else:
ts = ts / 60
lisp.fprint("Finished in {} mins, memory {}".format(round(ts, 1), mem))
#endif
lisp_inject_mode_count = 0
