1012 lines
31 KiB
Python
1012 lines
31 KiB
Python
from settings import config
|
|
from flask import g, url_for, request, session, make_response, flash
|
|
from paramecio2.libraries.generate_admin_class import GenerateAdminClass
|
|
from paramecio2.libraries.i18n import I18n, PGetText
|
|
from paramecio2.modules.admin import admin_app, t as admin_t
|
|
from paramecio2.libraries.db.coreforms import SelectForm, SelectModelForm, HiddenForm
|
|
from paramecio2.libraries.mtemplates import PTemplate, env_theme
|
|
from paramecio2.libraries import datetime
|
|
from paramecio2.libraries.urls import make_media_url, make_url
|
|
#from modules.monit.models.monit import Server, ServerData, Alerts
|
|
from modules.pastafari2.libraries.scandir import scandir
|
|
from paramecio2.libraries.db.webmodel import WebModel
|
|
from paramecio2.libraries.lists import AjaxList
|
|
from paramecio2.libraries.db.extraforms.fileform import FileForm
|
|
from paramecio2.libraries.formsutils import show_form, check_form
|
|
from modules.pastafari2.libraries.task import Task as SSHTask
|
|
from modules.pastafari2.models.tasks import Task, LogTask
|
|
from modules.pastafari2.libraries.configtask import config_task
|
|
from modules.pastafari2.models.pastafari2 import ServerGroup, ServerDbTask, UpdateServerScripts, SystemUser
|
|
from paramecio2.libraries.config_admin import config_admin
|
|
#from modules.pastafari2.settings.config_admin import pastafari_admin_i18n, pastafari_admin_i18n, pastafari_settings_i18n, pastafari_servers_i18n, pastafari_groups_i18n, pastafari_tasks_log_i18n, num_element_admin
|
|
|
|
from pathlib import Path
|
|
import paramiko
|
|
import socket
|
|
import os
|
|
import configparser
|
|
from collections import OrderedDict
|
|
from importlib import import_module, reload
|
|
from modules.pastafari2.libraries.progress import load_progress
|
|
from modules.pastafari2.libraries.load_task import load_db_in_task
|
|
from subprocess import call
|
|
from settings import config
|
|
|
|
try:
|
|
import ujson as json
|
|
except:
|
|
import json
|
|
|
|
pgettext=PGetText(__file__+'/../')
|
|
|
|
_=pgettext.gettext
|
|
|
|
env=env_theme(__file__)
|
|
|
|
t=PTemplate(env)
|
|
|
|
t.env.directories=admin_t.env.directories
|
|
|
|
t.env.directories.insert(1, os.path.dirname(__file__).replace('/admin', '')+'/templates/admin')
|
|
|
|
#system_path=config_task.ssh_directory+'/'
|
|
|
|
#if hasattr(config, 'pastafari_system_path'):
|
|
# system_path=config.pastafari_system_path
|
|
|
|
base_path='modules/pastafari2/tasks'
|
|
|
|
if hasattr(config, 'pastafari_base_path'):
|
|
base_path=config.pastafari_base_path
|
|
|
|
pastafari_paths=[]
|
|
|
|
#if hasattr(config, 'pastafari_paths'):
|
|
# pastafari_paths=config.pastafari_paths
|
|
|
|
pastafari_paths=config_task.pastafari_paths
|
|
|
|
@admin_app.route('/pastafari2/dashboard/')
|
|
def pastafari2_dashboard():
|
|
|
|
db=g.connection
|
|
|
|
config_parser=configparser.ConfigParser()
|
|
|
|
(select_task, select_hash)=scandir(base_path, config_parser, OrderedDict(), {}, 'tasks')
|
|
|
|
for module in pastafari_paths:
|
|
|
|
(select_task, select_hash)=scandir(module, config_parser, select_task, select_hash, 'tasks')
|
|
|
|
title_task=''
|
|
|
|
description_task=''
|
|
|
|
links=''
|
|
|
|
path_module='admin_app.pastafari2_dashboard'
|
|
|
|
task_path=request.args.get('task_path', '')
|
|
|
|
module=os.getcwd()+'/'+task_path
|
|
|
|
details_task=[]
|
|
|
|
#import the module for load links in general dashboard
|
|
|
|
if os.path.isfile(module) and task_path in select_hash:
|
|
final_path=task_path.replace('.py', '').replace('/','.')
|
|
#print(final_path)
|
|
ptask=import_module(final_path)
|
|
|
|
if config.reloader:
|
|
reload(ptask)
|
|
|
|
task_first=ptask.ServerTask('', db, remote_user='root', remote_password='', private_key=config_task.ssh_private_key, password_key='', remote_path='pastafari2', task_id=0, data=dict(request.args))
|
|
|
|
links=task_first.links
|
|
|
|
path_module=task_first.path_module
|
|
|
|
title_task=' - '+task_first.name_task
|
|
|
|
description_task=task_first.description_task
|
|
|
|
details_task=select_hash[task_path]
|
|
|
|
else:
|
|
task_path=''
|
|
#print(task_first.links)
|
|
|
|
#print(module)
|
|
|
|
return t.load_template('dash_pastafari.phtml', title=_('Servers Dashboard')+title_task, path_module=path_module, select_task=select_task, task_path=task_path, links=links, description_task=description_task, details_task=details_task)
|
|
|
|
@admin_app.route('/pastafari2/settings/')
|
|
def pastafari2_settings():
|
|
|
|
txt_error=''
|
|
txt_generate_key='<p>You have created your ssh keys</p>'
|
|
txt_generate_key_button='Regenerate SSH keys'
|
|
regenerate=True
|
|
|
|
if not os.path.isdir(config_task.ssh_directory):
|
|
|
|
try:
|
|
Path(config_task.ssh_directory).mkdir(mode=511)
|
|
|
|
except:
|
|
|
|
txt_error='<p><strong>You need create ssh directory for save ssh keys</strong></p>'
|
|
|
|
#Get ssh key
|
|
|
|
if not os.path.isfile(config_task.ssh_private_key):
|
|
|
|
txt_generate_key='<p>You need generate a global private ssh key, because doesn\'t exists</p>'
|
|
txt_generate_key_button='Generate SSH keys'
|
|
regenerate=False
|
|
pass
|
|
|
|
return t.load_template('settings.phtml', title=_('Settings'), path_module='admin_app.pastafari2_settings', txt_error=txt_error, txt_generate_key=txt_generate_key, txt_generate_key_button=txt_generate_key_button, regenerate=regenerate)
|
|
|
|
@admin_app.route('/pastafari2/edit_global_ssh_keys/', methods=['POST'])
|
|
def pastafari2_edit_global_ssh_keys():
|
|
|
|
form={}
|
|
|
|
error=1
|
|
|
|
if not os.path.isfile(config_task.ssh_private_key):
|
|
|
|
# -C "your_email@example.com" -f $HOME/.ssh/id_rsa
|
|
|
|
arr_type={'rsa': 'ssh-keygen -t rsa -b 4096', 'dsa': 'ssh-keygen -t dsa', 'ecdsa': 'ssh-keygen -t ecdsa -b 521', 'ed25519': 'ssh-keygen -t ed25519'}
|
|
|
|
ssh_key_type=request.args.get('ssh_key_type')
|
|
|
|
if ssh_key_type in arr_type:
|
|
|
|
file_ssh_path='-f {}id_rsa -q -N ""'.format(config_task.ssh_directory)
|
|
|
|
if not os.path.isfile(config_task.ssh_private_key):
|
|
|
|
if call(arr_type[ssh_key_type]+' '+file_ssh_path, shell=True) > 0:
|
|
|
|
error=1
|
|
else:
|
|
"""
|
|
config_admin.insert(num_element_admin-1, [pastafari_servers_i18n(), 'modules.pastafari2.admin.dashboard', 'admin_app.pastafari2_dashboard', 'fa-linux'])
|
|
config_admin.insert(num_element_admin, [pastafari_groups_i18n(), 'modules.pastafari2.admin.groups', 'admin_app.pastafari2_groups', 'fa-object-group'])
|
|
config_admin.insert(num_element_admin+1, [pastafari_tasks_log_i18n(), 'modules.pastafari2.admin.tasks', 'admin_app.pastafari2_tasks', 'fa-file-text-o'])
|
|
|
|
import_module('modules.pastafari2.admin.dashboard')
|
|
import_module('modules.pastafari2.admin.groups')
|
|
import_module('modules.pastafari2.admin.tasks')
|
|
|
|
print(config_admin)
|
|
"""
|
|
|
|
error=0
|
|
|
|
return {'error': error}
|
|
|
|
@admin_app.route('/pastafari2/add_server/')
|
|
def pastafari2_add_server():
|
|
|
|
db=g.connection
|
|
|
|
group_form=SelectModelForm('group_id', '', ServerGroup(db), 'group', 'id', field_parent=None)
|
|
|
|
return t.load_template('add_server.phtml', title=_('Add server'), path_module='admin_app.pastafari2_dashboard', group_form=group_form)
|
|
|
|
|
|
@admin_app.route('/pastafari2/add_server_task/', methods=['POST'])
|
|
def pastafari2_add_server_task():
|
|
|
|
db=g.connection
|
|
|
|
error_form={}
|
|
|
|
server_host=request.form.get('server_host', '')
|
|
server_username=request.form.get('server_username', '')
|
|
server_password=request.form.get('server_password', '')
|
|
repeat_server_password=request.form.get('repeat_server_password', '')
|
|
group_id=request.form.get('group_id', '')
|
|
private_key=config_task.ssh_private_key
|
|
public_key=config_task.ssh_public_key
|
|
remote_path='pastafari2'
|
|
task_id=0
|
|
ip=''
|
|
error=0
|
|
data={}
|
|
ssh_user=config_task.remote_user
|
|
ssh_port=config_task.port
|
|
|
|
try:
|
|
|
|
tmp_port=int(request.form.get('ssh_port', '22'))
|
|
|
|
ssh_port=tmp_port
|
|
|
|
except:
|
|
pass
|
|
ssh_port='22'
|
|
|
|
|
|
#make ping to server
|
|
|
|
if server_host=='':
|
|
error=1
|
|
error_form['#server_host_error']=_('Error: you need enter a valid hostname')
|
|
|
|
if server_username=='':
|
|
error=1
|
|
error_form['#server_username_error']=_('Error: you need enter a valid username for the server')
|
|
|
|
txt_error=''
|
|
|
|
try:
|
|
|
|
ip=socket.gethostbyname(server_host)
|
|
pass
|
|
except socket.error as err_msg:
|
|
error=1
|
|
error_form['#server_host_error']=_('Error: ')+err_msg.__str__()
|
|
|
|
if not error:
|
|
|
|
group_name=''
|
|
|
|
if group_id!='':
|
|
server_group=ServerGroup(db)
|
|
arr_group=server_group.set_conditions('WHERE id=%s', [group_id]).select_a_row_where()
|
|
group_name=arr_group['code_group']
|
|
|
|
|
|
data={'ssh_user': ssh_user, 'pub_key': public_key, 'hostname': server_host, 'ip': ip, 'group_id': group_id, 'group_name': group_name}
|
|
|
|
with SSHTask(server_host, db, remote_user=server_username, remote_password=server_password, private_key=private_key, remote_path=remote_path, task_id=task_id, data=data, port=ssh_port) as ssh_task:
|
|
if not ssh_task.prepare_connection():
|
|
error=1
|
|
txt_error=ssh_task.txt_error #_('Error: cannot connect to server')
|
|
error_form['#server_host_error']=txt_error #_('Error: cannot connect to server')
|
|
else:
|
|
# Prepare task for install monit
|
|
|
|
task=Task(db)
|
|
|
|
task_id=0
|
|
|
|
path_task='modules.pastafari2.tasks.system.task'
|
|
|
|
if not task.run_task(ip, path_task, 'Add new server', 'add_new_server', 'Task for add a new server', user=server_username, password=server_password, where_sql_server='', url='', data=data, send_task=True, ssh_port=ssh_port):
|
|
|
|
error=1
|
|
error_form['#server_host_error']=_('Error: cannot execute the task ')+task.txt_error
|
|
txt_error=_('Error: cannot execute the task ')+task.txt_error
|
|
|
|
task_id=task.task_id
|
|
|
|
return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}
|
|
|
|
# Maybe translate to api
|
|
|
|
@admin_app.route('/pastafari2/progress/')
|
|
def pastafari2_progress():
|
|
|
|
db=g.connection
|
|
|
|
return load_progress(db, t)
|
|
|
|
|
|
@admin_app.route('/pastafari2/getprogress/', methods=['POST'])
|
|
def pastafari2_getprogress():
|
|
|
|
s=session
|
|
|
|
db=g.connection
|
|
|
|
if request.args.get('task_id', '0')=='0':
|
|
|
|
s['get_progress']=s.get('get_progress', 0)
|
|
|
|
try:
|
|
|
|
task_id=int(request.args.get('task_id', '0'))
|
|
except:
|
|
task_id=0
|
|
|
|
try:
|
|
position=int(request.args.get('position', '0'))
|
|
except:
|
|
position=0
|
|
|
|
task=Task(db)
|
|
logtask=LogTask(db)
|
|
|
|
arr_task=task.select_a_row(task_id)
|
|
|
|
arr_rows={'wait': 1}
|
|
|
|
if arr_task:
|
|
|
|
logtask.set_limit([position, 5])
|
|
|
|
logtask.set_order({'id': 0})
|
|
|
|
logtask.conditions=['WHERE task_id=%s', [task_id]]
|
|
|
|
server=request.args.get('server', '')
|
|
|
|
if server!='':
|
|
logtask.conditions=['WHERE task_id=%s', [task_id]]
|
|
|
|
logtask.yes_reset_conditions=False
|
|
|
|
c=0
|
|
|
|
arr_rows=[]
|
|
|
|
with logtask.select([], True) as cursor:
|
|
for arr_row in cursor:
|
|
arr_rows.append(arr_row)
|
|
c+=1
|
|
|
|
if c==0:
|
|
arr_rows=[]
|
|
|
|
c_error=logtask.set_conditions('WHERE task_id=%s and logtask.error=%s and logtask.status=%s', [task_id, 1, 1]).select_count()
|
|
|
|
if c_error==0:
|
|
|
|
arr_rows={'wait': 1}
|
|
else:
|
|
logtask.limit=''
|
|
|
|
with logtask.set_conditions('WHERE task_id=%s and logtask.error=%s and logtask.status=%s', [task_id, 1, 1]).select([], True) as cursor:
|
|
for arr_row in cursor:
|
|
arr_rows.append(arr_row)
|
|
|
|
else:
|
|
|
|
arr_rows=[{'task_id': task_id, 'progress': 100, 'message': 'Error: no exists task', 'error': 1, 'status': 1}]
|
|
|
|
db.close()
|
|
|
|
resp=make_response(json.dumps(arr_rows))
|
|
|
|
resp.headers['Content-Type']='application/json'
|
|
|
|
return resp
|
|
|
|
@admin_app.route('/pastafari2/get_servers/', methods=['POST'])
|
|
def get_servers_task():
|
|
|
|
db=g.connection
|
|
|
|
group_sql=''
|
|
|
|
count_data=[]
|
|
sql_data=[]
|
|
|
|
group_id=request.form.get('group_id', '')
|
|
|
|
group_sql_count=''
|
|
group_sql=''
|
|
|
|
if group_id!='':
|
|
group_sql_count=' WHERE `group_id`=%s'
|
|
count_data=[group_id]
|
|
sql_data=[group_id]
|
|
group_sql=' WHERE `group_id`=%s'
|
|
|
|
fields=[[_('Hostname'), True], ['IP', True], [_('Selected'), False], [_('Options'), False]]
|
|
arr_order_fields=['hostname', 'ip']
|
|
|
|
count_query=['select count(serverdbtask.id) as num_elements from serverdbtask'+group_sql_count, count_data]
|
|
|
|
str_query=['select serverdbtask.hostname, serverdbtask.ip, serverdbtask.id as select_id, serverdbtask.id from serverdbtask'+group_sql, sql_data]
|
|
|
|
ajax=AjaxList(db, fields, arr_order_fields, count_query, str_query)
|
|
|
|
ajax.func_fields['select_id']=options_selected
|
|
ajax.func_fields['id']=options_options
|
|
ajax.limit=0
|
|
|
|
return ajax.show()
|
|
|
|
def options_selected(row_id, row):
|
|
|
|
return '<input type="checkbox" name="server_id_{}" class="server_id" value="{}"/>'.format(row_id, row_id)
|
|
|
|
def options_options(row_id, row):
|
|
|
|
arr_options=['<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_edit_server', id=row_id, op_admin=1), _('Edit'))]
|
|
|
|
arr_options.append('<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_edit_users', server_id=row_id), _('Users')))
|
|
|
|
arr_options.append('<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_delete_server', server_id=row_id), _('Delete')))
|
|
|
|
arr_options.append('<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_edit_update', server_id=row_id), _('Edit update task')))
|
|
|
|
return '<br />'.join(arr_options)
|
|
|
|
|
|
@admin_app.route('/pastafari2/get_groups/', methods=['GET'])
|
|
def get_groups_task():
|
|
|
|
db=g.connection
|
|
|
|
arr_groups=[]
|
|
|
|
with db.query('select * from servergroup', []) as cursor:
|
|
for data in cursor:
|
|
arr_groups.append(data)
|
|
|
|
return json.dumps(arr_groups)
|
|
|
|
|
|
@admin_app.route('/pastafari2/update_task/', methods=['POST'])
|
|
def pastafari2_update_task():
|
|
|
|
db=g.connection
|
|
|
|
ids=json.loads(request.form.get('ids', '[]'))
|
|
arr_ids=[]
|
|
|
|
error=0
|
|
txt_error=''
|
|
error_form={}
|
|
|
|
#print(ids)
|
|
for v in ids:
|
|
arr_ids.append(str(int(v)))
|
|
|
|
where_sql='WHERE id IN ('+",".join(arr_ids)+') order by hostname ASC'
|
|
|
|
task=Task(db)
|
|
|
|
task_id=0
|
|
|
|
path_task='modules.pastafari2.tasks.system.updates'
|
|
|
|
data={}
|
|
|
|
server_host=''
|
|
|
|
user=config_task.remote_user
|
|
|
|
ssh_key_priv=config_task.ssh_private_key
|
|
|
|
if not task.run_task(server_host, path_task, 'Update server', 'update_server', 'Task for update servers', user=user, password='', where_sql_server=where_sql, ssh_key_priv=ssh_key_priv, url='', data=data, send_task=True):
|
|
|
|
error=1
|
|
error_form['#server_host_error']=_('Error: cannot execute the task')
|
|
|
|
task_id=task.task_id
|
|
|
|
return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}
|
|
|
|
@admin_app.route('/pastafari2/make_task/', methods=['POST'])
|
|
def pastafari2_make_task():
|
|
|
|
db=g.connection
|
|
|
|
ids=json.loads(request.form.get('ids', '[]'))
|
|
|
|
json_ids=json.dumps(ids)
|
|
|
|
arr_ids=[]
|
|
|
|
task_path=request.form.get('task', '')
|
|
|
|
task_file=task_path.replace('/', '.')
|
|
|
|
task_file=task_file.replace('.py', '')
|
|
|
|
task_execute=import_module(task_file)
|
|
|
|
if config.reloader:
|
|
reload(task_execute)
|
|
|
|
task_first=task_execute.ServerTask('', db, remote_user='root', remote_password='', private_key=config_task.ssh_private_key, password_key='', remote_path='pastafari2', task_id=0, data=dict(request.args))
|
|
|
|
send_task=request.args.get('send_task', '')
|
|
|
|
error=0
|
|
txt_error=''
|
|
error_form={}
|
|
|
|
task=Task(db)
|
|
|
|
task_id=0
|
|
|
|
data={}
|
|
|
|
#if not os.path.isfile(task)
|
|
|
|
if send_task=='':
|
|
|
|
#Check if form
|
|
|
|
if hasattr(task_first, 'form'):
|
|
|
|
url_exec=url_for('.pastafari2_make_task', send_task=1, **request.args)
|
|
|
|
links='<a href="'+url_for('admin_app.pastafari2_dashboard')+'">'+_('Servers')+'</a>'
|
|
|
|
path_module='admin_app.pastafari2_dashboard'
|
|
|
|
if hasattr(task_first, 'links'):
|
|
links=task_first.links
|
|
|
|
if hasattr(task_first, 'path_module'):
|
|
path_module=task_first.path_module
|
|
|
|
return t.load_template('maketask.phtml', title=_('Make task'), form=task_first.form(t, yes_error=False, pass_values=False), url_exec=url_exec, ids=json_ids, task_file=task_path, links=links, path_module=path_module)
|
|
|
|
elif send_task!='':
|
|
|
|
if hasattr(task_first, 'form'):
|
|
|
|
#Check form
|
|
|
|
if not task_first.check_form(request.form):
|
|
|
|
error=1
|
|
txt_error=_('Errors: fields required')
|
|
|
|
for k,v in task_first.arr_form.items():
|
|
if task_first.arr_form[k].error:
|
|
error_form['#'+k+'_error']=task_first.arr_form[k].txt_error
|
|
|
|
return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}
|
|
|
|
for k, v in task_first.data.items():
|
|
data[k]=v
|
|
|
|
pass
|
|
|
|
for v in ids:
|
|
arr_ids.append(str(int(v)))
|
|
|
|
where_sql='WHERE id IN ('+",".join(arr_ids)+') order by hostname ASC'
|
|
|
|
path_task=task_file
|
|
|
|
#Load task, check if have question
|
|
|
|
server_host=''
|
|
|
|
user=config_task.remote_user
|
|
|
|
ssh_key_priv=config_task.ssh_private_key
|
|
|
|
if not task.run_task(server_host, path_task, task_first.name_task, task_first.codename_task, task_first.description_task, user=user, password='', where_sql_server=where_sql, ssh_key_priv=ssh_key_priv, url=task_first.url_return, data=data, send_task=True):
|
|
|
|
error=1
|
|
error_form['#server_host_error']=_('Error: cannot execute the task')
|
|
txt_error=task.txt_error
|
|
|
|
task_id=task.task_id
|
|
|
|
return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}
|
|
|
|
@admin_app.route('/pastafari2/multiprogress/')
|
|
def pastafari2_multiprogress():
|
|
|
|
db=g.connection
|
|
|
|
task_id=request.args.get('task_id', '')
|
|
|
|
task=Task(db)
|
|
|
|
arr_task=task.select_a_row(task_id)
|
|
|
|
num_servers=task.set_conditions('WHERE parent_id=%s', [task_id]).select_count()
|
|
|
|
links=''
|
|
path_module='admin_app.pastafari2_dashboard'
|
|
|
|
|
|
task_process=load_db_in_task(task_id, db)
|
|
|
|
if task_process:
|
|
links=task_process.links
|
|
path_module=task_process.path_module
|
|
|
|
if arr_task:
|
|
|
|
return t.load_template('multiprogress.phtml', title=_('Task progress'), path_module=path_module, name_task=arr_task['name_task'], description_task=arr_task['description_task'], task_id=task_id, server=arr_task['server'], num_servers=num_servers, links=links)
|
|
|
|
else:
|
|
|
|
return ""
|
|
|
|
@admin_app.route('/pastafari2/get_servers_task/')
|
|
def pastafari2_get_servers_task():
|
|
|
|
db=g.connection
|
|
|
|
task_id=request.args.get('task_id', '')
|
|
|
|
task=Task(db)
|
|
|
|
arr_ids=task.set_conditions('WHERE parent_id=%s', [task_id]).select_to_array(['id', 'hostname', 'server'])
|
|
|
|
resp=make_response(json.dumps(arr_ids))
|
|
|
|
resp.headers['Content-Type']='application/json'
|
|
|
|
return resp
|
|
|
|
@admin_app.route('/pastafari2/get_multiprogress/')
|
|
def pastafari2_get_multiprogress():
|
|
|
|
s=session
|
|
|
|
db=g.connection
|
|
|
|
ids=request.args.get('ids', '[]')
|
|
|
|
try:
|
|
position=int(request.args.get('position', '0'))
|
|
except:
|
|
position=0
|
|
|
|
final_ids=[str(i) for i in json.loads(ids)]
|
|
|
|
final_str=",".join(['%s']*len(final_ids))
|
|
|
|
task=Task(db)
|
|
|
|
logtask=LogTask(db)
|
|
|
|
arr_log=logtask.set_limit([position, 20]).set_conditions('WHERE task_id IN ({})'.format(final_str), final_ids).select_to_array([], True)
|
|
|
|
resp=make_response(json.dumps(arr_log))
|
|
|
|
resp.headers['Content-Type']='application/json'
|
|
|
|
return resp
|
|
|
|
@admin_app.route('/pastafari2/delete_server/')
|
|
def pastafari2_delete_server():
|
|
|
|
db=g.connection
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
server_id=request.args.get('server_id', '0')
|
|
|
|
arr_server=server.select_a_row(server_id)
|
|
|
|
if arr_server:
|
|
|
|
return t.load_template('delete_server.phtml', title=_('Delete server'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, server=arr_server)
|
|
|
|
else:
|
|
|
|
return ""
|
|
|
|
@admin_app.route('/pastafari2/delete_server_db/', methods=['POST'])
|
|
def pastafari2_delete_server_db():
|
|
|
|
db=g.connection
|
|
|
|
error=0
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
server_id=request.form.get('server_id', '0')
|
|
|
|
server.set_conditions('WHERE id=%s', [server_id]).delete()
|
|
|
|
return {'error': error}
|
|
|
|
|
|
@admin_app.route('/pastafari2/edit_server/', methods=['POST', 'GET'])
|
|
def pastafari2_edit_server():
|
|
|
|
db=g.connection
|
|
|
|
error=0
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
url=url_for('.pastafari2_edit_server')
|
|
|
|
admin=GenerateAdminClass(server, url, t)
|
|
|
|
admin.arr_fields_edit=['hostname', 'ip', 'ssh_port']
|
|
|
|
admin.url_redirect=url_for('.pastafari2_dashboard')
|
|
|
|
admin.pre_update=pre_update_server
|
|
|
|
form_admin=admin.show()
|
|
|
|
if type(form_admin).__name__=='str':
|
|
|
|
return t.load_template('edit_server.phtml', title=_('Edit server'), path_module='admin_app.pastafari2_dashboard', edit_server=form_admin)
|
|
|
|
else:
|
|
return form_admin
|
|
|
|
def pre_update_server(admin):
|
|
|
|
db=g.connection
|
|
|
|
ssh_user=config_task.remote_user
|
|
ssh_port=request.form.get('ssh_port', 22)
|
|
server_host=request.form.get('ip', '')
|
|
private_key=config_task.ssh_private_key
|
|
public_key=config_task.ssh_public_key
|
|
remote_path='pastafari2'
|
|
data={}
|
|
task_id=0
|
|
|
|
with SSHTask(server_host, db, remote_user=ssh_user, remote_password='', private_key=private_key, remote_path=remote_path, task_id=task_id, data=data, port=ssh_port) as ssh_task:
|
|
if not ssh_task.prepare_connection():
|
|
|
|
admin.model.fields['ssh_port'].txt_error=ssh_task.txt_error
|
|
admin.model.fields['ssh_port'].error=True
|
|
|
|
return False
|
|
|
|
|
|
return True
|
|
|
|
@admin_app.route('/pastafari2/edit_update/', methods=['POST', 'GET'])
|
|
def pastafari2_edit_update():
|
|
"""Simple function for edit and add extra scripts for update function"""
|
|
|
|
db=g.connection
|
|
|
|
server_id=request.args.get('server_id', '0')
|
|
|
|
update_server=UpdateServerScripts(db)
|
|
|
|
update_server.fields['server_id'].name_form=HiddenForm
|
|
|
|
update_server.fields['server_id'].extra_parameters=[]
|
|
|
|
update_server.fields['server_id'].default_value=server_id
|
|
|
|
update_server.enctype=True
|
|
|
|
update_server.fields['file'].yes_prefix=False
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
url=url_for('.pastafari2_edit_update', server_id=server_id)
|
|
|
|
arr_server=server.select_a_row(server_id)
|
|
|
|
update_server.set_conditions('WHERE server_id=%s', [server_id])
|
|
|
|
admin=GenerateAdminClass(update_server, url, t)
|
|
|
|
admin.list.fields_showed=['name', 'file', 'position']
|
|
|
|
admin.list.yes_search=False
|
|
|
|
#admin.list.table_div=True
|
|
|
|
admin.list.order_field='position'
|
|
|
|
form_admin=admin.show()
|
|
|
|
if type(form_admin).__name__=='str':
|
|
|
|
return t.load_template('edit_update.phtml', title=_('Edit update'), path_module='admin_app.pastafari2_edit_update', server_data=arr_server, edit_update=form_admin)
|
|
|
|
else:
|
|
return form_admin
|
|
|
|
@admin_app.route('/pastafari2/change_order_scripts/', methods=['POST', 'GET'])
|
|
def pastafari2_change_order_scripts():
|
|
|
|
db=g.connection
|
|
|
|
server_id=request.args.get('server_id', '0')
|
|
|
|
update_server=UpdateServerScripts(db)
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
arr_server=server.select_a_row(server_id)
|
|
|
|
update_server.set_conditions('WHERE server_id=%s', [server_id]).set_order({'position': 0})
|
|
|
|
arr_update_server=update_server.select_to_array()
|
|
|
|
return t.load_template('change_order_scripts.phtml', title=_('Edit update'), path_module='admin_app.pastafari2_change_order_scripts', server_data=arr_server, scripts=arr_update_server)
|
|
|
|
@admin_app.route('/pastafari2/save_positions' , methods=['POST'])
|
|
def pastafari2_save_positions():
|
|
|
|
db=g.connection
|
|
|
|
error=0
|
|
|
|
error_form={}
|
|
|
|
txt_error=''
|
|
|
|
text=''
|
|
|
|
server_id=request.args.get('server_id', '0').strip()
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
update_server=UpdateServerScripts(db)
|
|
|
|
update_server.create_forms()
|
|
|
|
update_server.safe_query()
|
|
|
|
arr_server=server.set_conditions('WHERE id=%s', [server_id]).select_a_row_where([], True)
|
|
|
|
if arr_server:
|
|
|
|
order_id=json.loads(request.form.get('order_id', '{}'))
|
|
|
|
#print(order_id)
|
|
position=0
|
|
|
|
for item_id in order_id:
|
|
|
|
update_server.set_conditions('WHERE server_id=%s AND id=%s', [server_id, item_id]).update({'position': position})
|
|
position+=1
|
|
|
|
pass
|
|
|
|
return {'error': error, 'form': error_form, 'txt_error': txt_error}
|
|
|
|
@admin_app.route('/pastafari2/edit_users/<int:server_id>')
|
|
def pastafari2_edit_users(server_id):
|
|
|
|
db=g.connection
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
arr_server=server.select_a_row(server_id)
|
|
|
|
return t.load_template('edit_users.phtml', title=_('Edit server users'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, server_data=arr_server)
|
|
|
|
@admin_app.route('/pastafari2/get_server_users/<int:server_id>', methods=['POST'])
|
|
def pastafari2_get_server_users(server_id):
|
|
|
|
db=g.connection
|
|
|
|
fields=[['Username', True], ['Options', False]]
|
|
|
|
#rows=[{'username': 'developer', 'options': ''}]
|
|
rows=[]
|
|
|
|
with db.query('select * from systemuser WHERE server_id=%s', [server_id]) as cursor:
|
|
for user in cursor:
|
|
rows.append({'username': user['username'], 'options': ''})
|
|
|
|
|
|
arr_return={'fields': fields, 'rows': rows, 'html_pages': ''}
|
|
|
|
#print(json.dumps(arr_return))
|
|
|
|
return json.dumps(arr_return)
|
|
|
|
|
|
@admin_app.route('/pastafari2/add_user/<int:server_id>')
|
|
def pastafari2_add_user(server_id):
|
|
|
|
db=g.connection
|
|
|
|
server=ServerDbTask(db)
|
|
|
|
system_user=SystemUser(db)
|
|
|
|
system_user.fields['server_id'].name_form=HiddenForm
|
|
system_user.fields['server_id'].extra_parameters=[]
|
|
|
|
system_user.create_forms()
|
|
|
|
arr_server=server.select_a_row(server_id)
|
|
|
|
if arr_server:
|
|
|
|
#system_user.forms['server_id'].default_value=arr_server['id']
|
|
#print(system_user.forms['server_id'].default_value)
|
|
|
|
form=show_form({'server_id': arr_server['id']}, system_user.forms, t, yes_error=False, pass_values=True, modelform_tpl='forms/modelform.phtml')
|
|
|
|
#system_user.forms['server_id'].parameters=[]
|
|
|
|
return t.load_template('add_user.phtml', title=_('Add server user'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, hostname=arr_server['hostname'], form=form)
|
|
|
|
return ""
|
|
|
|
@admin_app.route('/pastafari2/add_user_task/', methods=['POST'])
|
|
def pastafari2_add_user_task():
|
|
|
|
db=g.connection
|
|
|
|
error_form={}
|
|
|
|
arr_log={}
|
|
|
|
error=True
|
|
|
|
txt_error=''
|
|
|
|
task_id=0
|
|
|
|
server_id=request.form.get('server_id', '0')
|
|
|
|
system_user=SystemUser(db)
|
|
|
|
system_user.create_forms()
|
|
|
|
#(error, fields, values, post)=system_user.check_all_fields(dict(request.form), external_agent=True)
|
|
|
|
(error, error_form, post, arr_form)=check_form(dict(request.form), system_user.forms)
|
|
|
|
if not error:
|
|
|
|
with db.query('select count(*) as num_user from systemuser WHERE username=%s', [post['username']]) as cursor:
|
|
num_user=cursor.fetchone()['num_user']
|
|
|
|
if num_user==0:
|
|
|
|
with db.query('select * from serverdbtask WHERE id=%s', [server_id]) as cursor:
|
|
arr_server=cursor.fetchone()
|
|
|
|
if arr_server:
|
|
|
|
sshtask=Task(db)
|
|
|
|
if not sshtask.run_task(arr_server['ip'], 'modules.pastafari2.tasks.system.add_user', 'Create user in server', 'Create_user', 'Task for create and user in the server', {'username': post['username'], 'home': '/home/{}'.format(post['username'])}, config_task.remote_user, '', '', url_for('admin_app.pastafari2_dashboard'), ssh_key_priv=config_task.ssh_private_key, ssh_key_password=config_task.ssh_private_key_password, send_task=True, ssh_port=arr_server['ssh_port']):
|
|
|
|
error=1
|
|
|
|
else:
|
|
error=0
|
|
|
|
task_id=sshtask.task_id
|
|
|
|
if task_id:
|
|
|
|
check_task=True
|
|
|
|
while check_task:
|
|
|
|
with db.query('select * from logtask where task_id=%s order by id DESC limit 1', [task_id]) as cursor:
|
|
|
|
arr_log=cursor.fetchone()
|
|
|
|
if arr_log:
|
|
|
|
if arr_log['status']==1:
|
|
|
|
error=arr_log['error']
|
|
|
|
error_form['#username_error']=arr_log['message']
|
|
check_task=False
|
|
|
|
if not error:
|
|
flash(_('The user was added successfully'))
|
|
|
|
else:
|
|
|
|
error=1
|
|
error_form['#username_error']=_('User exists')
|
|
|
|
else:
|
|
error=1
|
|
error_form['#username_error']='Username invalid'
|
|
|
|
|
|
return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id, 'log': arr_log}
|
|
|