Mini Shell
#!/opt/imh-python/bin/python3
"""Grand Unified Disk Scanner.
For More Information and Usage:
http://wiki.inmotionhosting.com/index.php?title=RADS#disk_cleanup.py"""
import logging
import sys
from datetime import timedelta
from pathlib import Path
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
import pp_api
import yaml
from cpapis import whmapi1, CpAPIError
import rads
from guds_modules.change import run_disk_change
from guds_modules.aux import run_aux
from guds_modules.base import ModuleBase
from guds_modules.cli_args import get_args
__version__ = 'v1.0 Grand Unified Disk Scanner'
__author__ = 'SeanC, MadeleineF'
TOPDIR = Path(__file__).parent.resolve()
# Configurables
DELETER_PATH = TOPDIR / "guds_modules/deleters"
NOTIFIER_PATH = TOPDIR / "guds_modules/notifiers"
USER_TIMEOUT = int(timedelta(days=30).total_seconds()) # 30 days in seconds
SPAM_TIMER_LIST = "/var/log/guds_timer"
class DiskCleaner:
"""Automates a combination of techniques used to reclaim disk space
on Shared Servers"""
def __init__(
self,
args: dict,
modules: list[str],
delete: dict[str, type[ModuleBase]],
note: dict[str, type[ModuleBase]],
):
"""Initialize the DiskCleaner Object"""
# Setup logger
self.logger = logging.getLogger('disk_cleanup.py')
rads.setup_logging(
path=args['log_file'],
loglevel=args['loglevel'],
print_out=args['output'],
)
# Flag to toggle deletion/notification of users on run
self.dry_run: bool = args['dry_run']
# Command to run {delete,note,aux,change}
self.command: str = args['command']
# Modules to run on command guds_modules{deleters,notifiers}
self.modules = {}
# List of cPanel users to run cleaners on
self.users = rads.all_cpusers()
# Number of days to look back for 'change' command
self.days = 1
# parallel for delete and note
self.threads = 1 # changed later
# establish command specific cleaner object attriutes
if self.command == 'change':
self.days = args['days']
elif self.command in ('delete', 'note'):
self.threads = args['threads']
if not len(modules) == 0:
# initialize Module objects
for name, mod in delete.items():
delete[name] = mod(self.dry_run, self.logger)
for name, mod in note.items():
note[name] = mod(self.dry_run, self.logger)
self.modules = {'delete': delete, 'note': note}
else:
self.logger.warning('action=main warning=no modules selected')
print(
'Please select modules with ',
f'`disk_cleanup.py {self.command}` as shown above.',
file=sys.stderr,
)
sys.exit(0)
# Timeout list containing users who have already been notified
self.timeout_list = {}
def add_timeout_list(self, reason, user):
"""Format user information and timestamp for the timeout list"""
if user in self.timeout_list:
self.timeout_list[user].update({reason: int(time.time())})
else:
self.timeout_list[user] = {reason: int(time.time())}
self.logger.info(
'user=%s action=add_timeout_list timeout=%s', user, reason
)
self.write_timeout_list()
def load_timeout_list(self, target_file):
"""Returns timeout list from specified file in dict format
:param target_file: - file to read timeout data from"""
# timeout list open (re-create if invalid or missing)
try:
with open(target_file, encoding='ascii') as timeoutlist:
self.timeout_list: dict = yaml.load(
timeoutlist, yaml.SafeLoader
)
assert isinstance(self.timeout_list, dict)
self.logger.debug('timeout_list=%s', self.timeout_list)
except (AssertionError, OSError):
self.logger.error('error=invalid timeout list')
with open(target_file, 'w', encoding='ascii') as outfile:
yaml.dump({}, outfile, indent=4)
self.timeout_list = {}
self.logger.info('new empty timeout list created')
self.logger.debug('timeout_list=%s', self.timeout_list)
# timeout list refresh (remove people who are on longer on timeout)
for user, data in list(self.timeout_list.items()):
self.timeout_list[user] = {
cleaner: timer
for cleaner, timer in data.items()
if int(time.time()) - timer < USER_TIMEOUT
}
if self.timeout_list[user] == {}:
del self.timeout_list[user]
# write refreshed timeout list to target_file
with open(target_file, 'w', encoding='ascii') as outfile:
yaml.dump(self.timeout_list, outfile, indent=4)
self.logger.debug(
'action=load_timeout_list status=/var/log/guds_timer '
'has been refreshed'
)
@staticmethod
def iter_mods(path: Path):
"""Yield names of modules in a directory"""
for entry in path.iterdir():
if entry.name.endswith('.py') and not entry.name.startswith('_'):
yield entry.name[:-3]
@staticmethod
def load_submodules() -> tuple[
dict[str, type[ModuleBase]], dict[str, type[ModuleBase]]
]:
"""Import submodules. Submodules are added to available arguments"""
# Gather and Import Deleter Mods
deleter_mod_names = list(DiskCleaner.iter_mods(DELETER_PATH))
deleters = {}
guds_d_modules = __import__(
'guds_modules.deleters', globals(), locals(), deleter_mod_names, 0
)
for mod_name in deleter_mod_names:
deleters[mod_name] = getattr(guds_d_modules, mod_name).Module
# Gather and Import Notifier Mods
notifier_mod_names = list(DiskCleaner.iter_mods(NOTIFIER_PATH))
guds_n_modules = __import__(
'guds_modules.notifiers', globals(), locals(), notifier_mod_names, 0
)
notifiers = {}
for mod_name in notifier_mod_names:
notifiers[mod_name] = getattr(guds_n_modules, mod_name).Module
return deleters, notifiers
def notify_user(self, msgpack: dict, user: str):
"""Unpack the message and stuff it into the pp_api to notify the user"""
if rads.IMH_CLASS == 'reseller':
try:
resellers = whmapi1.listresellers()
except CpAPIError as exc:
sys.exit(str(exc))
if user not in resellers:
user = rads.get_owner(user)
if user not in resellers:
self.logger.error(
'user=%s action=notify_user status=unable to '
'determine owner',
user,
)
sys.exit('Unable to determine owner of that user')
pp_connect = pp_api.PowerPanel()
# Unpack message into the power panel email data
results = pp_connect.call(
"notification.send", cpanelUser=user, **msgpack
)
if not hasattr(results, 'status') or results.status != 0:
self.logger.error(
'user=%s action=notify_user status=pp api failed unexpectedly'
)
else:
self.logger.info('user=%s action=notify_user status=OK', user)
def run(self, modules: list[str]):
"""DiskCleaner object main flow control function"""
self.logger.debug(
'action=run command=%s modules=%s', self.command, modules
)
if self.command == 'aux':
run_aux()
sys.exit(0)
elif self.command == 'change':
run_disk_change(self)
sys.exit(0)
# Load timeout list
self.load_timeout_list(SPAM_TIMER_LIST)
if modules == ['all']:
modules = self.modules[self.command]
print(f"{self.command} running in {self.threads} threads", end=': ')
print(*modules, sep=', ')
with ThreadPoolExecutor(self.threads) as pool:
futures = {}
for user in self.users:
if not rads.cpuser_safe(user):
self.logger.debug(
'user=%s action=cpuser_safe status=restricted user',
user,
)
continue
try:
homedir = rads.get_homedir(user)
except rads.CpuserError as exc:
self.logger.error(
'user=%s action=get_homedir status=%s', user, exc
)
continue
for cleaner in modules:
mod = self.modules[self.command][cleaner]
future = pool.submit(
self.mod_thread, mod, cleaner, user, homedir
)
futures[future] = (user, cleaner)
for future in as_completed(futures):
user, cleaner = futures[future]
notify = future.result() # module exceptions are raised here
if not notify: # empty dict means no email
continue
if user in self.timeout_list:
if cleaner not in self.timeout_list[user]:
if not self.dry_run:
self.notify_user(notify, user)
self.add_timeout_list(cleaner, user)
else:
if not self.dry_run:
self.notify_user(notify, user)
self.add_timeout_list(cleaner, user)
def mod_thread(
self, mod: ModuleBase, cleaner: str, user: str, homedir: str
):
self.logger.debug('user=%s action=module:%s status=run', user, cleaner)
notify = mod.run_module(homedir)
# if this assertion fails, this is a bug. A subclass of ModuleBase
# returned the wrong data in run_module
assert isinstance(notify, dict)
return notify
def write_timeout_list(self):
"""Write contents of self.timeout_list() to SPAM_TIMER_LIST"""
try:
self.logger.debug(
'action=write_timeout_list update data=%s', self.timeout_list
)
with open(SPAM_TIMER_LIST, 'w', encoding='ascii') as outfile:
yaml.dump(self.timeout_list, outfile, indent=4)
self.logger.info('action=write_timeout_list update status=ok')
except OSError as e:
self.logger.error('action=write_timeout_list update error=%s', e)
def main():
"""Main function: get args"""
delete, note = DiskCleaner.load_submodules()
args, modules = get_args(delete, note)
cleaner = DiskCleaner(args, modules, delete, note)
cleaner.run(modules)
if __name__ == "__main__":
assert rads.IMH_ROLE == 'shared'
try:
main()
except KeyboardInterrupt:
sys.exit(1)
Zerion Mini Shell 1.0