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