add web serve quick start

python/paddle_serving_server/plugin_service.py

@@ -16,8 +16,8 @@ from flask import Flask, request, abort
 from paddle_serving_client import Client
 
 class PluginService(object):
-    def __init__(self, name="default_service", model="",
-                 port=9091, concurrency=10):
+    def __init__(self, name="default_service",
+                 model="", port=9091, concurrency=10):
         self.name = name
         self.port = port
         self.model = model
@@ -31,9 +31,11 @@ class PluginService(object):
         self.client_service = Client()
         self.client_service.load_client_config(
             "{}/serving_server_conf.prototxt".format(self.model))
-        self.client_service.connect(["127.0.0.1:9292"])
+        # TODO(guru4elephant): we need to specify the serving port later
+        self.client_service.connect(["127.0.0.1:{}".format(self.port+1)])
 
-        @app_instance.route('/PaddleServing/v1.0/prediction', methods=['POST'])
+        service_name = "/" + self.name + "/prediction"
+        @app_instance.route(service_name, methods=['POST'])
         def get_prediction():
             if not request.json:
                 abort(400)
@@ -42,8 +44,13 @@ class PluginService(object):
             feed, fetch = self.preprocess(request.json, request.json["fetch"])
             fetch_map = self.client_service.predict(feed=feed, fetch=fetch)
             fetch_map = self.postprocess(feed=request.json, fetch=fetch, fetch_map=fetch_map)
-        app_instance.run(host="127.0.0.1", port=self.port,
-                         threaded=False, processes=1)
+            return fetch_map
+
+        import socket
+        localIP = socket.gethostbyname(socket.gethostname())
+
+        print("http://{}:{}{}".format(localIP, self.port, service_name))
+        app_instance.run(host="127.0.0.1", port=self.port, threaded=False, processes=1)
 
     def preprocess(self, feed={}, fetch=[]):
         return feed, fetch

python/paddle_serving_server/web_serve.py

+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Usage:
+    Host a trained paddle model with one line command
+    Example:
+        python -m paddle_serving_server.web_serve --model ./serving_server_model --port 9292
+"""
+import argparse
+from multiprocessing import Pool, Process
+from plugin_service import PluginService
+
+def parse_args():
+    parser = argparse.ArgumentParser("web_serve")
+    parser.add_argument("--thread", type=int, default=10, help="Concurrency of server")
+    parser.add_argument("--model", type=str, default="", help="Model for serving")
+    parser.add_argument("--port", type=int, default=9292, help="Port the server")
+    parser.add_argument("--workdir", type=str, default="workdir", help="Working dir of current service")
+    parser.add_argument("--device", type=str, default="cpu", help="Type of device")
+    parser.add_argument("--name", type=str, default="default", help="Default service name")
+    return parser.parse_args()
+
+def start_web_service(args):
+    model = args.model
+    port = args.port
+    name = args.name
+    web_service = PluginService(name=name, model=model, port=port)
+    web_service.start_service()
+
+def start_standard_model(args):
+    thread_num = args.thread
+    model = args.model
+    port = args.port
+    workdir = args.workdir
+    device = args.device
+
+    if model == "":
+        print("You must specify your serving model")
+        exit(-1)
+
+    import paddle_serving_server as serving
+    op_maker = serving.OpMaker()
+    read_op = op_maker.create('general_reader')
+    general_infer_op = op_maker.create('general_infer')
+    general_response_op = op_maker.create('general_response')
+
+    op_seq_maker = serving.OpSeqMaker()
+    op_seq_maker.add_op(read_op)
+    op_seq_maker.add_op(general_infer_op)
+    op_seq_maker.add_op(general_response_op)
+
+    server = serving.Server()
+    server.set_op_sequence(op_seq_maker.get_op_sequence())
+    server.set_num_threads(thread_num)
+
+    server.load_model_config(model)
+    server.prepare_server(workdir=workdir, port=port + 1, device=device)
+    server.run_server()
+
+if __name__ == "__main__":
+    args = parse_args()
+    p_serving = Process(target=start_standard_model, args=(args,))
+    p_web_service = Process(target=start_web_service, args=(args,))
+    p_serving.start()
+    p_web_service.start()
+    p_web_service.join()
+    p_serving.join()