def register_node(node_model: NodeModel) -> NodeModel: if not node_model: raise ValueError("Missing node model.") # Let the SDN know who this is. # SDN determines peers and returns full config. node_config = cast(Dict[str, Any], http_service.post_json(SdnRoutes.nodes, node_model)) logger.trace("Registered node. Response: {}", json_encoder.to_json(node_config)) if not node_config: raise EnvironmentError( "Unable to reach SDN and register this node. Please check connection." ) registered_node_model = model_loader.load_model(NodeModel, node_config) if not registered_node_model.source_version: raise ValueError( f"Source version {node_model.source_version} is no longer supported. Please upgrade to the " f"latest version") if registered_node_model.blockchain_network_num == -1: raise ValueError( f"The blockchain network number {node_model.blockchain_network_num} does not exists. Please " f"check the blockchain network startup parameters") return registered_node_model
def test_nested_model(self): model_dict = { "foo": 1, "bar": [{"foo": 1, "bar": "123", "baz": [1, 2, 3]}, {"foo": 2, "bar": 234, "baz": [5]}], "baz": {"qux": {"foo": 12, "bar": "999", "baz": []}}, } model_json = json_encoder.to_json(model_dict) dict_result = model_loader.load_model(NestedModel, model_dict) json_result = model_loader.load_model_from_json(NestedModel, model_json) self.assertEqual(dict_result, json_result) self.assertEqual(1, dict_result.foo) bar_field = dict_result.bar self.assertEqual(2, len(bar_field)) self.assertEqual(1, bar_field[0].foo) self.assertEqual("123", bar_field[0].bar) self.assertEqual([1, 2, 3], bar_field[0].baz) baz_field = dict_result.baz self.assertEqual(1, len(baz_field)) self.assertEqual(12, baz_field["qux"].foo) self.assertEqual("999", baz_field["qux"].bar) self.assertEqual([], baz_field["qux"].baz)
def test_basic_model(self): model_dict = {"foo": 1, "bar": "123", "baz": [1, 2, 3]} model_json = json_encoder.to_json(model_dict) dict_result = model_loader.load_model(BasicModel, model_dict) json_result = model_loader.load_model_from_json(BasicModel, model_json) self.assertEqual(dict_result, json_result) self.assertEqual(1, dict_result.foo) self.assertEqual("123", dict_result.bar) self.assertEqual([1, 2, 3], dict_result.baz)
def format_http_error(client_error: HTTPClientError, content_type: ContentType) -> HTTPClientError: err_msg = client_error.text code = client_error.status_code response_json = { "result": None, "error": err_msg, "code": code, "message": err_msg, } client_error.content_type = content_type.value client_error.text = json_encoder.to_json(response_json) return client_error
def test_cloud_api_account_setting(self): new_account_model = BdnAccountModelBase( "fake_id", "fake_name", "fake_cert", tx_paid=BdnQuotaServiceModelConfigBase(), block_paid=BdnQuotaServiceModelConfigBase(), cloud_api=BdnFeedServiceModelConfigBase( expire_date=str(date.today() + timedelta(days=100)), ), new_transaction_streaming=BdnFeedServiceModelConfigBase()) new_account_model_json = json_encoder.to_json(new_account_model) old_account_model = model_loader.load_model_from_json( BdnOldAccountModelBase, new_account_model_json) self.assertTrue(new_account_model.cloud_api.is_service_valid()) self.assertTrue(old_account_model.cloud_api.is_service_valid()) self.assertFalse( old_account_model.new_transaction_streaming.is_service_valid())
def test_old_account_model_to_new(self): old_account_model = BdnOldAccountModelBase( "fake_id", "fake_name", "fake_cert", tx_paid=BdnServiceModelConfigBase( expire_date=str(date.today() + timedelta(days=100)), msg_quota=BdnServiceModelBase(limit=100)), new_transaction_streaming=BdnServiceModelConfigBase( expire_date=str(date.today() + timedelta(days=100)), permit=BdnServiceModelBase()), cloud_api=BdnServiceModelConfigBase( expire_date=str(date.today() + timedelta(days=100)), permit=BdnServiceModelBase())) old_account_model_json = json_encoder.to_json(old_account_model) new_account_model = model_loader.load_model_from_json( BdnAccountModelBase, old_account_model_json) self.assertEqual( old_account_model.tx_paid.is_service_valid(), new_account_model.tx_paid.is_service_valid(), ) self.assertEqual( old_account_model.tx_paid.msg_quota.limit, new_account_model.tx_paid.msg_quota.limit, ) self.assertEqual( old_account_model.cloud_api.is_service_valid(), new_account_model.cloud_api.is_service_valid(), ) self.assertEqual( old_account_model.new_transaction_streaming.is_service_valid(), new_account_model.new_transaction_streaming.is_service_valid(), ) # new account settings are not being set to default values, the SDN most verify that the payload is valid self.assertIsNone(new_account_model.new_transaction_streaming.feed)
def to_jsons(self) -> str: return json_encoder.to_json(self.to_json())
def get_json_with_payload(endpoint: str, payload=None) -> Optional[JT]: return _http_request("GET", endpoint, False, body=json_encoder.to_json(payload), headers=constants.HTTP_HEADERS)
def delete_json(endpoint: str, payload=None) -> Optional[JT]: return _http_request("DELETE", endpoint, False, body=json_encoder.to_json(payload), headers=constants.HTTP_HEADERS)
def to_json(self, case: Case = Case.SNAKE) -> Dict[str, Any]: params = self.params if params is not None and case == Case.CAMEL: params = humps.camelize(params) return { rpc_constants.JSON_RPC_VERSION_FIELD: self.json_rpc_version, rpc_constants.JSON_RPC_REQUEST_ID: self.id, rpc_constants.JSON_RPC_METHOD: self.method_name, rpc_constants.JSON_RPC_PARAMS: params, } def to_jsons(self, case: Case = Case.SNAKE) -> str: json_dict = self.to_json(case) return json_encoder.to_json(json_dict) def to_json_bytes(self, case: Case = Case.SNAKE) -> bytes: json_dict = self.to_json(case) return orjson.dumps(json_dict) def to_json_bytes_split_serialization(self, case: Case) -> Tuple[bytes, str]: """ This method should only be called for subscription messages. No runtime checks are added for performance reasons, so please make sure that other RPC request types don't trigger this. Returns result serialized separately for caching later. """
def submit_node_event(node_event_model: NodeEventModel) -> None: node_event_model.timestamp = str(time.time()) logger.trace("Submitting event for node {0} {1}", node_event_model.node_id, json_encoder.to_json(node_event_model)) url = SdnRoutes.node_event.format(node_event_model.node_id) http_service.post_json(url, node_event_model)
def patch_json(endpoint: str, payload=None) -> Optional[JT]: return _http_request("PATCH", endpoint, body=json_encoder.to_json(payload), headers=constants.HTTP_HEADERS)