def remove_router(router_name): print(f"Attempting to remove {router_name} from the database.") session = db_session.create_session() router = session.query(Router) \ .filter(Router.router_name == router_name) \ .first() session.delete(router) session.commit() logging.info("Router successfully removed from database.") print(f"Attempting to remove the backups for {router}.") try: # Gathering Backups path and removing it backup_path = os.path.abspath( os.path.join(os.path.dirname(__file__), f'../backups/{router_name}')) shutil.rmtree(backup_path) logging.info("Router backups successfully removed.") # Gathering Router info.txt path and removing it router_info_path = os.path.abspath( os.path.join(os.path.dirname(__file__), f'../router_info/{router_name}.txt')) os.remove(router_info_path) print("Router info successfully removed.") except: logging.error( "There was a problem removing the router's backups. See the error below." ) logging.error(sys.exc_info()[1])
def find_router_by_name(router_name: str) -> Optional[Router]: session = db_session.create_session() user = session.query(Router).filter( Router.router_name == router_name).first() session.close() return user
def get_router_ignore_list() -> List[Router]: session = db_session.create_session() routers = session.query(Router). \ filter(Router.ignore == True). \ all() session.close() return [r.router_name for r in routers]
def get_router_list() -> List[Router]: session = db_session.create_session() routers = session.query(Router). \ order_by(Router.router_name.asc()). \ all() session.close() return routers
def get_config_complete_count() -> int: session = db_session.create_session() config_status_query = session.query(Router.config_status) complete_count = sum(1 for status in config_status_query if status == ('Config Complete', )) session.close() return complete_count
def get_backup_complete_count() -> int: session = db_session.create_session() backup_status_query = session.query(Router.backup_status) complete_count = sum(1 for status in backup_status_query if status == ('Backup Complete', )) session.close() return complete_count
def get_users_list() -> List[User]: session = db_session.create_session() users = session.query(User). \ order_by(User.name.asc()). \ all() session.close() return users
def get_router_ignore_count() -> int: session = db_session.create_session() routers = session.query(Router). \ filter(Router.ignore == True). \ all() session.close() return sum(1 for _ in routers)
def run(): # setting start time for sync to async comparison start_time = datetime.datetime.now() # gathering list all routers and list of routers to be ignored and router count routers = router_service.get_router_list() ignored_routers = router_service.get_router_ignore_list() router_count = router_service.get_router_count() loop = asyncio.get_event_loop() for item in tqdm(routers, total=router_count, unit=" router"): if item.router_name in ignored_routers: logging.info(f"Backup skipped for {item.router_name}") tqdm.write(f"Backup skipped for {item.router_name}") backup_status = "Backup Skipped" config_status = "Config Skipped" session = db_session.create_session() r = session.query(Router).filter(Router.router_name == item.router_name).one() r.backup_status = backup_status r.config_status = config_status session.commit() else: # starting backup tqdm.write(f"Starting backup for {item.router_name}...") logging.info(f"Starting backup for {item.router_name}...") task_1 = loop.create_task(create_backup(item.router_name, item.router_ip, item.username)) # backup file completed tqdm.write(f"Completed backup for {item.router_name}") logging.info(f"Completed backup for {item.router_name}") # starting config export tqdm.write(f"Starting config export for {item.router_name}...") logging.info(f"Starting config export for {item.router_name}...") task_2 = loop.create_task(create_config(item.router_name, item.router_ip, item.username)) tqdm.write(f"Config export complete for {item.router_name}") logging.info(f"Config export complete for {item.router_name}") # gathering info from rotuers task_3 = loop.create_task(router_details_service.get_info(item.router_name, item.router_ip, item.username)) router_details_service.parse_info(item.router_name) final_task = asyncio.gather(task_1, task_2, task_3) loop.run_until_complete(final_task) dt = datetime.datetime.now() - start_time print(colorama.Fore.WHITE + "App exiting, total time: {:,.2f} sec.".format(dt.total_seconds()), flush=True)
def delete_user_by_id(user_id: int): if not find_user_by_id(user_id): return None session = db_session.create_session() try: user = session.query(User).filter(User.id == user_id).first() session.delete(user) session.commit() finally: session.close()
def get_config_failed_count() -> int: session = db_session.create_session() config_status_query = session.query(Router.config_status) failed_count = 0 for status in config_status_query: if status != ('Config Complete', ): failed_count += 1 if status == ('Config Skipped', ): failed_count -= 1 session.close() return failed_count
def get_backup_failed_count() -> int: session = db_session.create_session() backup_status_query = session.query(Router.backup_status) failed_count = 0 for status in backup_status_query: if status != ('Backup Complete', ): failed_count += 1 if status == ('Backup Skipped', ): failed_count -= 1 session.close() return failed_count
def delete_user_by_email(email: str): if not find_user_by_email(email): print('no user found') return None session = db_session.create_session() try: user = session.query(User).filter(User.email == email).first() session.delete(user) session.commit() print('user deleted') finally: session.close()
def get_unknown_status_count() -> int: session = db_session.create_session() backup_status_query = session.query(Router.backup_status) config_status_query = session.query(Router.config_status) unknown_count = sum(1 for backup_status in backup_status_query if backup_status == ('Unknown', )) for config_status in config_status_query: if config_status == ('Unknown', ): unknown_count += 1 session.close() return unknown_count
def get_router_details(router_name: str) -> Optional[Router]: if not router_name: return None router_name = router_name.strip() session = db_session.create_session() router = session.query(Router) \ .filter(Router.router_name == router_name) \ .first() session.close() return router
def add_router(router_name, router_ip, username, password, ignore): path = os.path.abspath( os.path.join(os.path.dirname(__file__), '../backups/')) logging.info(f'Add router path set to: {path}') directory_exists = os.path.isdir(path + f'/{router_name}') logging.info(f"Checking if directory for {router_name} already exists.") if directory_exists: logging.info("The directory did already exist.") return True else: logging.info("The directory didn't exist.") # writes new router to database file logging.info("Attempting to write new router to database.") r = Router() r.router_name = router_name r.router_ip = router_ip r.username = username r.password = password r.ignore = ignore session = db_session.create_session() session.add(r) session.commit() logging.info("Database entries added successfully.") logging.info(f"Attempting to create backup folder for {router_name}") try: os.mkdir(path + f'/{router_name}') except: logging.error( "There was a problem creating backup folder. See the error below:" ) logging.error(sys.exc_info()[1]) try: with open( os.path.abspath( os.path.join(os.path.dirname(__file__), f'../router_info/{router_name}.txt')), "w+") as f: f.write('') except: logging.error( "There was a problem creating the router info text file. See the error below:" ) logging.error(sys.exc_info()[1]) return False
def login_user(email: str, password: str) -> Optional[User]: session = db_session.create_session() try: user = session.query(User).filter(User.email == email).first() if not user: return None if not verify_hash(user.hashed_password, password): return None user.last_login = datetime.datetime.now() session.commit() return user finally: session.close()
def create_user(name: str, email: str, password: str) -> Optional[User]: if find_user_by_email(email): return None user = User() user.email = email user.name = name user.hashed_password = hash_text(password) session = db_session.create_session() try: session.add(user) session.commit() finally: session.close() return user
def run(): # setting start time for sync to async comparison t0 = datetime.datetime.now() # gathering list all routers and list of routers to be ignored and router count routers = router_service.get_router_list() ignored_routers = router_service.get_router_ignore_list() router_count = router_service.get_router_count() for item in tqdm(routers, total=router_count, unit=" router"): if item.router_name in ignored_routers: print(f'{log_date_time} Backup skipped for {item.router_name}') tqdm.write(f"Backup skipped for {item.router_name}") backup_status = "Backup Skipped" config_status = "Config Skipped" session = db_session.create_session() r = session.query(Router).filter(Router.router_name == item.router_name).one() r.backup_status = backup_status r.config_status = config_status session.commit() else: # starting backup tqdm.write(f"Starting backup for {item.router_name}...") print(f'{log_date_time} Starting backup for {item.router_name}...') create_backup(item.router_name, item.router_ip, item.username) tqdm.write(f"Completed backup for {item.router_name}") print(f'{log_date_time} Completed backup for {item.router_name}') # starting config export tqdm.write(f"Starting config export for {item.router_name}...") print(f'{log_date_time} Starting config export for {item.router_name}...') create_config(item.router_name, item.router_ip, item.username) tqdm.write(f"Config export complete for {item.router_name}") print(f'{log_date_time} Config export complete for {item.router_name}') # gathering info from rotuers router_details_service.get_info(item.router_name, item.router_ip, item.username) router_details_service.parse_info(item.router_name) dt = datetime.datetime.now() - t0 print(colorama.Fore.WHITE + "App exiting, total time: {:,.2f} sec.".format(dt.total_seconds()), flush=True)
def parse_info(router_name): # setting up db session and making query for update session = db_session.create_session() r = session.query(Router).filter(Router.router_name == router_name).one() top_folder = os.path.dirname(__file__) rel_folder = os.path.join('..', 'router_info', router_name + '.txt') filepath = os.path.abspath(os.path.join(top_folder, rel_folder)) with open(filepath, 'r') as f: lines = f.readlines() for line in lines: if 'uptime' in line: data = line.split(':') cleaned_data = data[1].split(' ') uptime = cleaned_data[1] tqdm.write(f"{router_name} uptime: {uptime}") print(f'{log_date_time} {router_name} uptime: {uptime}') r.uptime = uptime if 'version' in line: data = line.split(':') cleaned_data = data[1].split(' ') router_os = cleaned_data[1] tqdm.write(f"{router_name}: {router_os}") print(f'{log_date_time} {router_name} has a RouterOS: {router_os}') r.router_os_version = router_os if 'free-memory' in line: data = line.split(':') cleaned_data = data[1].split(' ') free_memory = cleaned_data[1] tqdm.write(f"{router_name} free_memory: {free_memory}") print(f'{log_date_time} {router_name} free_memory: {free_memory}') r.free_memory = free_memory if 'total-memory' in line: data = line.split(':') cleaned_data = data[1].split(' ') total_memory = cleaned_data[1] tqdm.write(f"{router_name} total_memory: {total_memory}") print(f'{log_date_time} {router_name} total_memory: {total_memory}') r.total_memory = total_memory if 'cpu-load' in line: data = line.split(':') cleaned_data = data[1].split(' ') cpu_load = cleaned_data[1] tqdm.write(f"{router_name} cpu_load: {cpu_load}") print(f'{log_date_time} {router_name} cpu_load: {cpu_load}') r.cpu_load = cpu_load if 'free-hdd-space' in line: data = line.split(':') cleaned_data = data[1].split(' ') free_hdd_space = cleaned_data[1] tqdm.write(f"{router_name} free_hdd_space: {free_hdd_space}") print(f'{log_date_time} {router_name} free_hdd_space: {free_hdd_space}') r.free_hdd_space = free_hdd_space if 'total-hdd-space' in line: data = line.split(':') cleaned_data = data[1].split(' ') total_hdd_space = cleaned_data[1] tqdm.write(f"{router_name} total_hdd_space: {total_hdd_space}") print(f'{log_date_time} {router_name} total_hdd_space: {total_hdd_space}') r.total_hdd_space = total_hdd_space if 'bad-blocks' in line: data = line.split(':') cleaned_data = data[1].split(' ') bad_blocks = cleaned_data[1] tqdm.write(f"{router_name} bad_blocks: {bad_blocks}") print(f'{log_date_time} {router_name} bad_blocks: {bad_blocks}') r.bad_blocks = bad_blocks if 'board-name' in line: data = line.split(':') cleaned_data = data[1].split(' ') board_name = cleaned_data[1] tqdm.write(f"{router_name} board_name: {board_name}") print(f'{log_date_time} {router_name} board_name: {board_name}') r.board_name = board_name # committing changes to the db session.commit()
async def create_backup(router_name, router_ip, username): global backup_status try: date = datetime.datetime.today().strftime('%m-%d-%Y_%H:%M:%S') backup_name = date + ".backup" try: backup_output = await asyncio.create_subprocess_shell('ssh {}@{} /system backup save name={}'.format(username, router_ip, backup_name), stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) try: tqdm.write(f'Starting transfer for {router_name}') top_folder = os.path.dirname(__file__) rel_folder = os.path.join('../..', 'backups') backups_path = os.path.abspath(os.path.join(top_folder, rel_folder)) transfer_output = await asyncio.create_subprocess_shell('scp {}@{}:/{} "{}/{}/{}"'.format(username, router_ip, backup_name, backups_path, router_name, backup_name), stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) if transfer_output.stdout == '': logging.info(transfer_output.stdout) backup_status = "Backup Complete" elif transfer_output.stdout != '': logging.info(transfer_output.stdout) backup_status = transfer_output.stdout if transfer_output.stderr != '': logging.warning(transfer_output.stderr) tqdm.write(f"transfer stderr: {transfer_output.stderr}") except: logging.error(sys.exc_info()[1]) tqdm.write(f"Exception: {sys.exc_info()[1]}") #backup_status = sys.exc_info()[1] if backup_output.stderr != '': logging.warning(backup_output.stderr) tqdm.write(f"stderr: {backup_output.stderr}") backup_status = backup_output.stderr except: the_type, the_value, the_traceback = sys.exc_info() tqdm.write(f"{the_type}\n{the_value}") #backup_status = the_value #backup_status = 'Backup Complete' except TimeoutError as err: tqdm.write(err) backup_status = err except EOFError as err: tqdm.write(err) backup_status = err except FileNotFoundError as err: tqdm.write(err) backup_status = err except: the_type, the_value, the_traceback = sys.exc_info() tqdm.write(f"{the_type}\n{the_value}") backup_status = the_value todays_date = datetime.datetime.today().strftime('%m-%d-%Y') # updating database values session = db_session.create_session() r = session.query(Router).filter(Router.router_name == router_name).one() r.backup_status = backup_status r.last_attempted = todays_date session.commit() return backup_status
def update_router(selected_router, router_name, router_ip, username, password, ignore): path = os.path.abspath( os.path.join(os.path.dirname(__file__), '../backups/')) logging.info(f'Path for update set to: {path}') if router_name != selected_router: logging.info( f"Changing name of router from {selected_router} to {router_name}." ) logging.info(f"Creating new backup directory for {router_name}") # creating new backup directory try: os.mkdir(path + f'/{router_name}') print("New backup directory created.") except: logging.error( "There was a problem creating new backup directory. See the error below." ) logging.error(sys.exc_info()[1]) print("Moving the backups from old directory.") # moving backup files to new backup directory try: fromDirectory = path + f'/{selected_router}' toDirectory = path + f'/{router_name}' copy_tree(fromDirectory, toDirectory) logging.info("Files moved successfully.") except: logging.error( "There was a problem moving the backups. See the error below.") logging.error(sys.exc_info()[1]) logging.info("Removing old backups directory.") # removing old backup directory try: shutil.rmtree(path + f'/{selected_router}') logging.info("Directory removed successfully.") except: logging.error( "There was a problem removing the directory. See the error below." ) logging.error(sys.exc_info()[1]) # # renaming info text file # try: # old_info_file = path + '/{}.txt'.format(selected_router) # new_info_file = path + '/{}.txt'.format(router_name) # os.rename(old_info_file,new_info_file) # except: # logging.error("There was a problem renaming the info file. See the error below.") # logging.error(sys.exc_info()[1]) # updating database values in sql database logging.info(f"Updating database values for {selected_router}.") session = db_session.create_session() r = session.query(Router).filter( Router.router_name == selected_router).one() r.router_name = router_name r.router_ip = router_ip r.username = username r.password = password r.ignore = ignore session.commit() logging.info("Database values updated successfully.")
async def create_config(router_name, router_ip, username): global config_status try: date = datetime.datetime.today().strftime('%m-%d-%Y_%H:%M:%S') export_name = date + ".rsc" try: top_folder = os.path.dirname(__file__) rel_folder = os.path.join('../..', 'backups') backups_path = os.path.abspath(os.path.join(top_folder, rel_folder)) config_output = await asyncio.create_subprocess_shell('ssh {}@{} export terse > "{}/{}/{}"'.format(username, router_ip, backups_path, router_name, export_name), stdout = asyncio.subprocess.PIPE, stderr = asyncio.subprocess.PIPE) if config_output.stdout == '': logging.info(config_output.stdout) config_status = "Config Complete" elif config_output.stdout != '': logging.info(config_output.stdout) config_status = config_output.stdout if config_output.stderr != '': logging.warning(config_output.stderr) config_status = config_output.stderr except: logging.info(sys.exc_info()[1]) tqdm.write(f"Exception: {sys.exc_info()[1]}") # config_status = sys.exc_info()[1] #config_status = 'Config Export Complete' except TimeoutError as err: tqdm.write(err) # flash(err) config_status = err except EOFError as err: tqdm.write(err) # flash(err) config_status = err except FileNotFoundError as err: tqdm.write(err) # flash(err) config_status = err except: the_type, the_value, the_traceback = sys.exc_info() tqdm.write(f"{the_type}\n{the_value}") # flash("{}\n{}".format(the_type, the_value)) config_status = the_value todays_date = datetime.datetime.today().strftime('%m-%d-%Y') # updating database values session = db_session.create_session() r = session.query(Router).filter(Router.router_name == router_name).one() r.config_status = config_status r.last_attempted = todays_date session.commit() return config_status
def create_config(router_name, router_ip, username): global config_status try: date = datetime.datetime.today().strftime('%m-%d-%Y_%H:%M:%S') export_name = date + ".rsc" try: top_folder = os.path.dirname(__file__) rel_folder = os.path.join('..', 'backups') backups_path = os.path.abspath(os.path.join(top_folder, rel_folder)) config_output = subprocess.run('ssh {}@{} export terse > "{}/{}/{}"'.format(username,router_ip,backups_path,router_name,export_name), shell=True, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # config_output = subprocess.run(f'ssh {username}@{router_ip} export terse > "{backups_path}/{router_name}/{export_name}"', # shell=True, # universal_newlines=True, # stdout=subprocess.PIPE, # stderr=subprocess.PIPE) if config_output.stdout == '': print(f'{log_date_time} {config_output.stdout}') config_status = "Config Complete" else: print(f'{log_date_time} {config_output.stdout}') config_status = config_output.stdout if config_output.stderr != '': print(f'{log_date_time} {config_output.stderr}') config_status = config_output.stderr except: print(f'{log_date_time} {sys.exc_info()[1]}') tqdm.write(f"Exception: {sys.exc_info()[1]}") # config_status = sys.exc_info()[1] #config_status = 'Config Export Complete' except TimeoutError as err: tqdm.write(err) # flash(err) config_status = err except EOFError as err: tqdm.write(err) # flash(err) config_status = err except FileNotFoundError as err: tqdm.write(err) # flash(err) config_status = err except: the_type, the_value, the_traceback = sys.exc_info() tqdm.write(f"{the_type}\n{the_value}") # flash("{}\n{}".format(the_type, the_value)) config_status = the_value todays_date = datetime.datetime.today().strftime('%m-%d-%Y') # updating database values session = db_session.create_session() r = session.query(Router).filter(Router.router_name == router_name).one() r.config_status = config_status r.last_attempted = todays_date session.commit() return config_status
def get_router_count() -> int: session = db_session.create_session() session.close() return session.query(Router).count()
def find_user_by_id(user_id: int) -> Optional[User]: session = db_session.create_session() try: return session.query(User).filter(User.id == user_id).first() finally: session.close()
def get_is_admin(user_id): session = db_session.create_session() try: return session.query(User).filter(User.id == user_id).first() finally: session.close()
def find_user_by_email(email: str) -> Optional[User]: session = db_session.create_session() try: return session.query(User).filter(User.email == email).first() finally: session.close()
def get_user_count() -> int: session = db_session.create_session() try: return session.query(User).count() finally: session.close()