def oursystem(ip, port, inputt):
channel = grpc.insecure_channel('%s:%s' % (ip, port))
stub = prediction_pb2_grpc.ProxyServerStub(channel)
response = stub.downstream(
prediction_pb2.request(
input_=model_pb2.input(inputType='string', inputStream=inputt)))
return response.status
def produce(ip, port, seq_id):
channel = grpc.insecure_channel('%s:%s' % (ip, port))
stub = prediction_pb2_grpc.ProxyServerStub(channel)
time = Timestamp()
time.GetCurrentTime()
response = stub.outputstream(
prediction_pb2.request(input_=model_pb2.input(
inputType='string', inputStream="Produced output"),
src_uri="localhost",
seq=seq_id,
req_id=1,
timestamp=time))
print('Response\n{res}'.format(res=response.status))
return response.status
def withoutproxy(ip, port, inputt):
channel = grpc.insecure_channel('%s:%s' % (ip, port))
stub = model_pb2_grpc.PredictServiceStub(channel)
response = stub.Predict(
model_pb2.input(inputStream=inputt, inputType="String"))
channel = grpc.insecure_channel('%s:%s' % (ip, port))
stub = model_pb2_grpc.PredictionServerStub(channel)
response = stub.downstream(
prediction_pb2.request(
input_=model_pb2.input(inputType='string', inputStream=inputt)))
time.sleep(1)
return response.outputStream
def consume(ip, port, inputt):
inputt = str(inputt)
channel = grpc.insecure_channel('%s:%s' % (ip, port))
stub = prediction_pb2_grpc.ProxyServerStub(channel)
a = datetime.datetime.now()
response = stub.downstream(
prediction_pb2.request(
input_=model_pb2.input(inputType='string', inputStream=inputt)))
b = datetime.datetime.now()
print('latency', (b - a).microseconds / 1000, "ms")
return response.status
def downstream(self, request, context): ## Consumer
#logging.info("Start processing request...")
#### received a request
#### stub.downstream(prediction_pb2.request(input_ = model_pb2.input(inputType = 'string', inputStream = stock_name),src_uri = "localhost", seq = 1, req_id =1, timestamp = Timestamp().GetCurrentTime()))
## Sequence Lock - Guarantee that sequence are consistent
self.seq_mutex.acquire()
temp_seq = self.seq_id
self.seq_id = self.seq_id + 1
self.seq_mutex.release()
##
call_time = Timestamp()
call_time.GetCurrentTime()
## Generate request
temp_request = prediction_pb2.request(input_=request.input_,
src_uri="front-end",
seq=temp_seq,
req_id=self.request_id,
timestamp=call_time)
## Create conditional variable
# Currently use seq id as thread id
thread_id = temp_seq
condition = threading.Event() #Condition()
self.event_dict[thread_id] = condition
#logging.info(self.event_dict[thread_id])
## Send request to downstream proxy
channel = grpc.insecure_channel(
'%s:%s' % (self.entry_proxy_name, self.entry_proxy_port))
stub = prediction_pb2_grpc.ProxyServerStub(channel)
response = stub.downstream(temp_request)
logging.info('Response\n{res}'.format(res=response.status))
#
logging.info("Received consume request%s" %
(request.input_.inputStream))
#logging.info(type(self.event_dict.get(thread_id, None)))
## Wait for task finish
event = self.event_dict.get(thread_id, None)
#event.acquire()
event.wait()
#event.release()
## Produce return
output = self.output_dict[thread_id]
#ret_time = self.timestamp_dict[thread_id]
ret_time = Timestamp()
ret_time.GetCurrentTime()
## Generate return string
ret = "Call Time: %s Return Time: %s Output: %s" % (
str(call_time), str(ret_time), str(output))
## Clean cache
del self.output_dict[thread_id]
del self.event_dict[thread_id]
del self.timestamp_dict[thread_id]
logging.info("Finished processing request with ret: %s" % (ret))
return model_pb2.response(status=ret)
