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 print_function
from __future__ import absolute_import
from __future__ import division
import getopt
import glob
import os
import re
import shutil
import sys
import pwd
import fnmatch
import secureio
import traceback
import requests
import requests.packages.urllib3.exceptions as urllib_exceptions #pylint: disable=E0401
from requests.exceptions import ConnectionError
from future.utils import iteritems
from . import clpassenger
from . import clselectctl
from . import utils
import cldetectlib as detect
from clcommon.cpapi import userdomains, docroot, cpusers, CP_NAME
from clcommon.cpapi.cpapiexceptions import NoDomain, NotSupported
from clcommon.utils import mod_makedirs
from .clselectpython.apps_manager import (
ApplicationsManager,
PythonAppFormatVersion,
get_venv_rel_path
)
from .clselectexcept import ClSelectExcept, BaseClSelectException
from .clselectprint import clprint
from .clselectpythonuser import extensions, environments, interpreters
from .baseclselect import APP_STARTED_CONST, APP_STOPPED_CONST
DEFAULT_STARTUP_FILE = 'passenger_wsgi.py'
DEFAULT_APP_STATE = u'started'
DEFAULT_APP_ENTRYPOINT = 'application'
WSGI_TEMPLATE = r'''import imp
import os
import sys
sys.path.insert(0, os.path.dirname(__file__))
wsgi = imp.load_source('wsgi', '%s')
application = wsgi.%s
'''
_CONFIGURABLE_WSGI_TEMPLATE = r'''import os
import sys
sys.path.insert(0, os.path.dirname(__file__))
def %s(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
message = 'It works!\n'
version = 'Python v' + sys.version.split()[0] + '\n'
response = '\n'.join([message, version])
return [response.encode()]
'''
WSGI_PATTERN = re.compile("imp\.load_source\(.+, '(?P<script>.+)'\)\s+"
"application.+\.(?P<callable>.+)")
def usage():
print('Warning: selectorctl utility for --interpreter python is deprecated. '
'Only update-interpreter option is still possible to use. '
'\nPlease, use cloudlinux-selector utility to manage your python applications')
print(' -v | --version VERSION : Specify alternative version')
print(' -u | --user USERNAME : Username')
print(' --domain DOMAIN : Domain (or subdomain); users main domain as default')
print(' -l | --list : List alternatives for interpreter')
print(' -G | --list-extensions : List global set of packages')
print(' -K | --list-extensions-version : List version set of packages')
print(' -s | --user-summary : List user summary of webapps')
print(' -y | --create-webapp : Create user webapp')
print(' | --update-interpreter : Update binary python in virtual environment; you can use with ')
print(' --user=* for all users; application name as default * (all app)')
print(' -n | --destroy-webapp : Destroy user webapp')
print(' -f | --relocate-webapp : Change webapp directory (files must be moved manually)')
print(' -F | --transit-webapp : Change webapp domain/alias')
print(' -Z | --restart-webapp : Restart webapp')
print(' -t | --stop-webapp : Stop webapp')
print(' -c | --user-current : Show currently selected alternative for user webapp')
print(' -b | --set-user-current : Set alternative as user webapp default')
print(' -e | --enable-user-extensions PACKAGES : Install comma-separated list of packages for user webapp')
print(' -d | --disable-user-extensions PACKAGES : Uninstall comma-separated list of packages for user webapp')
print(" : Use '-' (minus) for all packages")
print(' -r | --replace-user-extensions PACKAGES : Update comma-separated list of packages for user webapp')
print(" : Use '-' (minus) for all packages")
print(' --recreate-virtualenv : Recreate python virtual environment')
print(' --freeze-requirements : Freeze virtual environment installed packages')
print(' -g | --list-user-extensions : List installed packages for user webapp')
print(' -o | --setup-wsgi WSGI[:CALLABLE] : Setup wsgi')
print(' -p | --print-summary : If specified along with setting an alternative ')
print(' prints user summary')
print(' -j | --json : Print data as JSON')
print(' | --verbose : show detail information about action')
def _create_environment(user, directory, version, env_name=None, use_existing=True):
"""
Create new environment (or use existing if use_existing=True)
:param user: unix user name that app belongs to
:param directory: app root
:param version: python version
:param env_name: DEPRECATED
:param use_existing: do not raise exception if env already exists
"""
_, prefix = get_venv_rel_path(user, directory)
if not env_name:
env_name = version
environment = environments.Environment(env_name, user, prefix)
if environment.exists() and not use_existing:
raise ClSelectExcept.EnvironmentAlreadyExists(environment.path)
if not environment.exists():
try:
interpreter = interpreters.interpreters(key='version')[version]
except KeyError:
raise ClSelectExcept.NoSuchAlternativeVersion(version)
environment.create(interpreter)
return environment
def _get_environment(user, directory, app_summary=None, apps_manager=None):
if apps_manager is None:
apps_manager = ApplicationsManager()
try:
if app_summary:
binary = app_summary['binary']
else:
binary = apps_manager.get_binary_path(user, directory, pwd.getpwnam(user).pw_dir)
except ClSelectExcept.ConfigMissingError:
# this method is called in many places,
# there could be case when config is still absent or empty
app_summary = clpassenger.summary(user).get(directory)
if app_summary is None:
raise ClSelectExcept.WebAppError('No such application (or application not configured) "%s"' % directory)
binary = app_summary['binary']
env_name = os.path.basename(os.path.dirname(os.path.dirname(binary)))
_, prefix = get_venv_rel_path(user, directory)
environment = environments.Environment(env_name, user, prefix)
return environment
def create(user, directory, alias, version=None, doc_root=None,
env_vars=None, startup_file=None, domain_name=None, entry_point=None,
apps_manager=None, passenger_log_file=None):
"""
Create new python application
:param user: unix user name
:param directory: application path in user's home (app-root)
:param alias: alias (app-uri)
:param version: version of interpreter
:param doc_root: doc_root
:param env_vars: dict with environment variables
:param startup_file: main application file
:param domain_name: domain name
:param entry_point: application entry point
:param apps_manager: Application Manager. Class that responsible
for gathering and writing information about applications
:param passenger_log_file: Passenger log filename to write to app's .htaccess
:return: None
"""
if apps_manager is None:
apps_manager = ApplicationsManager()
if version is None:
raise ClSelectExcept.WrongData('Not passed version as argument')
alias = clselectctl.get_alias(alias)
user_summary = clpassenger.summary(user)
try:
app_summary = utils.get_using_realpath_keys(user, directory, user_summary)
except KeyError:
pass
else:
raise ClSelectExcept.AppRootBusy(app_summary['directory'])
environment = _create_environment(user, directory, version, use_existing=False)
binary = environment.interpreter().binary
clpassenger.configure(user, directory, alias, apps_manager.INTERPRETER, binary, doc_root=doc_root,
passenger_log_file = passenger_log_file)
clpassenger.restart(user, directory)
# create new startup file with supplied name
if entry_point:
content = _CONFIGURABLE_WSGI_TEMPLATE % entry_point
else:
content = clpassenger.WSGI_TEMPLATE
if startup_file and startup_file != DEFAULT_STARTUP_FILE:
# Custom startup file, use existing mechanism to set new startup file and entrypoint
startup_file_name = _get_full_path_to_startup_file(user, directory, startup_file)
# to be able set /some/not/existing/dir for startup file
dir_name = os.path.dirname(startup_file_name)
if not os.path.exists(dir_name):
mod_makedirs(dir_name, 0o755)
# save new startup file
utils.file_write(startup_file_name, content)
# Set startup file and entrypoint (if need)
if entry_point:
setup_wsgi(user, directory, startup_file_name, entry_point)
else:
# No startup file provided, use default
startup_file = DEFAULT_STARTUP_FILE
# Set new startup_file and/or entrypoint
# build startup_file full path - setup_wsgi function requirement
startup_file_name = _get_full_path_to_startup_file(user, directory, startup_file)
# save new startup file
utils.file_write(startup_file_name, content)
if entry_point:
# Set new entrypoint
setup_wsgi(user, directory, startup_file_name, entry_point)
if not env_vars:
env_vars = {}
if not entry_point:
# if entrypoint not supplied, use default in config.
# We don't need to set it in the application because it the same with passenger settings
entry_point = DEFAULT_APP_ENTRYPOINT
# Add application to user's config file
if not domain_name:
# if domain name not defined - try to determine it
summary_data = clpassenger.summary(user)
app_summary = utils.get_using_realpath_keys(user, directory, summary_data)
domain_name = app_summary['domain']
# TODO: use namedtuple or just class instead of plain dicts
app_data = {
u'python_version': version,
u'app_version': PythonAppFormatVersion.STABLE,
u'domain': domain_name,
u'app_uri': alias,
u'app_status': DEFAULT_APP_STATE,
u'startup_file': startup_file,
u'config_files': [],
u'env_vars': env_vars,
u'entry_point': entry_point
}
if passenger_log_file:
app_data[u'passenger_log_file'] = passenger_log_file
apps_manager.add_app_to_config(user, directory, app_data)
try:
apps_manager.add_env_vars_for_htaccess(user, directory, env_vars, doc_root)
except Exception as err:
clprint.print_diag('text', {'status': 'ERROR', 'message': str(err)})
def _ensure_version_enabled(version, user):
"""
Check whether particular interpreter version is enabled and raises
exception if not
:param user: user to include in exception
"""
from .clselectpython import python_manager
if not python_manager.PythonManager().is_version_enabled(version):
raise ClSelectExcept.UnableToSetAlternative(
user, version, 'version is not enabled')
def check_response_from_webapp(domain, alias, action=None):
"""
Check response from user's webapp before and after calling action.
Also compare both responses
:param domain: domain associated with webapp
:param alias: URI associated with webapp
:param action: called action, that make something with webapp: install modules, transit it, etc
:return: None
"""
app_is_inaccessible_before = 'Web application is inaccessible by its address "%s". The operation wasn\'t performed.'
app_is_inaccessible_after = 'The operation was performed, but check availability of application has failed. ' \
'Web application is inaccessible by its address "%s" after the operation.'
app_is_broken = 'The operation was performed, but check availability of application has failed. ' \
'Web application responds, but its return code "%s" or ' \
'content type before operation "%s" doesn\'t equal to contet type after operation "%s".'
requests.packages.urllib3.disable_warnings(urllib_exceptions.InsecureRequestWarning) #pylint: disable=E1101
if not callable(action):
raise ClSelectExcept.WrongData('Wrong action for calling in checking webapp')
webapp_url = 'https://{domain}/{alias}'.format(
domain=domain,
alias=alias,
)
try:
request = requests.get(webapp_url, verify=False)
except ConnectionError:
# site is not available by https protocol
webapp_url = webapp_url.replace('https://', 'http://')
try:
request = requests.get(webapp_url, verify=False)
except ConnectionError:
raise ClSelectExcept.WebAppError(app_is_inaccessible_before % webapp_url)
before_mime_type = request.headers.get('Content-Type')
before_status = request.headers.get('Status')
action()
try:
request = requests.get(webapp_url, verify=False)
except ConnectionError:
raise ClSelectExcept.WebAppError(app_is_inaccessible_after % webapp_url)
after_mime_type = request.headers.get('Content-Type')
after_status = request.headers.get('Status')
# assume that app is broken if:
# it's response Content-Type or Status code (if first code wasn't 500) changed
# if last Status code was 500 (internal error)
if before_mime_type.lower() != after_mime_type.lower() or \
(before_status != after_status and before_status is not None and before_status[:3] != '500') \
or (after_status is not None and after_status[:3] == '500'):
raise ClSelectExcept.WebAppError(app_is_broken % (after_status, before_mime_type, after_mime_type))
def _get_info_about_webapp(app_summary=None, user=None):
"""
Get info (alias and domain) about user's web application
:param app_summary: dict -> summary info about user's web application
:param user: str -> name of unix user
:return: tuple -> (alias, domain)
"""
if app_summary is None:
raise ClSelectExcept.WrongData('Was passed incorrect summary info about application')
if user is None:
raise ClSelectExcept.WrongData('Was passed incorrect name of user')
alias = app_summary['alias']
user_domains = userdomains(user)
found_domains = [
domain for domain, doc_root in user_domains
if utils.realpaths_are_equal(user, doc_root, app_summary['docroot'])]
if len(found_domains) == 0:
raise ClSelectExcept.WrongData('Can not found suitable domain for application')
app_domain = found_domains[0]
return alias, app_domain
def destroy(user, app_directory, doc_root, apps_manager=None):
"""
Destroy web app with specified directory for specified user
:param user: username
:param app_directory: application directory
:param doc_root: Document root for selected domain
:param apps_manager: Application Manager. Class that responsible
for gathering and writing information about applications
:return: None
"""
if apps_manager is None:
apps_manager = ApplicationsManager()
# get app state
app_config = apps_manager.get_app_config(user, app_directory)
# remove env from htaccess
try:
# if domain is already removed we shouldn't do anything
if doc_root is not None:
apps_manager.add_env_vars_for_htaccess(user, app_directory, None, doc_root)
except Exception as err:
clprint.print_diag('text', {'status': 'ERROR', 'message': str(err)})
if app_config is not None and app_config.get('app_status') == APP_STOPPED_CONST:
# stopped app
user_home = pwd.getpwnam(user).pw_dir
# Remove app's virtualenv, e.g. /home/cltest1/virtualenv/test_app
# TODO: Account for possible symlinks in LU-832
virtual_env_path = os.path.join(
user_home, get_venv_rel_path(user, app_directory)[1])
try:
shutil.rmtree(virtual_env_path)
except OSError:
pass
# if domain is already removed we shouldn't do anything
if doc_root is not None:
# Remove passenger lines from .htaccess
htaccess_filename = apps_manager.get_htaccess_by_appdir(user, app_directory, doc_root)
clpassenger.remove_passenger_lines_from_htaccess(htaccess_filename)
# remove app from python-selector.json file
apps_manager.remove_app_from_config(user, app_directory)
# Update application status in passenger
clpassenger.restart(user, app_directory)
return
# Moved before removing an app from node-selector.json because in case if
# app_root is absent we still want to remove venv dir of an application.
# The method didn't anyhing if app_root is absent and skip other commands
# including removal of a venv dir
_, prefix = get_venv_rel_path(user, app_directory)
abs_dir, _ = utils.get_abs_rel(user, prefix)
try:
# Remove app's virtualenv, e.g. /home/cltest1/virtualenvnv/test_app
shutil.rmtree(abs_dir)
except OSError:
pass
user_summary = clpassenger.summary(user)
# remove app from python-selector.json file
app_in_config = apps_manager.remove_app_from_config(user, app_directory)
try:
utils.get_using_realpath_keys(user, app_directory, user_summary)
except KeyError:
# if app was existed and app's dir is not exists, we skip all further actions
if app_in_config:
return None
else:
raise ClSelectExcept.WrongData("No such application (or application not configured) \"%s\""
% app_directory)
# remove app from passenger
clpassenger.unconfigure(user, app_directory) # Clear .htaccess
try:
clpassenger.restart(user, app_directory)
except ClSelectExcept.MissingApprootDirectory:
pass
def fix_homedir(user):
user = clselectctl.get_user(user)
envs, _ = utils.get_abs_rel(user, environments.DEFAULT_PREFIX)
for env in glob.glob(os.path.join(envs, '*', '*')):
for script in glob.glob(os.path.join(env, 'bin', '*')):
# we should not even try to read symlinks
if os.path.islink(script):
continue
old_script = utils.file_read(script, 'rb')
new_script = []
encoded_env = env.encode()
# in fact, this is only for activate scripts
if b'VIRTUAL_ENV' in old_script:
for line in old_script.splitlines():
if b'VIRTUAL_ENV' in line:
# matches both cases with single and double quotes
# example: VIRTUAL_ENV="<some_path>" VIRTUAL_ENV='<some_path>'
line = re.sub(
rb'VIRTUAL_ENV[^\\]([\"\'])(?P<old_path>.+)\1$',
lambda m: m.group(0).replace(m.group('old_path'), encoded_env),
line)
new_script.append(line)
# change all shebangs to python
# TODO: what about shebangs to global python?
elif old_script.startswith(b'#!'):
new_script = old_script.splitlines()
new_script[0] = b'#!%s/bin/python' % encoded_env
if new_script:
utils.file_writelines(script, (b'%s\n' % line for line in new_script), 'wb')
def install(user, directory, extension=None, requirements_path=None, skip_web_check=False, apps_manager=None):
"""
Install defined extension to python web application
:param requirements_path: path to the text file with list of python modules for installation
:param user: name of owner of web application
:param directory: application's root
:param extension: name of installed module
:param skip_web_check: skip check web application after change it's properties
:param apps_manager: Application Manager. Class that responsible
for gathering and writing information about applications
:return: None
"""
if apps_manager is None:
apps_manager = ApplicationsManager()
user = clselectctl.get_user(user)
user_config = apps_manager.get_user_config_data(user)
try:
app_data = utils.get_using_realpath_keys(user, directory, user_config)
except KeyError:
raise ClSelectExcept.WrongData('Record about application {} is absent'.format(directory))
if app_data['app_status'] != APP_STARTED_CONST:
skip_web_check = True
environment = _get_environment(user, directory, apps_manager=apps_manager)
def action():
if extension is not None:
environment.extension_install(extension)
elif requirements_path is not None:
environment.extension_install_requirements(os.path.join(directory, requirements_path))
if not skip_web_check:
try:
check_response_from_webapp(
domain=app_data['domain'],
alias=app_data['app_uri'],
action=action,
)
except ClSelectExcept.WebAppError as err:
raise ClSelectExcept.WebAppError('An error occured during installation of modules. %s' % err)
else:
action()
def list_extensions(user, directory):
user = clselectctl.get_user(user)
environment = _get_environment(user, directory)
return environment.extensions()
def restart(user, app_directory, doc_root=None, apps_manager=None):
"""
Restarts web app with specified directory for specified user
:param user: username
:param app_directory: application directory
:param doc_root: Document root for selected domain
:param apps_manager: Application Manager. Class that responsible
for gathering and writing information about applications
:return: None
"""
if apps_manager is None:
apps_manager = ApplicationsManager()
app_config = apps_manager.get_app_config(user, app_directory)
if app_config is not None and app_config.get('app_status') == APP_STOPPED_CONST:
# If application was stopped - start it
# doc_root is None during 'update-interpreter' command
if doc_root is not None:
start(user, app_directory, doc_root)
else:
apps_summary = clpassenger.summary(user)
if app_directory not in apps_summary:
raise ClSelectExcept.WrongData(
'No such application (or application not configured) "%s"' % app_directory)
clpassenger.restart(user, app_directory)
def stop(user, app_directory, doc_root, apps_manager=None):
"""
Stops web app with specified directory for specified user
:param user: username
:param app_directory: application directory
:param doc_root: Document root for selected domain
:param apps_manager: Application Manager. Class that responsible
for gathering and writing information about applications
:return: None
"""
if apps_manager is None:
apps_manager = ApplicationsManager()
app_config = apps_manager.get_app_config(user, app_directory)
if app_config is None:
raise ClSelectExcept.WrongData("No such application (or application not configured) \"%s\""
% app_directory)
# Do nothing if application already stopped
if app_config.get('app_status') == APP_STOPPED_CONST:
return
htaccess_filename = apps_manager.get_htaccess_by_appdir(user, app_directory, doc_root, app_config)
# Remove passenger lines from .htaccess
clpassenger.remove_passenger_lines_from_htaccess(htaccess_filename)
# Save new application status in user's config
apps_manager.set_app_status(user, app_directory, APP_STOPPED_CONST)
# Update application status in passenger
clpassenger.restart(user, app_directory)
def start(user, app_directory, doc_root, apps_manager=None):
"""
Starts web app with specified directory for specified user
:param user: username
:param app_directory: application directory
:param doc_root: Document root for selected domain
:param apps_manager: Application Manager. Class that responsible
for gathering and writing information about applications
:return: None
"""
if apps_manager is None:
apps_manager = ApplicationsManager()
app_config = apps_manager.get_app_config(user, app_directory)
if app_config is None:
raise ClSelectExcept.WrongData("No such application (or application not configured) \"%s\""
% app_directory)
# Do nothing if application already started
if app_config.get('app_status') == APP_STARTED_CONST:
return
# Create .htaccess file for the application
apps_manager.update_htaccess_file(user, app_directory, doc_root)
# Save new application status in user's config
apps_manager.set_app_status(user, app_directory, APP_STARTED_CONST)
# Update application status in passenger
clpassenger.restart(user, app_directory)
# Update wsgi file. It can be changed while app was stopped
startup_file = app_config.get('startup_file')
if startup_file != DEFAULT_STARTUP_FILE:
startup_file_full_path = _get_full_path_to_startup_file(
user,
app_directory,
app_config.get('startup_file'),
)
setup_wsgi(user, app_directory, startup_file_full_path, app_config.get('entry_point'))
def setup_wsgi(user, directory, wsgi_path, callable_object=None):
user = clselectctl.get_user(user)
abs_dir, _ = utils.get_abs_rel(user, directory)
apps_summary = clpassenger.summary(user)
if directory not in apps_summary:
raise ClSelectExcept.WrongData("No such application (or application not configured) \"%s\"" % directory)
if os.path.isabs(wsgi_path):
if not os.path.isfile(wsgi_path):
raise ClSelectExcept.WrongData('No such WSGI script \"%s\"' % wsgi_path)
wsgi_path = utils.s_partition(wsgi_path, abs_dir)[2].strip(os.path.sep)
if not wsgi_path:
raise ClSelectExcept.WrongData('WSGI script is not in webapp directory')
else:
raise ClSelectExcept.WrongData('Path to WSGI script must be absolute')
app_wsgi = os.path.join(abs_dir, clpassenger.WSGI_PATH)
# Set new callable object if need
if not callable_object:
callable_object = DEFAULT_APP_ENTRYPOINT
utils.file_write(app_wsgi, WSGI_TEMPLATE % (wsgi_path, callable_object), 'w')
# Restart application
clpassenger.restart(user, directory)
def has_virtenv_dir(user):
"""
return True if user home dir has virtualenv dir
"""
homedir = pwd.getpwnam(user).pw_dir
path = os.path.join(homedir, 'virtualenv')
return os.path.isdir(path)
def summary(user):
user = clselectctl.get_user(user)
summ = {}
if not has_virtenv_dir(user):
return summ
for directory, data in iteritems(clpassenger.summary(user)):
if data['interpreter'] != ApplicationsManager.INTERPRETER:
continue
try:
environment = _get_environment(user, directory, data).as_deepdict()
app_wsgi = os.path.join(data['directory'], clpassenger.WSGI_PATH)
wsgi_conf = utils.file_read(app_wsgi)
match = WSGI_PATTERN.search(wsgi_conf)
if match:
groupdict = match.groupdict()
wsgi_path = groupdict['script']
callable_object = groupdict['callable']
else:
wsgi_path = callable_object = ''
env_info = {
'alias': data['alias'],
'domain': data['domain'],
'environment': environment['name'],
'interpreter': environment['interpreter'],
'extensions': environment['extensions'],
'wsgi': {'script': wsgi_path, 'callable': callable_object},
}
# add only list with additions domains
if "domains" in data and len(data["domains"]) > 1:
env_info["domains"] = data["domains"]
except Exception as e:
env_info = {"error": str(e)}
summ[directory] = env_info
return summ
def _get_full_path_to_startup_file(user, directory, startup_file):
# type: (str, str, str) -> str
"""
:param user: name of system user
:param directory: name of dir with python applicatoin
:param startup_file: name of startup file of python application
Get full path to startup file of python application
"""
abs_dir, rel_dir = utils.get_abs_rel(user, directory)
return os.path.join(abs_dir, startup_file)
def uninstall(user, directory, extension):
user = clselectctl.get_user(user)
environment = _get_environment(user, directory)
environment.extension_uninstall(extension)
def update(user, directory, extension):
user = clselectctl.get_user(user)
environment = _get_environment(user, directory)
environment.extension_update(extension)
# TODO: We should remove that method completely, because this script already doesn't caused directly
def main():
try:
opts, args = getopt.getopt(
sys.argv[1:],
'hi:v:u:lGsynfFZtcbe:d:r:go:pjK:', [
'help',
'interpreter=',
'version=',
'user=',
'domain=',
'list',
'list-extensions',
'user-summary',
'create-webapp',
'update-interpreter',
'destroy-webapp',
'relocate-webapp',
'transit-webapp',
'restart-webapp',
'start-webapp',
'stop-webapp',
'user-current',
'set-user-current',
'enable-user-extensions=',
'disable-user-extensions=',
'replace-user-extensions=',
'recreate-virtualenv',
'freeze-requirements',
'list-user-extensions',
'setup-wsgi=',
'print-summary',
'json',
'verbose',
'list-extensions-version='
])
except getopt.GetoptError as err:
sys.stderr.write(str(err))
usage()
sys.exit(1)
ext_list = ''
fmt = 'text'
verbose = False
print_summary = False
user = None
domain = None
action = ''
version = None
if not opts:
usage()
sys.exit(1)
allowed_opts = ('--update-interpreter', )
if not any(item[0] in allowed_opts for item in opts):
clprint.print_diag(fmt, {'status': 'ERROR',
'message': 'Unsupported option was passed. Currently, selectorctl utility '
'supports only update-interpreter option. '
'Please, use cloudlinux-selector utility for python '
'interpreter'})
sys.exit(1)
for o, a in opts:
if o in ('-i', '--interpreter'):
pass
elif o in ('-l', '--list'):
action = 'list'
elif o in ('-y', '--create-webapp'):
action = 'create-webapp'
elif o == '--update-interpreter':
action = 'update-interpreter'
elif o in ('-n', '--destroy-webapp'):
action = 'destroy-webapp'
elif o in ('-f', '--relocate-webapp'):
action = 'relocate-webapp'
elif o in ('-F', '--transit-webapp'):
action = 'transit-webapp'
elif o in ('-Z', '--restart-webapp'):
action = 'restart-webapp'
elif o in ('-S', '--start-webapp'):
action = 'start-webapp'
elif o in ('-t', '--stop-webapp'):
action = 'stop-webapp'
elif o in ('-c', '--user-current'):
action = 'user-current'
elif o in ('-b', '--set-user-current'):
action = 'set-user-current'
elif o in ('-g', '--list-user-extensions'):
action = 'list-user-extensions'
elif o in ('-e', '--enable-user-extensions'):
action = 'enable-user-extensions'
ext_list = a
elif o in ('--recreate-virtualenv',):
action = 'recreate-virtualenv'
ext_list = a
elif o in ('--freeze-requirements',):
action = 'freeze-requirements'
ext_list = a
elif o in ('-s', '--user-summary'):
action = 'user-summary'
elif o in ('-j', '--json'):
fmt = 'json'
elif o == '--verbose':
verbose = True
elif o in ('-r', '--replace-user-extensions'):
action = 'replace-user-extensions'
ext_list = a
elif o in ('-d', '--disable-user-extensions'):
action = 'disable-user-extensions'
ext_list = a
elif o in ('-v', '--version'):
version = a
elif o in ('-G', '--list-extensions'):
action = 'list-extensions'
elif o in ('-u', '--user'):
user = a.strip("'\"") # for deleting \' and \"
elif o == '--domain':
domain = a
elif o in ('-o', '--setup-wsgi'):
action = 'setup-wsgi'
wsgi_path, _, callable_object = utils.s_partition(a, ':')
elif o in ('-p', '--print-summary'):
print_summary = True
elif o in ('-K', '--list-extensions-version'):
action = 'list-extensions-version'
ext_list = a
else:
sys.stderr.write('unhandled option')
sys.exit(1)
if action == '':
sys.stderr.write('ERROR:you must provide option for interpreter python')
sys.exit(1)
if action in (
'create-webapp',
'destroy-webapp',
'relocate-webapp',
'transit-webapp',
'restart-webapp',
'start-webapp',
'stop-webapp',
'enable-user-extensions',
'list-user-extensions',
'replace-user-extensions',
'disable-user-extensions',
'setup-wsgi',
'user-current',
'set-user-current',
):
if not args:
sys.stderr.write('webapp must be specified')
sys.exit(3)
if ext_list == '-':
if action == 'enable-user-extensions':
sys.stderr.write('installation of all extensions is not possible')
sys.exit(4)
elif ext_list:
_exts = [_f for _f in ext_list.split(',') if _f]
if domain:
try:
doc_root, user_ = docroot(domain)
except NoDomain:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': 'No such domain: "%s"' % domain})
sys.exit(1)
except NotSupported:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': 'Python selector not supported for %s' % CP_NAME})
sys.exit(1)
if not user: # we can obtain user name for domain
user = user_
elif user != user_:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': 'domain "%s" is not owned by the user "%s"' % (domain, user)})
sys.exit(1)
else:
# commands that need user specified
if action in (
'create-webapp',
'destroy-webapp',
'relocate-webapp',
'transit-webapp',
'restart-webapp',
'start-webapp',
'stop-webapp',
'enable-user-extensions',
'list-user-extensions',
'replace-user-extensions',
'disable-user-extensions',
'setup-wsgi',
'user-summary',
'update-interpreter',
'user-current',
'set-user-current',
):
try:
user = clselectctl.get_user(user)
except ValueError as e:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': str(e)})
sys.exit(1)
if user and not action == 'update-interpreter':
try:
domain_list = userdomains(user)
except NotSupported:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': 'Python selector not supported for %s' % CP_NAME})
sys.exit(1)
_, doc_root = domain_list[0] # get document root for main domain
try:
error = 0
ok = 0
result = {}
if action == 'list-extensions':
raise DeprecationWarning('%s is deprecated in old python selector' % action)
elif action == 'list-extensions-version':
result = extensions.ExtensionInfo().list_extensions_version(_exts)
ext_list = ''
elif action == 'list':
result = interpreters.interpreters_dict('version')
elif action == 'user-summary':
result = summary(user)
elif action == 'create-webapp':
create(user, args[0], args[1], version, doc_root=doc_root)
elif action == 'update-interpreter':
app_name = '*' # all applications as default
if len(args) == 1:
app_name = args[0].strip("'\"")
update_interpreter(user=user, app_name=app_name, version=(version,), verbose=verbose)
elif action == 'destroy-webapp':
destroy(user, args[0], doc_root)
elif action == 'relocate-webapp':
raise DeprecationWarning('%s is deprecated in old python selector' % action)
elif action == 'transit-webapp':
new_doc_root = None
if domain: # remove app to new domain if domain present
new_doc_root = doc_root
raise DeprecationWarning('%s is deprecated in old python selector' % action)
elif action == 'restart-webapp':
# username, app-dir
restart(user, args[0], doc_root)
elif action == 'start-webapp':
# username, app-dir, doc_root
start(user, args[0], doc_root)
elif action == 'stop-webapp':
# username, app-dir, doc_root
stop(user, args[0], doc_root)
elif action == 'user-current':
raise DeprecationWarning('%s is deprecated in old python selector' % action)
elif action == 'set-user-current':
raise DeprecationWarning('%s is deprecated in old python selector' % action)
elif action == 'list-user-extensions':
result = list_extensions(user, args[0])
elif action == 'setup-wsgi':
# --setup-wsgi=<file_path:callable>
# args[0] -- app_root
# wsgi_path -- file_path
# callable_object -- callable
setup_wsgi(user, args[0], wsgi_path, callable_object)
elif action == 'recreate-virtualenv':
for env in environments.environments():
env.recreate()
elif action == 'freeze-requirements':
for env in environments.environments():
env.pip_freeze()
else:
alias = args[0]
if ext_list == '-':
_exts = list_extensions(user, alias)
for extension in _exts:
try:
if action == 'enable-user-extensions':
install(user, alias, extension)
elif action == 'disable-user-extensions':
uninstall(user, alias, extension)
elif action == 'replace-user-extensions':
update(user, alias, extension)
result.update({extension: {'status': 'OK'}})
ok += 1
except (ValueError, ClSelectExcept.ExternalProgramFailed) as err:
result.update(
{extension: {'status': 'ERROR', 'message': str(err)}})
error += 1
except (BaseClSelectException, extensions.PyPIRpcApiError) as err:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': str(err)})
sys.exit(1)
except NotSupported:
clprint.print_diag(fmt, {'status': 'ERROR', 'message': 'Python selector not supported for %s' % CP_NAME})
sys.exit(1)
except Exception as err:
msg = traceback.format_exc()
clprint.print_diag(fmt, {'status': 'ERROR', 'message': msg})
sys.exit(1)
if not result and print_summary:
result = summary(user)
if error and ok:
status = 'PARTIAL'
exit_status = 2
elif error:
status = 'ERROR'
exit_status = 5
else:
if ext_list and ok < 2:
if print_summary:
clprint.print_data(fmt, summary(user))
else:
clprint.print_data(fmt, {})
else:
clprint.print_data(fmt, result)
sys.exit(0)
message = '\n'.join(
'%s: %s' % (k, v.get('message', v.get('status', '')))
for k, v in iteritems(result))
clprint.print_diag(fmt, {'status': status, 'message': message})
sys.exit(exit_status)
def _glob_users(user='*'):
"""
Return filtered control panels users
:param user:
:return:
"""
return [user_name for user_name in cpusers() if fnmatch.fnmatch(user_name, user)]
def update_interpreter(user='*', version=('2.7', '3.3', '3.4'), app_name='*', verbose=True):
if detect.is_plesk():
sys.stderr.write("WARNING: Update interpreter with Python selector not supported on %s, skipped\n" % CP_NAME)
return
alt_interpreters_dict = interpreters.interpreters(key='version') # obtain data about installed alt-python
is_da_panel = detect.detect_DA_admin()
apps_manager = ApplicationsManager()
for user_name in _glob_users(user):
if is_da_panel and utils.user_should_be_skipped(user_name):
continue
if not has_virtenv_dir(user_name):
continue
# change uid/gid to user_name
user_pwd = pwd.getpwnam(user_name)
real_uid = os.getuid()
real_gid = os.getgid()
os.setregid(user_pwd.pw_gid, real_uid)
os.setreuid(user_pwd.pw_uid, real_gid)
# turns off quota
secureio.set_capability()
# get users apps from selector json config
for app_name_, data in iteritems(apps_manager.get_user_config_data(user_name)):
if not fnmatch.fnmatch(app_name_, app_name): # filtering application name
continue
try:
environment = _get_environment(user_name, app_name_, apps_manager=apps_manager)
env_python_ver = environment.interpreter().version
if env_python_ver not in version: # filtering virtual environment python version
continue
if verbose:
print('Updating user: "%s"; application: "%s"...' % (user_name, app_name_))
update_result = environment.update_python_interpreter(backup=True, verbose=verbose, force=False,
_alt_interpreters_dict=alt_interpreters_dict)
if update_result: # restart application only if updating success
try:
# do not worry, stopped apps will not be started
# see restart method for details
restart(user_name, app_name_)
except (OSError, IOError) as e:
if verbose:
print('Failed to restart application "%s"; %s' % (app_name_, str(e)))
except ClSelectExcept.InterpreterError as e:
if verbose:
print('Failed updating user: "%s"; application: "%s"; %s' % (user_name, app_name_, str(e)))
# restore original uid/gid
os.setuid(real_uid)
os.setgid(real_gid)
Zerion Mini Shell 1.0