github
/
haproxy-wi
mirror of https://github.com/Aidaho12/haproxy-wi
1
0
Fork 0
Code Issues Releases Wiki Activity

v6.0.2.0 

Changelog: https://roxy-wi.org/changelog.py#6_0_2
pull/328/head
Pavel Loginov 2022-05-23 21:41:39 +03:00
parent ecaff8ef7a
commit 1fabdffb97
2 changed files with 114 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
api/api_funct.py
View File

@ -139,7 +139,7 @@ def get_server(server_id, service):
'master': s[6], 'master': s[6],
'creds': s[7] 'creds': s[7]
} }
except: except Exception:
data = '' data = ''
return dict(server=data) return dict(server=data)
@ -171,9 +171,9 @@ def get_status(server_id, service):
apache_stats_port = sql.get_setting('apache_stats_port') apache_stats_port = sql.get_setting('apache_stats_port')
apache_stats_page = sql.get_setting('apache_stats_page') apache_stats_page = sql.get_setting('apache_stats_page')
cmd = "curl -s -u %s:%s http://%s:%s/%s?auto |grep 'ServerVersion\|Processes\|ServerUptime:'" % \ cmd = "curl -s -u %s:%s http://%s:%s/%s?auto |grep 'ServerVersion\|Processes\|ServerUptime:'" % \
( (
apache_stats_user, apache_stats_password, s[2], apache_stats_port, apache_stats_page apache_stats_user, apache_stats_password, s[2], apache_stats_port, apache_stats_page
) )
servers_with_status = list() servers_with_status = list()
try: try:
out = funct.subprocess_execute(cmd) out = funct.subprocess_execute(cmd)
@ -192,13 +192,13 @@ def get_status(server_id, service):
data = {server_id: {"error": "Cannot get status: " + str(e)}} data = {server_id: {"error": "Cannot get status: " + str(e)}}
except: except Exception:
data = {server_id: {"error": "Cannot find the server"}} data = {server_id: {"error": "Cannot find the server"}}
return dict(error=data) return dict(error=data)
return dict(status=data) return dict(status=data)
def get_all_statuses(): def get_all_statuses():
data = {} data = {}
try: try:
@ -215,13 +215,13 @@ def get_all_statuses():
data[s[2]] = {} data[s[2]] = {}
out = funct.subprocess_execute(cmd) out = funct.subprocess_execute(cmd)
data[s[2]] = return_dict_from_out(s[1], out[0]) data[s[2]] = return_dict_from_out(s[1], out[0])
except: except Exception:
data = {"error": "Cannot find the server"} data = {"error": "Cannot find the server"}
return dict(error=data) return dict(error=data)
return dict(status=data) return dict(status=data)
def actions(server_id, action, service): def actions(server_id, action, service):
if action != 'start' and action != 'stop' and action != 'restart' and action != 'reload': if action != 'start' and action != 'stop' and action != 'restart' and action != 'reload':
return dict(status='wrong action') return dict(status='wrong action')
@ -244,9 +244,8 @@ def actions(server_id, action, service):
return dict(status=data) return dict(status=data)
except Exception as e: except Exception as e:
return dict(status=str(e)) return dict(status=str(e))
def runtime(server_id): def runtime(server_id):
data = {} data = {}
try: try:
@ -256,36 +255,36 @@ def runtime(server_id):
haproxy_sock = sql.get_setting('haproxy_sock') haproxy_sock = sql.get_setting('haproxy_sock')
servers = check_permit_to_server(server_id) servers = check_permit_to_server(server_id)
cmd = ['echo "%s" |sudo socat stdio %s' % (action, haproxy_sock)] cmd = ['echo "%s" |sudo socat stdio %s' % (action, haproxy_sock)]
for s in servers: for s in servers:
out = funct.ssh_command(s[2], cmd) out = funct.ssh_command(s[2], cmd)
data = {server_id: {}} data = {server_id: {}}
sep_data = out.split('\r\n') sep_data = out.split('\r\n')
data = {server_id: sep_data} data = {server_id: sep_data}
return dict(status=data) return dict(status=data)
except: except Exception:
return dict(status='error') return dict(status='error')
def show_backends(server_id): def show_backends(server_id):
data = {} data = {}
try: try:
servers = check_permit_to_server(server_id) servers = check_permit_to_server(server_id)
for s in servers: for s in servers:
out = funct.show_backends(s[2], ret=1) out = funct.show_backends(s[2], ret=1)
data = {server_id: out} data = {server_id: out}
except: except Exception:
data = {server_id: {"error": "Cannot find the server"}} data = {server_id: {"error": "Cannot find the server"}}
return dict(error=data) return dict(error=data)
return dict(backends=data) return dict(backends=data)
def get_config(server_id, **kwargs): def get_config(server_id, **kwargs):
service = kwargs.get('service') service = kwargs.get('service')
if service != 'apache' and service != 'nginx' and service != 'haproxy' and service != 'keepalived': if service != 'apache' and service != 'nginx' and service != 'haproxy' and service != 'keepalived':
@ -294,7 +293,7 @@ def get_config(server_id, **kwargs):
data = {} data = {}
try: try:
servers = check_permit_to_server(server_id) servers = check_permit_to_server(server_id)
for s in servers: for s in servers:
cfg = '/tmp/' + s[2] + '.cfg' cfg = '/tmp/' + s[2] + '.cfg'
out = funct.get_config(s[2], cfg, service=service, config_file_name=kwargs.get('config_path')) out = funct.get_config(s[2], cfg, service=service, config_file_name=kwargs.get('config_path'))
@ -303,16 +302,16 @@ def get_config(server_id, **kwargs):
conf = open(cfg, "r") conf = open(cfg, "r")
config_read = conf.read() config_read = conf.read()
conf.close conf.close
except IOError: except IOError:
conf = '<br />Cannot read import config file' conf = '<br />Cannot read import config file'
data = {server_id: config_read} data = {server_id: config_read}
except Exception as e: except Exception as e:
data = {server_id: {"error": "Cannot find the server " + str(e)}} data = {server_id: {"error": "Cannot find the server " + str(e)}}
return dict(error=data) return dict(error=data)
return dict(config=data) return dict(config=data)
@ -447,8 +446,8 @@ def upload_config(server_id, **kwargs):
return dict(error=data) return dict(error=data)
return dict(config=data) return dict(config=data)
def add_to_config(server_id): def add_to_config(server_id):
data = {} data = {}
body = request.body.getvalue().decode('utf-8') body = request.body.getvalue().decode('utf-8')
@ -456,15 +455,15 @@ def add_to_config(server_id):
hap_configs_dir = funct.get_config_var('configs', 'haproxy_save_configs_dir') hap_configs_dir = funct.get_config_var('configs', 'haproxy_save_configs_dir')
token = request.headers.get('token') token = request.headers.get('token')
login, group_id = sql.get_username_groupid_from_api_token(token) login, group_id = sql.get_username_groupid_from_api_token(token)
if save == '': if save == '':
save = 'save' save = 'save'
elif save == 'restart': elif save == 'restart':
save = '' save = ''
try: try:
servers = check_permit_to_server(server_id) servers = check_permit_to_server(server_id)
for s in servers: for s in servers:
ip = s[2] ip = s[2]
cfg = '/tmp/' + ip + '.cfg' cfg = '/tmp/' + ip + '.cfg'
@ -483,15 +482,15 @@ def add_to_config(server_id):
return_mess = out return_mess = out
except IOError: except IOError:
return_mess = "cannot upload config" return_mess = "cannot upload config"
data = {server_id: return_mess} data = {server_id: return_mess}
except: except Exception:
data[server_id] = {"error": "cannot find the server"} data[server_id] = {"error": "cannot find the server"}
return dict(error=data) return dict(error=data)
return dict(config=data) return dict(config=data)
def show_log(server_id): def show_log(server_id):
data = {} data = {}
rows = request.headers.get('rows') rows = request.headers.get('rows')
@ -501,7 +500,7 @@ def show_log(server_id):
minute = request.headers.get('start_minute') minute = request.headers.get('start_minute')
hour1 = request.headers.get('end_hour') hour1 = request.headers.get('end_hour')
minute1 = request.headers.get('end_minute') minute1 = request.headers.get('end_minute')
if rows is None: if rows is None:
rows = '10' rows = '10'
if waf is None: if waf is None:
@ -517,14 +516,14 @@ def show_log(server_id):
try: try:
servers = check_permit_to_server(server_id) servers = check_permit_to_server(server_id)
for s in servers: for s in servers:
ip = s[2] ip = s[2]
except: except Exception:
data[server_id] = {"error": "Cannot find the server"} data[server_id] = {"error": "Cannot find the server"}
return dict(error=data) return dict(error=data)
out = funct.show_haproxy_log(ip, rows=rows, waf=str(waf), grep=grep, hour=str(hour), minut=str(minute), hour1=str(hour1), minut1=str(minute1), html=0) out = funct.show_haproxy_log(ip, rows=rows, waf=str(waf), grep=grep, hour=str(hour), minut=str(minute), hour1=str(hour1), minut1=str(minute1), html=0)
data = {server_id: out} data = {server_id: out}

122
app/sql.py
View File

@ -347,9 +347,10 @@ def select_users(**kwargs):
where(UserGroups.user_group_id == kwargs.get("group")) where(UserGroups.user_group_id == kwargs.get("group"))
) )
else: else:
query = User.select(User,Case(0, [(( query = User.select(User,Case(0, [(
User.last_login_date >= funct.get_data('regular', timedelta_minutes_minus=15) (
), 0)], 1).alias('last_login')).order_by(User.user_id) User.last_login_date >= funct.get_data('regular', timedelta_minutes_minus=15)
), 0)], 1).alias('last_login')).order_by(User.user_id)
try: try:
query_res = query.execute() query_res = query.execute()
@ -2377,14 +2378,15 @@ def response_time(time, smon_id):
def smon_list(user_group): def smon_list(user_group):
if user_group == 1: if user_group == 1:
query = (SMON.select(SMON.ip, SMON.port, SMON.status, SMON.en, SMON.desc, SMON.response_time, SMON.time_state, query = (SMON.select(
SMON.group, SMON.script, SMON.http, SMON.http_status, SMON.body, SMON.body_status) SMON.ip, SMON.port, SMON.status, SMON.en, SMON.desc, SMON.response_time, SMON.time_state,
.order_by(SMON.group)) SMON.group, SMON.script, SMON.http, SMON.http_status, SMON.body, SMON.body_status
).order_by(SMON.group))
else: else:
query = (SMON.select(SMON.ip, SMON.port, SMON.status, SMON.en, SMON.desc, SMON.response_time, SMON.time_state, query = (SMON.select(
SMON.group, SMON.script, SMON.http, SMON.http_status, SMON.body, SMON.body_status) SMON.ip, SMON.port, SMON.status, SMON.en, SMON.desc, SMON.response_time, SMON.time_state,
.where(SMON.user_group == user_group) SMON.group, SMON.script, SMON.http, SMON.http_status, SMON.body, SMON.body_status
.order_by(SMON.group)) ).where(SMON.user_group == user_group).order_by(SMON.group))
try: try:
query_res = query.execute() query_res = query.execute()
@ -2571,8 +2573,9 @@ def delete_ports(serv):
def insert_port_scanner_history(serv, port, port_status, service_name): def insert_port_scanner_history(serv, port, port_status, service_name):
try: try:
PortScannerHistory.insert(serv=serv, port=port, status=port_status, service_name=service_name, PortScannerHistory.insert(
date=funct.get_data('regular')).execute() serv=serv, port=port, status=port_status, service_name=service_name,date=funct.get_data('regular')
).execute()
except Exception as e: except Exception as e:
out_error(e) out_error(e)
@ -2618,9 +2621,10 @@ def add_provider_do(provider_name, provider_group, provider_token):
def add_provider_aws(provider_name, provider_group, provider_key, provider_secret): def add_provider_aws(provider_name, provider_group, provider_key, provider_secret):
try: try:
ProvidersCreds.insert(name=provider_name, type='aws', group=provider_group, key=provider_key, ProvidersCreds.insert(
secret=provider_secret, create_date=funct.get_data('regular'), name=provider_name, type='aws', group=provider_group, key=provider_key, secret=provider_secret,
edit_date=funct.get_data('regular')).execute() create_date=funct.get_data('regular'),edit_date=funct.get_data('regular')
).execute()
return True return True
except Exception as e: except Exception as e:
out_error(e) out_error(e)
@ -2669,15 +2673,17 @@ def delete_provider(provider_id):
return False return False
def add_server_aws(region, instance_type, public_ip, floating_ip, volume_size, ssh_key_name, name, os, firewall, def add_server_aws(
provider_id, group_id, status, delete_on_termination, volume_type): region, instance_type, public_ip, floating_ip, volume_size, ssh_key_name, name, os, firewall,
provider_id, group_id, status, delete_on_termination, volume_type
):
try: try:
ProvisionedServers.insert(region=region, instance_type=instance_type, public_ip=public_ip, ProvisionedServers.insert(
floating_ip=floating_ip, volume_size=volume_size, volume_type=volume_type, region=region, instance_type=instance_type, public_ip=public_ip, floating_ip=floating_ip,
ssh_key_name=ssh_key_name, name=name, os=os, firewall=firewall, volume_size=volume_size, volume_type=volume_type, ssh_key_name=ssh_key_name, name=name, os=os,
provider_id=provider_id, group_id=group_id, firewall=firewall, provider_id=provider_id, group_id=group_id, delete_on_termination=delete_on_termination,
delete_on_termination=delete_on_termination, type='aws', status=status, date=funct.get_data('regular')
type='aws', status=status, date=funct.get_data('regular')).execute() ).execute()
return True return True
except Exception as e: except Exception as e:
out_error(e) out_error(e)
@ -2835,11 +2841,11 @@ def update_server_gcore(region, size, network_type, network_name, volume_size, s
def update_server_do(size, privet_net, floating_ip, ssh_ids, ssh_name, oss, firewall, monitoring, backup, provider, def update_server_do(size, privet_net, floating_ip, ssh_ids, ssh_name, oss, firewall, monitoring, backup, provider,
group, status, server_id): group, status, server_id):
query = ProvisionedServers.update(instance_type=size, private_networking=privet_net, query = ProvisionedServers.update(
floating_ip=floating_ip, ssh_ids=ssh_ids, ssh_key_name=ssh_name, instance_type=size, private_networking=privet_net, floating_ip=floating_ip, ssh_ids=ssh_ids,
os=oss, firewall=firewall, monitoring=monitoring, backup=backup, ssh_key_name=ssh_name, os=oss, firewall=firewall, monitoring=monitoring, backup=backup, provider_id=provider,
provider_id=provider, group_id=group, status=status
group_id=group, status=status).where(ProvisionedServers.id == server_id) ).where(ProvisionedServers.id == server_id)
try: try:
query.execute() query.execute()
return True return True
@ -2860,13 +2866,16 @@ def select_provisioned_servers(**kwargs):
prov_serv = ProvisionedServers.alias() prov_serv = ProvisionedServers.alias()
if kwargs.get('new'): if kwargs.get('new'):
query = ( query = (
prov_serv.select(prov_serv.id, prov_serv.name, prov_serv.provider_id, prov_serv.type, prov_serv.select(
prov_serv.group_id, prov_serv.instance_type, prov_serv.status, prov_serv.date, prov_serv.id, prov_serv.name, prov_serv.provider_id, prov_serv.type, prov_serv.group_id,
prov_serv.region, prov_serv.os, prov_serv.IP, prov_serv.last_error, prov_serv.instance_type, prov_serv.status, prov_serv.date, prov_serv.region, prov_serv.os,
prov_serv.name_template) prov_serv.IP, prov_serv.last_error, prov_serv.name_template
.where((prov_serv.name == kwargs.get('new')) & ) .where(
(prov_serv.group_id == kwargs.get('group')) & (prov_serv.name == kwargs.get('new')) &
(prov_serv.type == kwargs.get('type')))) (prov_serv.group_id == kwargs.get('group')) &
(prov_serv.type == kwargs.get('type'))
)
)
else: else:
query = prov_serv.select(prov_serv.id, prov_serv.name, prov_serv.provider_id, prov_serv.type, query = prov_serv.select(prov_serv.id, prov_serv.name, prov_serv.provider_id, prov_serv.type,
prov_serv.group_id, prov_serv.group_id,
@ -3034,12 +3043,14 @@ def delete_service_settings(server_id: int):
def insert_action_history(service: str, action: str, server_id: int, user_id: int, user_ip: str): def insert_action_history(service: str, action: str, server_id: int, user_id: int, user_ip: str):
try: try:
ActionHistory.insert(service=service, ActionHistory.insert(
action=action, service=service,
server_id=server_id, action=action,
user_id=user_id, server_id=server_id,
ip=user_ip, user_id=user_id,
date=funct.get_data('regular')).execute() ip=user_ip,
date=funct.get_data('regular')
).execute()
except Exception as e: except Exception as e:
out_error(e) out_error(e)
@ -3090,13 +3101,15 @@ def select_action_history_by_server_id_and_service(server_id: int, service: str)
def insert_config_version(server_id: int, user_id: int, service: str, local_path: str, remote_path: str, diff: str): def insert_config_version(server_id: int, user_id: int, service: str, local_path: str, remote_path: str, diff: str):
try: try:
ConfigVersion.insert(server_id=server_id, ConfigVersion.insert(
user_id=user_id, server_id=server_id,
service=service, user_id=user_id,
local_path=local_path, service=service,
remote_path=remote_path, local_path=local_path,
diff=diff, remote_path=remote_path,
date=funct.get_data('regular')).execute() diff=diff,
date=funct.get_data('regular')
).execute()
except Exception as e: except Exception as e:
out_error(e) out_error(e)
@ -3132,9 +3145,11 @@ def delete_config_version(service: str, local_path: str):
def select_remote_path_from_version(server_ip: str, service: str, local_path: str): def select_remote_path_from_version(server_ip: str, service: str, local_path: str):
server_id = select_server_id_by_ip(server_ip) server_id = select_server_id_by_ip(server_ip)
try: try:
query_res = ConfigVersion.get((ConfigVersion.server_id == server_id) & query_res = ConfigVersion.get(
(ConfigVersion.service == service) & (ConfigVersion.server_id == server_id) &
(ConfigVersion.local_path == local_path)).remote_path (ConfigVersion.service == service) &
(ConfigVersion.local_path == local_path)
).remote_path
except Exception as e: except Exception as e:
out_error(e) out_error(e)
else: else:
@ -3144,8 +3159,9 @@ def select_remote_path_from_version(server_ip: str, service: str, local_path: st
def insert_system_info(server_id: int, os_info: str, sys_info: str, cpu: str, ram: str, network: str, def insert_system_info(server_id: int, os_info: str, sys_info: str, cpu: str, ram: str, network: str,
disks: str) -> bool: disks: str) -> bool:
try: try:
SystemInfo.insert(server_id=server_id, os_info=os_info, sys_info=sys_info, cpu=cpu, ram=ram, SystemInfo.insert(
network=network, disks=disks).on_conflict('replace').execute() server_id=server_id, os_info=os_info, sys_info=sys_info, cpu=cpu, ram=ram, network=network, disks=disks
).on_conflict('replace').execute()
except Exception as e: except Exception as e:
out_error(e) out_error(e)
return False return False