def get_structured_data(rawoutput, params): # self.rawoutput=rawoutput # self.params=params index_file = params['index_file'] template_dir = params['template_dir'] # index_file='index' # template_dir='/Users/davis.kuriakose/PycharmProjects/ntc-ansible/ntc-templates/templates' cli_table = clitable.CliTable(index_file, template_dir) attrs = dict( # Command='show version', # Platform='cisco_ios' Command=params['command'], Platform=params['platform']) try: cli_table.ParseCmd(rawoutput, attrs) structured_data = clitable_to_dict(cli_table) except CliTableError as e: # Invalid or Missing template # module.fail_json(msg='parsing error', error=str(e)) # rather than fail, fallback to return raw text structured_data = [rawoutput] return structured_data
def parse_fsm(self, result, command): """ Parses command output through TextFSM """ result = ''.join(result) cli_table = clitable.CliTable(index_file, template_dir) attrs = {'Command': command['command'], 'Platform': self.device_type} try: cli_table.ParseCmd(result, attrs) # Timestamp precision is set to 'seconds' timestamp = int(time()) for field in clitable_to_dict(cli_table): data = {} data['tag'] = { 'host': self.hostname, 'command': command['tag'] } data['command'] = command['command'] data['fields'] = dict( (k, float_if_possible(v)) for (k, v) in field.items()) if command['tag']: data['tag'][command['tag']] = data['fields'][ command['tag']] data['timestamp'] = timestamp self.data_list.append(data) return True except clitable.CliTableError as e: logging.error('FSM parsing error: %s' % str(e)) return False
def reinit(self, platform=None, cli=None): self.root = os.path.join(os.path.dirname(__file__), '..', 'templates') self.samples = os.path.join(self.root, 'test') index_file = env.get("SPYTEST_TEXTFSM_INDEX_FILENAME", "index") self.cli_table = clitable.CliTable(index_file, self.root) self.platform = platform self.cli = cli
def send_commands(self): """ Send all commands in task Stores all parsed output in self.data_list """ for command in self.command_list: logging.debug('Sending command: %s' % command['command']) result = self.sock.send_command(command['command']) result_raw = ''.join(result) cli_table = clitable.CliTable(index_file, template_dir) attrs = { 'Command': command['command'], 'Platform': self.device_type } try: cli_table.ParseCmd(result_raw, attrs) except CliTableError as e: module.fail_json(msg='parsing error', error=str(e)) data = {} data['tag'] = command['tag'] data['command'] = command['command'] data['fields'] = clitable_to_dict(cli_table) # Convert values to float if possible data_float = [] for i in data['fields']: i = dict((k, float_if_possible(v)) for (k, v) in i.items()) data_float.append(i) data['fields'] = data_float self.data_list.append(data)
def parse_command_dynamic(command_output, attributes_dict, index_file="index", templ_path="templates"): cli_table = clitable.CliTable(index_file, templ_path) cli_table.ParseCmd(command_output, attributes_dict) return [dict(zip(cli_table.header, row)) for row in cli_table]
def show_vlan(): # establish ssh connection device = ConnectHandler(**switch) # define cisco ios show command command = 'show vlan brief' # Execute show commands on the channel: output = device.send_command(command) # close ssh connection gracefully device.disconnect() # Create CliTable object cli_table = clitable.CliTable(index_file, template_dir) attrs = {'Command': command, 'platform': device_type} # Dynamically parse the output from the router against the template cli_table.ParseCmd(output, attrs) # Convert cli_table to Python Dictionary objs = [] for row in cli_table: temp_dict = {} for index, element in enumerate(row): temp_dict[cli_table.header[index].lower()] = element objs.append(temp_dict) # jsonify dictionary and return result return jsonify(vlans=objs)
def parse_command_dynamic(att_dict, output, index_f='index', index_dir='templates', show_output=False): cli_table = clitable.CliTable(index_f, index_dir) cli_table.ParseCmd(output, att_dict) #print ("CLI Table output:\n", cli_table) if show_output: print("Formatted Table:\n", cli_table.FormattedTable()) header = cli_table.header listd = [] for r in cli_table: d = {} for i in range(len(header)): d.update({header[i]: r[i]}) listd.append(d) return listd #parse_command_dynamic(attributes,output_sh_ip_route_ospf,show_output= True)
def __init__(self, platform=None): """ Construction of Template object """ self.root = os.path.join(os.path.dirname(__file__), '..', 'templates') self.samples = os.path.join(self.root, 'test') self.cli_table = clitable.CliTable('index', self.root) self.platform = platform
def send_and_parse(command, command_output, index_file='index', templates='templates'): attributes = {'Command': command, 'Vendor': 'cisco_ios'} cli_table = clitable.CliTable(index_file, templates) cli_table.ParseCmd(command_output, attributes) return [dict(zip(cli_table.header, row)) for row in cli_table]
def testCompletion(self): """Tests '[[]]' syntax replacement.""" indx = clitable.CliTable() self.assertEqual('abc', re.sub(r'(\[\[.+?\]\])', indx._Completion, 'abc')) self.assertEqual('a(b(c)?)?', re.sub(r'(\[\[.+?\]\])', indx._Completion, 'a[[bc]]')) self.assertEqual('a(b(c)?)? de(f)?', re.sub(r'(\[\[.+?\]\])', indx._Completion, 'a[[bc]] de[[f]]'))
def get_structured_data(platform, command, rawoutput): """Return the structured data.""" cli_table = clitable.CliTable('index', 'templates') attrs = dict(Command=command, Platform=platform) cli_table.ParseCmd(rawoutput, attrs) structured_data = clitable_to_dict(cli_table) return structured_data
def initParser(): try: parser = clitable.CliTable('index', TEMPLATES_DIRECTORY) except Exception as e: print( "Problem with parser init - check index file and templates directory. Error is {}" .format(e)) return None return parser
def parse_command_dynamic(attributes, output, index = 'index', index_dir = 'templates'): result = [] cli_table = clitable.CliTable(index, index_dir) cli_table.ParseCmd(output, attributes) header = list(cli_table.header) data_rows = [list(row) for row in cli_table] for item in data_rows: zipped_dict = dict(zip(header, item)) result.append(zipped_dict) return result
def _parse_command_dynamic(self, command_output, attributes_dict, index_file='index', templ_path='templates'): cli_table = clitable.CliTable(index_file, templ_path) cli_table.ParseCmd(command_output, attributes_dict) headers = list(cli_table.header) result = [dict(zip(headers, list(row))) for row in cli_table] return result
def parse_command_dynamic(command_output, attributes_dict, index_file="index", templ_path="templates"): out_list = list() cli_table = clitable.CliTable(index_file, templ_path) cli_table.ParseCmd(command_output, attributes_dict) for itm in cli_table[1:]: out_list.append(dict(zip(cli_table[0], itm))) return out_list
def send_show_command(self, command, parse=False, templates='templates/'): if not parse: return self._write_line(command).decode('utf-8') command_output = self._write_line(command).decode('utf-8') cli_table = clitable.CliTable('index', templates) attributes_dict = {'Command':command} cli_table.ParseCmd(command_output, attributes_dict) res_lst = [list(row) for row in cli_table] header_lst = list(cli_table.header) return [(dict(zip(header_lst, fsm_el))) for fsm_el in res_lst]
def __init__(self, index_file=TEMPLATE_INDEX_FILE, template_dir=TEMPLATE_INDEX_DIR, attributes=None): super(CliParser, self).__init__(index_file, template_dir) self.template_dir = template_dir self.index_file = index_file self.attributes = attributes # set Version to 'DEFAULT' if it is not defined if 'Version' not in attributes.keys(): self.attributes['Version'] = 'DEFAULT' self.cli_table = clitable.CliTable(self.index_file, self.template_dir)
def parse_command_dynamic(command_output,attributes_dict,index_file='index',templ_path='templates'): cli = clitable.CliTable(index_file,templ_path) cli.ParseCmd(command_output,attributes_dict) headers,tab=list(cli.header),[list(r) for r in cli] result,intdict=[],{} for interf in tab: for i in range(0,len(headers)): intdict[headers[i]]=interf[i] result.append(intdict.copy()) return result
def send_and_parse_show(self, command, index_file='index', templates_dir='templates'): output = self.send_show_command(command) cli_table = clitable.CliTable(index_file, templates_dir) attributes = {'Vendor': 'huawei', 'Command': command} cli_table.ParseCmd(output, attributes) keys = list(cli_table.header) rows = [row for row in cli_table] return [{k: v for k, v in zip(keys, row)} for row in rows]
def get_structured_data(raw_output, platform, command): """Convert raw CLI output to structured data using TextFSM template.""" template_dir = get_template_dir() index_file = 'index' #CHANGED textfsm_obj = clitable.CliTable(index_file, template_dir) attrs = {'Command': command, 'Platform': platform} try: # Parse output through template textfsm_obj.ParseCmd(raw_output, attrs) return clitable_to_dict(textfsm_obj) except CliTableError: return raw_output
def setUp(self): clitable.CliTable.INDEX = {} self.clitable = clitable.CliTable('default_index', 'testdata') self.input_data = ('a b c\n' 'd e f\n') self.template = ('Value Key Col1 (.)\n' 'Value Col2 (.)\n' 'Value Col3 (.)\n' '\n' 'Start\n' ' ^${Col1} ${Col2} ${Col3} -> Record\n' '\n') self.template_file = cStringIO.StringIO(self.template)
def send_show_command(self, command, templates, parse=True): send = self._write_line(command) time.sleep(1) self.connection.read_until(b'#') output = self.connection.read_very_eager().decode('ascii') if parse: attribute = {} attribute['Command'] = command cli_table = clitable.CliTable('index', templates) cli_table.ParseCmd(output, attribute) to_return = [dict(zip(cli_table.header, row)) for row in cli_table] return to_return return output
def parse_command_dynamic(attributes, output, index='index', templates='templates'): cli_table = clitable.CliTable(index, templates) attributes = attributes cli_table.ParseCmd(output, attributes) data_rows = [list(row) for row in cli_table] header = list(cli_table.header) result = [dict(zip(header, row)) for row in data_rows] return result
def parse_output(output, vendor, command): #TextFsm parse output from switch try: cli_table = clitable.CliTable('index', 'templates') except: print('Warning TextFsm !!! >>>templates index error') # если комманда соотвествует только одному вендору то можно # не указывать его attributes = {'Vendor': vendor, 'Command': command} try: cli_table.ParseCmd(output, attributes) except: print('Warning TextFsm !!! >>> attribute parse error') return cli_table
def parse_command_dynamic(attrs, idx, templates, commands): cli_table = clitable.CliTable('index', 'templates') cli_table.ParseCmd(output_sh_ip_route_ospf, attributes) data_rows = [list(row) for row in cli_table] header = list(cli_table.header) rr = [] for r in data_rows: p = dict(zip(header, r)) rr.append(p) return rr
def parse_command_dynamic(attr, output, index='index', tmpl_dir='templates'): result = [] temp_dict = {} cli_table = clitable.CliTable(index, tmpl_dir) cli_table.ParseCmd(output, attr) header = list(cli_table.header) data_rows = [list(row) for row in cli_table] for i in range(len(data_rows)): for j in range(len(header)): temp_dict[header[j]] = data_rows[i][j] result.append(temp_dict.copy()) return result
def init_parser(): """ Init CliTable index and templates This function should be call first, before parsing :return: cliTable object or None """ try: parser = clitable.CliTable('index', TEMPLATES_DIRECTORY) logger.info("Collector module loads: Im Alive!!!") except Exception as e: logger.error("Problem with parser init - check index file and templates directory. Error is %s", e) return None return parser
def get_structured_data(raw_output, platform, command): """Convert raw CLI output to structured data using TextFSM template.""" template_dir = get_template_dir() index_file = os.path.join(template_dir, 'index') textfsm_obj = clitable.CliTable(index_file, template_dir) attrs = {'Command': command, 'Platform': platform} try: # Parse output through template textfsm_obj.ParseCmd(raw_output, attrs) structured_data = clitable_to_dict(textfsm_obj) output = raw_output if structured_data == [] else structured_data return output except CliTableError: return raw_output
def parse_command_dynamic(command_output, attributes_dict): cli = clitable.CliTable( 'index', 'templates' ) # что бы работал pytest use "index", что бы скрипт работал самостоятельно "use index_file" cli.ParseCmd(command_output, attributes_dict) data_rows = [list(row) for row in cli] # добавляем row from cli to list header = list(cli.header) # add to headers to list data = [] for d in data_rows: data.append(dict(zip(header, d))) # долаем список словарей return data
def send_and_parse_show_command(device_dict, command, templates_path): with ConnectHandler(**device_dict) as ssh: ssh.enable() result = ssh.send_command(command) attribute = {} attribute['Command'] = command cli_table = clitable.CliTable('index', templates_path) cli_table.ParseCmd(result, attribute) to_return = [dict(zip(cli_table.header, row)) for row in cli_table] return to_return