name : cluserextselect.py # -*- coding: utf-8 -*- # Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2019 All Rights Reserved # # Licensed under CLOUD LINUX LICENSE AGREEMENT # http://cloudlinux.com/docs/LICENSE.TXT from __future__ import absolute_import from __future__ import print_function from __future__ import division import os from .clextselect import ClExtSelect from .cluserselect import ClUserSelect from .clselectexcept import ClSelectExcept from .clselectprint import clprint from .utils import apply_for_at_least_one_user, in_cagefs class ClUserExtSelect(ClUserSelect, ClExtSelect): USER_INI = 'alt_php.ini' def __init__(self, item='php', exclude_pid_list=None): ClUserSelect.__init__(self, item, exclude_pid_list) self._alt_extensions = None self._user_extensions = [] self._conflicts = [] def list_enabled_extensions(self, user, version=None): """ Returns enabled user extensions for a version as a tuple @param user: string @param version: string @return: tuple """ self._check_user_in_cagefs(user) if version is None: version = self.get_version(user)[0] if version == 'native': raise ClSelectExcept.UnableToGetExtensions(version) return tuple(map((lambda i: (i, True)), sorted(self._get_enabled_extensions(user, version)))) def list_all_extensions(self, user, version=None): """ Returns as a tuple all user extensions for a version, marking enabled and disabled ones @param user: string @param version: string @return: tuple """ self._check_user_in_cagefs(user) if version is None: version = self.get_version(user)[0] if version == 'native': raise ClSelectExcept.UnableToGetExtensions(version) user_extensions = set(self._get_enabled_extensions(user, version)) builtin_extensions = set(self._get_builtins(version)) php_d_all_extensions = set(self._get_all_extensions(version)) all_extensions = builtin_extensions | php_d_all_extensions extensions = [] for ext in sorted(all_extensions): enabled = False if ext in builtin_extensions: enabled = None elif ext in user_extensions: enabled = True extensions.append((ext, enabled)) return tuple(extensions) def _get_enabled_extensions(self, user, version): """ Returns list of enabled user extensions @param user: string @param version: string @return: list """ if len(self._user_extensions) == 0: self._load_user_extensions(user, version) return self._user_extensions def _get_all_extensions(self, version): """ Returns list of all extensions for a version except compiled-in ones @param user: string @param version: string @return: list """ if self._alt_extensions is None: self._alt_extensions = self._load_extensions_list(version) return self._alt_extensions def _check_extensions(self, ext_list, version): """ validation extensions name @param ext_list: list @param version: string """ all_extensions = self._get_all_extensions(version) bad_extensions = set(ext_list).difference(set(all_extensions)) if bad_extensions: raise ClSelectExcept.NoSuchExtension(ext_list=bad_extensions, all_extensions=all_extensions) def bulk_enable_extensions(self, user, version, ext_list, check_ext=False): return self.bulk_handle_extensions(user, self.enable_extensions, version, ext_list, check_ext=check_ext) def bulk_handle_extensions(self, user, func, *args, **kwargs): return apply_for_at_least_one_user( func, self._clpwd.get_names(self._clpwd.get_uid(user)), ClSelectExcept.UnableToSaveData, *args, **kwargs ) def enable_extensions(self, user, version, ext_list, check_ext=False): """ Adds extensions to user php.ini @param user: string @param version: string @param ext_list: list @param check_ext: bool @return: None """ self._check_user_in_cagefs(user) if check_ext: self._check_extensions(ext_list=ext_list, version=version) user_ini_path = self._compose_user_ini_path(user, version) alt_path = self._compose_alt_path(version) contents, extensions, extensions_data = self._load_ini_contents(user_ini_path) resulting_extensions = list(extensions_data.keys()) + ext_list ext_list_without_conflicts = self._check_for_conflicts(resulting_extensions) _conflicts_info = ClExtSelect.get_conflicts_info(resulting_extensions, ext_list_without_conflicts) self._print_conflicts_info(_conflicts_info) extensions = [ext for ext in extensions + ext_list if ext in ext_list_without_conflicts] resolved_dependencies = [] for extension in extensions: resolved = [ext for ext in self._include_dependencies([extension], alt_path, extensions_data) if ext not in resolved_dependencies] dependence_info = ClExtSelect.get_dependencies_list(extension, resolved, ext_list) self._print_dependencies_info(dependence_info) resolved_dependencies.extend(resolved) for ext in resolved_dependencies: contents.extend( self._smooth_data(extensions_data[ext])) contents = self._move_ioncube_ext(contents) self._write_to_file( user, '\n'.join(contents)+'\n', user_ini_path) self._backup_settings(user) self._reload_processes(user) def bulk_replace_extensions(self, user, version, ext_list): return self.bulk_handle_extensions(user, self.replace_extensions_with_dependenses, version, ext_list) def replace_extensions(self, user, version, ext_list): """ (deprecated) Replaces extensions in user php.ini with supplied ones and print information about dependences and conflicts for old php selector @param user: string @param version: string @param ext_list: list @return: list """ (extensions_list, dependencies_list, conflict_dependencies) = \ self.bulk_replace_extensions(user, version, ext_list) self._print_dependencies_info(dependencies_list) self._print_conflicts_info(conflict_dependencies) return extensions_list def replace_extensions_with_dependenses(self, user, version, ext_list): """ Replaces extensions in user php.ini with supplied ones @param user: string @param version: string @param ext_list: list @return: extensions_list, dependencies_list, conflict_dependencieslist: (list, list, list) """ self._check_user_in_cagefs(user) resolved_dependencies = [] conflict_dependencies = [] dependencies_list = [] user_ini_path = self._compose_user_ini_path(user, version) alt_path = self._compose_alt_path(version) contents, extensions, extensions_data = self._load_ini_contents(user_ini_path) extensions_data = {} # we REPLACE extensions ext_list_without_conflicts = self._check_for_conflicts(ext_list) conflict_dependencies = ClExtSelect.get_conflicts_info(ext_list, ext_list_without_conflicts) extensions = [ext for ext in ext_list if ext in ext_list_without_conflicts] for extension in extensions: resolved = [ext for ext in self._include_dependencies([extension], alt_path, extensions_data) if ext not in resolved_dependencies] dependencies_list = dependencies_list + self.get_dependencies_list(extension, resolved, ext_list) resolved_dependencies.extend(resolved) for ext in resolved_dependencies: contents.extend( self._smooth_data(extensions_data[ext])) contents = self._move_ioncube_ext(contents) self._write_to_file( user, '\n'.join(contents)+'\n', user_ini_path) self._backup_settings(user) self._reload_processes(user) return list(extensions_data.keys()), dependencies_list, conflict_dependencies def bulk_disable_extensions(self, user, version, ext_list): return self.bulk_handle_extensions(user, self.disable_extensions, version, ext_list) def disable_extensions(self, user, version, ext_list): """ Removes extensions from user php.ini @param user: string @param version: string @param ext_list: list @return: None """ self._check_user_in_cagefs(user) user_ini_path = self._compose_user_ini_path(user, version) alt_path = self._compose_alt_path(version) (contents, extensions, extensions_data) = self._load_ini_contents(user_ini_path) for item in set(ext_list): if item not in extensions_data: continue rest_of_set = set(extensions_data.keys()).difference([item]) if (self._is_dependency(item, rest_of_set, alt_path) and not rest_of_set.issubset(set(ext_list))): clprint.print_diag( 'text', {'status': 'WARN', 'message': '%s left as dependency' % (item,)}) continue extensions_data.pop(item, None) for ext in extensions: if ext not in extensions_data: continue contents.extend( self._smooth_data(extensions_data[ext])) self._write_to_file( user, '\n'.join(contents)+'\n', user_ini_path) self._backup_settings(user) self._reload_processes(user) def reset_extensions(self, user, version): """ Replaces extensions in user php.ini with default ones @param user: string @param version: string @return: list """ if not version: raise ClSelectExcept.EmptyParam('Version') ext_list = ClExtSelect._get_enabled_extensions(self, version) # replace extensions already adapted for multiple users data = self.replace_extensions(user, version, ext_list) return data def _move_ioncube_ext(contents): """ PHP ioncube extensions must be at the beginning of extensions list @param contents: list @return: list """ found = False fixed_contents = [] stripped_contents = [] for item in contents: if item.startswith(';---ioncube'): found = True fixed_contents.append(item) continue if found: if item.startswith(';---'): found = False; else: fixed_contents.append(item) continue stripped_contents.append(item) fixed_contents.extend(stripped_contents) return fixed_contents _move_ioncube_ext = staticmethod(_move_ioncube_ext) @staticmethod def _load_ini_contents(path): """ Parses user ini file contents @param path: string @return: tuple """ contents = [] extensions = [] extensions_data = {} is_content = False is_extension = False ext_name = None try: ini = open(path, 'r') for line in ini: line = line.rstrip() # Check if it is content block (Custom PHP options) if line.startswith(';>==='): is_extension = False is_content = True contents.append(line) # Check if it is extension block elif line.startswith(';---'): tmp_ext_name = line.strip(';- ') if tmp_ext_name == "": continue ext_name = tmp_ext_name is_extension = True # Create the key-value pair if ext_name not in extensions_data: extensions_data[ext_name] = [line] # Processing content elif is_content: # Skip comments if line.startswith(';') and not line.startswith(';<==='): continue # Append until the end of block ('<===') contents.append(line) if line.startswith(';<==='): is_content = False # Processing extensions elif ext_name and is_extension: # Skip comments and empty lines if line.startswith(';') or line == "": continue # Append extension data if ext_name not in extensions: extensions.append(ext_name) if ext_name in extensions_data: extensions_data[ext_name].append(line) ini.close() except (OSError, IOError): pass return contents, extensions, extensions_data def _load_user_extensions(self, user, version): """ Loads user alternative extensions list for a version @param user: string @param version: string """ user_ini_path = self._compose_user_ini_path(user, version) extensions = self._skim_over_extensions(user_ini_path) self._user_extensions.extend(extensions) def _compose_user_ini_path(self, user, version): """ Composes user ini file path @param user: string @param version: string @return: string """ if self.without_cagefs: homedir = self._clpwd.get_homedir(user) php_dir = 'php%s' % version.replace('.', '') return homedir + '/.cl.selector/alt_' + php_dir + '.ini' uid = str(self._clpwd.get_uid(user)) user_prefix = '/' if in_cagefs() else os.path.join(self.CAGEFS_PATH, uid[-2:], user) path = os.path.join(user_prefix, 'etc', 'cl.%s.d' % (self._item,), 'alt-%s%s' % (self._item, version.replace('.', '')), self.USER_INI) return path