add English version for fastdeploy client (#1197)

* add english page for fastdeploy client

* fix a bug

visualdl/component/inference/fastdeploy_client/http_client_manager.py

@@ -19,7 +19,6 @@ import numpy as np
 import requests
 import tritonclient.http as httpclient
 from attrdict import AttrDict
-from tritonclient.utils import InferenceServerException
 
 
 def convert_http_metadata_config(metadata):
@@ -118,8 +117,63 @@ table, th {{
 </div>
 """
 
+metrics_table_head_en = """
+<style>
+table, th {{
+  border:0.1px solid black;
+}}
+</style>
+
+<div>
+<table style="width:100%">
+  <tr>
+    <th rowspan="2">Model name</th>
+    <th colspan="4">Execution metric</th>
+    <th colspan="5">Delay metric</th>
+
+  </tr>
+  <tr>
+   <th>inference request success</th>
+  <th>inference request failure</th>
+  <th>inference count</th>
+  <th>inference exec count</th>
+  <th>inference request duration(ms)</th>
+  <th>inference queue duration(ms)</th>
+  <th>inference comput input duration(ms)</th>
+  <th>inference compute infer duration
+(ms)</th>
+  <th>inference compute output duration(ms)</th>
+  </tr>
+  {}
+</table>
+</div>
+<br>
+<br>
+<br>
+<br>
+<br>
+<div>
+<table style="width:100%">
+  <tr>
+    <th rowspan="2">GPU</th>
+    <th colspan="4">Performance metric</th>
+    <th colspan="2">Memory</th>
+  </tr>
+  <tr>
+   <th>utilization(%)</th>
+  <th>power usage(W)</th>
+  <th>power limit(W)</th>
+  <th>energy consumption(W)</th>
+  <th>total(GB)</th>
+  <th>used(GB)</th>
+  </tr>
+  {}
+</table>
+</div>
+"""
+
 
-def get_metric_data(server_addr, metric_port):  # noqa:C901
+def get_metric_data(server_addr, metric_port, lang='zh'):  # noqa:C901
     '''
     Get metrics data from fastdeploy server, and transform it into html table.
     Args:
@@ -235,6 +289,8 @@ def get_metric_data(server_addr, metric_port):  # noqa:C901
                             for item in data]) + "</tr>"
         for data in gpu_data_list
     ])
+    if lang == 'en':
+        return metrics_table_head_en.format(model_data, gpu_data)
     return metrics_table_head.format(model_data, gpu_data)
 
 
@@ -294,7 +350,7 @@ class HttpClientManager:
         try:
             model_metadata = fastdeploy_client.get_model_metadata(
                 model_name=model_name, model_version=model_version)
-        except InferenceServerException as e:
+        except Exception as e:
             raise RuntimeError("Failed to retrieve the metadata: " + str(e))
 
         model_metadata = convert_http_metadata_config(model_metadata)

visualdl/component/inference/fastdeploy_server.py

@@ -25,6 +25,7 @@ from pathlib import Path
 import requests
 
 from .fastdeploy_client.client_app import create_gradio_client_app
+from .fastdeploy_client.client_app import create_gradio_client_app_en
 from .fastdeploy_lib import analyse_config
 from .fastdeploy_lib import check_process_zombie
 from .fastdeploy_lib import copy_config_file_to_default_config
@@ -53,7 +54,8 @@ class FastDeployServerApi(object):
         self.root_dir = Path(os.getcwd())
         self.opened_servers = {
         }  # Use to store the opened server process pid and process itself
-        self.client_port = None
+        self.client_port = None  # Chinese version
+        self.client_en_port = None  # English version
 
     @result()
     def get_directory(self, cur_dir):
@@ -351,9 +353,7 @@ class FastDeployServerApi(object):
                     version_filenames_dict_for_frontend)
         return version_info_for_frontend
 
-    def create_fastdeploy_client(self):
-        if self.client_port is None:
-
+    def create_fastdeploy_client(self, lang='zh'):
         def get_free_tcp_port():
             tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             # tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
@@ -362,22 +362,33 @@ class FastDeployServerApi(object):
             tcp.close()
             return port
 
-            self.client_port = get_free_tcp_port()
-            app = create_gradio_client_app()
-            thread = Process(
-                target=app.launch, kwargs={'server_port': self.client_port})
-            thread.start()
-
-            def check_alive():
+        def check_alive(client_port):
             while True:
                 try:
-                        requests.get('http://localhost:{}/'.format(
-                            self.client_port))
+                    requests.get('http://localhost:{}/'.format(client_port))
                     break
                 except Exception:
                     time.sleep(1)
 
-            check_alive()
+        if lang == 'en':
+            if self.client_en_port is None:
+                self.client_en_port = get_free_tcp_port()
+                app = create_gradio_client_app_en()
+                thread = Process(
+                    target=app.launch,
+                    kwargs={'server_port': self.client_en_port})
+                thread.start()
+                check_alive(self.client_en_port)
+            return self.client_en_port
+        else:
+            if self.client_port is None:
+                self.client_port = get_free_tcp_port()
+                app = create_gradio_client_app()
+                thread = Process(
+                    target=app.launch,
+                    kwargs={'server_port': self.client_port})
+                thread.start()
+                check_alive(self.client_port)
             return self.client_port
 
     def _poll_zombie_process(self):
@@ -410,7 +421,7 @@ def create_fastdeploy_api_call():
         'start_server': (api.start_server, ['config']),
         'stop_server': (api.stop_server, ['server_id']),
         'get_server_output': (api.get_server_output, ['server_id', 'length']),
-        'create_fastdeploy_client': (api.create_fastdeploy_client, []),
+        'create_fastdeploy_client': (api.create_fastdeploy_client, ['lang']),
         'get_server_list': (api.get_server_list, []),
         'get_server_metric': (api.get_server_metric, ['server_id']),
         'get_server_config': (api.get_server_config, ['server_id']),

visualdl/server/app.py

@@ -181,6 +181,7 @@ def create_app(args):  # noqa: C901
             error_msg = '{}'.format(e)
             return make_response(error_msg)
         args = urllib.parse.urlencode(request_args)
+
         if args:
             return redirect(
                 api_path + "/fastdeploy/fastdeploy_client/app?{}".format(args),
@@ -201,14 +202,30 @@ def create_app(args):  # noqa: C901
         Returns:
             Any thing from gradio server.
         '''
+        lang = 'zh'
         if request.method == 'POST':
+            if request.mimetype == 'application/json':
+                request_args = request.json
+            else:
+                request_args = request.form.to_dict()
+            if 'data' in request_args:
+                lang = request_args['data'][-1]
+                request_args['lang'] = lang
+            elif 'lang' in request_args:
+                lang = request_args['lang']
+
             port = fastdeploy_api_call('create_fastdeploy_client',
-                                       request.form)
-            request_args = request.form
+                                       request_args)
         else:
+            request_args = request.args.to_dict()
+            if 'data' in request_args:
+                lang = request_args['data'][-1]
+                request_args['lang'] = lang
+            elif 'lang' in request_args:
+                lang = request_args['lang']
             port = fastdeploy_api_call('create_fastdeploy_client',
-                                       request.args)
-            request_args = request.args
+                                       request_args)
+
         if path == 'app':
             proxy_url = request.url.replace(
                 request.host_url.rstrip('/') + api_path +
@@ -239,6 +256,47 @@ def create_app(args):  # noqa: C901
                 model_name = start_args.get('default_model_name', '')
                 content = content.decode()
                 try:
+                    if request_args.get('lang', 'zh') == 'en':
+                        default_server_addr = re.search(
+                            '"label": {}.*?"value": "".*?}}'.format(
+                                json.dumps(
+                                    "server ip", ensure_ascii=True).replace(
+                                        '\\', '\\\\')), content).group(0)
+                        cur_server_addr = default_server_addr.replace(
+                            '"value": ""', '"value": "localhost"')
+                        default_http_port = re.search(
+                            '"label": {}.*?"value": "".*?}}'.format(
+                                json.dumps(
+                                    "server port", ensure_ascii=True).replace(
+                                        '\\', '\\\\')), content).group(0)
+                        cur_http_port = default_http_port.replace(
+                            '"value": ""', '"value": "{}"'.format(http_port))
+                        default_metrics_port = re.search(
+                            '"label": {}.*?"value": "".*?}}'.format(
+                                json.dumps(
+                                    "metrics port", ensure_ascii=True).replace(
+                                        '\\', '\\\\')), content).group(0)
+                        cur_metrics_port = default_metrics_port.replace(
+                            '"value": ""',
+                            '"value": "{}"'.format(metrics_port))
+                        default_model_name = re.search(
+                            '"label": {}.*?"value": "".*?}}'.format(
+                                json.dumps(
+                                    "model name", ensure_ascii=True).replace(
+                                        '\\', '\\\\')), content).group(0)
+                        cur_model_name = default_model_name.replace(
+                            '"value": ""', '"value": "{}"'.format(model_name))
+                        default_model_version = re.search(
+                            '"label": {}.*?"value": "".*?}}'.format(
+                                json.dumps("model version",
+                                           ensure_ascii=True).replace(
+                                               '\\', '\\\\')),
+                            content).group(0)
+                        cur_model_version = default_model_version.replace(
+                            '"value": ""', '"value": "{}"'.format('1'))
+                        content = content.replace(default_server_addr,
+                                                  cur_server_addr)
+                    else:
                         default_server_addr = re.search(
                             '"label": {}.*?"value": "".*?}}'.format(
                                 json.dumps("服务ip", ensure_ascii=True).replace(
@@ -247,16 +305,19 @@ def create_app(args):  # noqa: C901
                             '"value": ""', '"value": "localhost"')
                         default_http_port = re.search(
                             '"label": {}.*?"value": "".*?}}'.format(
-                            json.dumps("推理服务端口", ensure_ascii=True).replace(
+                                json.dumps(
+                                    "推理服务端口", ensure_ascii=True).replace(
                                         '\\', '\\\\')), content).group(0)
                         cur_http_port = default_http_port.replace(
                             '"value": ""', '"value": "{}"'.format(http_port))
                         default_metrics_port = re.search(
                             '"label": {}.*?"value": "".*?}}'.format(
-                            json.dumps("性能服务端口", ensure_ascii=True).replace(
+                                json.dumps(
+                                    "性能服务端口", ensure_ascii=True).replace(
                                         '\\', '\\\\')), content).group(0)
                         cur_metrics_port = default_metrics_port.replace(
-                        '"value": ""', '"value": "{}"'.format(metrics_port))
+                            '"value": ""',
+                            '"value": "{}"'.format(metrics_port))
                         default_model_name = re.search(
                             '"label": {}.*?"value": "".*?}}'.format(
                                 json.dumps("模型名称", ensure_ascii=True).replace(