def get_nimbus_client(env_config=None, host=None, port=None, timeout=7000):
"""Get a Thrift RPC client for Nimbus given project's config file.
:param env_config: The project's parsed config.
:type env_config: `dict`
:param host: The host to use for Nimbus. If specified, `env_config` will
not be consulted.
:type host: `str`
:param port: The port to use for Nimbus. If specified, `env_config` will
not be consulted.
:type port: `int`
:param timeout: The time to wait (in milliseconds) for a response from
Nimbus.
:param timeout: `int`
:returns: a ThriftPy RPC client to use to communicate with Nimbus
"""
if host is None:
host, port = get_nimbus_host_port(env_config)
nimbus_client = make_client(
Nimbus,
host=host,
port=port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TFramedTransportFactory(),
timeout=timeout,
)
return nimbus_client
def __init__(self,
host,
port,
retry_interval,
report_status=None,
logging_timeout=None):
# set up thrift and scribe objects
timeout = logging_timeout if logging_timeout is not None else config.scribe_logging_timeout
self.socket = thriftpy.transport.socket.TSocket(
six.text_type(host), int(port))
if timeout:
self.socket.set_timeout(timeout)
self.transport = TFramedTransportFactory().get_transport(self.socket)
protocol = TBinaryProtocolFactory(strict_read=False).get_protocol(
self.transport)
self.client = TClient(scribe_thrift.scribe, protocol)
# our own bookkeeping for connection
self.connected = False # whether or not we think we're currently connected to the scribe server
self.last_connect_time = 0 # last time we got disconnected or failed to reconnect
self.retry_interval = retry_interval
self.report_status = report_status or get_default_reporter()
self.__lock = threading.RLock()
self._birth_pid = os.getpid()
def __init__(self, host, port, category='zipkin', timeout=None):
self.category = category
self.host = host
self.port = port
self.timeout = timeout
self.protocol_factory = TBinaryProtocolFactory(strict_read=False,
strict_write=False)
self.transport_factory = TFramedTransportFactory()
def blocking_call():
client = make_client(
service=addressbook.AddressBookService,
host=self.host,
port=self.port,
trans_factory=TFramedTransportFactory(),
proto_factory=TBinaryProtocolFactory(),
)
with closing_client(client):
return getattr(client, method)(*args, **kwargs)
def make_client(service,
host,
port,
proto_factory=TBinaryProtocolFactory(),
trans_factory=TFramedTransportFactory()):
socket = TNonBlockingSocket(host, port)
transport = trans_factory.get_transport(socket)
protocol = proto_factory.get_protocol(transport)
transport.open()
return TClient(service, protocol)
def __init__(self, ip="10.15.208.61", port=6800):
self.ip = ip
self.port = port
try:
self.client = make_client(CNN_i2i_thrift.CNNPredictService,
ip, port,trans_factory=TFramedTransportFactory(), timeout=12000) ## timeout ms
except Exception as err:
print err
traceback.print_exc()
return
class FramedTransportTestCase(TestCase):
TRANSPORT_FACTORY = TFramedTransportFactory()
def mk_server(self):
self.io_loop = ioloop.IOLoop()
server = make_server(addressbook.AddressBookService,
Dispatcher(self.io_loop),
io_loop=self.io_loop)
self.server = server
sock = self.server_sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
sock.bind(('localhost', 0))
sock.setblocking(0)
self.port = sock.getsockname()[-1]
self.server_thread = threading.Thread(target=self.listen)
self.server_thread.setDaemon(True)
self.server_thread.start()
def listen(self):
self.server_sock.listen(128)
self.server.add_socket(self.server_sock)
self.io_loop.start()
def mk_client(self):
return make_client(addressbook.AddressBookService,
'127.0.0.1',
self.port,
trans_factory=self.TRANSPORT_FACTORY)
def setUp(self):
self.mk_server()
time.sleep(0.1)
self.client = self.mk_client()
def test_able_to_communicate(self):
dennis = addressbook.Person(name='Dennis Ritchie')
success = self.client.add(dennis)
assert success
success = self.client.add(dennis)
assert not success
def test_zero_length_string(self):
dennis = addressbook.Person(name='')
success = self.client.add(dennis)
assert success
success = self.client.get(name='')
assert success
def api_handler(username, service, version, path):
runtime = Runtime.query.filter_by(
username=username,
service_name=service,
version=version,
obsolete=False,
).first()
if runtime is None:
return "service not found", 404
if request.method in ('POST', 'PUT'):
body = request.content
else:
body = None
client = make_client(okapi_thrift.InvokeService,
runtime.full_name,
23241,
trans_factory=TFramedTransportFactory())
result = client.InvokeAPI(path, request.method, request.args,
request.headers, body)
return result.body, result.code, result.headers
def DoPostProcess(self, datalst):
reqlst = []
for data in datalst:
req = CNN_i2i_thrift.Request()
req.inputImage = data
reqlst.append(req)
ret = []
try:
reslst = self.client.predict(reqlst)
#print res
for i in range(len(reslst)):
roiimglst = []
## get mask image
maskres = reslst[i].maskResult
roiimglst.append(maskres.outputImage)
## get roi image
roilist = reslst[i].roiResults
for k in range(len(roilist)):
roi = roilist[k]
val = roi.outputImage
resc= roi.imageChannel
resw= roi.imageWidth
resh= roi.imageHeight
roiimglst.append(val)
ret.append(roiimglst)
except Exception as err:
try:
self.client = make_client(CNN_i2i_thrift.CNNPredictService,
self.ip, self.port,trans_factory=TFramedTransportFactory(), timeout=12000) ## timeout ms
except Exception as err:
traceback.print_exc()
print err
print err
traceback.print_exc()
return ret
def mk_client(self):
return make_client(addressbook.AddressBookService,
'127.0.0.1',
self.port,
transport_factory=TFramedTransportFactory())
def serve_forever(runtime, port, client):
try:
api_details = import_module(runtime.entrypoint)
r = client.post("http://okapi-engine:5000/okapi/service/v1/%s/%s/spec" % (runtime.service_name, runtime.service_version), json = api_details)
logging.debug("post service spec status: %s" % r.status_code)
except:
traceback.print_exc()
try:
logging.info("start to serve on port %s" % port)
server = make_server(okapi_thrift.InvokeService, Dispatcher(), '0.0.0.0', port, trans_factory=TFramedTransportFactory())
server.serve()
except Exception as e:
traceback.print_exc()
sys.exit(2) # serve fails (e.g. port already used) or serve exited (e.g. user press CTRL+C)
