def handle_install_conflicts(self):
""" Adds installable packages conflicts to install list """
new_to_remove = []
i = 0
while i < len(self.to_install):
conflicts = self.to_install[i].get_conflicts()
for conflict in conflicts:
if Pkg.check_state(conflict):
# find package conflict
try:
self.to_install[i].conflict_get_next[conflict]
except:
try:
self.to_install[i].conflict_get_next[conflict] = 0
except:
self.to_install[i].conflict_get_next = {}
self.to_install[i].conflict_get_next[conflict] = 0
pkg = Pkg.check_state(conflict, get_true_pkg=True, get_true_pkg_next=self.to_install[i].conflict_get_next[conflict])
self.to_install[i].conflict_get_next[conflict] += 1
a = 0
added = False
if type(pkg) == list:
while a < len(self.to_remove):
if self.to_remove[a].data['name'] == pkg[0]:
added = True
a += 1
if not added:
new_to_remove.append(Pkg.load_last(pkg[0]))
i += 1
if new_to_remove:
self.remove(new_to_remove)
self.handle_install_reverse_conflicts()
def handle_install_reverse_depends(self):
""" Adds installable packages reverse depends to install list """
new_to_remove = []
i = 0
while i < len(self.to_install):
reverse_depends = self.to_install[i].get_reverse_depends()
for dep in reverse_depends:
if dep.installed():
dep = Pkg.load_version(dep.data['name'], dep.installed())
for tmp_dep in dep.get_depends():
result = Pkg.check_state(tmp_dep, virtual={
'install': [
[
self.to_install[i].data['name'], self.to_install[i].data['version']
]
],
})
if not result:
a = 0
added = False
while a < len(self.to_remove):
if self.to_remove[a].data['name'] == dep.data['name']:
added = True
a += 1
if not added:
new_to_remove.append(dep)
i += 1
if new_to_remove:
self.remove(new_to_remove)
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 """
# 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 handle_install_depends(self):
""" Adds installable packages depends to install list """
new_to_install = []
i = 0
while i < len(self.to_install):
depends = self.to_install[i].get_depends()
if self.with_recommends:
depends = [*depends, *self.to_install[i].get_recommends()]
for depend in depends:
if not Pkg.check_state(depend) and depend.strip()[0] != '@':
# find package depend
try:
self.to_install[i].depend_get_next[depend]
except:
try:
self.to_install[i].depend_get_next[depend] = 0
except:
self.to_install[i].depend_get_next = {}
self.to_install[i].depend_get_next[depend] = 0
pkg = Pkg.check_state(depend, get_false_pkg=True, get_false_pkg_next=self.to_install[i].depend_get_next[depend])
self.to_install[i].depend_get_next[depend] += 1
if len(pkg) == 1:
a = 0
added = False
while a < len(self.to_install):
if self.to_install[a].data['name'] == pkg[0]:
added = True
a += 1
if not added:
new_to_install.append(Pkg.load_last(pkg[0]))
elif len(pkg) == 3:
a = 0
added = False
while a < len(self.to_install):
if self.to_install[a].data['name'] == pkg[0]:
wanted_version = pkg[2]
installed_version = self.to_install[a].wanted_version
if pkg[1] == '=':
if Pkg.compare_version(installed_version, wanted_version) == 0:
added = True
elif pkg[1] == '>=':
if Pkg.compare_version(installed_version, wanted_version) >= 0:
added = True
elif pkg[1] == '<=':
if Pkg.compare_version(installed_version, wanted_version) <= 0:
added = True
elif pkg[1] == '>':
if Pkg.compare_version(installed_version, wanted_version) == 1:
added = True
elif pkg[1] == '<':
if Pkg.compare_version(installed_version, wanted_version) == -1:
added = True
a += 1
if not added:
pkg_obj = None
if pkg[1] == '=':
pkg_obj = Pkg.load_version(pkg[0], pkg[2])
elif pkg[1] == '>=' or pkg[1] == '>':
pkg_obj = Pkg.load_last(pkg[0])
elif pkg[1] == '<=':
pkg_obj = Pkg.load_version(pkg[0], pkg[2])
elif pkg[1] == '<':
pkg_obj = Pkg.load_last(pkg[0])
versions = pkg_obj.get_versions_list()
x = 0
while x < len(versions):
if Pkg.compare_version(versions[x][0], pkg[0]) >= 0:
versions.pop(x)
x += 1
versions = [v[0] for v in versions]
wanted_ver = pkg.get_last_version(versions)
pkg_obj = Pkg.load_version(pkg[0], wanted_ver)
new_to_install.append(pkg_obj)
i += 1
if new_to_install:
self.install(new_to_install)
self.handle_install_reverse_depends()