Mirrors/WGDashboard
1
0
Fork 0
mirror of https://github.com/donaldzou/WGDashboard.git synced 2025-06-28 01:06:58 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Update SQLAlchemy Settings

Browse Source
This commit is contained in:
Donald Zou 2025-05-24 18:25:52 +08:00
parent be10a644a0
commit 9ffb7f54c7
9 changed files with 160 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/dashboard.py
View File

@ -1189,14 +1189,14 @@ def peerInformationBackgroundThread():
with app.app_context():
for c in WireguardConfigurations.values():
if c.getStatus():
try:
c.getPeersTransfer()
c.getPeersLatestHandshake()
c.getPeersEndpoint()
c.getPeersList()
c.getRestrictedPeersList()
except Exception as e:
print(f"[WGDashboard] Background Thread #1 Error: {str(e)}", flush=True)
# try:
c.getPeersTransfer()
c.getPeersLatestHandshake()
c.getPeersEndpoint()
c.getPeersList()
c.getRestrictedPeersList()
# except Exception as e:
# print(f"[WGDashboard] Background Thread #1 Error: {str(e)}", flush=True)
time.sleep(10)
def peerJobScheduleBackgroundThread():

78
src/modules/AmneziaWireguardConfiguration.py
View File

@ -1,9 +1,7 @@
"""
AmneziaWG Configuration
"""
import re
import sqlalchemy
import random, sqlalchemy, os, subprocess, re, uuid
from .PeerJobs import PeerJobs
from .AmneziaWGPeer import AmneziaWGPeer
@ -69,55 +67,55 @@ class AmneziaWireguardConfiguration(WireguardConfiguration):
self.peersTable = sqlalchemy.Table(
dbName, self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String),
sqlalchemy.Column('DNS', sqlalchemy.String),
sqlalchemy.Column('advanced_security', sqlalchemy.String),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.String),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String(255)),
sqlalchemy.Column('DNS', sqlalchemy.Text),
sqlalchemy.Column('advanced_security', sqlalchemy.String(255)),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.Text),
sqlalchemy.Column('name', sqlalchemy.Text),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
sqlalchemy.Column('endpoint', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String),
sqlalchemy.Column('latest_handshake', sqlalchemy.String),
sqlalchemy.Column('allowed_ip', sqlalchemy.String),
sqlalchemy.Column('endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('latest_handshake', sqlalchemy.String(255)),
sqlalchemy.Column('allowed_ip', sqlalchemy.String(255)),
sqlalchemy.Column('cumu_receive', sqlalchemy.Float),
sqlalchemy.Column('cumu_sent', sqlalchemy.Float),
sqlalchemy.Column('cumu_data', sqlalchemy.Float),
sqlalchemy.Column('mtu', sqlalchemy.Integer),
sqlalchemy.Column('keepalive', sqlalchemy.Integer),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String),
sqlalchemy.Column('preshared_key', sqlalchemy.String),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('preshared_key', sqlalchemy.String(255)),
extend_existing=True
)
self.peersRestrictedTable = sqlalchemy.Table(
f'{dbName}_restrict_access', self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String),
sqlalchemy.Column('DNS', sqlalchemy.String),
sqlalchemy.Column('advanced_security', sqlalchemy.String),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.String),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String(255)),
sqlalchemy.Column('DNS', sqlalchemy.Text),
sqlalchemy.Column('advanced_security', sqlalchemy.String(255)),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.Text),
sqlalchemy.Column('name', sqlalchemy.Text),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
sqlalchemy.Column('endpoint', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String),
sqlalchemy.Column('latest_handshake', sqlalchemy.String),
sqlalchemy.Column('allowed_ip', sqlalchemy.String),
sqlalchemy.Column('endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('latest_handshake', sqlalchemy.String(255)),
sqlalchemy.Column('allowed_ip', sqlalchemy.String(255)),
sqlalchemy.Column('cumu_receive', sqlalchemy.Float),
sqlalchemy.Column('cumu_sent', sqlalchemy.Float),
sqlalchemy.Column('cumu_data', sqlalchemy.Float),
sqlalchemy.Column('mtu', sqlalchemy.Integer),
sqlalchemy.Column('keepalive', sqlalchemy.Integer),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String),
sqlalchemy.Column('preshared_key', sqlalchemy.String),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('preshared_key', sqlalchemy.String(255)),
extend_existing=True
)
self.peersTransferTable = sqlalchemy.Table(
f'{dbName}_transfer', self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
@ -130,26 +128,26 @@ class AmneziaWireguardConfiguration(WireguardConfiguration):
)
self.peersDeletedTable = sqlalchemy.Table(
f'{dbName}_deleted', self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String),
sqlalchemy.Column('advanced_security', sqlalchemy.String),
sqlalchemy.Column('DNS', sqlalchemy.String),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.String),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False),
sqlalchemy.Column('private_key', sqlalchemy.String(255)),
sqlalchemy.Column('DNS', sqlalchemy.Text),
sqlalchemy.Column('advanced_security', sqlalchemy.String(255)),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.Text),
sqlalchemy.Column('name', sqlalchemy.Text),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
sqlalchemy.Column('endpoint', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String),
sqlalchemy.Column('latest_handshake', sqlalchemy.String),
sqlalchemy.Column('allowed_ip', sqlalchemy.String),
sqlalchemy.Column('endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('latest_handshake', sqlalchemy.String(255)),
sqlalchemy.Column('allowed_ip', sqlalchemy.String(255)),
sqlalchemy.Column('cumu_receive', sqlalchemy.Float),
sqlalchemy.Column('cumu_sent', sqlalchemy.Float),
sqlalchemy.Column('cumu_data', sqlalchemy.Float),
sqlalchemy.Column('mtu', sqlalchemy.Integer),
sqlalchemy.Column('keepalive', sqlalchemy.Integer),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String),
sqlalchemy.Column('preshared_key', sqlalchemy.String),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('preshared_key', sqlalchemy.String(255)),
extend_existing=True
)

14
src/modules/DashboardConfig.py
View File

@ -97,19 +97,21 @@ class DashboardConfig:
if not os.path.isdir(sqlitePath):
os.mkdir(sqlitePath)
cn = None
if self.GetConfig("Database", "type")[1] == "sqlite":
cn = f'sqlite:///{os.path.join(sqlitePath, f"{database}.db")}'
elif self.GetConfig("Database", "type")[1] == "postgresql":
cn = f'postgresql+psycopg2://{self.GetConfig("Database", "username")[1]}:{self.GetConfig("Database", "password")[1]}@{self.GetConfig("Database", "host")[1]}/{database}'
# cn = None
if self.GetConfig("Database", "type")[1] == "postgresql":
cn = f'postgresql+psycopg2://{self.GetConfig("Database", "username")[1]}:{self.GetConfig("Database", "password")[1]}@{self.GetConfig("Database", "host")[1]}/{database}'
elif self.GetConfig("Database", "type")[1] == "mysql":
cn = f'mysql+mysqldb://{self.GetConfig("Database", "username")[1]}:{self.GetConfig("Database", "password")[1]}@{self.GetConfig("Database", "host")[1]}/{database}'
else:
cn = f'sqlite:///{os.path.join(sqlitePath, f"{database}.db")}'
if not database_exists(cn):
create_database(cn)
return cn
def __createAPIKeyTable(self):
self.apiKeyTable = db.Table('DashboardAPIKeys', self.dbMetadata,
db.Column("Key", db.String, nullable=False, primary_key=True),
db.Column("Key", db.String(255), nullable=False, primary_key=True),
db.Column("CreatedAt",
(db.DATETIME if self.GetConfig('Database', 'type')[1] == 'sqlite' else db.TIMESTAMP),
server_default=db.func.now()

10
src/modules/DashboardLogger.py
View File

@ -10,14 +10,14 @@ class DashboardLogger:
self.engine = db.create_engine(DashboardConfig.getConnectionString("wgdashboard_log"))
self.metadata = db.MetaData()
self.dashboardLoggerTable = db.Table('DashboardLog', self.metadata,
db.Column('LogID', db.VARCHAR, nullable=False, primary_key=True),
db.Column('LogID', db.String(255), nullable=False, primary_key=True),
db.Column('LogDate', (db.DATETIME if DashboardConfig.GetConfig("Database", "type")[1] == 'sqlite' else db.TIMESTAMP),
server_default=db.func.now()),
db.Column('URL', db.VARCHAR),
db.Column('IP', db.VARCHAR),
db.Column('URL', db.String(255)),
db.Column('IP', db.String(255)),
db.Column('Status', db.VARCHAR, nullable=False),
db.Column('Message', db.VARCHAR)
db.Column('Status', db.String(255), nullable=False),
db.Column('Message', db.Text)
)
self.metadata.create_all(self.engine)
self.log(Message="WGDashboard started")

8
src/modules/PeerJobLogger.py
View File

@ -10,12 +10,12 @@ class PeerJobLogger:
self.engine = db.create_engine(DashboardConfig.getConnectionString("wgdashboard_log"))
self.metadata = db.MetaData()
self.jobLogTable = db.Table('JobLog', self.metadata,
db.Column('LogID', db.String, nullable=False, primary_key=True),
db.Column('JobID', db.String, nullable=False),
db.Column('LogID', db.String(255), nullable=False, primary_key=True),
db.Column('JobID', db.String(255), nullable=False),
db.Column('LogDate', (db.DATETIME if DashboardConfig.GetConfig("Database", "type")[1] == 'sqlite' else db.TIMESTAMP),
server_default=db.func.now()),
db.Column('Status', db.String, nullable=False),
db.Column('Message', db.String)
db.Column('Status', db.String(255), nullable=False),
db.Column('Message', db.Text)
)
self.logs: list[Log] = []
self.metadata.create_all(self.engine)

14
src/modules/PeerJobs.py
View File

@ -12,15 +12,15 @@ class PeerJobs:
self.engine = db.create_engine(DashboardConfig.getConnectionString('wgdashboard_job'))
self.metadata = db.MetaData()
self.peerJobTable = db.Table('PeerJobs', self.metadata,
db.Column('JobID', db.String, nullable=False, primary_key=True),
db.Column('Configuration', db.String, nullable=False),
db.Column('Peer', db.String, nullable=False),
db.Column('Field', db.String, nullable=False),
db.Column('Operator', db.String, nullable=False),
db.Column('Value', db.String, nullable=False),
db.Column('JobID', db.String(255), nullable=False, primary_key=True),
db.Column('Configuration', db.String(255), nullable=False),
db.Column('Peer', db.String(255), nullable=False),
db.Column('Field', db.String(255), nullable=False),
db.Column('Operator', db.String(255), nullable=False),
db.Column('Value', db.String(255), nullable=False),
db.Column('CreationDate', (db.DATETIME if DashboardConfig.GetConfig("Database", "type")[1] == 'sqlite' else db.TIMESTAMP), nullable=False),
db.Column('ExpireDate', (db.DATETIME if DashboardConfig.GetConfig("Database", "type")[1] == 'sqlite' else db.TIMESTAMP)),
db.Column('Action', db.String, nullable=False),
db.Column('Action', db.String(255), nullable=False),
)
self.metadata.create_all(self.engine)
self.__getJobs()

6
src/modules/PeerShareLinks.py
View File

@ -13,9 +13,9 @@ class PeerShareLinks:
self.metadata = db.MetaData()
self.peerShareLinksTable = db.Table(
'PeerShareLinks', self.metadata,
db.Column('ShareID', db.String, nullable=False, primary_key=True),
db.Column('Configuration', db.String, nullable=False),
db.Column('Peer', db.String, nullable=False),
db.Column('ShareID', db.String(255), nullable=False, primary_key=True),
db.Column('Configuration', db.String(255), nullable=False),
db.Column('Peer', db.String(255), nullable=False),
db.Column('ExpireDate', (db.DATETIME if DashboardConfig.GetConfig("Database", "type")[1] == 'sqlite' else db.TIMESTAMP)),
db.Column('SharedDate', (db.DATETIME if DashboardConfig.GetConfig("Database", "type")[1] == 'sqlite' else db.TIMESTAMP),
server_default=db.func.now()),

166
src/modules/WireguardConfiguration.py
View File

@ -1,13 +1,9 @@
"""
WireGuard Configuration
"""
import random, shutil, configparser, ipaddress, os, subprocess
import time, re, uuid, psutil
import traceback
import sqlalchemy, random, shutil, configparser, ipaddress, os, subprocess, time, re, uuid, psutil, traceback
from zipfile import ZipFile
from datetime import datetime, timedelta
import sqlalchemy
from itertools import islice
from .DashboardConfig import DashboardConfig
@ -222,53 +218,53 @@ class WireguardConfiguration:
dbName = self.Name
self.peersTable = sqlalchemy.Table(
dbName, self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String),
sqlalchemy.Column('DNS', sqlalchemy.String),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.String),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String(255)),
sqlalchemy.Column('DNS', sqlalchemy.Text),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.Text),
sqlalchemy.Column('name', sqlalchemy.Text),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
sqlalchemy.Column('endpoint', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String),
sqlalchemy.Column('latest_handshake', sqlalchemy.String),
sqlalchemy.Column('allowed_ip', sqlalchemy.String),
sqlalchemy.Column('endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('latest_handshake', sqlalchemy.String(255)),
sqlalchemy.Column('allowed_ip', sqlalchemy.String(255)),
sqlalchemy.Column('cumu_receive', sqlalchemy.Float),
sqlalchemy.Column('cumu_sent', sqlalchemy.Float),
sqlalchemy.Column('cumu_data', sqlalchemy.Float),
sqlalchemy.Column('mtu', sqlalchemy.Integer),
sqlalchemy.Column('keepalive', sqlalchemy.Integer),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String),
sqlalchemy.Column('preshared_key', sqlalchemy.String),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('preshared_key', sqlalchemy.String(255)),
extend_existing=True
)
self.peersRestrictedTable = sqlalchemy.Table(
f'{dbName}_restrict_access', self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String),
sqlalchemy.Column('DNS', sqlalchemy.String),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.String),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String(255)),
sqlalchemy.Column('DNS', sqlalchemy.Text),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.Text),
sqlalchemy.Column('name', sqlalchemy.Text),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
sqlalchemy.Column('endpoint', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String),
sqlalchemy.Column('latest_handshake', sqlalchemy.String),
sqlalchemy.Column('allowed_ip', sqlalchemy.String),
sqlalchemy.Column('endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('latest_handshake', sqlalchemy.String(255)),
sqlalchemy.Column('allowed_ip', sqlalchemy.String(255)),
sqlalchemy.Column('cumu_receive', sqlalchemy.Float),
sqlalchemy.Column('cumu_sent', sqlalchemy.Float),
sqlalchemy.Column('cumu_data', sqlalchemy.Float),
sqlalchemy.Column('mtu', sqlalchemy.Integer),
sqlalchemy.Column('keepalive', sqlalchemy.Integer),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String),
sqlalchemy.Column('preshared_key', sqlalchemy.String),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('preshared_key', sqlalchemy.String(255)),
extend_existing=True
)
self.peersTransferTable = sqlalchemy.Table(
f'{dbName}_transfer', self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
@ -281,25 +277,25 @@ class WireguardConfiguration:
)
self.peersDeletedTable = sqlalchemy.Table(
f'{dbName}_deleted', self.metadata,
sqlalchemy.Column('id', sqlalchemy.String, nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String),
sqlalchemy.Column('DNS', sqlalchemy.String),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.String),
sqlalchemy.Column('name', sqlalchemy.String),
sqlalchemy.Column('id', sqlalchemy.String(255), nullable=False, primary_key=True),
sqlalchemy.Column('private_key', sqlalchemy.String(255)),
sqlalchemy.Column('DNS', sqlalchemy.Text),
sqlalchemy.Column('endpoint_allowed_ip', sqlalchemy.Text),
sqlalchemy.Column('name', sqlalchemy.Text),
sqlalchemy.Column('total_receive', sqlalchemy.Float),
sqlalchemy.Column('total_sent', sqlalchemy.Float),
sqlalchemy.Column('total_data', sqlalchemy.Float),
sqlalchemy.Column('endpoint', sqlalchemy.String),
sqlalchemy.Column('status', sqlalchemy.String),
sqlalchemy.Column('latest_handshake', sqlalchemy.String),
sqlalchemy.Column('allowed_ip', sqlalchemy.String),
sqlalchemy.Column('endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('status', sqlalchemy.String(255)),
sqlalchemy.Column('latest_handshake', sqlalchemy.String(255)),
sqlalchemy.Column('allowed_ip', sqlalchemy.String(255)),
sqlalchemy.Column('cumu_receive', sqlalchemy.Float),
sqlalchemy.Column('cumu_sent', sqlalchemy.Float),
sqlalchemy.Column('cumu_data', sqlalchemy.Float),
sqlalchemy.Column('mtu', sqlalchemy.Integer),
sqlalchemy.Column('keepalive', sqlalchemy.Integer),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String),
sqlalchemy.Column('preshared_key', sqlalchemy.String),
sqlalchemy.Column('remote_endpoint', sqlalchemy.String(255)),
sqlalchemy.Column('preshared_key', sqlalchemy.String(255)),
extend_existing=True
)
@ -353,7 +349,8 @@ class WireguardConfiguration:
return changed
def getPeers(self):
self.Peers = []
# self.Peers = []
tmpList = []
if self.configurationFileChanged():
with open(self.configPath, 'r') as configFile:
p = []
@ -419,7 +416,7 @@ class WireguardConfiguration:
self.peersTable.columns.id == i['PublicKey']
)
)
self.Peers.append(Peer(tempPeer, self))
tmpList.append(Peer(tempPeer, self))
except Exception as e:
if __name__ == '__main__':
print(f"[WGDashboard] {self.Name} getPeers() Error: {str(e)}")
@ -427,7 +424,9 @@ class WireguardConfiguration:
with self.engine.connect() as conn:
existingPeers = conn.execute(self.peersTable.select()).mappings().fetchall()
for i in existingPeers:
self.Peers.append(Peer(i, self))
tmpList.append(Peer(i, self))
self.Peers = []
self.Peers = tmpList
def addPeers(self, peers: list) -> tuple[bool, dict]:
result = {
@ -661,43 +660,48 @@ class WireguardConfiguration:
def getPeersTransfer(self):
if not self.getStatus():
self.toggleConfiguration()
try:
data_usage = subprocess.check_output(f"{self.Protocol} show {self.Name} transfer",
shell=True, stderr=subprocess.STDOUT)
data_usage = data_usage.decode("UTF-8").split("\n")
data_usage = [p.split("\t") for p in data_usage]
with self.engine.begin() as conn:
for i in range(len(data_usage)):
if len(data_usage[i]) == 3:
cur_i = conn.execute(
self.peersTable.select().where(
self.peersTable.c.id == data_usage[i][0]
)
).mappings().fetchone()
if cur_i is not None:
total_sent = cur_i['total_sent']
total_receive = cur_i['total_receive']
cur_total_sent = float(data_usage[i][2]) / (1024 ** 3)
cur_total_receive = float(data_usage[i][1]) / (1024 ** 3)
cumulative_receive = cur_i['cumu_receive'] + total_receive
cumulative_sent = cur_i['cumu_sent'] + total_sent
if total_sent <= cur_total_sent and total_receive <= cur_total_receive:
total_sent = cur_total_sent
total_receive = cur_total_receive
else:
conn.execute(
self.peersTable.update().values({
"cumu_receive": cumulative_receive,
"cumu_sent": cumulative_sent,
"cumu_data": cumulative_sent + cumulative_receive
}).where(
self.peersTable.c.id == data_usage[i][0]
)
)
# try:
data_usage = subprocess.check_output(f"{self.Protocol} show {self.Name} transfer",
shell=True, stderr=subprocess.STDOUT)
data_usage = data_usage.decode("UTF-8").split("\n")
total_sent = 0
total_receive = 0
_, p = self.searchPeer(data_usage[i][0])
data_usage = [p.split("\t") for p in data_usage]
cur_i = None
with self.engine.begin() as conn:
for i in range(len(data_usage)):
if len(data_usage[i]) == 3:
cur_i = conn.execute(
self.peersTable.select().where(
self.peersTable.c.id == data_usage[i][0]
)
).mappings().fetchone()
if cur_i is not None:
# print(cur_i is None)
total_sent = cur_i['total_sent']
# print(cur_i is None)
total_receive = cur_i['total_receive']
cur_total_sent = float(data_usage[i][2]) / (1024 ** 3)
cur_total_receive = float(data_usage[i][1]) / (1024 ** 3)
cumulative_receive = cur_i['cumu_receive'] + total_receive
cumulative_sent = cur_i['cumu_sent'] + total_sent
if total_sent <= cur_total_sent and total_receive <= cur_total_receive:
total_sent = cur_total_sent
total_receive = cur_total_receive
else:
conn.execute(
self.peersTable.update().values({
"cumu_receive": cumulative_receive,
"cumu_sent": cumulative_sent,
"cumu_data": cumulative_sent + cumulative_receive
}).where(
self.peersTable.c.id == data_usage[i][0]
)
)
total_sent = 0
total_receive = 0
status, p = self.searchPeer(data_usage[i][0])
if status:
if p.total_receive != total_receive or p.total_sent != total_sent:
conn.execute(
self.peersTable.update().values({
@ -709,8 +713,10 @@ class WireguardConfiguration:
)
)
except Exception as e:
print(f"[WGDashboard] {self.Name} getPeersTransfer() Error: {str(e)} {str(e.__traceback__)}")
# except Exception as e:
# print(cur_i, cur_i['total_receive'])
# print(f"[WGDashboard] {self.Name} getPeersTransfer() Error: {str(e)} {str(e.__traceback__)}")
def getPeersEndpoint(self):
if not self.getStatus():

1
src/requirements.txt
View File

@ -11,3 +11,4 @@ tcconfig
sqlalchemy
sqlalchemy_utils
psycopg2
mysqlclient