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()
