internal void IncomingMessage(NList message)
{
int message_id = message.Get <int>(0);
NList dispatch_msg = message.GetRange(1, message.Count - 1);
if (message_id == SystemMsg.CLIENT.ACCESS_TOKEN && !Inited)
{
string access_token = dispatch_msg.Get <string>(0);
int realm = dispatch_msg.Get <int>(1);
IAccessToken token = _ClusterClient.GetGrain <IAccessToken>(access_token);
Guid user_id = token.GetUserId().Result;
_User = _ClusterClient.GetGrain <IUser>(user_id);
long role = _User.GetRole(realm).Result;
RoleAgent = _ClusterClient.GetGrain <IRoleAgent>(role);
RoleAgent.BindSession(user_id, Protocol.ToString());
_AgentObserver = new AgentObserver(this);
var stream = _ClusterClient.GetStreamProvider(StreamProviders.AgentProvider).GetStream <NList>(user_id, Protocol.ToString());
_SubscriptionHandle = stream.SubscribeAsync(_AgentObserver).Result;
Inited = true;
OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(true));
}
else if (Inited)
{
if (RoleAgent != null)
{
RoleAgent.OnResponse(message_id, dispatch_msg);
}
}
}
public async Task <T> GetRowCol <T>(Nuid id, string table_name, long row, int col)
{
Entity entity = EntityManager.Get(id);
if (entity != null)
{
Table table = entity.GetTable(table_name);
if (table == null)
{
return(default(T));
}
return(table.GetRowCol <T>(row, col));
}
else
{
if (id.Origin == Identity)
{
NList row_value = await GetCacheRowValue(id, table_name, row);
return(row_value.Get <T>(col));
}
else
{
INode node = GrainFactory.GetGrain <INode>(id.Origin);
return(await node.GetRowCol <T>(id, table_name, row, col));
}
}
}
private async Task OnRecv_Custom(NList msg)
{
int custom_msg = msg.Get <int>(0);
NList args = msg.GetRange(1, msg.Count - 1);
await NModule.CallbackCustom(_RoleNode, _RoleId, custom_msg, args);
}
private async Task <TColValue> GetKeyCol <TColValue, TPrimaryKey>(Nuid id, string table_name, TPrimaryKey primary_key, int col)
{
if (NodeType == NodeType.Grain)
{
Entity entity = EntityManager.Get(id);
if (entity != null)
{
Table <TPrimaryKey> table = entity.GetTable(table_name) as Table <TPrimaryKey>;
if (table == null)
{
return(default(TColValue));
}
return(table.GetCol <TColValue>(primary_key, col));
}
}
else if (NodeType == NodeType.Cache)
{
NList row_value = await GetCacheTableKeyValue(id, table_name, primary_key);
return(row_value.Get <TColValue>(col));
}
return(default(TColValue));
}
private async Task SetKeyCol <TColValue, TPrimaryKey>(Nuid id, string table_name, TPrimaryKey primary_key, int col, TColValue col_value)
{
if (col_value == null)
{
_Logger.LogError($"{id} SetKeyCol {table_name} {primary_key}_{col} when col_value is null!");
return;
}
if (NodeType == NodeType.Grain)
{
Entity entity = EntityManager.Get(id);
if (entity == null)
{
_Logger.LogError($"{id} SetKeyCol {table_name} {primary_key}_{col} when Grain dont found entity!");
return;
}
Table <TPrimaryKey> table = entity.GetTable(table_name) as Table <TPrimaryKey>;
if (table == null)
{
_Logger.LogError($"{id} SetKeyCol {table_name} {primary_key}_{col} when Grain dont found field!");
return;
}
NList result;
if (!table.TrySetKeyCol(primary_key, col, col_value, out result))
{
_Logger.LogError($"{id} SetKeyCol {table_name} {primary_key}_{col} when {col_value} TrySetRowCol failed!");
return;
}
await CallbackTable(id, table_name, TableEvent.SetCol, result);
}
else if (NodeType == NodeType.Cache)
{
NList value = await GetCacheTableKeyValue(id, table_name, primary_key);
TColValue old_value = value.Get <TColValue>(col);
if (old_value.Equals(col_value))
{
_Logger.LogError($"{id} SetKeyCol {table_name} {primary_key}_{col} when new=old SetCacheRow failed!");
}
value.Set(col, col_value);
if (!await SetCacheTableKeyValue(id, table_name, primary_key, value))
{
_Logger.LogError($"{id} SetKeyCol {table_name} {primary_key}_{col} when {value} SetCacheTableKeyValue failed!");
return;
}
NList result = NList.New();
result.Add(primary_key);
result.Add(col);
result.Add(old_value);
result.Add(col_value);
await CallbackTable(id, table_name, TableEvent.SetCol, result);
}
}
public async Task SetRowCol <T>(Nuid id, string table_name, long row, int col, T value)
{
if (value == null)
{
return;
}
Entity entity = EntityManager.Get(id);
if (entity != null)
{
Table table = entity.GetTable(table_name);
if (table == null)
{
return;
}
NList result;
if (!table.TrySetRowCol(row, col, value, out result))
{
return;
}
NList row_value = table.GetRow(row);
BatchCahceList.Add(NList.New().Add((int)CacheOption.SetRow).Add(id).Add(table_name).Add(row).Add(row_value));
await CallbackTable(id, table_name, TableEvent.SetCol, result);
}
else
{
if (id.Origin == Identity)
{
NList row_value = NList.New();
NList old_value = await GetCacheRowValue(id, table_name, row);
T old_row_value = old_value.Get <T>(col);
row_value.Append(old_value);
row_value.Set(col, value);
if (await SetCacheRow(id, table_name, row, row_value))
{
NList result = NList.New();
result.Add(row);
result.Add(col);
result.Add(old_row_value);
result.Add(value);
await CallbackTable(id, table_name, TableEvent.SetCol, result);
}
}
else
{
INode node = GrainFactory.GetGrain <INode>(id.Origin);
await node.SetRowCol(id, table_name, row, col, value);
}
}
}
private async Task PushPersistTables(Entity entity)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
return;
}
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
Table[] tables = entity.GetTables();
foreach (Table table in tables)
{
var collection = database.GetCollection <BsonDocument>(table.Name);
TablePrefab table_prefab = entity_prefab.tables[table.Name];
if (table_prefab == null)
{
continue;
}
if (!table_prefab.save)
{
continue;
}
NList rows = table.GetRows();
for (int i = 0; i < rows.Count; i++)
{
long row = rows.Get <long>(i);
NList row_value = table.GetRow(row);
Dictionary <string, object> models = new Dictionary <string, object>();
models.Add(Global.MARK_ORIGIN, entity.Id.Origin);
models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
models.Add(Global.MARK_ROW, row);
for (int col = 0; col < table_prefab.cols; col++)
{
TablePrefab.ColumnPrefab column = table_prefab.columns[col];
switch (column.type)
{
case VarType.Bool:
models.Add(column.name, row_value.Get <bool>(col));
break;
case VarType.Int:
models.Add(column.name, row_value.Get <int>(col));
break;
case VarType.Float:
models.Add(column.name, row_value.Get <float>(col));
break;
case VarType.Long:
models.Add(column.name, row_value.Get <long>(col));
break;
case VarType.Time:
models.Add(column.name, row_value.Get <DateTime>(col));
break;
case VarType.Nuid:
models.Add(column.name, BsonDocument.Parse(JsonUtils.ToJson(row_value.Get <Nuid>(col))));
break;
case VarType.String:
models.Add(column.name, row_value.Get <string>(col));
break;
case VarType.List:
models.Add(column.name, BsonDocument.Parse(JsonUtils.ToJson(row_value.Get <NList>(col))));
break;
}
}
await collection.InsertOneAsync(new BsonDocument(models));
}
}
}
private async Task SavePersistEntities()
{
IReadOnlyList <Entity> entities = null;
if (NodeType == Abstractions.NodeType.Grain)
{
entities = EntityManager.GetEntities();
}
else if (NodeType == Abstractions.NodeType.Cache)
{
entities = await GetCacheEntities();
}
if (entities == null || entities.Count == 0)
{
return;
}
EntityList entity_list = new EntityList();
entity_list.entities = new List <EntityChild>();
entity_list.origin = Identity;
entity_list.node = NodeType;
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
foreach (Entity entity in entities)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
continue;
}
Dictionary <string, object> entity_models = new Dictionary <string, object>();
entity_models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
Field[] fields = entity.GetFields();
foreach (Field field in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[field.Name];
if (field_prefab == null)
{
continue;
}
if (!field_prefab.save)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
entity_models.Add(field_prefab.name, field.Get <bool>());
}
break;
case VarType.Int:
{
entity_models.Add(field_prefab.name, field.Get <int>());
}
break;
case VarType.Float:
{
entity_models.Add(field_prefab.name, field.Get <float>());
}
break;
case VarType.Long:
{
entity_models.Add(field_prefab.name, field.Get <long>());
}
break;
case VarType.Nuid:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <Nuid>()));
entity_models.Add(field_prefab.name, document);
}
break;
case VarType.String:
{
entity_models.Add(field_prefab.name, field.Get <string>());
}
break;
case VarType.List:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <NList>()));
entity_models.Add(field_prefab.name, document);
}
break;
default:
break;
}
}
Table[] tables = entity.GetTables();
foreach (Table base_table in tables)
{
BsonArray table_model = new BsonArray();
TablePrefab table_prefab = entity_prefab.tables[base_table.GetName()];
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
UpdateTableKeyValue <bool>();
}
break;
case VarType.Int:
{
UpdateTableKeyValue <int>();
}
break;
case VarType.Long:
{
UpdateTableKeyValue <long>();
}
break;
case VarType.Float:
{
UpdateTableKeyValue <float>();
}
break;
case VarType.String:
{
UpdateTableKeyValue <string>();
}
break;
case VarType.Nuid:
{
UpdateTableKeyValue <Nuid>();
}
break;
default:
break;
}
void UpdateTableKeyValue <TPrimaryKey>()
{
Table <TPrimaryKey> table = base_table as Table <TPrimaryKey>;
foreach (TPrimaryKey key in table.GetPrimaryKeys())
{
Dictionary <string, object> key_value_models = new Dictionary <string, object>();
key_value_models.Add(nameof(TablePrefab.primary_key), key);
NList key_value = table.GetKeyValue(key);
for (int col = 0; col < table_prefab.cols; col++)
{
TablePrefab.ColumnPrefab col_prefab = table_prefab.columns[col];
switch (col_prefab.type)
{
case VarType.Bool:
{
bool col_value = key_value.Get <bool>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Int:
{
int col_value = key_value.Get <int>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Long:
{
long col_value = key_value.Get <long>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Float:
{
float col_value = key_value.Get <float>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.String:
{
string col_value = key_value.Get <string>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Nuid:
{
Nuid col_value = key_value.Get <Nuid>(col);
key_value_models.Add(col_prefab.name, BsonDocument.Parse(JsonUtils.ToJson(col_value)));
}
break;
case VarType.List:
{
NList col_value = key_value.Get <NList>(col);
key_value_models.Add(col_prefab.name, BsonDocument.Parse(JsonUtils.ToJson(col_value)));
}
break;
default:
break;
}
}
table_model.Add(new BsonDocument(key_value_models));
}
}
entity_models.Add(base_table.GetName(), table_model);
}
entity_list.entities.Add(new EntityChild()
{
unique = entity.Id.Unique, type = entity.Type, entity = new BsonDocument(entity_models)
});
}
var collection = database.GetCollection <EntityList>(PersistUtils.ENTITIES);
var filter = Builders <EntityList> .Filter.And(Builders <EntityList> .Filter.Eq(n => n.origin, Identity));
EntityList found = await collection.FindOneAndReplaceAsync(filter, entity_list);
if (found == null)
{
await collection.InsertOneAsync(entity_list);
}
}
internal async Task IncomingMessage(NList message)
{
try
{
int message_id = message.Get <int>(0);
NList dispatch_msg = message.GetRange(1, message.Count - 1);
if (message_id == SystemMsg.CLIENT.ACCESS_TOKEN && !Access)
{
string access_token = dispatch_msg.Get <string>(0);
IAccessToken token = _ClusterClient.GetGrain <IAccessToken>(access_token);
Guid user_id = await token.GetUserId();
if (user_id == Guid.Empty)
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(false));
return;
}
_PlatformAccount = _ClusterClient.GetGrain <IUserAccount>(user_id);
IReadOnlyList <Role> roles = await _PlatformAccount.GetRoles();
if (roles == null)
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(false));
return;
}
Access = true;
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(true).Add(JsonConvert.SerializeObject(roles)));
}
else if (message_id == SystemMsg.CLIENT.CREATE_ROLE && Access)
{
int realm = dispatch_msg.Get <int>(0);
string json = dispatch_msg.Get <string>(1);
Role role = await _PlatformAccount.CreateRole(realm, json);
if (role != null)
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.CREATE_ROLE).Add(true).Add(JsonConvert.SerializeObject(role)));
}
else
{
await OutcomingMessage(NList.New().Add(SystemMsg.SERVER.CREATE_ROLE).Add(false));
}
}
else if (message_id == SystemMsg.CLIENT.SELECT_ROLE && Access && !Inited)
{
long role_id = dispatch_msg.Get <long>(0);
if (!await _PlatformAccount.HasRole(role_id))
{
return;
}
RoleAgent = _ClusterClient.GetGrain <IRoleAgent>(role_id);
await RoleAgent.BindSession(_PlatformAccount.GetPrimaryKey(), Protocol.ToString());
_AgentObserver = new AgentObserver(this);
var stream = _ClusterClient.GetStreamProvider(StreamProviders.AgentProvider).GetStream <NList>(_PlatformAccount.GetPrimaryKey(), Protocol.ToString());
_SubscriptionHandle = await stream.SubscribeAsync(_AgentObserver);
await RoleAgent.SendEntities();
Inited = true;
}
else if (message_id == SystemMsg.CLIENT.ONLINE && Inited)
{
if (RoleAgent != null)
{
await RoleAgent.Online();
}
}
else if (Inited)
{
if (RoleAgent != null)
{
await RoleAgent.OnResponse(message_id, dispatch_msg);
}
}
}
catch (Exception ex)
{
_Logger.LogError(ex, "IncomingMessage Failed!");
}
}
