def load_prefix_lists():
all_words = load_all_words()
prefix_lists = {}
for i in range(1, 8): # only need prefixes up to 7, right?
# ignore words that are the length of the prefix or less
long_enough_words = f.select(lambda d: len(d) > i, all_words)
# grab the first i letters
prefix_lists[i] = set(f.walk(lambda d: d[0:i], long_enough_words))
# this line is probably extraneous at this point, right?
# prefix_lists[i]= f.select(lambda d: len(d)==i, prefix_lists[i])
return prefix_lists
def get_bingfa(ip):
try:
child = telnet(ip)
rslt = do_some(child, 'show subscriber peak')
close(child)
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
rslt1 = [x for x in re.split(r'\r\n-+\r\n', rslt) if 'Slot:' in x]
rslt2 = [re_find(
r'Slot:(\d+).*Total\s+(\d+)\s+(\d{4}/\d{2}/\d{2})', x, flags=re.S) for x in rslt1]
rslt3 = select(bool, rslt2)
rslt3 = [(x[0], int(x[1]), x[2]) for x in rslt3]
return ('success', rslt3, ip)
def get_infs(ip):
def _get_info(record):
name = re_find(r'interface\s(x?gigabitethernet\S+)',
record, flags=re.I)
desc = re_find(r'description\s(\S+ *\S*)', record)
group = re_find(r'(eth-trunk\s\d+)', record)
return dict(name=name, desc=desc, group=group)
try:
child = telnet(ip)
rslt = do_some(child, 'disp cu interface')
close(child)
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
rslt1 = select(r'GigabitEthernet', rslt.split('#'))
rslt2 = map(_get_info, rslt1)
return ('success', rslt2, ip)
def get_vlans(ip):
def _vlan(record):
if re_test(r'(Ports:\snone.*Ports:\snone)', record, re.S):
return 0
vlan = re_find(r'VLAN\sID:\s(\d+)', record)
vlan = int(vlan or 0)
return vlan
try:
child = telnet(ip)
rslt = do_some(child, 'disp vlan all')
close(child)
rslt = re.split(r'\r\n *\r\n', rslt)
vlans = select(lambda x: x > 1,
lmap(_vlan, rslt))
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
return ('success', vlans, ip)
def get_ports(ip):
def _get_info(record):
name = re_find(r'(\S+) current state :', record)
state = re_find(r'current state : ?(\S+ ?\S+)', record)
desc = re_find(r'Description: (\S+ *\S+)', record)
inTraffic = int(re_find(
r'\d+ seconds input:\s+\d+\spackets/sec\s(\d+)\sbits/sec', record) or 0) / 1000000
outTraffic = int(re_find(
r'\d+ seconds output:\s+\d+\spackets/sec\s(\d+)\sbits/sec', record) or 0) / 1000000
return dict(name=name, desc=desc, state=state, inTraffic=inTraffic, outTraffic=outTraffic)
try:
child = telnet(ip)
rslt = do_some(child, 'disp interface')
close(child)
rslt = re.split(r'\r\n *\r\n', rslt)
rslt = select(lambda x: bool(x['name']),
lmap(_get_info, rslt))
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
return ('success', rslt, ip)
def get_groups(ip):
def _get_info(record):
name = re_find(r'interface\s(eth-trunk)(\d+)', record, flags=re.I)
name = ' '.join(name).lower()
mode = re_find(r'mode\s(\S+)', record)
if mode is None:
mode = 'manual'
elif 'lacp' in mode:
mode = 'yes'
desc = re_find(r'description\s(\S+ *\S*)', record)
return dict(name=name, mode=mode, desc=desc)
try:
child = telnet(ip)
rslt = do_some(child, 'disp cu int eth-trunk')
close(child)
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
rslt1 = select(r'interface', rslt.split('#'))
rslt2 = map(_get_info, rslt1)
return ('success', rslt2, ip)
def get_ports(ip):
def _get_info(record):
name = re_find(r'(\S+) current state :', record)
state = re_find(r'current state : ?(\S+ ?\S+)', record)
desc = re_find(r'Description:(\S+ *\S+)', record)
inTraffic = int(
re_find(r'300 seconds input rate (\d+)\sbits/sec', record) or 0) / 1000000
outTraffic = int(
re_find(r'300 seconds output rate (\d+)\sbits/sec', record) or 0) / 1000000
return dict(name=name, desc=desc, state=state, inTraffic=inTraffic, outTraffic=outTraffic)
try:
child = telnet(ip)
rslt = do_some(child, 'disp interface')
close(child)
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
rslt = select(lambda x: re_test(r'^x?gigabitethernet', x, re.I),
re.split(r'\r\n *\r\n *', rslt))
rslt = lmap(_get_info, rslt)
return ('success', rslt, ip)
def get_ports(ip):
def _get_info(record):
name = re_find(r'((?:xg|g|f)ei\S+) is \w+ ?\w+,', record)
state = re_find(r'(?:xg|g|f)ei\S+ is (\w+ ?\w+),', record)
desc = re_find(r'Description is (\S+ *\S+)', record)
inTraffic = int(
re_find(r'120 seconds input.*:\s+(\d+)\sBps', record) or 0) * 8 / 1000000
outTraffic = int(
re_find(r'120 seconds output.*:\s+(\d+)\sBps', record) or 0) * 8 / 1000000
return dict(name=name, desc=desc, state=state, inTraffic=inTraffic, outTraffic=outTraffic)
try:
child = telnet(ip)
rslt = do_some(child, 'show interface')
close(child)
except (pexpect.EOF, pexpect.TIMEOUT) as e:
return ('fail', None, ip)
rslt = re.split(r'\r\n *\r\n', rslt)
rslt = select(lambda x: bool(x['name']),
lmap(_get_info, rslt))
return ('success', rslt, ip)
def search(self, query, treat_as_regex=True):
if treat_as_regex:
return map(Task, select(query, self.iterate(raw=True)))
return map(Task, ifilter(lambda t: query in t, self.iterate(raw=True)))
def merge_update(self, other: "Context", overwrite=False):
matches = select(lambda key: key in other, self._reserved_keys.keys())
if matches:
raise ReservedKeyError(matches)
return super().merge_update(other, overwrite=overwrite)
