mirror of
https://github.com/YunoHost/moulinette.git
synced 2024-09-03 20:06:31 +02:00
952 lines
33 KiB
Python
952 lines
33 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import os
|
|
import sys
|
|
import json
|
|
import shutil
|
|
import stat
|
|
import yaml
|
|
import time
|
|
from yunohost import YunoHostError, YunoHostLDAP, win_msg, random_password, lvl, is_true, lemon_configuration
|
|
from yunohost_domain import domain_list, domain_add
|
|
from yunohost_user import user_info
|
|
|
|
repo_path = '/var/cache/yunohost/repo'
|
|
apps_path = '/usr/share/yunohost/apps'
|
|
apps_setting_path= '/etc/yunohost/apps/'
|
|
a2_settings_path = '/etc/yunohost/apache/domains/'
|
|
a2_template_path = '/etc/yunohost/apache/templates'
|
|
install_tmp = '/tmp/yunohost/install'
|
|
app_tmp_folder = install_tmp + '/from_file'
|
|
lemon_tmp_conf = '/tmp/tmplemonconf'
|
|
|
|
def app_listlists():
|
|
"""
|
|
List fetched lists
|
|
|
|
Returns:
|
|
Dict of lists
|
|
|
|
"""
|
|
list_list = []
|
|
try:
|
|
for filename in os.listdir(repo_path):
|
|
if '.json' in filename:
|
|
list_list.append(filename[:len(filename)-5])
|
|
except OSError:
|
|
raise YunoHostError(1, _("No list found"))
|
|
|
|
return { 'Lists' : list_list }
|
|
|
|
|
|
def app_fetchlist(url=None, name=None):
|
|
"""
|
|
Fetch application list
|
|
|
|
Keyword arguments:
|
|
url -- Custom list URL
|
|
name -- Name of the app list
|
|
|
|
Returns:
|
|
True | YunoHostError
|
|
|
|
"""
|
|
# Create app path if not exists
|
|
try: os.listdir(repo_path)
|
|
except OSError: os.makedirs(repo_path)
|
|
|
|
if not url:
|
|
url = 'http://app.yunohost.org/list.json'
|
|
name = 'yunohost'
|
|
else:
|
|
if not name: raise YunoHostError(22, _("You must indicate a name for your custom list"))
|
|
|
|
if os.system('wget "'+ url +'" -O "'+ repo_path +'/'+ name +'.json"') != 0:
|
|
raise YunoHostError(1, _("List server connection failed"))
|
|
|
|
win_msg(_("List successfully fetched"))
|
|
|
|
|
|
def app_removelist(name):
|
|
"""
|
|
Remove specified application list
|
|
|
|
Keyword arguments:
|
|
name -- Name of the list to remove
|
|
|
|
"""
|
|
try:
|
|
os.remove(repo_path +'/'+ name + '.json')
|
|
except OSError:
|
|
raise YunoHostError(22, _("Unknown list"))
|
|
|
|
win_msg(_("List successfully removed"))
|
|
|
|
|
|
def app_list(offset=None, limit=None, filter=None, raw=False):
|
|
"""
|
|
List available applications
|
|
|
|
Keyword arguments:
|
|
offset -- App to begin with
|
|
limit -- Number of apps to list
|
|
filter -- Name filter
|
|
raw -- Return the full app_dict
|
|
|
|
Returns:
|
|
Dict of apps
|
|
|
|
"""
|
|
# TODO: List installed applications
|
|
|
|
if offset: offset = int(offset)
|
|
else: offset = 0
|
|
if limit: limit = int(limit)
|
|
else: limit = 1000
|
|
|
|
applists = os.listdir(repo_path)
|
|
app_dict = {}
|
|
list_dict = {}
|
|
|
|
if not applists: app_fetchlist()
|
|
|
|
for applist in applists:
|
|
if '.json' in applist:
|
|
with open(repo_path +'/'+ applist) as json_list:
|
|
app_dict.update(json.loads(str(json_list.read())))
|
|
|
|
if len(app_dict) > (0 + offset) and limit > 0:
|
|
i = 0 + offset
|
|
sorted_app_dict = {}
|
|
for sorted_keys in sorted(app_dict.keys())[i:]:
|
|
if i <= limit:
|
|
sorted_app_dict[sorted_keys] = app_dict[sorted_keys]
|
|
i += 1
|
|
for app_id, app_info in sorted_app_dict.items():
|
|
if (filter and ((filter in app_id) or (filter in app_info['manifest']['name']))) or not filter:
|
|
instance_number = len(_installed_instance_number(app_id))
|
|
if instance_number > 1:
|
|
installed_txt = 'Yes ('+ str(instance_number) +' times)'
|
|
elif instance_number == 1:
|
|
installed_txt = 'Yes'
|
|
else:
|
|
installed_txt = 'No'
|
|
|
|
if raw:
|
|
list_dict[app_id] = app_info
|
|
else:
|
|
list_dict[app_id] = [
|
|
('Name', app_info['manifest']['name']),
|
|
('Version', app_info['manifest']['version']),
|
|
('Description', app_info['manifest']['description']),
|
|
('Installed', installed_txt)
|
|
]
|
|
|
|
return list_dict
|
|
|
|
|
|
def app_info(app, instance=None, raw=False):
|
|
"""
|
|
Fetch informations for selected apps
|
|
|
|
Keyword arguments:
|
|
app -- App ID
|
|
instance -- Specific number of instance to get info from
|
|
raw -- Return the full app_dict
|
|
|
|
Returns:
|
|
Dict | Fail
|
|
|
|
"""
|
|
try:
|
|
app_info = app_list(filter=app, limit=1, raw=True)[app]
|
|
except YunoHostError:
|
|
app_info = {}
|
|
|
|
# If installed
|
|
instance_number = len(_installed_instance_number(app))
|
|
if instance_number > 0 and instance:
|
|
unique_app_id = app +'__'+ instance
|
|
with open(apps_setting_path + unique_app_id+ '/manifest.webapp') as json_manifest:
|
|
app_info['manifest'] = json.loads(str(json_manifest.read()))
|
|
with open(apps_setting_path + unique_app_id +'/app_settings.yml') as f:
|
|
app_info['settings'] = yaml.load(f)
|
|
|
|
if raw:
|
|
return app_info
|
|
else:
|
|
return [
|
|
('Name', app_info['manifest']['name']),
|
|
('Version', app_info['manifest']['version']),
|
|
('Description', app_info['manifest']['description']),
|
|
#TODO: Add more infos
|
|
]
|
|
|
|
|
|
def app_map(app=None, raw=False):
|
|
"""
|
|
Map of installed apps
|
|
|
|
Keyword arguments:
|
|
app -- App ID of app to map
|
|
raw -- Return complete dict
|
|
|
|
Returns:
|
|
Dict
|
|
"""
|
|
|
|
result = {}
|
|
|
|
for unique_app_id in os.listdir(apps_setting_path):
|
|
if app and (app != unique_app_id) and (app != unique_app_id[:unique_app_id.find('__')]):
|
|
continue
|
|
|
|
with open(apps_setting_path + unique_app_id +'/app_settings.yml') as f:
|
|
app_settings = yaml.load(f)
|
|
|
|
if raw:
|
|
if app_settings['domain'] not in result:
|
|
result[app_settings['domain']] = {}
|
|
result[app_settings['domain']][app_settings['path']] = {
|
|
'label': app_settings['label'],
|
|
'uid': app_settings['uid'],
|
|
'instance': app_settings['instance'],
|
|
}
|
|
else:
|
|
result['https://'+app_settings['domain']+app_settings['path']] = app_settings['label']
|
|
|
|
return result
|
|
|
|
|
|
def app_upgrade(app, instance=[], url=None, file=None):
|
|
"""
|
|
Upgrade selected apps
|
|
|
|
Keyword arguments:
|
|
app -- List of app_id to upgrade (default all upgradable app)
|
|
instance -- Specific number(s) of instance(s) to upgrade
|
|
url -- Git url to fetch before upgrade
|
|
file -- Folder or tarball for upgrade
|
|
|
|
Returns:
|
|
Win | Fail
|
|
|
|
"""
|
|
with YunoHostLDAP() as yldap:
|
|
try:
|
|
app_list()
|
|
except YunoHostError:
|
|
raise YunoHostError(1, _("No app to upgrade"))
|
|
|
|
upgraded_apps = []
|
|
if not app:
|
|
unique_app_id_list = os.listdir(apps_setting_path)
|
|
for unique_app_id in unique_app_id_list:
|
|
app_id = unique_app_id[:unique_app_id.find('__')]
|
|
if app_id not in app:
|
|
app.append(app_id)
|
|
|
|
for app_id in app:
|
|
instance_number = _installed_instance_number(app_id)
|
|
if instance_number == 0:
|
|
raise YunoHostError(1, app_id + _(" is not installed"))
|
|
elif not instance:
|
|
instance = range(1, instance_number + 1)
|
|
|
|
for number in instance:
|
|
if int(number) > instance_number:
|
|
continue
|
|
number = str(number)
|
|
unique_app_id = app_id +'__'+ number
|
|
if unique_app_id in upgraded_apps:
|
|
raise YunoHostError(1, _("Conflict, multiple upgrades of the same app: ")+ app_id +' (instance n°'+ number +')')
|
|
|
|
current_app_dict = app_info(app_id, instance=number, raw=True)
|
|
new_app_dict = app_info(app_id, raw=True)
|
|
|
|
if file:
|
|
manifest = _extract_app_from_file(file)
|
|
elif url:
|
|
manifest = _fetch_app_from_git(url)
|
|
elif (new_app_dict['lastUpdate'] > current_app_dict['lastUpdate']) or ('update_time' not in current_app_dict['settings'] and (new_app_dict['lastUpdate'] > current_app_dict['settings']['install_time'])) or ('update_time' in current_app_dict['settings'] and (new_app_dict['lastUpdate'] > current_app_dict['settings']['update_time'])):
|
|
manifest = _fetch_app_from_git(app_id)
|
|
else:
|
|
continue
|
|
|
|
is_web = lvl(manifest, 'yunohost', 'webapp')
|
|
|
|
app_final_path = apps_path +'/'+ unique_app_id
|
|
script_var_dict = {
|
|
'APP_DIR': app_tmp_folder,
|
|
'APP_FINAL_DIR': app_final_path,
|
|
'APP_ID': unique_app_id
|
|
}
|
|
|
|
if is_web:
|
|
script_var_dict.update({
|
|
'APP_DOMAIN': current_app_dict['settings']['domain'],
|
|
'APP_PATH': current_app_dict['settings']['path']
|
|
})
|
|
|
|
|
|
#########################################
|
|
# Install dependencies #
|
|
#########################################
|
|
|
|
if lvl(manifest, 'dependencies'):
|
|
_install_app_dependencies(manifest['dependencies'])
|
|
|
|
|
|
#########################################
|
|
# DB Vars #
|
|
#########################################
|
|
|
|
if lvl(manifest, 'yunohost', 'webapp', 'db'):
|
|
script_var_dict.update({
|
|
'DB_USER': current_app_dict['settings']['db_user'],
|
|
'DB_PWD': current_app_dict['settings']['db_pwd'],
|
|
'DB_NAME': current_app_dict['settings']['db_user']
|
|
})
|
|
|
|
#########################################
|
|
# Execute App install script #
|
|
#########################################
|
|
|
|
if lvl(manifest, 'yunohost', 'script_path'):
|
|
_exec_app_script(step='upgrade', path=app_tmp_folder +'/'+ manifest['yunohost']['script_path'], var_dict=script_var_dict, app_type=manifest['type'])
|
|
|
|
#########################################
|
|
# Copy files to the right final place #
|
|
#########################################
|
|
|
|
# TMP: Remove old application
|
|
if os.path.exists(app_final_path): shutil.rmtree(app_final_path)
|
|
|
|
os.system('cp -a "'+ app_tmp_folder +'" "'+ app_final_path +'"')
|
|
|
|
if is_web:
|
|
os.system('chown -R www-data: "'+ app_final_path +'"')
|
|
os.system('service apache2 reload')
|
|
shutil.rmtree(app_final_path + manifest['yunohost']['script_path'])
|
|
|
|
|
|
#########################################
|
|
# Write App settings #
|
|
#########################################
|
|
|
|
app_setting_path = apps_setting_path +'/'+ unique_app_id
|
|
|
|
current_app_dict['settings']['update_time'] = int(time.time())
|
|
|
|
with open(app_setting_path +'/app_settings.yml', 'w') as f:
|
|
yaml.safe_dump(current_app_dict['settings'], f, default_flow_style=False)
|
|
win_msg(_("App setting file updated"))
|
|
|
|
if lvl(manifest, 'yunohost', 'script_path'):
|
|
os.system('cp -a "'+ app_tmp_folder +'/'+ manifest['yunohost']['script_path'] +'" '+ app_setting_path)
|
|
|
|
shutil.rmtree(app_tmp_folder)
|
|
os.system('mv "'+ app_final_path +'/manifest.webapp" '+ app_setting_path)
|
|
|
|
if os.system('chmod 400 -R '+ app_setting_path) != 0:
|
|
raise YunoHostError(22, _("Error during permission setting"))
|
|
|
|
|
|
#########################################
|
|
# So much win #
|
|
#########################################
|
|
|
|
upgraded_apps.append(unique_app_id)
|
|
win_msg(app_id + _(" upgraded successfully"))
|
|
|
|
if not upgraded_apps:
|
|
raise YunoHostError(1, _("No app to upgrade"))
|
|
|
|
win_msg(_("Upgrade complete"))
|
|
|
|
|
|
def app_install(app, domain, path='/', label=None, mode='private'):
|
|
"""
|
|
Install selected app
|
|
|
|
Keyword arguments:
|
|
app -- AppID to install (or filename)
|
|
domain -- Web domain for the app
|
|
path -- Subpath of the domain
|
|
label -- User defined name for the app
|
|
mode -- public|private|protected
|
|
|
|
Returns:
|
|
Win | Fail
|
|
|
|
"""
|
|
# TODO: Virer la règle "default" lemon
|
|
# TODO: check path and url_to_(un)protect pattern
|
|
|
|
with YunoHostLDAP() as yldap:
|
|
|
|
|
|
##########################################
|
|
# Check if App location is available #
|
|
##########################################
|
|
|
|
if path[len(path)-1:] != '/':
|
|
path = path + '/'
|
|
|
|
apps_map = app_map()
|
|
|
|
if lvl(apps_map, domain, path):
|
|
raise YunoHostError(1, _("An app is already installed on this location"))
|
|
|
|
if lvl(apps_map, domain):
|
|
for app_path, v in apps_map[domain].items():
|
|
if app_path in path and app_path.count('/') < path.count('/'):
|
|
raise YunoHostError(1, _("Unable to install app at this location"))
|
|
|
|
|
|
##########################################
|
|
# Fetch or extract sources #
|
|
##########################################
|
|
|
|
try: os.listdir(install_tmp)
|
|
except OSError: os.makedirs(install_tmp)
|
|
|
|
if app in app_list(raw=True) or ('@' in app) or ('http://' in app) or ('https://' in app):
|
|
manifest = _fetch_app_from_git(app)
|
|
else:
|
|
manifest = _extract_app_from_file(app)
|
|
|
|
|
|
#########################################
|
|
# Define App ID & path #
|
|
#########################################
|
|
|
|
if not lvl(manifest, 'yunohost', 'uid') or '__' in manifest['yunohost']['uid']:
|
|
raise YunoHostError(22, _("App uid is invalid"))
|
|
|
|
is_web = lvl(manifest, 'yunohost', 'webapp')
|
|
|
|
instance_number = _installed_instance_number(manifest['yunohost']['uid'], last=True) + 1
|
|
if instance_number > 1:
|
|
if not lvl(manifest, 'yunohost', 'multi_instance') or not is_true(manifest['yunohost']['multi_instance']):
|
|
raise YunoHostError(1, _("App is already installed"))
|
|
|
|
|
|
unique_app_id = manifest['yunohost']['uid'] +'__'+ str(instance_number)
|
|
app_final_path = apps_path +'/'+ unique_app_id
|
|
script_var_dict = {
|
|
'APP_DIR': app_tmp_folder,
|
|
'APP_FINAL_DIR': app_final_path,
|
|
'APP_ID': unique_app_id
|
|
}
|
|
|
|
if is_web:
|
|
script_var_dict.update({
|
|
'APP_DOMAIN': domain,
|
|
'APP_PATH': path
|
|
})
|
|
|
|
|
|
#########################################
|
|
# Install dependencies #
|
|
#########################################
|
|
|
|
if lvl(manifest, 'dependencies'):
|
|
_install_app_dependencies(manifest['dependencies'])
|
|
|
|
|
|
#########################################
|
|
# Create and init DB #
|
|
#########################################
|
|
|
|
if lvl(manifest, 'yunohost', 'webapp', 'db'):
|
|
db_user = random_password(10)
|
|
db_pwd = random_password(12)
|
|
script_var_dict.update({
|
|
'DB_USER': db_user,
|
|
'DB_PWD': db_pwd,
|
|
'DB_NAME': db_user
|
|
})
|
|
|
|
_init_app_db(db_user, db_pwd, manifest['yunohost']['webapp']['db'])
|
|
|
|
|
|
#########################################
|
|
# Execute App install script #
|
|
#########################################
|
|
|
|
if lvl(manifest, 'yunohost', 'script_path'):
|
|
_exec_app_script(step='install', path=app_tmp_folder +'/'+ manifest['yunohost']['script_path'], var_dict=script_var_dict, app_type=manifest['type'])
|
|
|
|
|
|
#########################################
|
|
# Specifically configure lemon & apache #
|
|
#########################################
|
|
|
|
if is_web:
|
|
domain_add([domain], web=True)
|
|
|
|
|
|
#############
|
|
# LemonLDAP #
|
|
#############
|
|
|
|
if mode == 'private':
|
|
lemon_mode = 'accept'
|
|
elif mode == 'protected' and lvl(manifest, 'yunohost', 'webapp', 'access_control', 'can_be_protected') and is_true(manifest['yunohost']['webapp']['access_control']['can_be_protected']):
|
|
lemon_mode = 'unprotect'
|
|
elif mode == 'public' and lvl(manifest, 'yunohost', 'webapp', 'access_control', 'can_be_public') and is_true(manifest['yunohost']['webapp']['access_control']['can_be_public']):
|
|
lemon_mode = 'skip'
|
|
else:
|
|
raise YunoHostError(22, _("Invalid privacy mode"))
|
|
|
|
lemon_configuration({
|
|
('locationRules', domain, '(?#'+ unique_app_id +'Z)^'+ path ): lemon_mode
|
|
})
|
|
|
|
##########
|
|
# Apache #
|
|
##########
|
|
|
|
a2_conf_lines = [ 'Alias '+ path +' '+ app_final_path + manifest['launch_path'] ]
|
|
if path != '/':
|
|
a2_conf_lines.append('Alias '+ path[:len(path)-1] +' '+ app_final_path + manifest['launch_path'])
|
|
|
|
if lvl(manifest, 'yunohost', 'webapp', 'language') and manifest['yunohost']['webapp']['language'] == 'php':
|
|
for line in open(a2_template_path +'/php.conf'): a2_conf_lines.append(line.rstrip())
|
|
|
|
with open(a2_settings_path +'/'+ domain +'.d/'+ unique_app_id +'.app.conf', 'w') as a2_conf:
|
|
for line in a2_conf_lines:
|
|
a2_conf.write(line + '\n')
|
|
|
|
|
|
#########################################
|
|
# Copy files to the right final place #
|
|
#########################################
|
|
|
|
try: os.listdir(apps_path)
|
|
except OSError: os.makedirs(apps_path)
|
|
|
|
# TMP: Remove old application
|
|
if os.path.exists(app_final_path): shutil.rmtree(app_final_path)
|
|
|
|
os.system('cp -a "'+ app_tmp_folder +'" "'+ app_final_path +'"')
|
|
|
|
if is_web:
|
|
os.system('chown -R www-data: "'+ app_final_path +'"')
|
|
os.system('service apache2 reload')
|
|
shutil.rmtree(app_final_path + manifest['yunohost']['script_path'])
|
|
|
|
|
|
#########################################
|
|
# Write App settings #
|
|
#########################################
|
|
|
|
app_setting_path = apps_setting_path +'/'+ unique_app_id
|
|
|
|
# TMP: Remove old settings
|
|
if os.path.exists(app_setting_path): shutil.rmtree(app_setting_path)
|
|
os.makedirs(app_setting_path)
|
|
|
|
yaml_dict = {
|
|
'uid': manifest['yunohost']['uid'],
|
|
'instance' : instance_number,
|
|
'install_time': int(time.time()),
|
|
'mode': mode,
|
|
}
|
|
if is_web:
|
|
yaml_dict.update({
|
|
'domain': domain,
|
|
'path': path,
|
|
})
|
|
|
|
if lvl(manifest, 'yunohost', 'webapp', 'db'):
|
|
yaml_dict.update({
|
|
'db_pwd': db_pwd,
|
|
'db_user': db_user
|
|
})
|
|
if label: yaml_dict['label'] = label
|
|
else: yaml_dict['label'] = manifest['name']
|
|
|
|
with open(app_setting_path +'/app_settings.yml', 'w') as f:
|
|
yaml.safe_dump(yaml_dict, f, default_flow_style=False)
|
|
win_msg(_("App setting file created"))
|
|
|
|
if lvl(manifest, 'yunohost', 'script_path'):
|
|
os.system('cp -a "'+ app_tmp_folder +'/'+ manifest['yunohost']['script_path'] +'" '+ app_setting_path)
|
|
|
|
shutil.rmtree(app_tmp_folder)
|
|
os.system('mv "'+ app_final_path +'/manifest.webapp" '+ app_setting_path)
|
|
|
|
if os.system('chmod 400 -R '+ app_setting_path) != 0:
|
|
raise YunoHostError(22, _("Error during permission setting"))
|
|
|
|
|
|
#########################################
|
|
# So much win #
|
|
#########################################
|
|
|
|
win_msg(_("Installation complete"))
|
|
|
|
|
|
def app_remove(app, instance=[]):
|
|
"""
|
|
Remove app(s)
|
|
|
|
Keyword arguments:
|
|
app -- App ID to remove
|
|
instance -- List of instances to remove (default all)
|
|
|
|
"""
|
|
lemon_conf_lines = {}
|
|
|
|
if not instance:
|
|
instance = _installed_instance_number(app)
|
|
|
|
for number in instance:
|
|
number = str(number)
|
|
unique_app_id = app +'__'+ number
|
|
app_final_path = apps_path +'/'+ unique_app_id
|
|
app_dict = app_info(app, instance=number, raw=True)
|
|
app_settings = app_dict['settings']
|
|
manifest = app_dict['manifest']
|
|
is_web = lvl(manifest, 'yunohost', 'webapp')
|
|
has_db = lvl(manifest, 'yunohost', 'webapp', 'db')
|
|
|
|
script_var_dict = {
|
|
'APP_DIR': apps_path +'/'+ unique_app_id,
|
|
'APP_ID': unique_app_id
|
|
}
|
|
|
|
if lvl(manifest, 'dependencies'):
|
|
#TODO: _remove_app_dependencies(manifest['dependencies'])
|
|
pass
|
|
|
|
if lvl(manifest, 'yunohost', 'script_path'):
|
|
_exec_app_script(step='remove', path=app_tmp_folder +'/'+ manifest['yunohost']['script_path'], var_dict=script_var_dict, app_type=manifest['type'])
|
|
|
|
if is_web:
|
|
with open(lemon_tmp_conf, 'w') as lemon_conf:
|
|
hash = "$tmp->{'locationRules'}->{'"+ app_settings['domain'] +"'}"
|
|
lemon_conf.write("foreach my $key (keys %{ "+ hash +" }) { delete "+ hash +"{$key} if $key =~ /"+ app_settings['uid'] +"/; }" + '\n')
|
|
|
|
os.system('/usr/share/lemonldap-ng/bin/lmYnhMoulinette')
|
|
try:
|
|
os.remove(a2_settings_path +'/'+ app_settings['domain'] +'.d/'+ unique_app_id +'.app.conf')
|
|
except OSError:
|
|
pass
|
|
|
|
if has_db:
|
|
mysql_root_pwd = open('/etc/yunohost/mysql').read().rstrip()
|
|
mysql_command = 'mysql -u root -p'+ mysql_root_pwd +' -e "REVOKE ALL PRIVILEGES ON '+ app_settings['db_user'] +'.* FROM \''+ app_settings['db_user'] +'\'@localhost ; DROP USER \''+ app_settings['db_user'] +'\'@localhost; DROP DATABASE '+ app_settings['db_user'] +' ;"'
|
|
os.system(mysql_command)
|
|
|
|
try:
|
|
shutil.rmtree(apps_setting_path +'/'+ unique_app_id)
|
|
shutil.rmtree(apps_path +'/'+ unique_app_id)
|
|
except OSError:
|
|
pass
|
|
|
|
win_msg(_("App removed: ")+ unique_app_id)
|
|
|
|
if is_web:
|
|
lemon_configuration(lemon_conf_lines)
|
|
|
|
|
|
def app_addaccess(apps, users):
|
|
"""
|
|
Grant access to a private app to a user
|
|
|
|
Keyword arguments:
|
|
apps -- List of app to grant access to
|
|
users -- Users to grant access for
|
|
|
|
"""
|
|
if not isinstance(users, list): users = [users]
|
|
if not isinstance(apps, list): apps = [apps]
|
|
|
|
installed_apps = os.listdir(apps_setting_path)
|
|
|
|
lemon_conf_lines = {}
|
|
|
|
for installed_app in installed_apps:
|
|
for app in apps:
|
|
if '__' not in app:
|
|
app = app + '__1'
|
|
|
|
if app == installed_app:
|
|
with open(apps_setting_path + installed_app +'/app_settings.yml') as f:
|
|
app_settings = yaml.load(f)
|
|
|
|
if app_settings['mode'] == 'private':
|
|
if 'allowed_users' in app_settings:
|
|
new_users = app_settings['allowed_users']
|
|
else:
|
|
new_users = ''
|
|
|
|
for allowed_user in users:
|
|
if allowed_user not in new_users.split(' '):
|
|
try:
|
|
user_info(allowed_user)
|
|
except YunoHostError:
|
|
continue
|
|
new_users = new_users +' '+ allowed_user
|
|
|
|
app_settings['allowed_users'] = new_users.strip()
|
|
with open(apps_setting_path + installed_app +'/app_settings.yml', 'w') as f:
|
|
yaml.safe_dump(app_settings, f, default_flow_style=False)
|
|
win_msg(_("App setting file updated"))
|
|
|
|
lemon_conf_lines[('locationRules', app_settings['domain'], '(?#'+ installed_app +'Z)^'+ app_settings['path'] )] = 'grep( /^$uid$/, qw('+ new_users.strip() +'))'
|
|
|
|
lemon_configuration(lemon_conf_lines)
|
|
|
|
|
|
def app_removeaccess(apps, users):
|
|
"""
|
|
Revoke access to a private app to a user
|
|
|
|
Keyword arguments:
|
|
apps -- List of app to revoke access to
|
|
users -- Users to revoke access for
|
|
|
|
"""
|
|
if not isinstance(users, list): users = [users]
|
|
if not isinstance(apps, list): apps = [apps]
|
|
|
|
installed_apps = os.listdir(apps_setting_path)
|
|
|
|
lemon_conf_lines = {}
|
|
|
|
for installed_app in installed_apps:
|
|
for app in apps:
|
|
new_users = ''
|
|
if '__' not in app:
|
|
app = app + '__1'
|
|
|
|
if app == installed_app:
|
|
with open(apps_setting_path + installed_app +'/app_settings.yml') as f:
|
|
app_settings = yaml.load(f)
|
|
|
|
if app_settings['mode'] == 'private':
|
|
if 'allowed_users' in app_settings:
|
|
for allowed_user in app_settings['allowed_users'].split(' '):
|
|
if allowed_user not in users:
|
|
new_users = new_users +' '+ allowed_user
|
|
|
|
app_settings['allowed_users'] = new_users.strip()
|
|
with open(apps_setting_path + installed_app +'/app_settings.yml', 'w') as f:
|
|
yaml.safe_dump(app_settings, f, default_flow_style=False)
|
|
win_msg(_("App setting file updated"))
|
|
|
|
lemon_conf_lines[('locationRules', app_settings['domain'], '(?#'+ installed_app +'Z)^'+ app_settings['path'] )] = 'grep( /^$uid$/, qw('+ new_users.strip() +'))'
|
|
|
|
lemon_configuration(lemon_conf_lines)
|
|
|
|
|
|
def _extract_app_from_file(path):
|
|
"""
|
|
Unzip or untar application tarball in app_tmp_folder, or copy it from a directory
|
|
|
|
Keyword arguments:
|
|
path -- Path of the tarball or directory
|
|
|
|
Returns:
|
|
Dict manifest
|
|
|
|
"""
|
|
if os.path.exists(app_tmp_folder): shutil.rmtree(app_tmp_folder)
|
|
os.makedirs(app_tmp_folder)
|
|
|
|
if ".zip" in path:
|
|
extract_result = os.system('cd '+ os.getcwd() +' && unzip '+ path +' -d '+ app_tmp_folder)
|
|
elif ".tar" in path:
|
|
extract_result = os.system('cd '+ os.getcwd() +' && tar -xf '+ path +' -C '+ app_tmp_folder)
|
|
elif (path[:1] == '/' and os.path.exists(path)) or (os.system('cd '+ os.getcwd() +'/'+ path) == 0):
|
|
shutil.rmtree(app_tmp_folder)
|
|
if path[len(path)-1:] != '/':
|
|
path = path + '/'
|
|
extract_result = os.system('cd '+ os.getcwd() +' && cp -a "'+ path +'" '+ app_tmp_folder)
|
|
else:
|
|
extract_result = 1
|
|
|
|
if extract_result != 0:
|
|
raise YunoHostError(22, _("Invalid install file"))
|
|
|
|
try:
|
|
with open(app_tmp_folder + '/manifest.webapp') as json_manifest:
|
|
manifest = json.loads(str(json_manifest.read()))
|
|
manifest['lastUpdate'] = int(time.time())
|
|
except IOError:
|
|
raise YunoHostError(1, _("Invalid App file"))
|
|
|
|
win_msg(_("Sources extracted"))
|
|
|
|
return manifest
|
|
|
|
|
|
def _fetch_app_from_git(app):
|
|
"""
|
|
Unzip or untar application tarball in app_tmp_folder
|
|
|
|
Keyword arguments:
|
|
app -- App_id or git repo URL
|
|
|
|
Returns:
|
|
Dict manifest
|
|
|
|
"""
|
|
global app_tmp_folder
|
|
|
|
if ('@' in app) or ('http://' in app) or ('https://' in app):
|
|
git_result = os.system('git clone '+ app +' '+ app_tmp_folder)
|
|
git_result_2 = 0
|
|
try:
|
|
with open(app_tmp_folder + '/manifest.webapp') as json_manifest:
|
|
manifest = json.loads(str(json_manifest.read()))
|
|
manifest['lastUpdate'] = int(time.time())
|
|
except IOError:
|
|
raise YunoHostError(1, _("Invalid App manifest"))
|
|
|
|
else:
|
|
app_tmp_folder = install_tmp +'/'+ app
|
|
if os.path.exists(app_tmp_folder): shutil.rmtree(app_tmp_folder)
|
|
|
|
app_dict = app_list(raw=True)
|
|
|
|
if app in app_dict:
|
|
app_info = app_dict[app]
|
|
app_info['manifest']['lastUpdate'] = app_info['lastUpdate']
|
|
manifest = app_info['manifest']
|
|
else:
|
|
raise YunoHostError(22, _("App doesn't exists"))
|
|
|
|
git_result = os.system('git clone '+ app_info['git']['url'] +' -b '+ app_info['git']['branch'] +' '+ app_tmp_folder)
|
|
git_result_2 = os.system('cd '+ app_tmp_folder +' && git reset --hard '+ str(app_info['git']['revision']))
|
|
|
|
if not git_result == git_result_2 == 0:
|
|
raise YunoHostError(22, _("Sources fetching failed"))
|
|
|
|
win_msg(_("Repository fetched"))
|
|
|
|
return manifest
|
|
|
|
|
|
def _install_app_dependencies(dep_dict):
|
|
"""
|
|
Install debian, npm, gem, pip and pear dependencies of the app
|
|
|
|
Keyword arguments:
|
|
dep_dict -- Dict of dependencies from the manifest
|
|
|
|
"""
|
|
if ('debian' in dep_dict) and (len(dep_dict['debian']) > 0):
|
|
#os.system('apt-get update')
|
|
if os.system('apt-get install -y "'+ '" "'.join(dep_dict['debian']) +'"') != 0:
|
|
raise YunoHostError(1, _("Dependency installation failed: ") + dependency)
|
|
|
|
# TODO: Install npm, pip, gem and pear dependencies
|
|
|
|
win_msg(_("Dependencies installed"))
|
|
|
|
|
|
def _init_app_db(db_user, db_pwd, db_dict):
|
|
"""
|
|
Create database and initialize it with optionnal attached script
|
|
|
|
Keyword arguments:
|
|
db_user -- Name of the DB user (also used as database name)
|
|
db_pwd -- Password for the user
|
|
db_dict -- Dict of DB parameters from the manifest
|
|
|
|
"""
|
|
# Need MySQL DB ?
|
|
if lvl(db_dict, 'has_mysql_db') and is_true(db_dict['has_mysql_db']):
|
|
mysql_root_pwd = open('/etc/yunohost/mysql').read().rstrip()
|
|
mysql_command = 'mysql -u root -p'+ mysql_root_pwd +' -e "CREATE DATABASE '+ db_user +' ; GRANT ALL PRIVILEGES ON '+ db_user +'.* TO \''+ db_user +'\'@localhost IDENTIFIED BY \''+ db_pwd +'\';"'
|
|
if os.system(mysql_command) != 0:
|
|
raise YunoHostError(1, _("MySQL DB creation failed"))
|
|
if lvl(db_dict, 'mysql_init_script'):
|
|
if os.system('mysql -u '+ db_user +' -p'+ db_pwd +' '+ db_user +' < '+ app_tmp_folder + db_dict['mysql_init_script'] +' ;') != 0:
|
|
raise YunoHostError(1, _("MySQL DB init failed"))
|
|
|
|
# TODO: PgSQL/MongoDB ?
|
|
|
|
win_msg(_("Database initiliazed"))
|
|
|
|
|
|
def _exec_app_script(step, path, var_dict, app_type):
|
|
"""
|
|
Execute step user script
|
|
|
|
Keyword arguments:
|
|
step -- Name of the script to call regarding the current step (e.g. install|upgrade|remove|etc.)
|
|
path -- Absolute path of the script's directory
|
|
var_dict -- Dictionnary of environnement variable to pass to the script
|
|
app_type -- Decides whether to execute as root or as yunohost-app user (e.g. web|privileged|certified)
|
|
|
|
"""
|
|
scripts = [ step, step +'.sh', step +'.py' ]
|
|
|
|
for script in scripts:
|
|
script_path = path +'/'+ script
|
|
if os.path.exists(script_path):
|
|
st = os.stat(script_path)
|
|
os.chmod(script_path, st.st_mode | stat.S_IEXEC)
|
|
|
|
if app_type == 'privileged' or app_type == 'certified':
|
|
user = 'root'
|
|
else:
|
|
user = 'yunohost-app'
|
|
os.system('chown -R '+ user +': '+ app_tmp_folder)
|
|
|
|
env_vars = ''
|
|
for key, value in var_dict.items():
|
|
env_vars = env_vars + key + "='"+ value +"' "
|
|
|
|
command = 'su - '+ user +' -c "'+ env_vars +' sh '+ path +'/'+ script +'"'
|
|
if os.system(command) == 0:
|
|
win_msg(_("Script executed: ") + script)
|
|
else:
|
|
raise YunoHostError(1, _("Script execution failed: ") + script)
|
|
|
|
break
|
|
|
|
|
|
def _installed_instance_number(app, last=False):
|
|
"""
|
|
Check if application is installed and return instance number
|
|
|
|
Keyword arguments:
|
|
app -- uid of App to check
|
|
last -- Return only last instance number
|
|
|
|
Returns:
|
|
Number of last installed instance | List or instances
|
|
|
|
"""
|
|
if last:
|
|
number = 0
|
|
try:
|
|
installed_apps = os.listdir(apps_setting_path)
|
|
except OSError:
|
|
os.makedirs(apps_setting_path)
|
|
return 0
|
|
|
|
for installed_app in installed_apps:
|
|
if '__' in installed_app:
|
|
if app == installed_app[:installed_app.index('__')]:
|
|
if int(installed_app[installed_app.index('__') + 2:]) > number:
|
|
number = int(installed_app[installed_app.index('__') + 2:])
|
|
|
|
return number
|
|
|
|
else:
|
|
instance_number_list = []
|
|
instances_dict = app_map(app=app, raw=True)
|
|
for key, domain in instances_dict.items():
|
|
for key, path in domain.items():
|
|
instance_number_list.append(path['instance'])
|
|
|
|
return sorted(instance_number_list)
|
|
|