ok
Mini Shell
# coding=utf-8
#
# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENCE.TXT
#
"""
Main API module that provides class uses as proxy
to public vendors methods and converts data to
internal objects.
"""
import os
import subprocess
from itertools import compress
import json
import jsonschema
import yaml
from jsonschema import ValidationError
from typing import Optional, List, Dict, Any # NOQA
from clcommon.features import ALL_CL_FEATURES
from vendors_api.config import integration_scripts
from vendors_api.exceptions import (
BadScriptError,
MalformedError,
ErrorMessage,
InternalError,
PermissionDenied,
BadRequest,
NotFound,
UnexpectedResult,
VendorApiMalformedData
)
from vendors_api.models import (
PanelInfo,
Databases,
Package,
User,
DomainData,
Reseller,
Admin, InstalledPHP,
)
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
_ERROR_MESSAGE_TO_ERROR = {
ErrorMessage.INTERNAL_ERROR: InternalError,
ErrorMessage.PERMISSION_DENIED: PermissionDenied,
ErrorMessage.BAD_REQUEST: BadRequest,
ErrorMessage.NOT_FOUND: NotFound
}
class PublicApi:
"""
Proxy to the public universal api for control panels
"""
@property
def _scripts(self):
"""
Re-read this each time we call api
due to lve-stats daemon.
"""
# already cached inside and refreshed when
# integration config changes
return integration_scripts()
def _execute(self, command, schema_file):
# type: (List[str], str) -> Any[List[Dict], Dict]
# remove PYTHONPATH and set PYTHONNOUSERSITE to '1' for additional security
env = os.environ.copy()
env.pop('PYTHONPATH', None)
env['PYTHONNOUSERSITE'] = '1'
try:
with subprocess.Popen(command,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
text=True,
env=env) as p:
output, _ = p.communicate()
except OSError as e:
raise BadScriptError(
f"Something is wrong with integration script: `{e}`"
) from e
return self._validate(output, schema_file)
def _error_key_to_error(self, result, message):
# type: (str, str) -> None
"""
Convert documented api error constants into
python exceptions.
:param result: error constant
:param message: custom message that vendor returned
"""
error_cls = _ERROR_MESSAGE_TO_ERROR.get(result)
if error_cls is None:
raise UnexpectedResult(
"Unexpected result key: `%(result)s`; message=`%(error)s`",
result=result, error=message)
raise error_cls(message)
def _validate(self, raw_data, schema_path):
# type: (str, str) -> Any[List, Dict]
"""
Checks input for valid json structure
:param raw_data: json
:return: dict or list
"""
try:
# or {} in order to avoid None
deserialized = json.loads(raw_data) or {}
except (TypeError, ValueError) as e:
raise MalformedError(raw_data) from e
try:
metadata = deserialized['metadata'] or {}
result = metadata['result']
except KeyError as e:
raise MalformedError(output=raw_data) from e
if result == 'ok':
try:
schema = self._read_data_schema(schema_path)
jsonschema.validate(deserialized['data'], schema)
except (ValidationError, KeyError, TypeError) as e:
# TypeError in case when something is None
# KeyError when dict is not complete
raise VendorApiMalformedData(str(e)) from e
return deserialized['data']
else:
self._error_key_to_error(result, message=metadata.get('message'))
def _read_data_schema(self, filename):
# type: (str) -> Dict[str, Any]
"""
Knowing the fact that we store all data schemas
in one folder we can easily find their absolute path.
We do not handle errors here as normally package
contains all it's files.
:param filename: schema filename to load
:return: dict, jsonschema
"""
with open(os.path.join(BASE_DIR, 'schemas', filename), encoding='utf-8') as f:
data_schema = yaml.load(f.read(), yaml.SafeLoader)
return data_schema
def panel_info(self):
# type: () -> PanelInfo
"""
Returns the information about the control panel.
Necessity: Always
Accessed by: All UNIX users
Must work inside CageFS also: Yes
"""
valid_data = self._execute(self._scripts.panel_info, schema_file='panel_info.yaml')
result = PanelInfo(valid_data)
if not result.supported_cl_features:
return result
for feature in result.supported_cl_features:
if feature in ALL_CL_FEATURES:
continue
raise ValidationError(
f"Feature {feature} is not available, "
"please check your panel_info integration script. "
f"Available keys are: {', '.join([f.value for f in ALL_CL_FEATURES])}"
)
return result
def db_info(self):
# type: () -> Databases
"""
Returns the information about databases that are
available to the control panel users and are
managed by the control panel.
Necessity: Only for LVE-Stats
Accessed by: admins (UNIX users)
Must work inside CageFS also: No
"""
valid_data = self._execute(self._scripts.db_info, schema_file='db_info.yaml')
return Databases(valid_data)
def packages(self, owner=None):
# type: (Optional[str]) -> List[Package]
"""
Returns list of abstractions called "package" that
represents a group of users that have the
same default limits.
Necessity: For limits functionality
Accessed by: admins (UNIX users)
Must work inside CageFS also: No
"""
args = self._scripts.packages
if owner is not None:
args += ('--owner', owner)
valid_data = self._execute(args, schema_file='packages.yaml')
return [Package(x) for x in valid_data]
def users(self, owner=None, # type: Optional[str]
package_name=None, # type: Optional[str]
package_owner=None, # type: Optional[str]
filter_names=None, # type: Optional[Any[str, List[str]]]
unix_id=None, # type: Optional[int]
fields=None # type: Optional[List[str]]
):
# type: (...) -> List[User]
"""
Returns information about UNIX users, created
and managed by the control panel.
Necessity: Always
Accessed by: admins (UNIX users)
Must work inside CageFS also: No
"""
allowed_fields = {'id', 'username', 'owner',
'domain', 'package', 'email', 'locale_code'}
if bool(package_name) ^ bool(package_owner):
raise ValueError('You can only use package_name '
'and package_owner in pair')
if not isinstance(fields, (list, tuple, type(None))):
raise ValueError('fields accept only list of strings')
if fields is not None:
# get bunch of requested fields that are not allowed by the api
not_allowed_fields = set(fields) - allowed_fields
if not_allowed_fields:
raise ValueError(f"{not_allowed_fields} are not allowed fields")
exclusive_groups = [
[owner],
[package_name, package_owner],
[filter_names],
[unix_id],
]
# take groups where all args are given
used_args = list(compress(exclusive_groups, [all(i) for i in exclusive_groups]))
if len(used_args) > 1:
raise ValueError(
f"You cannot use all these args in one request: {used_args}"
)
command = self._scripts.users
if owner is not None:
command += ('--owner', owner)
if package_name and package_owner:
command += ('--package-name', package_name,
'--package-owner', package_owner)
if filter_names and isinstance(filter_names, str):
command += ('--username', filter_names)
if unix_id:
command += ('--unix-id', str(unix_id))
if fields:
command += ('--fields', ','.join(fields))
valid_data = self._execute(command, schema_file='users.yaml')
result = [User(x) for x in valid_data]
# special case when we request for many usernames at once
# we do in our code because this can be quite hard for hoster
if isinstance(filter_names, (list, tuple)):
result = [u for u in result if u.username in filter_names]
return result
def domains(self, owner=None, name=None, with_php=False):
# type: (Optional[str], Optional[str], bool) -> Dict[str, DomainData]
"""
Returns key-value object, where a key is a domain (or subdomain)
and a value is DomainData object
Necessity: Selectors, some UI features
Accessed by: All UNIX users
Must work inside CageFS also: Yes
"""
if owner and name:
raise ValueError('you cannot use both owner and name')
command = self._scripts.domains
schema = 'domains.yaml'
if owner:
command += ('--owner', owner)
if name:
command += ('--name', name)
if with_php:
command += ('--with-php', )
schema = 'domains_with_php.yaml'
valid_data = self._execute(command, schema_file=schema)
result = {}
for k, v in valid_data.items():
result[k] = DomainData(v)
return result
def resellers(self, id_=None, filter_names=None):
# type: (Optional[int], Optional[Any[str], List[str]]) -> List[Reseller]
"""
Gives information about resellers who can be users owners
in the control panel. Resellers do not obligatory have
their own same-name UNIX accounts in the system and could
exist only as an account in the control panel.
Necessity: Always
Accessed by: admins (UNIX users)
Must work inside CageFS also: no
:param int id_: int, reseller id
:param filter_names: name or list of reseller names to return
"""
if id_ and filter_names:
raise ValueError('You cannot use id and name at one call')
command = self._scripts.resellers
if id_ is not None:
command += ('--id', str(id_))
if isinstance(filter_names, str):
command += ('--name', filter_names)
valid_data = self._execute(command, schema_file='resellers.yaml')
result = [Reseller(x) for x in valid_data] # type: List[Reseller]
if isinstance(filter_names, (list, tuple)):
result = [u for u in result if u.name in filter_names]
return result
def admins(self, filter_names=None, is_main=None):
# type: (Optional[Any[str, List[str]]], Optional[bool]) -> List[Admin]
"""
Gives information about panel’s administrators,
output information about all panel’s administrators who:
- could be (or actually are) the owners of the users, listed in users()
- could be (or actually are) the owners of the packages, listed in packages()
- has UNIX users with the rights to run LVE Manager UI
Necessity: Always
Accessed by: admins (UNIX users)
Must work inside CageFS also: no
:param filter_names: name or list of names to return
:param is_main: filter output by type of admins:
None means no filtering, return all
False means only additional admins
True means only main admin
"""
if filter_names and is_main is not None:
raise ValueError('unable to use name and is_main at once')
command = self._scripts.admins
if isinstance(filter_names, str):
command += ('--name', filter_names)
if is_main is not None:
command += ('--is-main', str(is_main).lower())
valid_data = self._execute(command, schema_file='admins.yaml')
result = [Admin(x) for x in valid_data] # type: List[Admin]
if isinstance(filter_names, (list, tuple)):
result = [u for u in result if u.name in filter_names]
return result
def php(self) -> List[InstalledPHP]:
"""
Returns list of abstractions called "php" that
represents an installed php with it's binary,
ini file, modules directory, etc
Necessity: For accelerate wp functionality
Accessed by: admins (UNIX users)
Must work inside CageFS also: No
"""
args = self._scripts.php
valid_data = self._execute(args, schema_file='php.yaml')
return [InstalledPHP(x) for x in valid_data]
if __name__ == '__main__':
# usage example
api = PublicApi()
print(api.panel_info())
print(api.users(unix_id=123))
print(api.admins())
print(api.resellers())
print(api.domains())
Zerion Mini Shell 1.0