change plugin service to web service

python/paddle_serving_server/web_serve.py

@@ -19,7 +19,7 @@ Usage:
 """
 import argparse
 from multiprocessing import Pool, Process
-from plugin_service import PluginService
+from .web_service import WebService
 
 def parse_args():
     parser = argparse.ArgumentParser("web_serve")
@@ -35,7 +35,7 @@ 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 = WebService(name=name, model=model, port=port)
     web_service.start_service()
 
 def start_standard_model(args):

python/paddle_serving_server/plugin_service.py → python/paddle_serving_server/web_service.py

@@ -13,27 +13,45 @@
 # limitations under the License.
 #!flask/bin/python
 from flask import Flask, request, abort
+from multiprocessing import Pool, Process
+from paddle_serving_server import OpMaker, OpSeqMaker, Server
 from paddle_serving_client import Client
 
-class PluginService(object):
-    def __init__(self, name="default_service",
-                 model="", port=9091, concurrency=10):
+class WebService(object):
+    def __init__(self, name="default_service"):
         self.name = name
-        self.port = port
-        self.model = model
-        self.concurrency = concurrency
 
-    def prepare_service(self, args={}):
-        return
+    def load_model_config(self, model_config):
+        self.model_config = model_config
 
-    def start_service(self):
-        app_instance = Flask(__name__)
-        self.client_service = Client()
-        self.client_service.load_client_config(
-            "{}/serving_server_conf.prototxt".format(self.model))
-        # TODO(guru4elephant): we need to specify the serving port later
-        self.client_service.connect(["127.0.0.1:{}".format(self.port+1)])
+    def _launch_rpc_service(self):
+        op_maker = 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 = 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 = Server()
+        server.set_op_sequence(op_seq_maker.get_op_sequence())
+        server.set_num_threads(16)
+        server.load_model_config(self.model_config)
+        server.prepare_server(
+            workdir=self.workdir, port=self.port+1, device=self.device)
+        server.run_server()
+
+    def prepare_server(self, workdir="", port=9393, device="cpu"):
+        self.workdir = workdir
+        self.port = port
+        self.device = device
 
+    def _launch_web_service(self):
+        app_instance = Flask(__name__)
+        client_service = Client()
+        client_service.load_client_config(
+            "{}/serving_server_conf.prototxt".format(self.model_config))
+        client_service.connect(["127.0.0.1:{}".format(self.port+1)])
         service_name = "/" + self.name + "/prediction"
         @app_instance.route(service_name, methods=['POST'])
         def get_prediction():
@@ -42,15 +60,22 @@ class PluginService(object):
             if "fetch" not in request.json:
                 abort(400)
             feed, fetch = self.preprocess(request.json, request.json["fetch"])
-            fetch_map = self.client_service.predict(feed=feed, fetch=fetch)
+            fetch_map = client_service.predict(feed=feed, fetch=fetch)
             fetch_map = self.postprocess(feed=request.json, fetch=fetch, fetch_map=fetch_map)
             return fetch_map
+        app_instance.run(host="127.0.0.1", port=self.port, threaded=False, processes=1)
 
+    def run_server(self):
         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)
+        print("web service address:")
+        print("http://{}:{}/{}/prediction".format(localIP, self.port, self.name))
+        p_rpc = Process(target=self._launch_rpc_service)
+        p_web = Process(target=self._launch_web_service)
+        p_rpc.start()
+        p_web.start()
+        p_web.join()
+        p_rpc.join()
 
     def preprocess(self, feed={}, fetch=[]):
         return feed, fetch