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 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