async def done_caller(self, future, method_index, retdata):
# INFO_MSG("Future %i preparing to done" % method_index)
# method = self.entity_class.get_method_by_id(method_index)
method = self.entity_info.get_method(self.context_name, method_index)
_, returns = method.signature
serialized_rets = BinarySerialization(retdata)
rets = tuple()
for param_index, ret_type in enumerate(returns):
try:
ret = ret_type.deserialize(
serialized_rets.get_data()[param_index])
except SerializationError:
ERROR_MSG(
f"Failed to return result by method {method.name}, return value {param_index} invalid"
)
raise
if isinstance(ret, AsyncObj):
ret = await ret
rets += ret,
if len(rets) == 1:
rets = rets[0]
try:
future.set_result(rets)
except asyncio.InvalidStateError:
ERROR_MSG(
f"Failed to done future {future} (of method {method}), retdata: {retdata}"
)
def send_method_call(self, method_index, future_id, *args, **kwargs):
if not self:
WARN_MSG("Call to invalid mailbox %s" % self, depth=1)
return
method_info = self.entity_info.get_method(self.context_name,
method_index)
params, _ = method_info.signature
name = method_info.name
serialized_params = BinarySerialization()
for param_index, (param_name, param_type) in enumerate(params):
param = param_type.instantiate(args[param_index])
serialized_params << param.serialize()
serialized_call = BinarySerialization()
serialized_call << self.remote_id
serialized_call << Globals.generator_signature
serialized_call << method_index
serialized_call << future_id
serialized_call << Globals.access_token
serialized_call << serialized_params
message = BinarySerialization()
message << ConnectionMessageTypes.rmi_call
message << serialized_call
self.send_data(message.get_archive())
def serialize(self):
sr = BinarySerialization()
sr << str(self.get_endpoint()[0])
sr << self.get_endpoint()[1]
sr << self.get_id()
sr << self.get_context()
sr << self.get_class_name()
return sr.get_archive()
def serialize(self):
serialized = BinarySerialization()
count = len(self)
serialized << count
for index, item in enumerate(self):
if not isinstance(item, self.base):
item = self.base.instantiate(item)
serialized << item.serialize()
return serialized.get_archive()
def deserialize(cls, serialized_value):
result = cls()
serialized = BinarySerialization(serialized_value)
proxy = serialized.proxy()
for field_name, field_type in cls.fields:
ds = proxy >> bytes
value = field_type.deserialize(ds)
result[field_name] = value
return result
async def _async_UnrealEngine4_go_to(asset_path):
global EditorTCPClient
from Core.TCP.TestProtocolClient import create_connection
if EditorTCPClient is None or not is_valid(EditorTCPClient):
_, EditorTCPClient = await create_connection(("127.0.0.1", 6666), None)
bs = BinarySerialization()
bs << "open_asset"
bs << asset_path
EditorTCPClient.send(bs.get_archive())
def serialize(self):
sr = BinarySerialization()
sr << self
sr << self.key
sr << self.namespace
sr << len(self.format_values)
for value in self.format_values:
if isinstance(value, FText):
sr << TextFormatValueType.Simple
sr << str(value)
else:
sr << TextFormatValueType.Text
sr << value.serialize()
return sr.get_archive()
def deserialize(cls, serialized_value):
srp = BinarySerialization(serialized_value).proxy()
ds = srp >> str
if "::" in ds:
ds = ds.split("::")[1]
deserialized = cls(ds)
return deserialized
def serialize(self):
serialized = BinarySerialization()
for field_name, field_type in self.fields:
# if field_name.lower() in self:
# value = self.get(field_name.lower(), None)
# else:
# value = self.get(field_name, None)
if field_name in self:
value = self[field_name]
if not isinstance(value, field_type):
value = field_type.instantiate(value)
else:
value = field_type.instantiate() if field_name not in self.defaults else field_type.instantiate(self.defaults[field_name])
serialized << value.serialize()
return serialized.get_archive()
def deserialize(cls, serialized_value):
sr = BinarySerialization(serialized_value).proxy()
count = sr >> int
ds = cls()
for i in range(count):
item = cls.base.deserialize(sr >> bytes)
ds.add(item)
return ds
def serialize(self):
serialized = BinarySerialization()
count = len(self)
serialized << count
for key in self.keys():
if not isinstance(key, self.base_key):
key = self.base_key.instantiate(key)
serialized << key.serialize()
for value in self.values():
if not isinstance(value, self.base_value):
try:
value = self.base_value.instantiate(value)
except TypeError:
print(self.base_value, value)
raise
serialized << value.serialize()
return serialized.get_archive()
def replicate_value(self, value):
if not self.with_partial_replication or not value.replication_buffer:
serialized = value.serialize()
self.client.UpdateClientEntityVariable(self.entity_id, self.owner_property_name, serialized)
else:
sr = BinarySerialization()
sr << SliceReplicationDataType.Map
for rep_kind, rep_data in value.replication_buffer:
if rep_kind == SliceReplicationKind.Nop:
continue
sr << rep_kind
if rep_kind == SliceReplicationKind.Full:
sr << value.serialize()
elif rep_kind == SliceReplicationKind.Clear:
pass
elif rep_kind == SliceReplicationKind.EditEntry:
sr << value.serialize_entry(rep_data)
elif rep_kind == SliceReplicationKind.RemoveEntry:
sr << value.serialize_key(rep_data[0])
self.client.UpdateClientEntityVariableSlice(self.entity_id, self.owner_property_name, sr.get_archive())
async def load_persistents(self):
if not is_valid(self.db):
self.failed = True
return
class_name = self.__class__.__name__
serialized_data = await self.db.GetEntityData(self.dbid, class_name)
srp = BinarySerialization(serialized_data).proxy()
for prop_name, prop_info in self.properties.items():
if Persistent in prop_info.specifiers:
if not issubclass(prop_info.prop_type, BaseEntity):
prop_value = srp >> bytes
if "FDateTime" in prop_info.prop_type.__name__:
print(",,,")
deserialized = prop_info.prop_type.deserialize(prop_value)
T = prop_info.prop_type
value = T.instantiate(deserialized)
value.set_db_interface(
DatabaseVariableProxy(self.db, self.dbid, class_name,
prop_name, prop_info))
value.initialize_property(self, prop_name)
self.properties_locks[prop_name] = asyncio.Lock()
else:
prop_value = srp >> int32
value = EntitiesDispatcher().get_by_dbid(prop_value)
if value is None:
is_new_entity = False
if prop_value == 0:
prop_value = await self.db.CreateDefaultEntity(
prop_info.prop_type.__name__)
is_new_entity = True
value = await prop_info.prop_type(prop_value,
outer=self)
value.initialize_property(self, prop_name)
value.set_db_interface(
DatabaseVariableProxy(self.db, self.dbid,
class_name, prop_name,
prop_info))
if is_new_entity:
await value.on_entity_created()
if is_new_entity:
await value.async_save()
# ERROR_MSG("Lolz %s %s" % (prop_name, value))
# if issubclass(prop_info.prop_type, BaseEntity):
# if value
self.set_property_value(prop_name, value)
def deserialize(cls, serialized_value):
sr = BinarySerialization(serialized_value).proxy()
count = sr >> int
keys = list()
values = list()
for i in range(count):
item = cls.base_key.deserialize(sr >> bytes)
keys.append(item)
for i in range(count):
item = cls.base_value.deserialize(sr >> bytes)
values.append(item)
return cls({keys[i]: values[i] for i in range(count)})
async def GetEntityData(self, entity_dbid: int32, entity_class: FString) -> FBytes:
"""
Получение бинарных данных о сущности
@param entity_dbid: ДБИД сущности
@param entity_class: класс сущности
@return: сериализованные байты (по классу)
"""
properties = ConfigurationGenerator().generated_entities_info.get_by_name(entity_class).get_properties('base', only_persistent=True)
props_templ = ", ".join([f'"{key}"' for key in properties.keys()])
res = await self.driver.exec_raw(""" SELECT {0}
FROM "class_{1}"
WHERE db_id={2}; """.format(props_templ, entity_class, entity_dbid))
sr = BinarySerialization()
for data in res:
values = tuple(data.values())
for index, (prop_name, prop_data) in enumerate(properties.items()):
print(prop_name, prop_data)
T = self.find_type(prop_data.typename, BaseEntity)
value = values[index]
value = T.pg_null(value)
sr << T.serializable_value(value).serialize()
return sr.get_archive()
def deserialize(cls, serialized_value):
srp = BinarySerialization(serialized_value).proxy()
endpoint = [None, None]
try:
endpoint[0] = srp >> str
endpoint[1] = srp >> int
id = srp >> int
context = srp >> str
cls_name = srp >> str
except Exception as e:
ERROR_MSG("Failed to deserialize mailbox: %s", srp)
raise
# symbol = SymbolsRegistry().get_by_context(context, cls_name)
# return Mailbox(symbol, endpoint, id, context)
return cls.get_mailbox_class()(context, cls_name, endpoint, id)
def deserialize(cls, serialized_value):
srp = BinarySerialization(serialized_value).proxy()
text = srp >> str
key = srp >> str
namespace = srp >> str
format_values_count = srp >> int
format_values = list()
for i in range(0, format_values_count):
value_type = srp >> int
if value_type == TextFormatValueType.Simple:
serialized_value = srp >> str
value = serialized_value
elif value_type == TextFormatValueType.Text:
serialized_value = srp >> bytes
value = FText.deserialize(serialized_value)
else:
raise SerializationError("Cannot deserialize FText")
format_values.append(value)
result = FText(text)
result.init_text(namespace=namespace, key=key)
result.format_values = format_values
return result
async def handle_message(self, data):
""" Обработка входящего сообщения """
try:
message_proxy = BinarySerialization(data).proxy()
except Exception as e:
ERROR_MSG("Unable to make proxy for data %s: %s" % (data, e))
return
try:
message_type = message_proxy >> int
message_data = message_proxy >> bytes
except:
print(message_proxy)
if message_type == ConnectionMessageTypes.rmi_call:
proxy = BinarySerialization(message_data).proxy()
entity_id = proxy >> int
gen_sig = proxy >> str
method_index = proxy >> int
future_id = proxy >> int
access_token = proxy >> str
params = proxy >> bytes
if gen_sig == Globals.generator_signature:
await EntitiesDispatcher().execute_rmi(self.client_connection, entity_id, method_index, future_id, access_token, params)
else:
EntitiesDispatcher().remote_response_error(self.client_connection, entity_id, future_id, "Generator signature mismatch")
elif message_type == ConnectionMessageTypes.rmi_future:
proxy = BinarySerialization(message_data).proxy()
entity_id = proxy >> int
method_index = proxy >> int
future_id = proxy >> int
returns = proxy >> bytes
if future_id != -1:
EntitiesDispatcher().yield_rmi_result(future_id, entity_id, method_index, returns)
elif message_type == ConnectionMessageTypes.rmi_error:
proxy = BinarySerialization(message_data).proxy()
error_source = proxy >> str
error_message = proxy >> str
future_id = proxy >> int
WARN_MSG("Error from %s: %s" % (error_source, error_message))
if future_id != -1:
EntitiesDispatcher().yield_rmi_error(future_id)
elif message_type == ConnectionMessageTypes.rmi_exception:
proxy = BinarySerialization(message_data).proxy()
exception_source = proxy >> str
exception_class = proxy >> str
exception_args = proxy >> str
future_id = proxy >> int
WARN_MSG("Exception from %s: %s" % (exception_source, exception_class))
if future_id != -1:
EntitiesDispatcher().yield_rmi_exception(future_id, exception_class, exception_args)
await asyncio.sleep(0.1)
def serialize(self):
sr = BinarySerialization()
sr << self._names[int(self)]
return sr.get_archive()
def deserialize(cls, serialized_value):
srp = BinarySerialization(serialized_value).proxy()
deserialized = srp >> str
return json.loads(deserialized)
def serialize(self):
serialized = BinarySerialization()
serialized << json.dumps(self)
return serialized.get_archive()
def serialize_key(cls, key):
return BinarySerialization() << cls.base_key.serializable_value(key).serialize()
def serialize_entry(cls, key_value):
key, value = key_value
return BinarySerialization() << cls.base_key.serializable_value(key).serialize() << cls.base_value.serializable_value(value).serialize()