server.py 24.1 KB
Newer Older
Z
update  
zhangjun 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
# Copyright (c) 2021 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.
M
MRXLT 已提交
14 15 16

import os
import tarfile
M
MRXLT 已提交
17
import socket
Z
zhangjun 已提交
18
import paddle_serving_server as paddle_serving_server
H
HexToString 已提交
19
from paddle_serving_server.serve import format_gpu_to_strlist
Z
update  
zhangjun 已提交
20 21 22
from .proto import server_configure_pb2 as server_sdk
from .proto import general_model_config_pb2 as m_config
import google.protobuf.text_format
23
import time
24
from .version import version_tag, version_suffix, device_type
M
MRXLT 已提交
25
from contextlib import closing
G
guru4elephant 已提交
26
import argparse
Z
zhangjun 已提交
27

J
Jiawei Wang 已提交
28
import sys
W
wangjiawei04 已提交
29 30
if sys.platform.startswith('win') is False:
    import fcntl
M
MRXLT 已提交
31
import shutil
Z
update  
zhangjun 已提交
32
import platform
B
barrierye 已提交
33
import numpy as np
B
barrierye 已提交
34
import sys
35
import collections
Z
update  
zhangjun 已提交
36
import subprocess
Z
zhangjun 已提交
37

B
barrierye 已提交
38 39 40
from multiprocessing import Pool, Process
from concurrent import futures

Z
update  
zhangjun 已提交
41

H
HexToString 已提交
42 43
# The whole file is about to be discarded.
# We will use default config-file to start C++Server.
M
MRXLT 已提交
44 45
class Server(object):
    def __init__(self):
H
HexToString 已提交
46 47 48 49 50 51 52 53 54 55 56
        """
        self.model_toolkit_conf:'list'=[] # The quantity of self.model_toolkit_conf is equal to the InferOp quantity/Engine--OP
        self.model_conf:'collections.OrderedDict()' # Save the serving_server_conf.prototxt content (feed and fetch information) this is a map for multi-model in a workflow
        self.workflow_fn:'str'="workflow.prototxt" # Only one for one Service/Workflow
        self.resource_fn:'str'="resource.prototxt" # Only one for one Service,model_toolkit_fn and general_model_config_fn is recorded in this file
        self.infer_service_fn:'str'="infer_service.prototxt" # Only one for one Service,Service--Workflow
        self.model_toolkit_fn:'list'=[] # ["general_infer_0/model_toolkit.prototxt"]The quantity is equal to the InferOp quantity,Engine--OP
        self.general_model_config_fn:'list'=[] # ["general_infer_0/general_model.prototxt"]The quantity is equal to the InferOp quantity,Feed and Fetch --OP
        self.subdirectory:'list'=[] # The quantity is equal to the InferOp quantity, and name = node.name = engine.name
        self.model_config_paths:'collections.OrderedDict()' # Save the serving_server_conf.prototxt path (feed and fetch information) this is a map for multi-model in a workflow
        """
M
MRXLT 已提交
57 58
        self.server_handle_ = None
        self.infer_service_conf = None
H
HexToString 已提交
59
        self.model_toolkit_conf = []
M
MRXLT 已提交
60 61
        self.resource_conf = None
        self.memory_optimization = False
M
MRXLT 已提交
62
        self.ir_optimization = False
Z
zhangjun 已提交
63
        self.model_conf = collections.OrderedDict()
H
HexToString 已提交
64 65 66
        self.workflow_fn = "workflow.prototxt"
        self.resource_fn = "resource.prototxt"
        self.infer_service_fn = "infer_service.prototxt"
Z
zhangjun 已提交
67 68 69
        self.model_toolkit_fn = []
        self.general_model_config_fn = []
        self.subdirectory = []
W
wangjiawei04 已提交
70
        self.cube_config_fn = "cube.conf"
M
MRXLT 已提交
71 72
        self.workdir = ""
        self.max_concurrency = 0
M
MRXLT 已提交
73
        self.num_threads = 2
M
MRXLT 已提交
74
        self.port = 8080
75 76
        self.precision = "fp32"
        self.use_calib = False
M
MRXLT 已提交
77
        self.reload_interval_s = 10
M
MRXLT 已提交
78
        self.max_body_size = 64 * 1024 * 1024
M
MRXLT 已提交
79 80
        self.module_path = os.path.dirname(paddle_serving_server.__file__)
        self.cur_path = os.getcwd()
M
MRXLT 已提交
81
        self.use_local_bin = False
Z
zhangjun 已提交
82
        self.mkl_flag = False
Z
zhangjun 已提交
83
        self.device = "cpu"
84
        self.gpuid = []
H
HexToString 已提交
85 86
        self.runtime_thread_num = [0]
        self.batch_infer_size = [32]
M
add trt  
MRXLT 已提交
87
        self.use_trt = False
88
        self.gpu_multi_stream = False
Z
zhangjun 已提交
89 90
        self.use_lite = False
        self.use_xpu = False
Z
zhangjun 已提交
91
        self.model_config_paths = collections.OrderedDict()
92 93
        self.product_name = None
        self.container_id = None
M
MRXLT 已提交
94

Z
zhangjun 已提交
95 96 97 98 99
    def get_fetch_list(self, infer_node_idx=-1):
        fetch_names = [
            var.alias_name
            for var in list(self.model_conf.values())[infer_node_idx].fetch_var
        ]
B
fix cpu  
barriery 已提交
100 101
        return fetch_names

M
MRXLT 已提交
102 103 104 105 106 107
    def set_max_concurrency(self, concurrency):
        self.max_concurrency = concurrency

    def set_num_threads(self, threads):
        self.num_threads = threads

M
MRXLT 已提交
108 109 110 111 112 113 114 115
    def set_max_body_size(self, body_size):
        if body_size >= self.max_body_size:
            self.max_body_size = body_size
        else:
            print(
                "max_body_size is less than default value, will use default value in service."
            )

116 117 118
    def use_encryption_model(self, flag=False):
        self.encryption_model = flag

M
MRXLT 已提交
119 120 121
    def set_port(self, port):
        self.port = port

122 123 124 125 126 127
    def set_precision(self, precision="fp32"):
        self.precision = precision

    def set_use_calib(self, use_calib=False):
        self.use_calib = use_calib

M
MRXLT 已提交
128 129 130 131 132 133
    def set_reload_interval(self, interval):
        self.reload_interval_s = interval

    def set_op_sequence(self, op_seq):
        self.workflow_conf = op_seq

B
barrierye 已提交
134 135 136
    def set_op_graph(self, op_graph):
        self.workflow_conf = op_graph

M
MRXLT 已提交
137 138 139
    def set_memory_optimize(self, flag=False):
        self.memory_optimization = flag

M
MRXLT 已提交
140 141 142
    def set_ir_optimize(self, flag=False):
        self.ir_optimization = flag

143
    # Multi-Server does not have this Function.
144 145 146 147 148
    def set_product_name(self, product_name=None):
        if product_name == None:
            raise ValueError("product_name can't be None.")
        self.product_name = product_name

149
    # Multi-Server does not have this Function.
150 151 152 153 154
    def set_container_id(self, container_id):
        if container_id == None:
            raise ValueError("container_id can't be None.")
        self.container_id = container_id

M
MRXLT 已提交
155 156 157 158
    def check_local_bin(self):
        if "SERVING_BIN" in os.environ:
            self.use_local_bin = True
            self.bin_path = os.environ["SERVING_BIN"]
M
MRXLT 已提交
159

M
MRXLT 已提交
160
    def check_cuda(self):
M
MRXLT 已提交
161 162 163
        if os.system("ls /dev/ | grep nvidia > /dev/null") == 0:
            pass
        else:
M
MRXLT 已提交
164
            raise SystemExit(
M
MRXLT 已提交
165
                "GPU not found, please check your environment or use cpu version by \"pip install paddle_serving_server\""
M
MRXLT 已提交
166 167
            )

Z
zhangjun 已提交
168 169 170
    def set_device(self, device="cpu"):
        self.device = device

171
    def set_gpuid(self, gpuid):
H
HexToString 已提交
172
        self.gpuid = format_gpu_to_strlist(gpuid)
M
MRXLT 已提交
173

H
HexToString 已提交
174 175
    def set_runtime_thread_num(self, runtime_thread_num):
        self.runtime_thread_num = runtime_thread_num
176

H
HexToString 已提交
177 178
    def set_batch_infer_size(self, batch_infer_size):
        self.batch_infer_size = batch_infer_size
179

M
bug fix  
MRXLT 已提交
180
    def set_trt(self):
M
add trt  
MRXLT 已提交
181 182
        self.use_trt = True

183 184 185
    def set_gpu_multi_stream(self):
        self.gpu_multi_stream = True

Z
zhangjun 已提交
186 187 188 189 190 191
    def set_lite(self):
        self.use_lite = True

    def set_xpu(self):
        self.use_xpu = True

H
HexToString 已提交
192
    def _prepare_engine(self, model_config_paths, device, use_encryption_model):
H
HexToString 已提交
193
        self.device = device
M
MRXLT 已提交
194
        if self.model_toolkit_conf == None:
H
HexToString 已提交
195
            self.model_toolkit_conf = []
H
HexToString 已提交
196

H
HexToString 已提交
197
        # Generally, self.gpuid = str[] or [].
H
HexToString 已提交
198 199 200
        # when len(self.gpuid) means no gpuid is specified.
        # if self.device == "gpu" or self.use_trt:
        # we assume you forget to set gpuid, so set gpuid = ['0'];
H
HexToString 已提交
201 202 203 204
        if len(self.gpuid) == 0 or self.gpuid == ["-1"]:
            if self.device == "gpu" or self.use_trt or self.gpu_multi_stream:
                self.gpuid = ["0"]
                self.device = "gpu"
205
            else:
H
HexToString 已提交
206
                self.gpuid = ["-1"]
207

H
HexToString 已提交
208 209 210 211
        if isinstance(self.runtime_thread_num, int):
            self.runtime_thread_num = [self.runtime_thread_num]
        if len(self.runtime_thread_num) == 0:
            self.runtime_thread_num.append(0)
212

H
HexToString 已提交
213 214 215 216
        if isinstance(self.batch_infer_size, int):
            self.batch_infer_size = [self.batch_infer_size]
        if len(self.batch_infer_size) == 0:
            self.batch_infer_size.append(32)
217 218

        index = 0
M
MRXLT 已提交
219

B
barrierye 已提交
220 221 222 223
        for engine_name, model_config_path in model_config_paths.items():
            engine = server_sdk.EngineDesc()
            engine.name = engine_name
            # engine.reloadable_meta = model_config_path + "/fluid_time_file"
224
            engine.reloadable_meta = model_config_path + "/fluid_time_file"
B
barrierye 已提交
225 226
            os.system("touch {}".format(engine.reloadable_meta))
            engine.reloadable_type = "timestamp_ne"
H
HexToString 已提交
227 228 229 230
            engine.runtime_thread_num = self.runtime_thread_num[index % len(
                self.runtime_thread_num)]
            engine.batch_infer_size = self.batch_infer_size[index % len(
                self.batch_infer_size)]
231

H
HexToString 已提交
232 233
            engine.enable_overrun = False
            engine.allow_split_request = True
Z
update  
zhangjun 已提交
234
            engine.model_dir = model_config_path
B
barrierye 已提交
235
            engine.enable_memory_optimization = self.memory_optimization
M
MRXLT 已提交
236
            engine.enable_ir_optimization = self.ir_optimization
M
add trt  
MRXLT 已提交
237
            engine.use_trt = self.use_trt
238
            engine.gpu_multi_stream = self.gpu_multi_stream
Z
update  
zhangjun 已提交
239 240
            engine.use_lite = self.use_lite
            engine.use_xpu = self.use_xpu
Z
zhangjun 已提交
241 242
            engine.use_gpu = False

243 244 245 246 247 248
            if len(self.gpuid) == 0:
                raise ValueError("CPU: self.gpuid = -1, GPU: must set it ")
            op_gpu_list = self.gpuid[index % len(self.gpuid)].split(",")
            for ids in op_gpu_list:
                engine.gpu_ids.extend([int(ids)])

H
HexToString 已提交
249
            if self.device == "gpu" or self.use_trt or self.gpu_multi_stream:
H
HexToString 已提交
250 251 252 253 254
                engine.use_gpu = True
                # this is for Mixed use of GPU and CPU
                # if model-1 use GPU and set the device="gpu"
                # but gpuid[1] = "-1" which means use CPU in Model-2
                # so config about GPU should be False.
H
HexToString 已提交
255 256
                # op_gpu_list = gpuid[index].split(",")
                # which is the gpuid for each engine.
H
HexToString 已提交
257 258 259 260 261 262
                if len(op_gpu_list) == 1:
                    if int(op_gpu_list[0]) == -1:
                        engine.use_gpu = False
                        engine.gpu_multi_stream = False
                        engine.use_trt = False

Z
fix  
zhangjun 已提交
263
            if os.path.exists('{}/__params__'.format(model_config_path)):
Z
update  
zhangjun 已提交
264
                engine.combined_model = True
Z
fix  
zhangjun 已提交
265 266
            else:
                engine.combined_model = False
Z
update  
zhangjun 已提交
267 268
            if use_encryption_model:
                engine.encrypted_model = True
Z
fix  
zhangjun 已提交
269
            engine.type = "PADDLE_INFER"
H
HexToString 已提交
270 271
            self.model_toolkit_conf.append(server_sdk.ModelToolkitConf())
            self.model_toolkit_conf[-1].engines.extend([engine])
272
            index = index + 1
M
MRXLT 已提交
273 274 275 276 277 278 279 280 281 282

    def _prepare_infer_service(self, port):
        if self.infer_service_conf == None:
            self.infer_service_conf = server_sdk.InferServiceConf()
            self.infer_service_conf.port = port
            infer_service = server_sdk.InferService()
            infer_service.name = "GeneralModelService"
            infer_service.workflows.extend(["workflow1"])
            self.infer_service_conf.services.extend([infer_service])

M
MRXLT 已提交
283
    def _prepare_resource(self, workdir, cube_conf):
284
        self.workdir = workdir
M
MRXLT 已提交
285 286
        if self.resource_conf == None:
            self.resource_conf = server_sdk.ResourceConf()
Z
zhangjun 已提交
287 288
            for idx, op_general_model_config_fn in enumerate(
                    self.general_model_config_fn):
H
HexToString 已提交
289
                with open("{}/{}".format(workdir, op_general_model_config_fn),
Z
zhangjun 已提交
290
                          "w") as fout:
H
HexToString 已提交
291 292 293 294 295 296 297 298 299 300 301 302 303 304
                    fout.write(str(list(self.model_conf.values())[idx]))
                for workflow in self.workflow_conf.workflows:
                    for node in workflow.nodes:
                        if "dist_kv" in node.name:
                            self.resource_conf.cube_config_path = workdir
                            self.resource_conf.cube_config_file = self.cube_config_fn
                            if cube_conf == None:
                                raise ValueError(
                                    "Please set the path of cube.conf while use dist_kv op."
                                )
                            shutil.copy(cube_conf, workdir)
                            if "quant" in node.name:
                                self.resource_conf.cube_quant_bits = 8
                self.resource_conf.model_toolkit_path.extend([workdir])
Z
zhangjun 已提交
305 306
                self.resource_conf.model_toolkit_file.extend(
                    [self.model_toolkit_fn[idx]])
H
HexToString 已提交
307
                self.resource_conf.general_model_path.extend([workdir])
Z
zhangjun 已提交
308 309
                self.resource_conf.general_model_file.extend(
                    [op_general_model_config_fn])
H
HexToString 已提交
310 311 312 313 314
                #TODO:figure out the meaning of product_name and container_id.
                if self.product_name != None:
                    self.resource_conf.auth_product_name = self.product_name
                if self.container_id != None:
                    self.resource_conf.auth_container_id = self.container_id
M
MRXLT 已提交
315 316 317 318 319

    def _write_pb_str(self, filepath, pb_obj):
        with open(filepath, "w") as fout:
            fout.write(str(pb_obj))

H
HexToString 已提交
320
    def load_model_config(self, model_config_paths_args):
B
barrierye 已提交
321 322 323
        # At present, Serving needs to configure the model path in
        # the resource.prototxt file to determine the input and output
        # format of the workflow. To ensure that the input and output
B
barrierye 已提交
324
        # of multiple models are the same.
H
HexToString 已提交
325 326 327 328 329 330 331
        if isinstance(model_config_paths_args, str):
            model_config_paths_args = [model_config_paths_args]

        for single_model_config in model_config_paths_args:
            if os.path.isdir(single_model_config):
                pass
            elif os.path.isfile(single_model_config):
Z
zhangjun 已提交
332 333 334
                raise ValueError(
                    "The input of --model should be a dir not file.")

H
HexToString 已提交
335
        if isinstance(model_config_paths_args, list):
B
barrierye 已提交
336
            # If there is only one model path, use the default infer_op.
M
MRXLT 已提交
337
            # Because there are several infer_op type, we need to find
B
barrierye 已提交
338
            # it from workflow_conf.
H
HexToString 已提交
339
            default_engine_types = [
Z
zhangjun 已提交
340 341 342 343
                'GeneralInferOp',
                'GeneralDistKVInferOp',
                'GeneralDistKVQuantInferOp',
                'GeneralDetectionOp',
B
barrierye 已提交
344
            ]
H
HexToString 已提交
345 346 347
            # now only support single-workflow.
            # TODO:support multi-workflow
            model_config_paths_list_idx = 0
B
barrierye 已提交
348
            for node in self.workflow_conf.workflows[0].nodes:
H
HexToString 已提交
349 350 351 352 353
                if node.type in default_engine_types:
                    if node.name is None:
                        raise Exception(
                            "You have set the engine_name of Op. Please use the form {op: model_path} to configure model path"
                        )
Z
zhangjun 已提交
354

H
HexToString 已提交
355
                    f = open("{}/serving_server_conf.prototxt".format(
Z
zhangjun 已提交
356 357 358 359 360 361 362 363 364 365 366 367
                        model_config_paths_args[model_config_paths_list_idx]),
                             'r')
                    self.model_conf[
                        node.name] = google.protobuf.text_format.Merge(
                            str(f.read()), m_config.GeneralModelConfig())
                    self.model_config_paths[
                        node.name] = model_config_paths_args[
                            model_config_paths_list_idx]
                    self.general_model_config_fn.append(
                        node.name + "/general_model.prototxt")
                    self.model_toolkit_fn.append(node.name +
                                                 "/model_toolkit.prototxt")
H
HexToString 已提交
368 369
                    self.subdirectory.append(node.name)
                    model_config_paths_list_idx += 1
Z
zhangjun 已提交
370 371
                    if model_config_paths_list_idx == len(
                            model_config_paths_args):
H
HexToString 已提交
372 373 374 375 376
                        break
        #Right now, this is not useful.
        elif isinstance(model_config_paths_args, dict):
            self.model_config_paths = collections.OrderedDict()
            for node_str, path in model_config_paths_args.items():
B
barrierye 已提交
377 378 379 380 381
                node = server_sdk.DAGNode()
                google.protobuf.text_format.Parse(node_str, node)
                self.model_config_paths[node.name] = path
            print("You have specified multiple model paths, please ensure "
                  "that the input and output of multiple models are the same.")
H
HexToString 已提交
382 383
            f = open("{}/serving_server_conf.prototxt".format(path), 'r')
            self.model_conf[node.name] = google.protobuf.text_format.Merge(
Z
zhangjun 已提交
384
                str(f.read()), m_config.GeneralModelConfig())
B
barrierye 已提交
385
        else:
Z
zhangjun 已提交
386 387 388 389
            raise Exception(
                "The type of model_config_paths must be str or list or "
                "dict({op: model_path}), not {}.".format(
                    type(model_config_paths_args)))
M
MRXLT 已提交
390 391
        # check config here
        # print config here
Z
update  
zhangjun 已提交
392

Z
zhangjun 已提交
393 394 395
    def use_mkl(self, flag):
        self.mkl_flag = flag

Z
zhangjun 已提交
396
    def check_avx(self):
397 398 399 400 401
        p = subprocess.Popen(
            ['cat /proc/cpuinfo | grep avx 2>/dev/null'],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            shell=True)
Z
zhangjun 已提交
402
        out, err = p.communicate()
Z
zhangjun 已提交
403
        if err == b'' and len(out) > 0:
Z
zhangjun 已提交
404 405 406 407
            return True
        else:
            return False

Z
zhangjun 已提交
408 409
    def get_device_version(self):
        avx_flag = False
Z
zhangjun 已提交
410
        avx_support = self.check_avx()
Z
update  
zhangjun 已提交
411
        if avx_support:
Z
zhangjun 已提交
412
            avx_flag = True
Z
zhangjun 已提交
413 414
            self.use_mkl(True)
        mkl_flag = self.mkl_flag
Z
zhangjun 已提交
415 416
        if avx_flag:
            if mkl_flag:
Z
update  
zhangjun 已提交
417
                device_version = "cpu-avx-mkl"
Z
zhangjun 已提交
418
            else:
Z
update  
zhangjun 已提交
419
                device_version = "cpu-avx-openblas"
Z
zhangjun 已提交
420 421 422 423 424
        else:
            if mkl_flag:
                print(
                    "Your CPU does not support AVX, server will running with noavx-openblas mode."
                )
Z
update  
zhangjun 已提交
425 426 427 428 429 430 431
            device_version = "cpu-noavx-openblas"
        return device_version

    def get_serving_bin_name(self):
        if device_type == "0":
            device_version = self.get_device_version()
        elif device_type == "1":
B
bjjwwang 已提交
432
            if version_suffix == "101" or version_suffix == "1027" or version_suffix == "1028" or version_suffix == "112":
Z
update  
zhangjun 已提交
433 434 435 436 437
                device_version = "gpu-" + version_suffix
            else:
                device_version = "gpu-cuda" + version_suffix
        elif device_type == "2":
            device_version = "xpu-" + platform.machine()
Z
zhangjun 已提交
438
        return device_version
M
MRXLT 已提交
439 440 441

    def download_bin(self):
        os.chdir(self.module_path)
M
MRXLT 已提交
442 443 444

        #acquire lock
        version_file = open("{}/version.py".format(self.module_path), "r")
Z
update  
zhangjun 已提交
445

Z
fix  
zhangjun 已提交
446
        folder_name = "serving-%s-%s" % (self.get_serving_bin_name(),
447
                                         version_tag)
Z
fix  
zhangjun 已提交
448 449 450
        tar_name = "%s.tar.gz" % folder_name
        bin_url = "https://paddle-serving.bj.bcebos.com/bin/%s" % tar_name

451 452 453 454
        self.server_path = os.path.join(self.module_path, folder_name)

        download_flag = "{}/{}.is_download".format(self.module_path,
                                                   folder_name)
M
MRXLT 已提交
455 456 457

        fcntl.flock(version_file, fcntl.LOCK_EX)

458 459 460 461 462
        if os.path.exists(download_flag):
            os.chdir(self.cur_path)
            self.bin_path = self.server_path + "/serving"
            return

M
MRXLT 已提交
463 464
        if not os.path.exists(self.server_path):
            print('Frist time run, downloading PaddleServing components ...')
M
MRXLT 已提交
465

M
MRXLT 已提交
466 467 468 469
            r = os.system('wget ' + bin_url + ' --no-check-certificate')
            if r != 0:
                if os.path.exists(tar_name):
                    os.remove(tar_name)
M
MRXLT 已提交
470
                raise SystemExit(
T
TeslaZhao 已提交
471 472
                    'Download failed, please check your network or permission of {}.'
                    .format(self.module_path))
M
MRXLT 已提交
473 474 475 476 477 478
            else:
                try:
                    print('Decompressing files ..')
                    tar = tarfile.open(tar_name)
                    tar.extractall()
                    tar.close()
Z
zhangjun 已提交
479
                    open(download_flag, "a").close()
M
MRXLT 已提交
480
                except:
Z
zhangjun 已提交
481 482
                    if os.path.exists(self.server_path):
                        os.remove(self.server_path)
M
MRXLT 已提交
483
                    raise SystemExit(
T
TeslaZhao 已提交
484 485
                        'Decompressing failed, please check your permission of {} or disk space left.'
                        .format(self.module_path))
M
MRXLT 已提交
486 487
                finally:
                    os.remove(tar_name)
M
MRXLT 已提交
488
        #release lock
B
barrierye 已提交
489
        version_file.close()
M
MRXLT 已提交
490 491
        os.chdir(self.cur_path)
        self.bin_path = self.server_path + "/serving"
Z
update  
zhangjun 已提交
492

M
MRXLT 已提交
493 494 495
    def prepare_server(self,
                       workdir=None,
                       port=9292,
H
HexToString 已提交
496
                       device=None,
W
wangjiawei04 已提交
497
                       use_encryption_model=False,
M
MRXLT 已提交
498
                       cube_conf=None):
H
HexToString 已提交
499 500 501 502 503 504 505 506
        # if `device` is not set, use self.device
        # self.device may not be changed.
        # or self.device may have changed by set_device.
        if device == None:
            device = self.device
        # if `device` is set, let self.device = device.
        else:
            self.device = device
M
MRXLT 已提交
507 508
        if workdir == None:
            workdir = "./tmp"
Z
zhangjun 已提交
509
            os.system("mkdir -p {}".format(workdir))
M
MRXLT 已提交
510
        else:
Z
zhangjun 已提交
511
            os.system("mkdir -p {}".format(workdir))
H
HexToString 已提交
512
        for subdir in self.subdirectory:
513
            os.system("mkdir -p {}/{}".format(workdir, subdir))
H
HexToString 已提交
514 515
            os.system("touch {}/{}/fluid_time_file".format(workdir, subdir))

M
MRXLT 已提交
516
        if not self.port_is_available(port):
G
gongweibao 已提交
517
            raise SystemExit("Port {} is already used".format(port))
M
MRXLT 已提交
518

G
guru4elephant 已提交
519
        self.set_port(port)
M
MRXLT 已提交
520
        self._prepare_resource(workdir, cube_conf)
H
HexToString 已提交
521 522
        self._prepare_engine(self.model_config_paths, device,
                             use_encryption_model)
M
MRXLT 已提交
523 524 525 526 527
        self._prepare_infer_service(port)
        self.workdir = workdir

        infer_service_fn = "{}/{}".format(workdir, self.infer_service_fn)
        self._write_pb_str(infer_service_fn, self.infer_service_conf)
H
HexToString 已提交
528 529

        workflow_fn = "{}/{}".format(workdir, self.workflow_fn)
M
MRXLT 已提交
530
        self._write_pb_str(workflow_fn, self.workflow_conf)
H
HexToString 已提交
531 532

        resource_fn = "{}/{}".format(workdir, self.resource_fn)
M
MRXLT 已提交
533
        self._write_pb_str(resource_fn, self.resource_conf)
H
HexToString 已提交
534

Z
zhangjun 已提交
535
        for idx, single_model_toolkit_fn in enumerate(self.model_toolkit_fn):
H
HexToString 已提交
536 537
            model_toolkit_fn = "{}/{}".format(workdir, single_model_toolkit_fn)
            self._write_pb_str(model_toolkit_fn, self.model_toolkit_conf[idx])
M
MRXLT 已提交
538

M
MRXLT 已提交
539
    def port_is_available(self, port):
M
MRXLT 已提交
540 541
        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
            sock.settimeout(2)
H
HexToString 已提交
542
            result = sock.connect_ex(('127.0.0.1', port))
M
MRXLT 已提交
543 544 545 546 547
        if result != 0:
            return True
        else:
            return False

M
MRXLT 已提交
548 549 550
    def run_server(self):
        # just run server with system command
        # currently we do not load cube
M
MRXLT 已提交
551
        self.check_local_bin()
M
MRXLT 已提交
552 553
        if not self.use_local_bin:
            self.download_bin()
B
fix bug  
barrierye 已提交
554 555 556
            # wait for other process to download server bin
            while not os.path.exists(self.server_path):
                time.sleep(1)
M
MRXLT 已提交
557 558
        else:
            print("Use local bin : {}".format(self.bin_path))
Z
zhangjun 已提交
559
        #self.check_cuda()
H
HexToString 已提交
560 561 562 563 564 565 566 567
        command = "{} " \
                    "-enable_model_toolkit " \
                    "-inferservice_path {} " \
                    "-inferservice_file {} " \
                    "-max_concurrency {} " \
                    "-num_threads {} " \
                    "-port {} " \
                    "-precision {} " \
568
                    "-use_calib={} " \
H
HexToString 已提交
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
                    "-reload_interval_s {} " \
                    "-resource_path {} " \
                    "-resource_file {} " \
                    "-workflow_path {} " \
                    "-workflow_file {} " \
                    "-bthread_concurrency {} " \
                    "-max_body_size {} ".format(
                        self.bin_path,
                        self.workdir,
                        self.infer_service_fn,
                        self.max_concurrency,
                        self.num_threads,
                        self.port,
                        self.precision,
                        self.use_calib,
                        self.reload_interval_s,
                        self.workdir,
                        self.resource_fn,
                        self.workdir,
                        self.workflow_fn,
                        self.num_threads,
                        self.max_body_size)

M
MRXLT 已提交
592 593
        print("Going to Run Comand")
        print(command)
594

M
MRXLT 已提交
595
        os.system(command)