magnax 1.0.0__py3-none-any.whl

magnax/view/pages.py

@@ -0,0 +1,146 @@
+import json
+import os
+from flask import Blueprint
+from flask import render_template
+from flask import request
+from logzero import logger
+from solox.public.common import Devices,File,Method
+
+page = Blueprint("page", __name__)
+d = Devices()
+m = Method()
+f = File()
+
+@page.app_errorhandler(404)
+def page_404(e):
+    settings = m._settings(request)
+    return render_template('404.html', **locals()), 404
+
+@page.app_errorhandler(500)
+def page_500(e):
+    settings = m._settings(request)
+    return render_template('500.html', **locals()), 500
+
+@page.route('/')
+def index():
+    platform = request.args.get('platform')
+    lan = request.args.get('lan')
+    settings = m._settings(request)
+    return render_template('index.html', **locals())
+
+@page.route('/pk')
+def pk():
+    lan = request.args.get('lan')
+    model = request.args.get('model')
+    settings = m._settings(request)
+    return render_template('pk.html', **locals())
+
+@page.route('/report')
+def report():
+    lan = request.args.get('lan')
+    settings = m._settings(request)
+    report_dir = os.path.join(os.getcwd(), 'report')
+    if not os.path.exists(report_dir):
+        os.mkdir(report_dir)
+    dirs = os.listdir(report_dir)
+    dir_list = reversed(sorted(dirs, key=lambda x: os.path.getmtime(os.path.join(report_dir, x))))
+    apm_data = []
+    for dir in dir_list:
+        if dir.split(".")[-1] not in ['log', 'json', 'mkv']:
+            try:
+                fpath = open(os.path.join(report_dir, dir, 'result.json'))
+                json_data = json.loads(fpath.read())
+                dict_data = {
+                    'scene': dir,
+                    'app': json_data['app'],
+                    'platform': json_data['platform'],
+                    'model': json_data['model'],
+                    'devices': json_data['devices'],
+                    'ctime': json_data['ctime'],
+                    'video': json_data.get('video', 0)
+                }
+                fpath.close()
+                apm_data.append(dict_data)
+            except Exception as e:
+                logger.exception(e)
+                continue
+    apm_data_len = len(apm_data)
+    return render_template('report.html', **locals())
+
+@page.route('/analysis', methods=['post', 'get'])
+def analysis():
+    lan = request.args.get('lan')
+    scene = request.args.get('scene')
+    app = request.args.get('app')
+    platform = request.args.get('platform')
+    settings = m._settings(request)
+    report_dir = os.path.join(os.getcwd(), 'report')
+    dirs = os.listdir(report_dir)
+    filter_dir = f.filter_secen(scene)
+    apm_data = {}
+    # Initialize disk variables with defaults
+    initial_disk = []
+    current_disk = []
+    sum_init_disk = {'sum_size': 0}
+    sum_current_disk = {'sum_size': 0}
+    for dir in dirs:
+        if dir == scene:
+            try:
+                if platform == 'Android':
+                    apm_data = f._setAndroidPerfs(scene)
+                    disk = f.analysisDisk(scene)
+                    if disk and len(disk) >= 4:
+                        initial_disk  = disk[0]
+                        current_disk  = disk[1]
+                        sum_init_disk = disk[2]
+                        sum_current_disk = disk[3]
+                else:
+                    apm_data = f._setiOSPerfs(scene)
+            except ZeroDivisionError:
+                pass
+            except Exception as e:
+                logger.exception(e)
+            finally:
+                break
+    return render_template('analysis.html', **locals())
+
+@page.route('/pk_analysis', methods=['post', 'get'])
+def analysis_pk():
+    lan = request.args.get('lan')
+    scene = request.args.get('scene')
+    app = request.args.get('app')
+    model = request.args.get('model')
+    settings = m._settings(request)
+    report_dir = os.path.join(os.getcwd(), 'report')
+    dirs = os.listdir(report_dir)
+    apm_data = {}
+    for dir in dirs:
+        if dir == scene:
+            try:
+                apm_data = f._setpkPerfs(scene)
+            except Exception as e:
+                logger.exception(e)
+            finally:
+                break
+    return render_template('analysis_pk.html', **locals())
+
+@page.route('/compare_analysis', methods=['post', 'get'])
+def analysis_compare():
+    platform = request.args.get('platform')
+    lan = request.args.get('lan')
+    scene1 = request.args.get('scene1')
+    scene2 = request.args.get('scene2')
+    app = request.args.get('app')
+    settings = m._settings(request)
+    try:
+        if platform == 'Android':
+            apm_data1 = f._setAndroidPerfs(scene1)
+            apm_data2 = f._setAndroidPerfs(scene2)
+        elif platform == 'iOS':
+            apm_data1 = f._setiOSPerfs(scene1)
+            apm_data2 = f._setiOSPerfs(scene2)
+    except ZeroDivisionError:
+        pass 
+    except Exception as e:
+        logger.exception(e)          
+    return render_template('analysis_compare.html', **locals())

magnax/web.py

@@ -0,0 +1,345 @@
+from __future__ import absolute_import
+import multiprocessing
+import subprocess
+import time
+import os
+import platform
+import re
+import webbrowser
+import requests
+import socket
+import sys
+import psutil
+import atexit
+from logzero import logger
+from threading import Lock
+from flask_socketio import SocketIO, disconnect
+from flask import Flask
+from pyfiglet import Figlet
+from solox.view.apis import api
+from solox.view.pages import page
+from solox import __version__
+
+# Global reference to tunneld process
+_tunneld_process = None
+
+app = Flask(__name__, template_folder='templates', static_folder='static')
+app.register_blueprint(api)
+app.register_blueprint(page)
+
+# socketio = SocketIO(app, cors_allowed_origins="*")
+# thread = True
+# thread_lock = Lock()
+
+
+# @socketio.on('connect', namespace='/logcat')
+# def connect():
+#     socketio.emit('start connect', {'data': 'Connected'}, namespace='/logcat')
+#     logDir = os.path.join(os.getcwd(),'adblog')
+#     if not os.path.exists(logDir):
+#         os.mkdir(logDir)
+#     global thread
+#     thread = True
+#     with thread_lock:
+#         if thread:
+#             thread = socketio.start_background_task(target=backgroundThread)
+
+
+# def backgroundThread():
+#     global thread
+#     try:
+#         current_time = time.strftime("%Y%m%d%H", time.localtime())
+#         logPath = os.path.join(os.getcwd(),'adblog',f'{current_time}.log')
+#         logcat = subprocess.Popen(f'adb logcat *:E > {logPath}', stdout=subprocess.PIPE,
+#                                   shell=True)
+#         with open(logPath, "r") as f:
+#             while thread:
+#                 socketio.sleep(1)
+#                 for line in f.readlines():
+#                     socketio.emit('message', {'data': line}, namespace='/logcat')
+#         if logcat.poll() == 0:
+#             thread = False
+#     except Exception:
+#         pass
+
+
+# @socketio.on('disconnect_request', namespace='/logcat')
+# def disconnect():
+#     global thread
+#     logger.warning('Logcat client disconnected')
+#     thread = False
+#     disconnect()
+
+def ip() -> str:
+    try:
+        ip = socket.gethostbyname(socket.gethostname())
+    except:
+        logger.info('hostname:{}'.format(socket.gethostname()))
+        logger.warning('config [127.0.0.1 hostname] in /etc/hosts file')
+        ip = '127.0.0.1'    
+    return ip
+
+
+def listen(port):
+    net_connections = psutil.net_connections()
+    conn = [c for c in net_connections if c.status == "LISTEN" and c.laddr.port == port]
+    if conn:
+        pid = conn[0].pid
+        logger.warning('Port {} is used by process {}'.format(port, pid))
+        logger.info('you can start solox : python -m solox --host={ip} --port={port}')
+        return False
+    return True
+
+def status(host: str, port: int):
+    r = requests.get('http://{}:{}'.format(host, port), timeout=2.0)
+    flag = (True, False)[r.status_code == 200]
+    return flag
+
+
+def open_url(host: str, port: int):
+    flag = True
+    while flag:
+        logger.info('start solox service')
+        f = Figlet(font="slant", width=300)
+        print(f.renderText("SOLOX {}".format(__version__)))
+        flag = status(host, port)
+    try:    
+        webbrowser.open('http://{}:{}/?platform=Android&lan=en'.format(host, port), new=2)
+    except Exception as e:
+        logger.exception(e)    
+    logger.info('Running on http://{}:{}/?platform=Android&lan=en (Press CTRL+C to quit)'.format(host, port))
+
+
+def start(host: str, port: int):
+    app.run(host=host, port=port, debug=False)
+
+
+def check_ios17_device():
+    """Check if there are iOS 17+ devices connected."""
+    try:
+        from pymobiledevice3.usbmux import list_devices
+        from pymobiledevice3.lockdown import create_using_usbmux
+
+        devices = list_devices()
+        for device in devices:
+            try:
+                lockdown = create_using_usbmux(serial=device.serial)
+                version = lockdown.product_version
+                if version:
+                    major = int(version.split('.')[0])
+                    if major >= 17:
+                        return True
+            except:
+                pass
+        return False
+    except ImportError:
+        return False
+    except Exception:
+        return False
+
+
+def is_tunneld_running():
+    """Check if tunneld is already running."""
+    try:
+        from pymobiledevice3.tunneld.api import get_tunneld_devices
+        devices = get_tunneld_devices()
+        return len(devices) > 0
+    except:
+        return False
+
+
+def _run_with_sudo_macos(cmd_args):
+    """Run command with sudo using macOS GUI password prompt."""
+    try:
+        # Use osascript to get admin privileges with GUI prompt
+        cmd_str = ' '.join(cmd_args)
+        apple_script = f'''
+        do shell script "{cmd_str} > /dev/null 2>&1 &" with administrator privileges
+        '''
+        result = subprocess.run(
+            ['osascript', '-e', apple_script],
+            capture_output=True,
+            timeout=60  # Give user time to enter password
+        )
+        return result.returncode == 0
+    except subprocess.TimeoutExpired:
+        logger.warning('[iOS] Password prompt timed out')
+        return False
+    except Exception as e:
+        logger.debug(f'[iOS] osascript failed: {e}')
+        return False
+
+
+def _run_with_sudo_linux(cmd_args):
+    """Run command with sudo using Linux GUI password prompt (if available)."""
+    try:
+        # Try pkexec (PolicyKit) for GUI prompt
+        result = subprocess.run(
+            ['which', 'pkexec'],
+            capture_output=True
+        )
+        if result.returncode == 0:
+            subprocess.Popen(
+                ['pkexec'] + cmd_args,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            return True
+    except:
+        pass
+
+    # Try zenity/kdialog for password input
+    try:
+        # Try zenity (GNOME)
+        result = subprocess.run(
+            ['zenity', '--password', '--title=SoloX - iOS tunneld'],
+            capture_output=True,
+            text=True,
+            timeout=60
+        )
+        if result.returncode == 0 and result.stdout:
+            password = result.stdout.strip()
+            proc = subprocess.Popen(
+                ['sudo', '-S'] + cmd_args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+            proc.stdin.write(f'{password}\n'.encode())
+            proc.stdin.close()
+            return True
+    except:
+        pass
+
+    return False
+
+
+def start_tunneld():
+    """Start tunneld daemon for iOS 17+ devices."""
+    global _tunneld_process
+
+    # Only run on macOS/Linux
+    if platform.system() == 'Windows':
+        logger.warning('[iOS] tunneld is not supported on Windows')
+        return False
+
+    # Check if already running
+    if is_tunneld_running():
+        logger.info('[iOS] tunneld is already running')
+        return True
+
+    # Check if iOS 17+ device exists
+    if not check_ios17_device():
+        logger.debug('[iOS] No iOS 17+ device found, skipping tunneld')
+        return True
+
+    logger.info('[iOS] iOS 17+ device detected, starting tunneld...')
+
+    tunneld_cmd = [sys.executable, '-m', 'pymobiledevice3', 'remote', 'tunneld']
+
+    # Try to start tunneld
+    try:
+        # First try without sudo (might work if user has permissions)
+        _tunneld_process = subprocess.Popen(
+            tunneld_cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True
+        )
+
+        # Wait a moment and check if it's working
+        time.sleep(2)
+        if is_tunneld_running():
+            logger.info('[iOS] tunneld started successfully')
+            return True
+
+        # If not working, kill it and try with sudo
+        if _tunneld_process:
+            try:
+                _tunneld_process.terminate()
+            except:
+                pass
+            _tunneld_process = None
+
+        # Try with GUI sudo prompt based on platform
+        logger.info('[iOS] Requesting administrator privileges for tunneld...')
+
+        if platform.system() == 'Darwin':
+            # macOS: Use osascript for GUI password prompt
+            if _run_with_sudo_macos(tunneld_cmd):
+                # Wait for tunneld to start
+                for _ in range(10):
+                    time.sleep(1)
+                    if is_tunneld_running():
+                        logger.info('[iOS] tunneld started successfully')
+                        return True
+        else:
+            # Linux: Try GUI methods
+            if _run_with_sudo_linux(tunneld_cmd):
+                for _ in range(10):
+                    time.sleep(1)
+                    if is_tunneld_running():
+                        logger.info('[iOS] tunneld started successfully')
+                        return True
+
+        # Last resort: try terminal sudo (will prompt in terminal)
+        logger.info('[iOS] Trying terminal sudo (enter password if prompted)...')
+        subprocess.Popen(
+            ['sudo'] + tunneld_cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True
+        )
+
+        for _ in range(15):
+            time.sleep(1)
+            if is_tunneld_running():
+                logger.info('[iOS] tunneld started successfully')
+                return True
+
+        logger.warning('[iOS] Could not start tunneld automatically')
+        logger.warning('[iOS] Please run manually: sudo python3 -m pymobiledevice3 remote tunneld')
+        return False
+
+    except Exception as e:
+        logger.warning(f'[iOS] Failed to start tunneld: {e}')
+        logger.warning('[iOS] Please run manually: sudo python3 -m pymobiledevice3 remote tunneld')
+        return False
+
+
+def stop_tunneld():
+    """Stop tunneld daemon if we started it."""
+    global _tunneld_process
+    if _tunneld_process:
+        try:
+            _tunneld_process.terminate()
+            _tunneld_process.wait(timeout=5)
+        except:
+            try:
+                _tunneld_process.kill()
+            except:
+                pass
+        _tunneld_process = None
+
+
+# Register cleanup on exit
+atexit.register(stop_tunneld)
+
+
+def main(host=ip(), port=50003):
+    # Start tunneld for iOS 17+ devices if needed
+    start_tunneld()
+
+    try:
+        pool = multiprocessing.Pool(processes=2)
+        pool.apply_async(start, (host, port))
+        pool.apply_async(open_url, (host, port))
+        pool.close()
+        pool.join()
+    except KeyboardInterrupt:
+        logger.info('stop solox success')
+        sys.exit()
+    except Exception as e:
+        logger.exception(e)