ok
Mini Shell
# -*- 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
Zerion Mini Shell 1.0