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