def lisp_ms_show_site_detail_command(eid_key, group_key): eid = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0) if (eid_key): if (eid_key == "[0]/0"): eid.store_iid_range(0, 0) else: eid.store_prefix(eid_key) #endif #endif group = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0) if (group_key): group.store_prefix(group_key) eid_str = lisp.lisp_print_eid_tuple(eid, group) eid_str = lisp.lisp_print_cour(eid_str) # # Do longest match lookup. We do this so prefix slashes are not in URLs. # site_eid = lisp.lisp_site_eid_lookup(eid, group, True) if (site_eid == None): output = "Could not find EID {} in site cache".format(eid_str) return (output) #endif indent4 = lisp.space(4) indent8 = lisp.space(8) indent12 = lisp.space(12) yesno = lisp.green("yes", True) if site_eid.registered else \ lisp.red("no", True) output = '<font face="Sans-Serif">' sn = lisp.lisp_print_cour(site_eid.site.site_name) si = lisp.lisp_print_cour(str(site_eid.site_id)) xi = "0" if site_eid.xtr_id == 0 else lisp.lisp_hex_string(site_eid.xtr_id) xi = lisp.lisp_print_cour("0x" + xi) fr = lisp.lisp_print_elapsed(site_eid.first_registered) lr = lisp.lisp_print_elapsed(site_eid.last_registered) if (time.time() - site_eid.last_registered >= (site_eid.register_ttl / 2) and lr != "never"): lr = lisp.red(lr, True) #endif if (site_eid.last_registerer.afi == lisp.LISP_AFI_NONE): reger = "none" else: reger = site_eid.last_registerer.print_address() #endif reger = lisp.lisp_print_cour(reger) shutdown = ", " + lisp.lisp_print_cour("site is in admin-shutdown") if \ site_eid.site.shutdown else "" ams = ", accepting more specifics" if site_eid.accept_more_specifics \ else "" if (ams == "" and site_eid.dynamic): ams = ", dynamic" output += '''Site name: {}, EID-prefix: {}, registered: {}{}{} <br>'''.format(sn, eid_str, yesno, ams, shutdown) output += "{}Description: {}<br>".format( indent4, lisp.lisp_print_cour(site_eid.site.description)) output += "{}Last registerer: {}, xTR-ID: {}, site-ID: {}<br>".format( \ indent4, reger, xi, si) flags = site_eid.print_flags(False) flags = lisp.lisp_print_cour(flags) auth_type = "none" if (site_eid.registered): auth_type = "sha1" if (site_eid.auth_sha1_or_sha2) else "sha2" #endif output += ("{}First registered: {}, last registered: {}, auth-type: " + \ "{}, registration flags: {}<br>").format(indent4, lisp.lisp_print_cour(fr), lisp.lisp_print_cour(lr), lisp.lisp_print_cour(auth_type), flags) ttl = lisp.lisp_print_cour(str(site_eid.register_ttl) + " seconds") output += "{}{} registration timeout TTL: {}<br>".format( \ indent4, "Registered" if site_eid.use_register_ttl_requested else \ "Default", ttl) # # First print a policy line, if one is configured for this site-eid. # if (site_eid.policy): p = lisp.lisp_print_cour(site_eid.policy) output += "{}Apply policy: '{}'<br>".format(indent4, p) #endif # # Show proxy-reply settings. # yesno = "yes" if site_eid.force_proxy_reply else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Forcing proxy Map-Reply: {}<br>".format(indent4, yesno) if (site_eid.force_ttl != None): ttl = lisp.lisp_print_cour(str(site_eid.force_ttl) + " seconds") output += "{}Forced proxy Map-Reply TTL: {}<br>".format( \ indent4, ttl) #endif yesno = "yes" if site_eid.force_nat_proxy_reply else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Forcing proxy Map-Reply for xTRs behind NATs: {}<br>". \ format(indent4, yesno) yesno = "yes" if site_eid.pitr_proxy_reply_drop else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Send drop-action proxy Map-Reply to PITR: {}<br>".format( \ indent4, yesno) action = "not configured" if site_eid.proxy_reply_action == "" else \ site_eid.proxy_reply_action action = lisp.lisp_print_cour(action) output += "{}Proxy Map-Reply action: {}<br>".format(indent4, action) if (site_eid.force_proxy_reply and site_eid.echo_nonce_capable): yes = lisp.lisp_print_cour("yes") output += "{}RLOCs are echo-nonce capable: {}<br>".format(indent4, yes) #endif yesno = "yes" if site_eid.require_signature else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Require signatures: {}<br>".format(indent4, yesno) # # Print configured allowed RLOC-sets, if any. # any_rloc = "any" if len(site_eid.site.allowed_rlocs) == 0 else "" if (any_rloc != ""): any_rloc = lisp.lisp_print_cour(any_rloc) output += "{}Allowed RLOC-set: {}<br>".format(indent4, any_rloc) if (any_rloc == ""): for rloc in site_eid.site.allowed_rlocs.values(): a = lisp.lisp_print_cour(rloc.rloc.print_address()) s = lisp.lisp_print_cour(rloc.print_state()) up = lisp.lisp_print_cour(str(rloc.priority)) uw = lisp.lisp_print_cour(str(rloc.weight)) mp = lisp.lisp_print_cour(str(rloc.mpriority)) mw = lisp.lisp_print_cour(str(rloc.mweight)) rn = rloc.print_rloc_name(True) if (rn != ""): rn = ", " + rn output += '''{}{}, state: {}, up/uw/mp/mw: {}/{}/{}/{}{}<br>'''. \ format(indent8, a, s, up, uw, mp, mw, rn) #endfor #endif none = "none" if len(site_eid.registered_rlocs) == 0 else "" if (none != ""): none = lisp.lisp_print_cour(none) output += "<br>Registered RLOC-set ({}): {}<br>".format("merge-semantics" \ if (site_eid.merge_register_requested) else "replacement-semantics", none) if (none == ""): for rloc in site_eid.registered_rlocs: a = lisp.lisp_print_cour(rloc.rloc.print_address()) s = lisp.lisp_print_cour(rloc.print_state()) up = lisp.lisp_print_cour(str(rloc.priority)) uw = lisp.lisp_print_cour(str(rloc.weight)) mp = lisp.lisp_print_cour(str(rloc.mpriority)) mw = lisp.lisp_print_cour(str(rloc.mweight)) rn = rloc.print_rloc_name(True) if (rn != ""): rn = ", " + rn output += '''{}{}, state: {}, up/uw/mp/mw: {}/{}/{}/{}{}<br>'''.\ format(indent4, a, s, up, uw, mp, mw, rn) if (rloc.geo): geo = lisp.lisp_print_cour(rloc.geo.print_geo_url()) output += "{}geo: {}<br>".format(indent12, geo) #endif if (rloc.elp): elp = lisp.lisp_print_cour(rloc.elp.print_elp(False)) output += "{}elp: {}<br>".format(indent12, elp) #endif if (rloc.rle): rle = lisp.lisp_print_cour(rloc.rle.print_rle(True)) output += "{}rle: {}<br>".format(indent12, rle) #endif if (rloc.json): json = lisp.lisp_print_cour(rloc.json.print_json(True)) output += "{}json: {}<br>".format(indent12, json) #endif #endfor #endif none = "none" if len(site_eid.individual_registrations) == 0 else "" if (none == "none"): none = lisp.lisp_print_cour(none) elif (site_eid.inconsistent_registration): none = lisp.red("inconsistent registrations", True) none = lisp.lisp_print_cour(none) #endif output += "<br>Individual registrations: {}<br>".format(none) for site_eid in site_eid.individual_registrations.values(): yesno = lisp.green("yes", True) if site_eid.registered else \ lisp.red("no", True) auth_type = "sha1" if (site_eid.auth_sha1_or_sha2) else "sha2" auth_type = lisp.lisp_print_cour(auth_type) flags = site_eid.print_flags(False) flags = lisp.lisp_print_cour(flags) a = lisp.lisp_print_cour(site_eid.last_registerer.print_address()) fr = lisp.lisp_print_elapsed(site_eid.first_registered) fr = lisp.lisp_print_cour(fr) lr = lisp.lisp_print_elapsed(site_eid.last_registered) if (time.time() - site_eid.last_registered >= (site_eid.register_ttl / 2) and lr != "never"): lr = lisp.red(lr, True) #endif lr = lisp.lisp_print_cour(lr) si = lisp.lisp_print_cour(str(site_eid.site_id)) xi = lisp.lisp_print_cour(lisp.lisp_hex_string(site_eid.xtr_id)) output += ''' {}Registerer: {}, xTR-ID: 0x{}, site-id: {}, registered: {}<br> {}First registered: {}, last registered: {}, auth-type: {}, registration flags: {}<br> '''.format(indent4, a, xi, si, yesno, indent4, fr, lr, auth_type, flags) none = "none" if len(site_eid.registered_rlocs) == 0 else "" none = lisp.lisp_print_cour(none) output += "{}Registered RLOC-set: {}<br>".format(indent4, none) for rloc in site_eid.registered_rlocs: a = lisp.lisp_print_cour(rloc.rloc.print_address()) s = lisp.lisp_print_cour(rloc.print_state()) up = lisp.lisp_print_cour(str(rloc.priority)) uw = lisp.lisp_print_cour(str(rloc.weight)) mp = lisp.lisp_print_cour(str(rloc.mpriority)) mw = lisp.lisp_print_cour(str(rloc.mweight)) rn = rloc.print_rloc_name(True) if (rn != ""): rn = ", " + rn output += '''{}{}, state: {}, up/uw/mp/mw: {}/{}/{}/{}{}<br>'''.\ format(indent8, a, s, up, uw, mp, mw, rn) if (rloc.geo): geo = lisp.lisp_print_cour(rloc.geo.print_geo_url()) output += "{}geo: {}<br>".format(indent12, geo) #endif if (rloc.elp): elp = lisp.lisp_print_cour(rloc.elp.print_elp(False)) output += "{}elp: {}<br>".format(indent12, elp) #endif if (rloc.rle): rle = lisp.lisp_print_cour(rloc.rle.print_rle(True)) output += "{}rle: {}<br>".format(indent12, rle) #endif if (rloc.json): json = lisp.lisp_print_cour(rloc.json.print_json(True)) output += "{}json: {}<br>".format(indent12, json) #endif #endfor output += "<br>" #endif output += "</font>" return (output)
def lisp_ms_show_site_lookup(input_str): eid, eid_exact, group, group_exact = \ lispconfig.lisp_get_lookup_string(input_str) output = "<br>" # # Do lookup in site-cache first. # site_eid = lisp.lisp_site_eid_lookup(eid, group, eid_exact) if (site_eid and site_eid.is_star_g() == False): eid_str = site_eid.print_eid_tuple() registered = lisp.green("registered", True) if site_eid.registered \ else lisp.red("not registered", True) output += "{} '{}' {} {} {} {} {} {}".format( \ lisp.lisp_print_sans("Site"), lisp.lisp_print_cour(site_eid.site.site_name), lisp.lisp_print_sans("entry"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("site EID is"), lisp.lisp_print_cour(registered)) return (output + "<br>") #endif # # Compute negative prefixes. # neg_prefix, gneg_prefix, action = \ lisp.lisp_ms_compute_neg_prefix(eid, group) if (group.is_null()): neg_prefix = lisp.lisp_print_cour(neg_prefix.print_prefix()) else: gneg_prefix = lisp.lisp_print_cour(gneg_prefix.print_prefix()) neg_prefix = lisp.lisp_print_cour(neg_prefix.print_prefix()) neg_prefix = "(" + neg_prefix + ", " + gneg_prefix + ")" #endif if (action == lisp.LISP_DDT_ACTION_NOT_AUTH): banner = "Site entry not found for non-authoritative EID" output += "{} {} {} {}".format( lisp.lisp_print_sans(banner), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) #endif # # Try to find a auth-prefix in the DDT-cache. # if (action == lisp.LISP_DDT_ACTION_DELEGATION_HOLE): ddt_entry = lisp.lisp_ddt_cache_lookup(eid, group, False) if (ddt_entry == None or ddt_entry.is_auth_prefix() == False): banner = "Could not find Authoritative-prefix entry for" output += "{} {} {} {}".format( lisp.lisp_print_sans(banner), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) else: eid_str = ddt_entry.print_eid_tuple() output += "{} {} {} {} {} {}".format( \ lisp.lisp_print_sans("Authoritative-prefix entry"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) #endif #endif return (output + "<br>")
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