def CreateCirqueDevice(self, request, context):
if request.home_id is None or request.home_id not in self.homes:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
return service_pb2.CreateCirqueDeviceResponse()
elif request.specification is None:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.INVALID_ARGUMENT)))
return service_pb2.CreateCirqueDeviceResponse()
else:
specification = request.specification
device_config = {
'type': specification.device_type,
'capability': [],
}
if specification.base_image:
device_config['base_image'] = specification.base_image
if specification.WhichOneof('optional_weave_capability'):
add_weave_capability_to_config(device_config,
specification.weave_capability)
if specification.WhichOneof('optional_thread_capability'):
add_thread_capability_to_config(
device_config, specification.thread_capability)
if specification.WhichOneof('optional_wifi_capability'):
add_wifi_capability_to_config(device_config,
specification.wifi_capability)
if specification.WhichOneof('optional_xvnc_capability'):
add_xvnc_capability_to_config(device_config,
specification.xvnc_capability)
if specification.WhichOneof('optional_interactive_capability'):
add_interactive_capability_to_config(
device_config, specification.interactive_capability)
if specification.WhichOneof('optional_lan_access_capability'):
add_lan_access_capability_to_config(
device_config, specification.lan_access_capability)
if specification.WhichOneof('optional_mount_capability'):
add_mount_capability_to_config(device_config,
specification.mount_capability)
device_id = self.homes[request.home_id].add_device(device_config)
if device_id is None:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.INTERNAL)))
return service_pb2.CreateCirqueDeviceResponse()
else:
device = self.homes[request.home_id].get_device_state(
device_id)
return service_pb2.CreateCirqueDeviceResponse(
device=convert_to_device_pb(device))
def make_call(status_pb: Status) -> grpc.Call:
status = rpc_status.to_status(status_pb)
mock_call = MagicMock(spec=grpc.Call)
mock_call.details.return_value = status.details
mock_call.code.return_value = status.code
mock_call.trailing_metadata.return_value = status.trailing_metadata
return mock_call
def unary_error_via_context(self, request, context):
# using rich status to test compatibility with
# https://grpc.github.io/grpc/python/grpc_status.html
status = make_status(
code=StatusCode.UNAUTHENTICATED,
message="Not allowed!",
)
context.abort_with_status(rpc_status.to_status(status))
def SayHello(self, request, context):
with self._lock:
if request.name in self._greeted:
rich_status = create_greet_limit_exceed_error_status(
request.name)
context.abort_with_status(rpc_status.to_status(rich_status))
else:
self._greeted.add(request.name)
return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)
def RecordPlayerScore(self, request_iterator, context):
try:
for player_score in request_iterator:
yield database.save_player_score(self.db_connection, player_score)
except Exception as error:
player_score = ScoreResponse()
err_status = create_internal_error_status(str(error))
context.abort_with_status(rpc_status.to_status(err_status))
return player_score
def SayHello(self, request, context):
with self._lock:
if request.name in self._greeted:
rich_status = create_greet_limit_exceed_error_status(
request.name)
context.abort_with_status(rpc_status.to_status(rich_status))
else:
self._greeted.add(request.name)
return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)
def ListCirqueHomeDevices(self, request, context):
if request.home_id is None or request.home_id not in self.homes:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
return service_pb2.ListCirqueHomeDevicesResponse()
devices = self.homes[request.home_id].get_home_devices().values()
device_pbs = [convert_to_device_pb(d) for d in devices]
return service_pb2.ListCirqueHomeDevicesResponse(devices=device_pbs)
def StopCirqueHome(self, request, context):
if request.home_id is None or \
request.home_id not in self.homes:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
else:
self.homes[request.home_id].destroy_home()
del self.homes[request.home_id]
return empty_pb2.Empty()
def GetLeaderBoardPages(self, request, context):
try:
leaderboard_response = database.get_leaderboard_data(self.db_connection, request)
except ValueError as error:
leaderboard_response = LeaderBoardResponse()
argument_name = error.args[0] if error.args else EXCEPTION_ARGS_ERROR
err_status = create_invalid_argument_status(argument_name)
context.abort_with_status(rpc_status.to_status(err_status))
return leaderboard_response
def AuthenticateUser(self, request, context):
try:
auth_token = database.get_token(self.db_connection, request)
if auth_token.token: # if it's valid store value in validator
self.token_validator.set_token(auth_token)
except Exception as error:
auth_token = TokenAuth()
err_status = create_internal_error_status(str(error))
context.abort_with_status(rpc_status.to_status(err_status))
return auth_token
def _abort(context, err_msg: str, code: int, detail_msg: str = ""):
detail = any_pb2.Any()
detail.Pack(
error_details_pb2.DebugInfo(
stack_entries=traceback.format_stack(),
detail=detail_msg,
))
rich_status = status_pb2.Status(code=code,
message=err_msg,
details=[detail])
context.abort_with_status(rpc_status.to_status(rich_status))
def wrapped_func(self, request, context, *args, **kwargs):
try:
return func(self, request, context, *args, **kwargs)
except GrpcError as e:
status_proto = _grpc_error_to_status_proto(e)
grpc_status = rpc_status.to_status(status_proto)
context.abort_with_status(grpc_status)
except Exception as e:
if on_uncaught_exception:
on_uncaught_exception(e)
context.abort(StatusCode.UNKNOWN, 'Server error')
def _error_details_unary_unary(request, servicer_context):
details = any_pb2.Any()
details.Pack(
error_details_pb2.DebugInfo(stack_entries=traceback.format_stack(),
detail='Intentionally invoked'))
rich_status = status_pb2.Status(
code=code_pb2.INTERNAL,
message=_STATUS_DETAILS,
details=[details],
)
servicer_context.abort_with_status(rpc_status.to_status(rich_status))
def StopCirqueDevice(self, request, context):
if request.home_id is None or \
request.home_id not in self.homes or \
request.device_id is None or \
request.device_id not in self.homes[request.home_id].devices:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
else:
self.homes[request.home_id].stop_device(request.device_id)
return empty_pb2.Empty()
def stream_error_via_context(self, request, context):
message = request.value * (request.multiplier or 1)
for i in range(request.response_count):
maybe_sleep(request)
# raise on the last message
if i == request.response_count - 1:
# using rich status to test compatibility with
# https://grpc.github.io/grpc/python/grpc_status.html
status = make_status(code=StatusCode.RESOURCE_EXHAUSTED,
message="Out of tokens!")
context.abort_with_status(rpc_status.to_status(status))
yield ExampleReply(message=message, seqno=i + 1)
def GetCirqueDeviceLog(self, request, context):
if request.home_id is None or \
request.home_id not in self.homes or \
request.device_id is None or \
request.device_id not in self.homes[request.home_id].devices:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
return service_pb2.GetCirqueDeviceLogResponse()
tail = request.tail if request.tail is not None else 'all'
log = self.homes[request.home_id].get_device_log(request.device_id,
tail=tail)
return service_pb2.GetCirqueDeviceLogResponse(log=log)
def QueryCirqueDevice(self, request, context):
if request.home_id is None or \
request.home_id not in self.homes or \
request.device_id is None or \
request.device_id not in self.homes[request.home_id].devices:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
return service_pb2.QueryCirqueDeviceResponse()
device = self.homes[request.home_id].get_device_state(
request.device_id)
return service_pb2.QueryCirqueDeviceResponse(
device=convert_to_device_pb(device))
def __init__(self, message, exc, stack_entries):
super().__init__(message)
if stack_entries is not None:
detail = any_pb2.Any()
detail.Pack(
error_details_pb2.DebugInfo(stack_entries=stack_entries,
detail=repr(exc)))
status = status_pb2.Status(code=code_pb2.INTERNAL,
message=str(exc),
details=[detail])
else:
status = status_pb2.Status(code=code_pb2.INTERNAL,
message=str(exc))
self.impl = rpc_status.to_status(status)
def ContractCall(self, request, context):
with futures.ProcessPoolExecutor(max_workers=1) as executor:
task = executor.submit(self.web3Task, request, 'eth_call')
try:
res = task.result(timeout=30)
return ethereum_pb2.CallResponse(result=Web3.toJSON(res))
except Exception as exc:
print("Exception: ", exc)
detail = any_pb2.Any()
rich_status = rpc_status.status_pb2.Status(
code=code_pb2.NOT_FOUND,
message=str(exc),
details=[detail])
context.abort_with_status(rpc_status.to_status(rich_status))
def ExecuteDeviceCommand(self, request, context):
if request.home_id is None or \
request.home_id not in self.homes or \
request.device_id is None or \
request.device_id not in self.homes[request.home_id].devices:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.NOT_FOUND)))
return service_pb2.ExecuteDeviceCommandResponse()
ret = self.homes[request.home_id].execute_device_cmd(
cmd=request.command,
node_id=request.device_id,
stream=request.streaming)
if ret.exit_code != 0:
context.abort_with_status(
rpc_status.to_status(
status_pb2.Status(code=code_pb2.ABORTED,
message=ret.output)))
return service_pb2.ExecuteDeviceCommandResponse()
return service_pb2.ExecuteDeviceCommandResponse(output=ret.output)
def exception_handler(self, exc, context):
log.exception(exc)
detail = any_pb2.Any()
if self.debug:
detail.Pack(
error_details_pb2.DebugInfo(
stack_entries=traceback.format_stack(),
detail=repr(exc)
)
)
status = status_pb2.Status(
code=code_pb2.INTERNAL,
message=str(exc),
details=[detail]
)
context.abort_with_status(rpc_status.to_status(status))
def SendRawTransactions(self, request, context):
with futures.ProcessPoolExecutor(max_workers=1) as executor:
task = executor.submit(self.web3Task, request,
'eth_sendRawTransaction')
try:
tx = task.result(timeout=30)
print(tx)
return ethereum_pb2.TransactionInfo(
transaction=Web3.toJSON(tx))
except Exception as exc:
print("Exception: ", exc)
detail = any_pb2.Any()
rich_status = rpc_status.status_pb2.Status(
code=code_pb2.NOT_FOUND,
message=str(exc),
details=[detail])
context.abort_with_status(rpc_status.to_status(rich_status))
def UnaryDoSomething(self, request, context):
if self._get_context_data_f("always_bork"):
log.debug("gRPC server is borking the unary request")
status = status_pb2.Status(
code=code_pb2.FAILED_PRECONDITION,
message="request borked per request",
)
context.abort_with_status(rpc_status.to_status(status))
elif self._get_context_data_f("always_stall"):
stall_time = self._get_context_data_f("stall_time")
log.debug(
"gRPC server is stalling the unary request for `{}` seconds".
format(stall_time))
time.sleep(stall_time)
return grpc_endpoint_pb2.StringMessage(
message="received: {}".format(request.message))
def Forecast(self, request, context):
self.datasetPath_ = request.DatasetPath
self.n_steps_in_ = request.DaysToTrain
self.n_steps_out_ = request.DaysForecastAhead
self.attributeSelected_ = request.ForecastAttributes
self.modelPath_ = request.ModelPath
self.scalerPath_ = request.ScalerPath
if(request.DatasetPath == ""):
# self.datasetPath_ = "./Data Science_20200214.xlsx"
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No Dataset File is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.DaysToTrain == 0):
# self.n_steps_in_ = 120
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No DaysToTrain is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.DaysForecastAhead == 0):
# self.n_steps_out_ = 90
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No DaysToForecast is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.ForecastAttributes == []):
# self.attributeSelected_ = ["Shipment", "Order", "Revenue"]
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No Attributes is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.ModelPath == ""):
# self.modelPath_ = "./default_model.h5"
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No Model is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.ScalerPath == ""):
# self.scalerPath_ = "./default_scaler.pkl"
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No Scaler is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
ForecastObj = ForecastModel(attributes=self.attributeSelected_, n_steps_in=self.n_steps_in_, n_steps_out=self.n_steps_out_, datasetPath=self.datasetPath_, modelPath=self.modelPath_, scalerPath=self.scalerPath_)
ForecastObj.LoadDataset()
ForecastObj.ForecastFuture()
# Return Response
response = forecast_pb2.ForecastResponse()
response.ForecastedValuesFilePath = os.path.realpath(ForecastObj.forecastDataFilename)
response.ForecastData = (ForecastObj.forecastData)
response.MaxForecastedValue.extend(ForecastObj.maxValuePred)
response.PercentDifference.extend(ForecastObj.percentDifference)
return response
def _cos_process_command(cls, id, command, context):
'''helper method to run process command'''
logger.debug("begin process_command")
client = cls._get_cos_client()
command_any = pack_any(command)
metadata = [('x-custom-request-uuid', str(uuid4()))]
request = ProcessCommandRequest(entity_id=id, command=command_any)
try:
response = client.ProcessCommand(request=request, metadata=metadata)
return cls._cos_unpack_state(response.state)
except grpc.RpcError as e:
output_status = rpc_status.from_call(e)
if not output_status:
context.abort(code=e.code(), details=e.details())
context.abort_with_status(rpc_status.to_status(output_status))
except Exception as e:
context.abort(code=StatusCode.INTERNAL, details=str(e))
def _validate(context: grpc.ServicerContext):
if not condition:
if field_name:
logger.warn(
f"validation failed, field: {field_name}, error: {error_message}"
)
detail = error_details_pb2.BadRequest(field_violations=[
error_details_pb2.BadRequest.FieldViolation(
field=field_name, description=error_message)
])
status = status_pb2.Status(code=error_code.value[0],
message="validation failed",
details=[proto.pack_any(detail)])
# abort with this status
output_status = rpc_status.to_status(status)
context.abort_with_status(output_status)
else:
logger.warn(f"validation failed, {error_message}")
context.abort(code=error_code, details=error_message)
def _invalid_code_unary_unary(request, servicer_context):
rich_status = status_pb2.Status(
code=42,
message='Invalid code',
)
servicer_context.abort_with_status(rpc_status.to_status(rich_status))
def RetrainModel(self, request, context):
self.datasetPath_ = request.DatasetPath
self.n_steps_in_ = request.DaysToTrain
self.n_steps_out_ = request.DaysForecastAhead
self.n_epochs_ = request.NumberEpochs
self.n_neurons_ = request.NumberNeurons
self.attributeSelected_ = request.ForecastAttributes
if(request.DatasetPath == ""):
# self.datasetPath_ = "./Data Science_20200214.xlsx"
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No Dataset File is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.DaysToTrain == 0):
# self.n_steps_in_ = 120
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No DaysToTrain is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.DaysForecastAhead == 0):
# self.n_steps_out_ = 90
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No DaysToForecast is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.NumberEpochs == 0):
# self.n_epochs_ = 300
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No NumberEpochs is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.NumberNeurons == 0):
# self.n_neurons_ = 300
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No NumberNeurons is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
if(request.ForecastAttributes == []):
# self.attributeSelected_ = ["Shipment", "Order", "Revenue"]
error_status = status_pb2.Status(code=code_pb2.INVALID_ARGUMENT, message='No Attributes is provided.')
context.abort_with_status(rpc_status.to_status(error_status))
RetrainObj = ForecastModel(attributes=self.attributeSelected_, n_steps_in=self.n_steps_in_, n_steps_out=self.n_steps_out_, n_epochs=self.n_epochs_, n_neurons=self.n_neurons_, datasetPath=self.datasetPath_)
RetrainObj.LoadDataset()
RetrainObj.TransformDataset()
trainModelThread = threading.Thread(target=RetrainObj.TrainModel, daemon=True)
trainModelThread.start()
global PROGRESS
n = 0
while(PROGRESS < (self.n_epochs_ - 1)):
time.sleep(5)
if(PROGRESS == n):
pass
else:
n = PROGRESS
response = forecast_pb2.TrainResponse(Progress=PROGRESS)
yield response
trainModelThread.join()
RetrainObj.ValidateModel()
# Return Response
finalResponse = forecast_pb2.TrainResponse()
finalResponse.Progress = PROGRESS
finalResponse.ValidationRMSE.extend(RetrainObj.validateRMSEScore)
finalResponse.ValidationFinalError.extend(RetrainObj.validateFinalValueError)
finalResponse.ValidationValuesFilePath = os.path.realpath(RetrainObj.validateDataFilename)
finalResponse.ValidationData = (RetrainObj.validateData)
yield finalResponse
