def removing_package_event(self, pkg: Pkg):
"""
will run as package remover event while starting removing a package
"""
pr.p('Removing ' + ansi.yellow + pkg.data['name'] + ' (' +
pkg.data['version'] + ')' + ansi.reset + '...',
end=' ')
def download_once(self, pkg, output=None):
""" Download once package """
try:
file_path = pkg.data['file_path']
except:
self.message('package "' + pkg.data['name'] +
'" is local and cannot be downloaded' + ansi.reset,
is_error=True,
before=ansi.red)
return False
if not self.is_quiet():
pr.p('Downloading ' + pkg.data['name'] + ':' +
pkg.data['version'] + ':' + pkg.data['arch'] + '...')
if output == None:
output = file_path.split('/')[-1]
if file_path[:7] == 'http://' or file_path[:8] == 'https://':
i = 0
while i < 5:
res = DownloadProgress.download(file_path, output)
if res == True:
break
else:
pr.e(ansi.red + str(res) + ansi.reset)
i += 1
if i == 5:
return False
else:
if not os.path.isfile(file_path):
return False
shutil.copy(file_path, output)
return True
def show_once(self, package: Pkg):
"""
show once item in loaded packages list
"""
if self.has_option('-q') or self.has_option('--quiet'):
pr.p(package.data['name'])
return
output = ansi.green + package.data[
'name'] + ansi.reset + '/' + ansi.yellow + package.data[
'version'] + ansi.reset
if package.installed():
if package.is_installed_manual(package.data['name']):
output += '/Installed-Manual:' + ansi.blue + package.installed(
).strip() + ansi.reset
else:
output += '/Installed:' + ansi.blue + package.installed(
).strip() + ansi.reset
output += '/[' + package.data['repo'] + ']'
# if verbose output wanted, show first line of description
if self.is_verbose():
try:
description_summary = package.data['description'].split(
'\n')[0]
if description_summary != '':
output += '/ ' + ansi.header + description_summary + ansi.reset
except:
pass
pr.p(output)
def sub_build(self):
""" build subcommand (cati pkg build) """
if len(self.arguments) <= 1:
self.message('argument package directory(s) required')
return 1
i = 1
while i < len(self.arguments):
try:
output = self.option_value('--output')
if output == None:
output = self.option_value('-o')
builder = Builder()
output_package = builder.build(self.arguments[i], output)
if not self.is_quiet():
pr.p(ansi.green + 'Package ' + self.arguments[i] +
' created successfuly in ' + output_package +
ansi.reset)
except FileNotFoundError as ex:
self.message('directory "' + self.arguments[i] +
'" not found' + ansi.reset,
before=ansi.red)
return 1
except InvalidPackageDirException as ex:
self.message('cannot build "' + self.arguments[i] + '": ' +
str(ex) + ansi.reset,
before=ansi.red)
return 1
i += 1
def run(self):
""" Run command """
if not self.is_quiet():
pr.p('Loading packages list...')
pr.p('========================')
loaded_packages = []
for argument in self.arguments:
arg_parts = argument.split('=')
if len(arg_parts) == 1:
# load last version as default
pkg = Pkg.load_last(argument)
elif len(arg_parts) == 2:
# load specify version
pkg = Pkg.load_version(arg_parts[0], arg_parts[1])
if pkg == 1:
pkg = False
elif pkg == 2:
self.message('package "' + arg_parts[0] +
'" has not version "' + arg_parts[1] + '"' +
ansi.reset,
before=ansi.red)
continue
else:
# load specify version and specify arch
pkg = Pkg.load_version(arg_parts[0], arg_parts[1],
arg_parts[2])
if pkg == 1:
pkg = False
elif pkg == 2:
self.message('package "' + arg_parts[0] +
'" has not version or arch "' + arg_parts[1] +
':' + arg_parts[2] + '"' + ansi.reset,
before=ansi.red)
continue
if pkg:
loaded_packages.append(pkg)
else:
self.message('unknow package "' + argument + '"' + ansi.reset,
before=ansi.red)
if not loaded_packages:
return 1
# download loaded packages
is_any_success = False
output_path = self.option_value('--output')
for pkg in loaded_packages:
if len(loaded_packages) > 1:
tmp = self.download_once(pkg)
else:
tmp = self.download_once(pkg, output_path)
if tmp:
is_any_success = True
if not is_any_success:
return 1
def package_new_installs_event(self, package: BaseArchive):
"""
installer package_new_installs event
will run when package will NEW installed
"""
pr.p('Installing ' + ansi.yellow + package.data['name'] + ':' +
package.data['version'] + ansi.reset + '...',
end=' ')
def install_once(self, pkg: BaseArchive):
"""
installs once package
is called from install sub command
"""
target_path = self.option_value('--target')
if target_path == None:
target_path = ''
installer = Installer()
try:
out = installer.install(
pkg, {
'cannot_read_file': self.cannot_read_file_event,
'invalid_json_data': self.invalid_json_data_event,
}, {
'package_currently_installed':
self.package_currently_installed_event,
'package_new_installs': self.package_new_installs_event,
'package_installed': self.package_installed_event,
'directory_not_empty': self.directory_not_empty_event,
'dep_and_conflict_error':
self.dep_and_conflict_error_event,
'arch_error': self.arch_error_event,
}, (not self.has_option('--auto')),
run_scripts=(not self.has_option('--without-scripts')),
target_path=str(target_path),
keep_conffiles=self.has_option('--keep-conffiles'),
check_security_blacklist=(not self.has_option('--force')
and not self.has_option('-f')))
if type(out) == int:
return out
except PackageScriptError as ex:
pr.e(ansi.red + 'cannot install "' + pkg.data['name'] + ':' +
pkg.data['version'] + '": ' + str(ex) + ansi.reset)
return 1
except PackageIsInSecurityBlacklist as ex:
pr.e(ansi.red + 'cannot install ' + pkg.data['name'] + ':' +
pkg.data['version'] +
' because this is in security blacklist:')
pr.e(' ' + ex.blacklist_item['title'] + ':')
for l in ex.blacklist_item['description'].split('\n'):
pr.e('\t' + l)
pr.p(ansi.reset, end='')
return 1
except CannotReadFileException as ex:
self.message(ansi.red + str(ex), True, before=ansi.reset)
return 1
except FileConflictError as ex:
pr.e(ansi.red + '\nCannot install ' + pkg.data['name'] + ':' +
pkg.data['version'] + ': File conflict error:')
pr.e(' ' + str(ex))
pr.p(ansi.reset, end='')
return 1
def package_currently_installed_event(self, package: BaseArchive,
current_version: str):
"""
installer package_currently_installed event
will run when package already installed
gets package and current installed version
"""
pr.p('Installing ' + ansi.yellow + package.data['name'] + ':' +
package.data['version'] + ansi.reset + ' (over ' + ansi.yellow +
current_version + ansi.reset + ')...',
end=' ')
def show_once(self, pkg: BaseArchive):
"""
shows once package (called from `show` subcommand function)
gives package data to cli package sohwer component to show package info
"""
PackageShower.show(pkg.data)
if self.has_option('--files') or self.has_option('-f'):
pr.p('Files:')
pkg.tar.list()
if len(self.arguments) > 2:
pr.p('=' * 50)
def run(self):
""" Run command """
pr.p("""
/\ /\ * * * * * * * * * * * * * *
| |_____| | * Meow.....! I am Cati! *
| -- -- | ....* I can manage your *
| { { * } } | ..../ * Packages! *
| | * *
__________| | * * * * * * * * * * * * * *
/ |
/ |
__/_ __ _________ _ _|
|_| |_| |_| |_|
""")
def run(self):
""" Run command """
if self.has_option('--abort'):
require_root_permission()
state_list = BaseTransaction.state_list()
if not state_list:
pr.p(ansi.green + 'There is not any undoned transaction and everything is ok' + ansi.reset)
return 0
user_answer = 'y'
if not self.has_option('-y') and not self.has_option('--yes'):
pr.p(ansi.yellow + 'WARNING: this process maybe dangerous and ' + str(len(state_list)) + ' transactions will be igonred. are you sure? [y/N] ' + ansi.reset, end='')
user_answer = input()
if user_answer in ['Y', 'y']:
BaseTransaction.finish_all_state()
pr.p(ansi.green + 'state was empty successfully' + ansi.reset)
else:
return
elif self.has_option('--complete'):
require_root_permission()
state_list = BaseTransaction.state_list()
if not state_list:
pr.p(ansi.green + 'There is not any undoned transaction and everything is ok' + ansi.reset)
return 0
BaseTransaction.finish_all_state()
# complete transactions
for item in state_list:
if item['action'] == 'remove':
tmp_arguments = [item['pkg'], '-y']
tmp_arguments.insert(0, 'cati')
tmp_arguments.insert(1, 'remove')
cmd = RemoveCommand()
cmd.handle(ArgParser.parse(tmp_arguments))
elif item['action'] == 'install':
tmp_arguments = ['install', item['file']]
tmp_arguments.insert(0, 'cati')
tmp_arguments.insert(1, 'pkg')
cmd = PkgCommand()
cmd.handle(ArgParser.parse(tmp_arguments))
return
else:
# show list of undoned transactions
state_list = BaseTransaction.state_list()
if state_list:
StateContentShower.show(state_list)
return 1
else:
pr.p(ansi.green + 'There is not any undoned transaction and everything is ok' + ansi.reset)
return 0
def run(self):
""" Run command """
if len(self.arguments) <= 0:
pr.p(self.help_full())
return 0
if self.arguments[0] == 'build':
return self.sub_build()
elif self.arguments[0] == 'show':
return self.sub_show()
elif self.arguments[0] == 'install':
return self.sub_install()
else:
self.message('unknow subcommand "' + self.arguments[0] + '"', True)
return 1
def run(self):
""" Run command """
if self.has_option('--edit') or self.has_option('-e'):
return os.system('vim "' + Env.repos_config() + '"')
if self.has_option('--add') or self.has_option('-a'):
RootRequired.require_root_permission()
repo_string = ''
for arg in self.arguments:
repo_string += arg + ' '
repo_string = repo_string.strip()
tmp_repo = Repo(repo_string)
tmp_repo.loaded_from_file = 'argument'
tmp_repo.line_number = 0
if not tmp_repo.successful_loaded:
ReposListErrorShower.show([tmp_repo])
return 1
# write repo
path = Env.repos_config_dir('/' + tmp_repo.name + '-' +
tmp_repo.get_pkg_str() + '-' +
tmp_repo.get_arch_str())
tmp = ''
tmp_i = 1
while os.path.isfile(path + tmp):
tmp = '-' + str(tmp_i)
f = open(path, 'w')
f.write('# added manually\n' + repo_string)
f.close()
return 0
if self.has_option('--scan'):
for arg in self.arguments:
if os.path.isdir(arg):
Scanner.scan(arg)
pr.p(ansi.green + 'directory ' + arg +
' scanned successfully' + ansi.reset)
else:
self.message('directory' + arg + ' not found',
is_error=True)
return 0
# show list of repos
if not self.is_quiet():
pr.p('Loading repositories list...')
repos = Repo.get_list()
if not self.is_quiet():
pr.p('============================')
ReposListErrorShower.show(repos)
for repo in repos:
if repo.successful_loaded:
is_disable = ''
if repo.is_disable:
is_disable = ' (Disabled)'
pr.p(repo.name + ': ' + repo.url + ' pkg=' +
repo.get_pkg_str() + ' arch=' + repo.get_arch_str() +
' channel=' + repo.get_channel_str() + is_disable)
def run(self):
""" Run command """
pr.p('Checking upgradable packages...')
installed_packages = Pkg.installed_list()['list']
upgradable_packages = []
for pkg in installed_packages:
installed_version = pkg.installed()
latest_version = pkg.data['version']
if Pkg.compare_version(latest_version, installed_version) == 1:
upgradable_packages.append(pkg)
if not upgradable_packages:
pr.p(ansi.green + 'all of packages are up to date' + ansi.reset)
return 0
packages_names = [pkg.data['name'] for pkg in upgradable_packages]
install_cmd = InstallCommand()
return install_cmd.handle(ArgParser.parse(['cati', 'install', *self.args['options'], *packages_names]))
def show(state_list: list):
"""
Shows and renders list of undoned transactions in state
Args:
state_list: loaded state from `transaction.BaseTransaction.state_list()` as (list)
"""
pr.e(ansi.yellow + 'Error: state is not done')
pr.p('\tthere is some undoned transactions:')
for item in state_list:
pr.p('\t\t' + BaseTransaction.state_item_to_string(item))
pr.p('to complete them, run `' + sys.argv[0] + ' state --complete`')
pr.p(ansi.reset, end='')
def run(self):
""" Run command """
if not self.is_quiet():
pr.p('Checking unused packages...')
self.unused_packages = []
self.find_unused_packages()
unused_packages = self.unused_packages
package_names = [pkg.data['name'] for pkg in unused_packages]
options = [op for op in self.args['options']]
if not package_names:
pr.p('There is not any unused package')
return 0
remove_cmd = RemoveCommand()
return remove_cmd.handle(
ArgParser.parse(['cati', 'remove', *package_names, *options]))
def run(self):
""" Run command """
pr.p('Loading packages list...')
pr.p('========================')
loaded_packages = []
for argument in self.arguments:
arg_parts = argument.split('=')
if len(arg_parts) == 1:
# load last version as default
pkg = Pkg.load_last(argument)
else:
# load specify version
pkg = Pkg.load_version(arg_parts[0], arg_parts[1])
if pkg == 1:
pkg = False
elif pkg == 2:
self.message('package "' + arg_parts[0] + '" has not version "' + arg_parts[1] + '"' + ansi.reset, before=ansi.red)
continue
if pkg:
loaded_packages.append(pkg)
else:
self.message('unknow package "' + argument + '"' + ansi.reset, before=ansi.red)
if not loaded_packages:
return 1
# show loaded packages
for pkg in loaded_packages:
if self.has_option('--versions'):
versions_list = pkg.get_versions_list()
pr.p(pkg.data['name'] + ':')
for ver in versions_list:
pr.p(' ' + ver[0] + ':' + ver[1])
else:
PackageShower.show(pkg.data)
if len(loaded_packages) > 1:
pr.p('---------------------')
def run(self):
""" Run command """
# join all of arguments as one argument
full_query_string = ''
if len(self.arguments) > 1:
for arg in self.arguments:
full_query_string += arg + ' '
full_query_string = full_query_string[:len(full_query_string) - 1]
else:
full_query_string = self.arguments[0]
result = Pkg.check_state(full_query_string)
if result:
if not self.is_quiet():
pr.p(ansi.green + 'True' + ansi.reset)
return 0
else:
if not self.is_quiet():
pr.p(ansi.red + 'False' + ansi.reset)
return 1
def run(self):
""" Run command """
RootRequired.require_root_permission()
for f in os.listdir(Env.cache_dir()):
if os.path.isfile(Env.cache_dir('/' + f)):
if self.is_verbose():
pr.p('removing ' + Env.cache_dir('/' + f) + '...')
os.remove(Env.cache_dir('/' + f))
for f in os.listdir(Env.cache_dir('/archives')):
if os.path.isfile(Env.cache_dir('/archives/' + f)):
if self.is_verbose():
pr.p('removing ' + Env.cache_dir('/archives/' + f) + '...')
os.remove(Env.cache_dir('/archives/' + f))
pr.p(ansi.green + 'Cache files cleared successfully' + ansi.reset)
def show(calc: Calculator):
"""
shows transactions from `Calculator` object.
Args:
calc: `transaction.Calculator.Calculator` object
"""
if calc.to_remove:
pr.p('The following packages will be removed:')
for pkg in calc.to_remove:
pr.p('- ' + ansi.red + pkg.data['name'] + ansi.reset)
to_install = []
to_upgrade = []
to_downgrade = []
to_reinstall = []
for pkg in calc.to_install:
if not pkg.installed():
to_install.append(pkg)
elif pkg.compare_version(pkg.wanted_version, pkg.installed()) == 1:
to_upgrade.append(pkg)
elif pkg.compare_version(pkg.wanted_version, pkg.installed()) == -1:
to_downgrade.append(pkg)
else:
to_reinstall.append(pkg)
if to_upgrade:
pr.p('The following packages will be upgraded:')
for pkg in to_upgrade:
pr.p('- ' + ansi.yellow + pkg.data['name'] + '(' +
pkg.installed() + ' -> ' + pkg.wanted_version + ') ' +
pkg.get_file_size_str() + ansi.reset)
if to_downgrade:
pr.p('The following packages will be downgraded:')
for pkg in to_downgrade:
pr.p('- ' + ansi.yellow + pkg.data['name'] + '(' +
pkg.installed() + ' >> ' + pkg.wanted_version + ') ' +
pkg.get_file_size_str() + ansi.reset)
if to_reinstall:
pr.p('The following packages will be re-installed:')
for pkg in to_reinstall:
pr.p('- ' + ansi.yellow + pkg.data['name'] + '(' +
pkg.wanted_version + ') ' + pkg.get_file_size_str() +
ansi.reset)
if to_install:
pr.p('The following packages will be installed:')
for pkg in to_install:
pr.p('- ' + ansi.green + pkg.data['name'] + '(' +
pkg.wanted_version + ') ' + pkg.get_file_size_str() +
ansi.reset)
total_download_size = calc.get_total_download_size()
if total_download_size > 0:
pr.p('Total download size: ' + str(total_download_size))
def run(self):
""" Run command """
RootRequired.require_root_permission()
pr.p('Loading packages list...')
pr.p('========================')
loaded_packages = []
for argument in self.arguments:
arg_parts = argument.split('=')
if len(arg_parts) == 1:
# load last version as default
pkg = Pkg.load_last(argument)
else:
# load specify version
pkg = Pkg.load_version(arg_parts[0], arg_parts[1])
if pkg == 1:
pkg = False
elif pkg == 2:
self.message('package "' + arg_parts[0] + '" has not version "' + arg_parts[1] + '"' + ansi.reset, before=ansi.red)
continue
else:
pkg.only_specify_version = True
if pkg:
try:
pkg.only_specify_version
except:
pkg.only_specify_version = False
if pkg.installed():
if not pkg.only_specify_version:
self.message('package "' + argument + '" is installed. cannot forget installed packages' + ansi.reset, before=ansi.red)
continue
else:
if pkg.installed() == pkg.data['version']:
self.message('package ' + argument + ' (' + pkg.data['version'] + ') is installed. cannot forget installed packages' + ansi.reset, before=ansi.red)
continue
loaded_packages.append(pkg)
else:
self.message('unknow package "' + argument + '"' + ansi.reset, before=ansi.red)
if not loaded_packages:
return 1
# forget loaded packages
for pkg in loaded_packages:
if not pkg.only_specify_version:
# forget all of package versions
shutil.rmtree(Env.packages_lists('/' + pkg.data['name']))
pr.p('Package ' + pkg.data['name'] + ' was forgoten successfully')
else:
files = glob.glob(Env.packages_lists('/' + pkg.data['name'] + '/' + pkg.data['version'] + '-*'))
for f in files:
if not '-' in f[len(Env.packages_lists('/' + pkg.data['name'] + '/' + pkg.data['version'] + '-')):]:
os.remove(f)
pr.p('Version ' + pkg.data['version'] + ' of package ' + pkg.data['name'] + ' was forgoten successfully')
try:
if len(os.listdir(Env.packages_lists('/' + pkg.data['name']))) <= 1:
shutil.rmtree(Env.packages_lists('/' + pkg.data['name']))
except:
pass
ListUpdater.update_indexes({
'cannot_read_file': self.empty_method_for_event,
'invalid_json_data': self.empty_method_for_event,
})
def run(self):
""" Run command """
# check -v|--version options
if self.has_option('--version') or self.has_option('-v'):
pr.p(cati_version)
return
if not self.is_quiet():
pr.p()
pr.p(ansi.yellow + " $$$$$$ $$ $$" +
ansi.reset)
pr.p(ansi.yellow + " $$ $$ $$" + ansi.reset)
pr.p(ansi.yellow + " $$ $$$$$$ $$$$$$ $$" +
ansi.reset)
pr.p(ansi.yellow + " $$ $$ $$ $$" +
ansi.reset)
pr.p(ansi.yellow + " $$ $$$$$$$ $$ $$" +
ansi.reset + ansi.cyan + " | " +
self.general_help().split('\n')[0] + ansi.reset)
pr.p(ansi.yellow + " $$ $$ $$ $$ $$ $$ $$" +
ansi.reset + ansi.cyan + " | " +
self.general_help().split('\n')[1] + ansi.reset)
pr.p(ansi.yellow + " $$$$$$ $$$$$$$ $$$$ $$" +
ansi.reset + ansi.cyan + " | " +
self.general_help().split('\n')[2] + ansi.reset)
pr.p()
pr.p('Options:')
pr.p(ansi.header + '\t-v|--version' + ansi.reset +
': shows cati version')
pr.p(ansi.header + '\t--no-ansi' + ansi.reset +
': disable terminal ansi colors')
pr.p(ansi.header + '\t--help' + ansi.reset +
': pass it to commands to show help of that command')
pr.p(ansi.header + '\t-q|--quiet' + ansi.reset + ': quiet output')
pr.p(ansi.header + '\t-v|--verbose' + ansi.reset + ': verbose output')
pr.p()
commands = kernel.commands
# check arguments
if len(self.arguments) >= 1:
# a command inserted. show detail of that command
try:
cmd = commands[self.arguments[0]]
obj = cmd()
pr.p(obj.help_full(False))
return 0
except:
self.message('unknow command "' + self.arguments[0] + '"' +
ansi.reset,
True,
before=ansi.red)
return 1
# show summary help of command
pr.p('Subcommands:')
for cmd in commands:
obj = commands[cmd]()
tabs = '\t\t'
if len(cmd) > 7:
tabs = '\t'
pr.p('\t' + ansi.green + cmd + ansi.reset + tabs +
obj.help_summary())
if not self.is_quiet():
pr.p('\nfor see detailed help about commands, run: "' +
ansi.yellow + self.cati_exec + ' help [command-name]' +
ansi.reset + '"')
return 0
def run(self):
""" Run command """
# require root permission
require_root_permission()
result_code = 0
packages_to_reinstall = []
if not self.is_quiet():
pr.p('Starting checking system health and security...')
pr.p('===============================================')
# check state
state_cmd = StateCommand()
out = state_cmd.handle(ArgParser.parse(['cati', 'state']))
if out > 0:
return out
# search for conflict and dependency corruptions
if not self.is_quiet():
pr.p('Checking dependency and conflict corruptions...')
dependency_problems = []
conflict_problems = []
installed_packages = Pkg.installed_list()['list']
for pkg in installed_packages:
if self.is_verbose():
pr.p('[info] checking dependencies and conflicts for ' + pkg.data['name'] + '...')
for dp in pkg.get_depends():
if not Pkg.check_state(dp):
dependency_problems.append([
pkg, dp
])
for conflict in pkg.get_conflicts():
if Pkg.check_state(conflict):
conflict_problems.append([
pkg, conflict
])
if dependency_problems or conflict_problems:
for depend in dependency_problems:
pr.p(ansi.red + 'dependency problem for ' + depend[0].data['name'] + ': ' + depend[1] + ansi.reset)
packages_to_reinstall.append(depend[0])
for conflict in conflict_problems:
pr.p(ansi.red + 'conflict problem for ' + conflict[0].data['name'] + ': ' + conflict[1] + ansi.reset)
packages_to_reinstall.append(conflict[0])
result_code = 1
else:
pr.p(ansi.green + 'There is not any conflict or dependnecy problem and everything is ok' + ansi.reset)
# check static files
if not self.is_quiet():
pr.p('Checking packages static files...')
staticfile_problems = []
for pkg in installed_packages:
if self.is_verbose():
pr.p('[info] checking static files for ' + pkg.data['name'] + '...')
files = pkg.installed_static_files()
for f in files:
f[1] = Env.base_path(f[1])
if os.path.isfile(f[1]):
wanted_hash = f[0]
current_hash = calc_file_sha256(f[1])
if wanted_hash != current_hash:
staticfile_problems.append([
pkg,
f,
'file is changed'
])
else:
staticfile_problems.append([
pkg,
f,
'file is deleted'
])
if staticfile_problems:
for problem in staticfile_problems:
pr.p(ansi.red + 'staticfile problem in package ' + problem[0].data['name'] + ': ' + problem[1][1] + ': ' + problem[2] + ansi.reset)
packages_to_reinstall.append(problem[0])
result_code = 1
else:
pr.p(ansi.green + 'all of static files are ok' + ansi.reset)
# check repos config files health
if not self.is_quiet():
pr.p('Checking cati configuration files...')
if self.is_verbose():
pr.p('[info] checking repositories config...')
repos = Repo.get_list()
pr.p(ansi.red, end='')
ReposListErrorShower.show(repos)
pr.p(ansi.reset, end='')
is_any_repo_error = False
for repo in repos:
if repo.syntax_errors:
is_any_repo_error = True
result_code = 1
if not is_any_repo_error:
pr.p(ansi.green + 'all of cati configuration files are ok' + ansi.reset)
# check database files
if not self.is_quiet():
pr.p('Checking cati database...')
database_problems = []
for f in os.listdir(Env.installed_lists()):
if self.is_verbose():
pr.p('[info] checking database install dir for ' + f + '...')
if not os.path.isfile(Env.installed_lists('/' + f + '/files')) or not os.path.isfile(Env.installed_lists('/' + f + '/ver')):
database_problems.append('installed packages database: directory ' + Env.installed_lists('/' + f) + ' is corrupt')
for f in os.listdir(Env.security_blacklist()):
if self.is_verbose():
pr.p('[info] checking security blacklist part ' + f + '...')
if not os.path.isfile(Env.security_blacklist('/' + f)):
database_problems.append('security blacklist: an directory detected: ' + Env.security_blacklist('/' + f))
else:
tmp = open(Env.security_blacklist('/' + f), 'r')
try:
json.loads(tmp.read())
except:
database_problems.append('security blacklist: invalid json data in ' + Env.security_blacklist('/' + f))
if database_problems:
for problem in database_problems:
pr.p(ansi.red + 'database: ' + problem + ansi.reset)
result_code = 1
else:
pr.p(ansi.green + 'all of cati database is ok' + ansi.reset)
if not self.is_quiet():
if packages_to_reinstall:
pr.p(ansi.blue + 'We suggest re-install this packages:')
for pkg in packages_to_reinstall:
pr.p('- ' + pkg.data['name'])
if not self.has_option('--autofix'):
pr.p('use --autofix option to re-install them or do this manually')
pr.p(ansi.reset, end='')
else:
pr.p(ansi.reset, end='')
packages_names = [pkg.data['name'] for pkg in packages_to_reinstall]
install_cmd = InstallCommand()
args = ['cati', 'install', '--reinstall', *packages_names]
cmd_str = ''
for arg in args:
cmd_str += arg + ' '
cmd_str = cmd_str.strip()
pr.p(cmd_str)
return install_cmd.handle(ArgParser.parse(args))
return result_code
def package_remove_finished_event(self, pkg: Pkg):
"""
will run as package remover event when package remove process finished
"""
pr.p(ansi.green + 'OK' + ansi.reset)
def run(self):
""" Run command """
if self.has_option('--installed'):
if not self.is_quiet():
pr.p('Loading files list...')
pr.p('=====================')
all_of_installed_files_list = Pkg.get_all_installed_files_list()
for item in all_of_installed_files_list:
if self.is_quiet():
pr.p(item[2])
else:
message = ''
if item[1] == 'd':
message = ' (directory)'
elif item[1] == 'cf':
message = ' (config file)'
elif item[1] == 'cd':
message = ' (config directory)'
pr.p(item[0] + ': ' + item[2] + message)
return 0
if not self.arguments:
self.message('argument package names is required', True)
return 1
if not self.is_quiet():
pr.p('Loading packages list...')
pr.p('========================')
loaded_packages = []
for argument in self.arguments:
arg_parts = argument.split('=')
if len(arg_parts) == 1:
# load last version as default
pkg = Pkg.load_last(argument)
else:
# load specify version
pkg = Pkg.load_version(arg_parts[0], arg_parts[1])
if pkg == 1:
pkg = False
elif pkg == 2:
self.message('package "' + arg_parts[0] +
'" has not version "' + arg_parts[1] + '"' +
ansi.reset,
before=ansi.red)
continue
if pkg:
loaded_packages.append(pkg)
else:
self.message('unknow package "' + argument + '"' + ansi.reset,
before=ansi.red)
if not loaded_packages:
return 1
# show files list of loaded packages
for pkg in loaded_packages:
try:
files_list = pkg.data['files']
except:
files_list = []
if not self.is_quiet():
pr.p(pkg.data['name'] + ':')
if not files_list:
pr.p(ansi.yellow + ' This package is empty' + ansi.reset)
for item in files_list:
pr.p(' ' + item)
else:
for item in files_list:
pr.p(item)
if len(loaded_packages) > 1:
if not self.is_quiet():
pr.p('========================')
def run(self):
""" Run command """
if not self.has_option('-q') and not self.has_option('--quiet'):
pr.p('Loading packages list...')
pr.p('========================')
# load list of packages
if self.has_option('--installed'):
# just list installed packages
packages = Pkg.installed_list()
elif self.has_option('--installed-manual'):
packages = Pkg.installed_list()
packages_list = [
tmp_pkg for tmp_pkg in packages['list']
if Pkg.is_installed_manual(tmp_pkg.data['name'])
]
packages['list'] = packages_list
else:
packages = Pkg.all_list()
for error in packages['errors']:
self.message(error + ansi.reset, True, before=ansi.red)
# load filter options
wanted_authors = []
if self.has_option('--author'):
wanted_authors = self.option_value('--author').strip().split('|')
wanted_authors = [author.strip() for author in wanted_authors]
wanted_maintainers = []
if self.has_option('--maintainer'):
wanted_maintainers = self.option_value(
'--maintainer').strip().split('|')
wanted_maintainers = [
maintainer.strip() for maintainer in wanted_maintainers
]
wanted_categories = []
if self.has_option('--category'):
wanted_categories = self.option_value('--category').strip().split(
'|')
wanted_categories = [
category.strip() for category in wanted_categories
]
search_query = self.option_value('--search')
if search_query:
search_query_words = search_query.strip().split(' ')
search_query_words = [word.strip() for word in search_query_words]
else:
search_query_words = []
for package in packages['list']:
# check filters
if wanted_authors:
try:
if not package.data['author'].strip() in wanted_authors:
continue
except:
continue
if wanted_maintainers:
try:
if not package.data['maintainer'].strip(
) in wanted_maintainers:
continue
except:
continue
if wanted_categories:
try:
if not package.data['category'].strip(
) in wanted_categories:
continue
except:
continue
if search_query:
is_math_with_query = False
for word in search_query_words:
if word in package.data['name']:
is_math_with_query = True
try:
if search_query in package.data['description']:
is_math_with_query = True
except:
pass
if not is_math_with_query:
continue
if self.has_option('--upgradable'):
if package.installed():
if Pkg.compare_version(package.data['version'],
package.installed()) != 1:
continue
else:
continue
# show item
self.show_once(package)
def run(self):
""" Run command """
require_root_permission()
# check transactions state before run new transactions
pr.p('Checking transactions state...')
state_list = BaseTransaction.state_list(
) # get list of undoned transactions
if state_list:
# the list is not empty
StateContentShower.show(state_list)
return 1
pr.p('Loading packages list...')
pr.p('==============================')
# load list of packages
packages = []
for arg in self.arguments:
pkg = Pkg.load_last(arg)
if pkg == False:
self.message('unknow package "' + arg + '"' + ansi.reset,
before=ansi.red)
else:
if pkg.installed():
packages.append(pkg)
else:
self.message('package "' + pkg.data['name'] +
'" is not installed' + ansi.reset,
before=ansi.red)
# start removing loaded packages
calc = Calculator()
calc.remove(packages)
# show transactions
TransactionShower.show(calc)
essential_packages = []
for pkg in calc.to_remove:
try:
if pkg.data['essential']:
essential_packages.append(pkg)
except:
pass
if not self.has_option('--force') and not self.has_option('-f'):
for pkg in essential_packages:
pr.p(
ansi.red + 'Package "' + pkg.data['name'] +
'" is a essential package and cannot be remove. use --force|-f option to force remove them'
+ ansi.reset)
if essential_packages:
return 1
if not calc.has_any_thing():
return
# check user confirmation
if not self.has_option('-y') and not self.has_option('--yes'):
pr.p('Do you want to continue? [Y/n] ', end='')
answer = input()
if not (answer == 'y' or answer == 'Y' or answer == ''):
pr.p(ansi.yellow + 'Abort.' + ansi.reset)
pr.exit(1)
# add packages to state
BaseTransaction.add_to_state(calc)
packages_to_remove_names_and_versions = [
pkg.data['name'] + '@' + pkg.data['version']
for pkg in calc.to_remove
]
# run transactions
for pkg in calc.to_remove:
Remove.run(pkg, {
'removing_package': self.removing_package_event,
'package_remove_finished': self.package_remove_finished_event,
'dir_is_not_empty': self.dir_is_not_empty_event,
},
self.has_option('--conffiles'),
run_scripts=(not self.has_option('--without-scripts')))
BaseTransaction.pop_state()
BaseTransaction.run_any_scripts(
['remove', packages_to_remove_names_and_versions],
events={
'start_run_script': self.start_run_any_script_event,
})
BaseTransaction.finish_all_state()
def package_installed_event(self, package: BaseArchive):
"""
installer package_installed event
will run when package installation finshed
"""
pr.p(ansi.green + 'OK' + ansi.reset)
def start_run_any_script_event(self, package_name: str):
""" will run when starting running an `any` script """
pr.p('Processing scripts for ' + package_name + '...')
def sub_install(self):
""" install sub command (cati pkg install) """
if len(self.arguments) <= 1:
self.message('argument package file(s) required')
return 1
require_root_permission()
# check transactions state before run new transactions
pr.p('Checking transactions state...')
state_list = BaseTransaction.state_list(
) # get list of undoned transactions
if state_list:
# the list is not empty
StateContentShower.show(state_list)
return 1
packages_to_install = []
i = 1
while i < len(self.arguments):
try:
pkg = archive_factory(self.arguments[i], 'r')
pkg.read()
pkg.package_file_path = os.path.abspath(self.arguments[i])
packages_to_install.append(pkg)
except FileNotFoundError as ex:
self.message('file "' + self.arguments[i] + '" not found' +
ansi.reset,
before=ansi.red)
return 1
except:
self.message('cannot open "' + self.arguments[i] +
'": file is corrupt' + ansi.reset,
before=ansi.red)
return 1
i += 1
# add packages to state
state_f = open(Env.state_file(), 'w')
tmp = ''
for pkg in packages_to_install:
tmp += ('install%' + pkg.data['name'] + '%' + pkg.data['version'] +
'%' + pkg.data['arch'] + '%' + pkg.package_file_path +
'\n')
state_f.write(tmp)
state_f.close()
packages_to_install_names_and_versions = [
pkg.data['name'] + '@' + pkg.data['version']
for pkg in packages_to_install
]
i = 0
while i < len(packages_to_install):
try:
pkg = packages_to_install[i]
tmp = self.install_once(pkg)
if type(tmp) == int and tmp != 0:
if not self.has_option('--dont-ignore-state'):
BaseTransaction.finish_all_state()
return tmp
pkg.close()
except:
if not self.has_option('--dont-ignore-state'):
BaseTransaction.finish_all_state()
self.message('cannot install "' +
packages_to_install[i].data['name'] + '"' +
ansi.reset,
before=ansi.red)
return 1
i += 1
BaseTransaction.run_any_scripts(
['install', packages_to_install_names_and_versions],
events={
'start_run_script': self.start_run_any_script_event,
})
BaseTransaction.finish_all_state()
