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)