hiddifypanel 9.0.0.dev92__py3-none-any.whl → 10.5.0.dev0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-9.0.0.dev92
+10.5.0.dev0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='9.0.0.dev92'
+__version__='10.5.0.dev0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-03-03','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-04-05','%Y-%m-%d')

hiddifypanel/auth.py

@@ -4,7 +4,7 @@ from hiddifypanel.hutils.flask import hurl_for
 from flask_login.utils import _get_user
 from functools import wraps
 from hiddifypanel.models import *
-
+from apiflask import abort as json_abort
 from hiddifypanel import hutils
 from werkzeug.local import LocalProxy
 current_account: "BaseAccount" = LocalProxy(lambda: _get_user())
@@ -97,14 +97,17 @@ def login_user(user: AdminUser | User, remember=False, duration=None, force=Fals
     return True
 
 
-def login_required(roles: set[Role] | None = None):
+def login_required(roles: set[Role] | None = None, node_auth: bool = False):
+    '''When both roles and node_auth is set, means authentication can be done by either uuid or unique_id'''
     def wrapper(fn):
         @wraps(fn)
         def decorated_view(*args, **kwargs):
             # print('xxxx', current_account)
-            if not current_account:
+            if node_auth and not Child.node and not roles:
+                json_abort(403, 'Unauthorized node')
+            if not current_account and not node_auth:
                 return redirect_to_login()  # type: ignore
-            if roles:
+            if roles and not Child.node:
                 account_role = current_account.role
                 if account_role not in roles:
                     return redirect_to_login()  # type: ignore
@@ -143,12 +146,20 @@ def auth_before_request():
         # print(account)
         if not account:
             return logout_redirect()
-
-        next_url = request.url.replace(f'/{g.uuid}/', '/admin/' if is_admin_path else '/client/').replace("/admin/admin/",
-                                                                                                          '/admin/').replace("http://", "https://")
+        if is_admin_path:
+            next_url = request.url
+            next_url = next_url.replace(f'/{g.uuid}/', '/admin/')
+            next_url = next_url.replace("/admin/admin/", '/admin/')
+            next_url = next_url.replace("http://", "https://")
 
     elif apikey := request.headers.get("Hiddify-API-Key"):
         account = get_account_by_api_key(apikey, is_admin_path)
+        if not account:
+            # when parent/child panel needs to call another parent/child api, it will pass its unique id in the header as apikey
+            if node := Child.by_unique_id(apikey):
+                g.node = node
+                return
+
         if not account:
             return logout_redirect()
     elif request.authorization:
@@ -180,8 +191,16 @@ def auth_before_request():
         g.is_admin = hutils.flask.is_admin_role(account.role)  # type: ignore
         login_user(account, force=True)
         # print("loggining in")
-        if next_url is not None and g.user_agent['is_browser'] and ".webmanifest" not in request.path:
-            return redirect(next_url)
+        if not g.is_admin:
+            return
+        if next_url is None:
+            return
+        if not g.user_agent['is_browser']:
+            return
+        if ".webmanifest" in request.path:
+            return
+
+        return redirect(next_url)
 
 
 def logout_redirect():
@@ -191,6 +210,8 @@ def logout_redirect():
 
 
 def redirect_to_login():
+    if hutils.flask.is_api_call(request.path):
+        json_abort(403, 'Unathorized')
     # if g.user_agent['is_browser']:
     # return redirect(hurl_for('common_bp.LoginView:basic_0', force=1, next=request.path))
     return redirect(hurl_for('common_bp.LoginView:index', force=1, next=request.path))

hiddifypanel/base.py

@@ -11,55 +11,57 @@ import datetime
 
 from dotenv import dotenv_values
 import os
+import sys
 from apiflask import APIFlask
 from werkzeug.middleware.proxy_fix import ProxyFix
-
+from loguru import logger
 from hiddifypanel.panel.init_db import init_db
-from hiddifypanel.cache import redis_client
-from hiddifypanel import auth
-from hiddifypanel.panel import hiddify
-from hiddifypanel import hutils
 
 
 def create_app(*args, cli=False, **config):
 
     app = APIFlask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True, version='2.0.0', title="Hiddify API",
-                   openapi_blueprint_url_prefix="/<proxy_path>/api", docs_ui='elements', json_errors=False, enable_openapi=True)
+                   openapi_blueprint_url_prefix="/<proxy_path>/api", docs_ui='elements', json_errors=False, enable_openapi=not cli)
     # app = Flask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True)
 
-    app.config["PREFERRED_URL_SCHEME"] = "https"
-    app.wsgi_app = ProxyFix(
-        app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1,
-    )
-    app.servers = {
-        'name': 'current',
-        'url': '',
-    }  # type: ignore
-    app.info = {
-        'description': 'Hiddify is a free and open source software. It is as it is.',
-        'termsOfService': 'https://hiddify.com',
-        'contact': {
-            'name': 'API Support',
-            'url': 'https://www.hiddify.com/support',
-            'email': 'panel@hiddify.com'
-        },
-        'license': {
-            'name': 'Creative Commons Zero v1.0 Universal',
-            'url': 'https://github.com/hiddify/Hiddify-Manager/blob/main/LICENSE'
+    if not cli:
+        from hiddifypanel.cache import redis_client
+        from hiddifypanel import auth
+        app.config["PREFERRED_URL_SCHEME"] = "https"
+        app.wsgi_app = ProxyFix(
+            app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1,
+        )
+        app.servers = {
+            'name': 'current',
+            'url': '',
+        }  # type: ignore
+        app.info = {
+            'description': 'Hiddify is a free and open source software. It is as it is.',
+            'termsOfService': 'https://hiddify.com',
+            'contact': {
+                'name': 'API Support',
+                'url': 'https://www.hiddify.com/support',
+                'email': 'panel@hiddify.com'
+            },
+            'license': {
+                'name': 'Creative Commons Zero v1.0 Universal',
+                'url': 'https://github.com/hiddify/Hiddify-Manager/blob/main/LICENSE'
+            }
         }
-    }
-    # setup flask server-side session
-    # app.config['APPLICATION_ROOT'] = './'
-    # app.config['SESSION_COOKIE_DOMAIN'] = '/'
-    app.config['SESSION_TYPE'] = 'redis'
-    app.config['SESSION_REDIS'] = redis_client
-    app.config['SESSION_PERMANENT'] = True
-    app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=10)
-    Session(app)
-    app.jinja_env.line_statement_prefix = '%'
-    app.jinja_env.filters['b64encode'] = hutils.encode.do_base_64
-    app.view_functions['admin.static'] = {}  # fix bug in apiflask
-    flask_bootstrap.Bootstrap4(app)
+        # setup flask server-side session
+        # app.config['APPLICATION_ROOT'] = './'
+        # app.config['SESSION_COOKIE_DOMAIN'] = '/'
+        app.config['SESSION_TYPE'] = 'redis'
+        app.config['SESSION_REDIS'] = redis_client
+        app.config['SESSION_PERMANENT'] = True
+        app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=10)
+        Session(app)
+
+        app.jinja_env.line_statement_prefix = '%'
+        from hiddifypanel import hutils
+        app.jinja_env.filters['b64encode'] = hutils.encode.do_base_64
+        app.view_functions['admin.static'] = {}  # fix bug in apiflask
+        flask_bootstrap.Bootstrap4(app)
 
     for c, v in dotenv_values(os.environ.get("HIDDIFY_CFG_PATH", 'app.cfg')).items():
         if v.isdecimal():
@@ -72,27 +74,34 @@ def create_app(*args, cli=False, **config):
     hiddifypanel.database.init_app(app)
     with app.app_context():
         init_db()
- # flaskbabel = FlaskBabel(app)
 
+        # configure logger
+        from hiddifypanel.models import ConfigEnum, hconfig
+        logger.remove()
+        log_format = '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level> | <level>{extra}</level>'
+        logger.add(sys.stderr, format=log_format, level=hconfig(ConfigEnum.log_level), colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
+
+    # flaskbabel = FlaskBabel(app)
     # @babel.localeselector
+
     def get_locale():
         # Put your logic here. Application can store locale in
         # user profile, cookie, session, etc.
-        from hiddifypanel.models import ConfigEnum, hconfig
         if "admin" in request.base_url:
             g.locale = auth.current_account.lang or hconfig(ConfigEnum.admin_lang) or 'fa'
         else:
             g.locale = auth.current_account.lang or hconfig(ConfigEnum.lang) or 'fa'
         return g.locale
+    app.jinja_env.globals['get_locale'] = get_locale
     babel = Babel(app, locale_selector=get_locale)
+    if not cli:
+        hiddifypanel.panel.common.init_app(app)
+        hiddifypanel.panel.common_bp.init_app(app)
 
-    hiddifypanel.panel.common.init_app(app)
-    hiddifypanel.panel.common_bp.init_app(app)
-
-    from hiddifypanel.panel import user, commercial, admin
-    admin.init_app(app)
-    user.init_app(app)
-    commercial.init_app(app)
+        from hiddifypanel.panel import user, commercial, admin
+        admin.init_app(app)
+        user.init_app(app)
+        commercial.init_app(app)
 
     app.config.update(config)  # Override with passed config
     # app.config['WTF_CSRF_CHECK_DEFAULT'] = False
@@ -115,8 +124,6 @@ def create_app(*args, cli=False, **config):
     #     return
     # csrf.protect()
 
-    app.jinja_env.globals['get_locale'] = get_locale
-
     hiddifypanel.panel.cli.init_app(app)
     return app
 
@@ -126,7 +133,8 @@ def create_app_wsgi(*args, **kwargs):
     # that doesn't allow **config
     # to be passed to create_app
     # https://github.com/pallets/flask/issues/4170
-    app = create_app()
+    cli = ("hiddifypanel" in sys.argv[0]) or (sys.argv[1] in ["update-usage", "all-configs", "admin_links", "admin_path"])
+    app = create_app(cli=cli)
     return app
 
 

hiddifypanel/cache.py

@@ -1,47 +1,65 @@
-from redis_cache import RedisCache
-from functools import wraps
+from redis_cache import RedisCache, CacheDecorator, compact_dump, chunks
+from redis_cache import loads as redis_cache_loads
 import redis
 from pickle import dumps, loads
+from loguru import logger
+
 redis_client = redis.from_url('unix:///opt/hiddify-manager/other/redis/run.sock?db=0')
 
 
-def exception_handler(e, original_fn, args, kwargs):
-    print("cache exception occur", e, original_fn, args, kwargs)
-    return original_fn(*args, **kwargs)
-    pass
+class CustomRedisCache(RedisCache):
+
+    def invalidate_all_cached_functions(self):
+        try:
+            logger.info("Invalidating all cached functions")
+            chunks_gen = chunks(f'{self.prefix}*', 500)
+            for keys in chunks_gen:
+                self.client.delete(*keys)
+            logger.success("Successfully invalidated all cached functions")
+            return True
+        except Exception as err:
+            with logger.contextualize(error=err):
+                logger.error("Failed to invalidate all cached functions")
+            return False
+
+
+cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)
 
 
 # cache = RedisCache(redis_client=redis_client, exception_handler=exception_handler)
 # cache = RedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads, exception_handler=exception_handler)
-cache = RedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)
 
+# def exception_handler(e, original_fn, args, kwargs):
+#     print("cache exception occur", e, original_fn, args, kwargs)
+#     return original_fn(*args, **kwargs)
+#     pass
 
-class CacheDecorator:
-    def __init__(self, *args, **kwargs):
-        pass
+# class CacheDecorator:
+#     def __init__(self, *args, **kwargs):
+#         pass
 
-    def __call__(self, fn):
-        @wraps(fn)
-        def inner(*args, **kwargs):
+#     def __call__(self, fn):
+#         @wraps(fn)
+#         def inner(*args, **kwargs):
 
-            parsed_result = fn(*args, **kwargs)
+#             parsed_result = fn(*args, **kwargs)
 
-            return parsed_result
+#             return parsed_result
 
-        inner.invalidate = self.invalidate
-        inner.invalidate_all = self.invalidate_all
-        inner.instance = self
-        return inner
+#         inner.invalidate = self.invalidate
+#         inner.invalidate_all = self.invalidate_all
+#         inner.instance = self
+#         return inner
 
-    def invalidate(self, *args, **kwargs):
-        pass
+#     def invalidate(self, *args, **kwargs):
+#         pass
 
-    def invalidate_all(self, *args, **kwargs):
-        pass
+#     def invalidate_all(self, *args, **kwargs):
+#         pass
 
 
-class DisableCache:
-    cache = CacheDecorator
+# class DisableCache:
+#     cache = CacheDecorator
 
 
 # cache = DisableCache()

hiddifypanel/database.py

@@ -2,6 +2,8 @@ from flask_sqlalchemy import SQLAlchemy
 from sqlalchemy_utils import UUIDType
 import re
 import os
+from sqlalchemy import text
+
 
 db: SQLAlchemy = SQLAlchemy()
 db.UUID = UUIDType  # type: ignore
@@ -10,3 +12,10 @@ db.UUID = UUIDType  # type: ignore
 def init_app(app):
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
     db.init_app(app)
+
+
+def db_execute(query: str, **params: dict):
+    with db.engine.connect() as connection:
+        res = connection.execute(text(query), params)
+        connection.commit()
+        return res

hiddifypanel/drivers/abstract_driver.py

@@ -5,3 +5,5 @@ class DriverABS:
     def get_enabled_users(self): pass
     def add_client(self, user): pass
     def remove_client(self, user): pass
+
+    def is_enabled(self) -> bool: return False

hiddifypanel/drivers/singbox_api.py

@@ -3,27 +3,22 @@ from hiddifypanel.models import *
 from .abstract_driver import DriverABS
 from flask import current_app
 import json
+from collections import defaultdict
 
 
 class SingboxApi(DriverABS):
+    def is_enabled(self) -> bool: return True
+
     def get_singbox_client(self):
-        if hconfig(ConfigEnum.is_parent):
-            return
         return xtlsapi.SingboxClient('127.0.0.1', 10086)
 
     def get_enabled_users(self):
-        if hconfig(ConfigEnum.is_parent):
-            return
         config_dir = current_app.config['HIDDIFY_CONFIG_PATH']
         with open(f"{config_dir}/singbox/configs/01_api.json") as f:
             json_data = json.load(f)
             return {u.split("@")[0]: 1 for u in json_data['experimental']['v2ray_api']['stats']['users']}
-        # raise NotImplementedError()
-#
 
     def get_inbound_tags(self):
-        if hconfig(ConfigEnum.is_parent):
-            return
         try:
             xray_client = self.get_singbox_client()
             inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')]
@@ -34,17 +29,24 @@ class SingboxApi(DriverABS):
         return list(set(inbounds))
 
     def add_client(self, user):
-        if hconfig(ConfigEnum.is_parent):
-            return
-        # raise NotImplementedError()
+        pass
 
     def remove_client(self, user):
-        if hconfig(ConfigEnum.is_parent):
-            return
-        # raise NotImplementedError()
+        pass
 
     def get_all_usage(self, users):
-        return {u: self.get_usage_imp(u.uuid) for u in users}
+        xray_client = self.get_singbox_client()
+        usages = xray_client.stats_query('user', reset=True)
+        uuid_user_map = {u.uuid: u for u in users}
+        res = defaultdict(int)
+        for use in usages:
+            if "user>>>" not in use.name:
+                continue
+            # print(use.name, use.value)
+            uuid = use.name.split(">>>")[1].split("@")[0]
+            res[uuid_user_map[uuid]] += use.value  # uplink + downlink
+        return res
+        # return {u: self.get_usage_imp(u.uuid) for u in users}
 
     def get_usage_imp(self, uuid):
         xray_client = self.get_singbox_client()

hiddifypanel/drivers/ssh_liberty_bridge_api.py

@@ -7,10 +7,12 @@ USERS_USAGE = "ssh-server:users-usage"
 
 
 class SSHLibertyBridgeApi(DriverABS):
+    def is_enabled(self) -> bool:
+        return hconfig(ConfigEnum.ssh_server_enable)
 
     def get_ssh_redis_client(self):
         if not hasattr(self, 'redis_client'):
-            self.redis_client = redis.from_url(hconfig(ConfigEnum.ssh_server_redis_url), decode_responses=True)
+            self.redis_client = redis.from_url('unix:///opt/hiddify-manager/other/redis/run.sock?db=1', decode_responses=True)
 
         return self.redis_client
 

hiddifypanel/drivers/user_driver.py

@@ -4,19 +4,25 @@ from .singbox_api import SingboxApi
 from .wireguard_api import WireguardApi
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
+from collections import defaultdict
+
 drivers = [XrayApi(), SingboxApi(), SSHLibertyBridgeApi(), WireguardApi()]
 
 
+def enabled_drivers():
+    return [d for d in drivers if d.is_enabled()]
+
+
 def get_users_usage(reset=True):
     res = {}
     users = list(User.query.all())
-    res = {u: {'usage': 0, 'ips': ''} for u in users}
-    for driver in drivers:
+    res = defaultdict(lambda: {'usage': 0, 'devices': ''})
+    for driver in enabled_drivers():
         all_usage = driver.get_all_usage(users)
         for user, usage in all_usage.items():
             if usage:
                 res[user]['usage'] += usage
-            # res[user]['ip'] +=usage
+            # res[user]['devices'] +=usage
     return res
 
 
@@ -24,7 +30,7 @@ def get_enabled_users():
     from collections import defaultdict
     d = defaultdict(int)
     total = 0
-    for driver in drivers:
+    for driver in enabled_drivers():
         try:
             for u, v in driver.get_enabled_users().items():
                 if not v:
@@ -41,7 +47,7 @@ def get_enabled_users():
 
 
 def add_client(user: User):
-    for driver in drivers:
+    for driver in enabled_drivers():
         try:
             driver.add_client(user)
         except Exception as e:
@@ -49,7 +55,7 @@ def add_client(user: User):
 
 
 def remove_client(user: User):
-    for driver in drivers:
+    for driver in enabled_drivers():
         try:
             driver.remove_client(user)
         except Exception as e:

hiddifypanel/drivers/wireguard_api.py

@@ -1,13 +1,14 @@
 import json
 import os
-import time
 
 from .abstract_driver import DriverABS
-from hiddifypanel.models import User
+from hiddifypanel.models import User, hconfig, ConfigEnum
 from hiddifypanel.panel.run_commander import Command, commander
 
 
 class WireguardApi(DriverABS):
+    def is_enabled(self) -> bool:
+        return hconfig(ConfigEnum.wireguard_enable)
     WG_LOCAL_USAGE_FILE_PATH = './hiddify_usages.json'
 
     def __init__(self) -> None:
@@ -71,6 +72,8 @@ class WireguardApi(DriverABS):
         return res
 
     def get_enabled_users(self):
+        if not hconfig(ConfigEnum.wireguard_enable):
+            return {}
         usages = self.__get_wg_usages()
         wg_pubs = set(usages.keys())
 
@@ -90,6 +93,8 @@ class WireguardApi(DriverABS):
         pass
 
     def get_all_usage(self, users, reset=True):
+        if not hconfig(ConfigEnum.wireguard_enable):
+            return {}
         all_usages = self.__sync_local_usages()
         res = {}
         for u in users:

hiddifypanel/drivers/xray_api.py

@@ -1,17 +1,17 @@
 import xtlsapi
 from hiddifypanel.models import *
 from .abstract_driver import DriverABS
+from collections import defaultdict
 
 
 class XrayApi(DriverABS):
+    def is_enabled(self) -> bool:
+        return hconfig(ConfigEnum.core_type) == "xray"
+
     def get_xray_client(self):
-        if hconfig(ConfigEnum.is_parent):
-            return
         return xtlsapi.XrayClient('127.0.0.1', 10085)
 
     def get_enabled_users(self):
-        if hconfig(ConfigEnum.is_parent):
-            return
         xray_client = self.get_xray_client()
         users = User.query.all()
         t = "xtls"
@@ -31,8 +31,6 @@ class XrayApi(DriverABS):
         return enabled
 
     def get_inbound_tags(self):
-        if hconfig(ConfigEnum.is_parent):
-            return
         try:
             xray_client = self.get_xray_client()
             inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')]
@@ -43,8 +41,6 @@ class XrayApi(DriverABS):
         return list(set(inbounds))
 
     def add_client(self, user):
-        if hconfig(ConfigEnum.is_parent):
-            return
         uuid = user.uuid
         xray_client = self.get_xray_client()
         tags = self.get_inbound_tags()
@@ -97,7 +93,16 @@ class XrayApi(DriverABS):
                 pass
 
     def get_all_usage(self, users):
-        return {u: self.get_usage_imp(u.uuid) for u in users}
+        xray_client = self.get_xray_client()
+        usages = xray_client.stats_query('user', reset=True)
+        uuid_user_map = {u.uuid: u for u in users}
+        res = defaultdict(int)
+        for use in usages:
+            if "user>>>" not in use.name:
+                continue
+            uuid = use.name.split(">>>")[1].split("@")[0]
+            res[uuid_user_map[uuid]] += use.value
+        return res
 
     def get_usage_imp(self, uuid):
         xray_client = self.get_xray_client()

hiddifypanel/hutils/__init__.py

@@ -8,3 +8,7 @@ from . import random
 from . import encode
 from . import auth
 from . import utils
+from . import model
+from . import crypto
+from . import proxy
+from . import node

hiddifypanel/hutils/convert.py

@@ -38,13 +38,24 @@ def json_to_date(date_str: str) -> datetime | str:
 
 
 def time_to_json(d: datetime) -> str | None:
+    return __fix_time_format(d.strftime("%Y-%m-%d %H:%M:%S")) if d else None
 
-    return d.strftime("%Y-%m-%d %H:%M:%S") if d else None
+
+def __fix_time_format(time_str):
+    'Convert "1-00-00 00:00:00" to "0001-00-00 00:00:00"'
+    t = time_str
+    char_index = t.find('-')
+    year_part = t[:char_index]
+
+    if len(year_part) < 4:
+        t = year_part.zfill(4) + t[char_index:]
+
+    return t
 
 
 def json_to_time(time_str: str) -> datetime | str:
     try:
-        return datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S")
+        return datetime.strptime(__fix_time_format(time_str), "%Y-%m-%d %H:%M:%S")
     except BaseException:
         return time_str