public async Task OnSnapshot_CreateKeyIterator(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("__db.snapshot.newiterator.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
var snap = peerSnapshots[snapheight];
//这里缺一个给唯一ID的方式,采用顺序编号是个临时方法
var beginkey = msgRecv.Params?["beginkey"];
var endkey = msgRecv.Params?["endkey"];
var iter = snap.CreateKeyIterator(msgRecv.Params["tableid"], beginkey, endkey);
ulong index = (UInt64)this.peerItertors.Count;
this.peerItertors[index] = iter;
msg.Params["iteratorid"] = BitConverter.GetBytes(index);
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
public async Task OnDB_UseSnapShot(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.usesnapshot.back");
msg.Params["_id"] = id;
try
{
UInt64?wantheight = msgRecv.Params.ContainsKey("snapheight") ? (UInt64?)BitConverter.ToUInt64(msgRecv.Params["snapheight"], 0) : null;
if (wantheight == null)
{
var snapshot = Program.storage.maindb.UseSnapShot();
wantheight = snapshot.DataHeight;
peerSnapshots[snapshot.DataHeight] = snapshot;
}
else
{
if (peerSnapshots.ContainsKey(wantheight.Value) == false)
{
msg.Params["_error"] = "do not have that snapheight".ToBytes_UTF8Encode();
}
}
if (msg.Params.ContainsKey("_error") == false)
{
msg.Params["snapheight"] = BitConverter.GetBytes(wantheight.Value);
}
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
SendToClient(msg);
}
public async Task OnSnapshotEXT_GetWriter(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.snapshot.getwriter.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
var snap = peerSnapshots[snapheight];
var allwriter = snap.CreateKeyFinder(StorageService.tableID_Writer);
int n = 0;
foreach (var wkey in allwriter)
{
var v = snap.GetValue(StorageService.tableID_Writer, wkey);
if (v.AsBool() == true)
{
msg.Params["writer" + n] = wkey;
n++;
}
}
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
public async Task OnPing(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_ping.back");
msg.Params["_id"] = id;
SendToClient(msg);
}
void OnUpdateDuration (SocketIOEvent e) {
Response.Duration msg = e.Deserialize<Response.Duration> ();
Debug.Log("OnUpdateDuration: " + msg.duration);
if(messageReceived != null)
messageReceived (NetMessage.Create ("UpdateDuration", msg.duration));
}
/**
* Events
*/
void OnMessage (SocketIOEvent e) {
Response.Message msg = e.Deserialize<Response.Message> ();
if (msg.key == "InstanceDataLoaded") { // Special case
Models.InstanceData ins = e.Deserialize<Models.InstanceData> ();
msg.str1 = JsonWriter.Serialize (ins);
}
if (messageReceived != null) {
messageReceived (NetMessage.Create (msg.key, msg.str1, msg.str2, msg.val));
}
}
public async Task OnSnapshotDataHeight(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.snapshot.dataheight.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
var snap = peerSnapshots[snapheight];
msg.Params["dataheight"] = BitConverter.GetBytes(snap.DataHeight);
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
SendToClient(msg);
}
public async Task OnDB_State(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.state.back");
msg.Params["_id"] = id;
msg.Params["dbopen"] = new byte[] { (byte)(Program.storage.state_DBOpen ? 1 : 0) };
if (Program.storage.state_DBOpen)
{
try
{
using (var snap = Program.storage.maindb.UseSnapShot())
{
msg.Params["height"] = BitConverter.GetBytes(snap.DataHeight);
//Console.WriteLine("dataheight=" + snap.DataHeight);
var value = snap.GetValue(AllpetDB.systemtable_info, "_magic_".ToBytes_UTF8Encode());
if (value != null)
{
msg.Params["magic"] = value.value;
}
var keys = snap.CreateKeyFinder(StorageService.tableID_Writer);
var i = 0;
foreach (byte[] keybin in keys)
{
//var key = keybin.ToString_UTF8Decode();
var iswriter = snap.GetValue(StorageService.tableID_Writer, keybin).AsBool();
if (iswriter)
{
i++;
msg.Params["writer" + i] = keybin;
//Console.WriteLine("writer:" + key);
}
}
}
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
}
else
{
msg.Params["_error"] = "db not open.".ToBytes_UTF8Encode();
}
SendToClient(msg);
}
public async Task OnSnapshotEXT_GetBlockHash(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.snapshot.getblockhash.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
var snap = peerSnapshots[snapheight];
byte[] data = snap.GetValueData(StorageService.tableID_BlockID2Hash, msgRecv.Params["blockid"]);
msg.Params["data"] = data;
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
public async Task OnSnapshot_IteratorReset(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.iterator.reset.back");
msg.Params["_id"] = id;
try
{
UInt64 iteratorid = BitConverter.ToUInt64(msgRecv.Params["iteratorid"]);
var it = peerItertors[iteratorid];
it.Reset();
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
public async Task OnSnapshot_GetTableCount(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.snapshot.gettablecount.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
var snap = peerSnapshots[snapheight];
byte[] data = BitConverter.GetBytes(snap.GetTableCount(msgRecv.Params["tableid"]));
msg.Params["count"] = data;
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
public async Task OnDB_UnuseSnapShot(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.unusesnapshot.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
bool b = peerSnapshots.TryRemove(snapheight, out ISnapShot value);
if (b)
{
value.Dispose();
}
msg.Params["remove"] = new byte[] { (byte)(b ? 1 : 0) };
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
SendToClient(msg);
}
public async Task OnSnapshot_GetTableInfo(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.snapshot.gettableinfo.back");
msg.Params["_id"] = id;
try
{
UInt64 snapheight = BitConverter.ToUInt64(msgRecv.Params["snapheight"]);
var snap = peerSnapshots[snapheight];
//此处可以优化，增加一个GetTableInfoData,不要转一次
byte[] data = snap.GetTableInfo(msgRecv.Params["tableid"]).ToBytes();
msg.Params["info"] = data;
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
public async Task OnSnapshot_IteratorNext(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.iterator.next.back");
msg.Params["_id"] = id;
try
{
UInt64 iteratorid = BitConverter.ToUInt64(msgRecv.Params["iteratorid"]);
var it = peerItertors[iteratorid];
var b = it.MoveNext();
msg.Params["movenext"] = new byte[] { (byte)(b ? 1 : 0) };
var data = it.Current;
msg.Params["data"] = data;
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
/// <summary>
/// Sends a message to all clients
/// </summary>
/// <param name="id">The message id</param>
/// <param name="str1">String information to include in the message</param>
/// <param name="str2">String information to include in the message</param>
public void ScheduleMessage(string id, string str1, string str2)
{
ScheduleMessage(NetMessage.Create(id, str1, str2));
}
// -- Public methods
/// <summary>
/// Sends a message to all clients
/// </summary>
/// <param name="id">The message id</param>
public void ScheduleMessage(string id)
{
ScheduleMessage(NetMessage.Create(id));
}
/// <summary>
/// Sends a message to all clients
/// </summary>
/// <param name="id">The message id</param>
/// <param name="str1">String information to include in the message</param>
/// <param name="str2">String information to include in the message</param>
/// <param name="val">Integer information to include in the message</param>
public void ScheduleMessage(string id, string str1, int val)
{
ScheduleMessage(NetMessage.Create(id, str1, "", val));
}
public NetMessage Process(UInt64 peerid, byte[] data)
{
using (MemoryStream ms = new MemoryStream(data))
{
NetMessage netMsg = NetMessage.Unpack(ms);
string cmd = netMsg.Cmd;
string id = netMsg.ID;
NetMessage netMsgBack;
try
{
switch (cmd)
{
case "_db.usesnapshot":
{
var snapshot = StorageService.maindb.UseSnapShot();
peerSnapshots[snapshot.DataHeight] = StorageService.maindb.UseSnapShot();
var p = new Param()
{
result = true, snapid = snapshot.DataHeight
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.disposeSnapshot":
{
ISnapShot snapshot;
peerSnapshots.TryRemove(netMsg.Param.snapid, out snapshot);
snapshot.Dispose();
var p = new Param()
{
result = true
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.CreateWriteBatch":
{
var wb = StorageService.maindb.CreateWriteBatch();
peerWriteBatch[wb.Wbid] = wb;
var p = new Param()
{
result = true, wbid = wb.Wbid
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.put":
{
IWriteBatch writeBatch = peerWriteBatch[netMsg.Param.wbid];
writeBatch.Put(netMsg.Param.tableid, netMsg.Param.key, netMsg.Param.value);
var p = new Param()
{
result = true
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.delete":
{
IWriteBatch writeBatch = peerWriteBatch[netMsg.Param.wbid];
writeBatch.Delete(netMsg.Param.tableid, netMsg.Param.key);
var p = new Param()
{
result = true
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.write":
{
IWriteBatch writeBatch = peerWriteBatch[netMsg.Param.wbid];
var p = new Param()
{
result = false
};
if (writeBatch.wbcount > 0)
{
StorageService.maindb.WriteBatch(writeBatch);
peerWriteBatch.Remove(netMsg.Param.wbid, out writeBatch);
p = new Param()
{
result = true
};
}
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.getvalue": //使用最新的snapshot 基本就是给apiserver用的
{
ISnapShot snapshot = StorageService.maindb.UseSnapShot();
var tableid = netMsg.Param.tableid;
var key = netMsg.Param.key;
var value = snapshot.GetValueData(tableid, key);
Param param = new Param();
param.snapid = snapshot.DataHeight;
param.result = true;
param.value = value;
param.key = key;
param.tableid = tableid;
netMsgBack = NetMessage.Create(cmd, param, id);
return(netMsgBack);
}
case "_db.snapshot.getvalue":
{
ISnapShot snapshot = peerSnapshots[netMsg.Param.snapid];
var tableid = netMsg.Param.tableid;
var key = netMsg.Param.key;
var value = snapshot.GetValueData(tableid, key);
Param param = new Param();
param.snapid = snapshot.DataHeight;
param.result = true;
param.value = value;
param.key = key;
param.tableid = tableid;
netMsgBack = NetMessage.Create(cmd, param, id);
return(netMsgBack);
}
case "_db.snapshot.newiterator":
{
ISnapShot snapshot = peerSnapshots[netMsg.Param.snapid];
var beginKey = netMsg.Param.key;
var endKey = netMsg.Param.value;
var tableid = netMsg.Param.tableid;
var iter = snapshot.CreateKeyIterator(tableid, beginKey, endKey);
var itid = iter.HandleID;
peerKeyIterator[itid] = iter;
var p = new Param()
{
result = true, itid = itid, snapid = netMsg.Param.snapid
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.iterator.current":
{
IKeyIterator keyIterator = peerKeyIterator[netMsg.Param.itid];
var cur = keyIterator.Current;
Param param = new Param();
param.itid = netMsg.Param.itid;
param.result = true;
param.value = cur;
netMsgBack = NetMessage.Create(cmd, param, id);
return(netMsgBack);
}
case "_db.iterator.next":
{
IKeyIterator keyIterator = peerKeyIterator[netMsg.Param.itid];
var result = keyIterator.MoveNext();
Param param = new Param();
param.itid = netMsg.Param.itid;
param.result = result;
netMsgBack = NetMessage.Create(cmd, param, id);
return(netMsgBack);
}
case "_db.iterator.seektofirst":
{
IKeyIterator keyIterator = peerKeyIterator[netMsg.Param.itid];
keyIterator.SeekToFirst();
var p = new Param()
{
result = true, itid = netMsg.Param.itid
};
netMsgBack = NetMessage.Create(cmd, p, id);
return(netMsgBack);
}
case "_db.iterator.reset":
{
IKeyIterator keyIterator = peerKeyIterator[netMsg.Param.itid];
keyIterator.Reset();
Param param = new Param();
param.result = true;
param.itid = netMsg.Param.itid;
netMsgBack = NetMessage.Create(cmd, param, id);
return(netMsgBack);
}
default:
throw new Exception("unknown msg cmd:" + netMsg.Cmd);
}
}
catch (Exception e)
{
netMsgBack = NetMessage.Create(cmd, new Param()
{
error = Encoding.UTF8.GetBytes(e.Message)
}, id);
return(netMsgBack);
}
}
}
public async Task OnDB_Write(NetMessage msgRecv, byte[] id)
{
var msg = NetMessage.Create("_db.write.back");
msg.Params["_id"] = id;
try
{
var data = msgRecv.Params["taskdata"];
var signdata = msgRecv.Params["signdata"];
var writetask = WriteTask.FromRaw(data);
if (writetask.extData?.ContainsKey("lasthash") == true)
{
var lastblockhashRecv = writetask.extData["lasthash"];
lock (dblock)
{
using (var snap = Program.storage.maindb.UseSnapShot())
{
var blockidlast = BitConverter.GetBytes((UInt64)(snap.DataHeight - 1));
byte[] taskhash = Helper.CalcHash256(data);//.Sha256.ComputeHash(data);
//不够用，还需要block高度
var lasthashFind = snap.GetValue(StorageService.tableID_BlockID2Hash, blockidlast).value;
if (Helper.BytesEquals(lastblockhashRecv, lasthashFind))
{
//数据追加处理
Action <WriteTask, byte[], IWriteBatch> afterparser = (_task, _data, _wb) =>
{
if (_wb.snapshot.DataHeight != snap.DataHeight)
{
throw new Exception("sync problem,diff snap found.");
}
_wb.Put(StorageService.tableID_BlockID2Hash, snap.DataHeightBuf, DBValue.FromValue(DBValue.Type.Bytes, taskhash));
};
//写入数据
Program.storage.maindb.Write(writetask, afterparser);
//进表
msg.Params["blockid"] = snap.DataHeightBuf;
msg.Params["blockhash"] = taskhash;
}
else
{
msg.Params["_error"] = "block hash is error".ToBytes_UTF8Encode();
}
}
}
}
else
{
msg.Params["_error"] = "no last block hash.".ToBytes_UTF8Encode();
}
}
catch (Exception err)
{
msg.Params["_error"] = err.Message.ToBytes_UTF8Encode();
}
//这个完全可以不要等待呀
SendToClient(msg);
}
/// <summary>
/// Sends a message to all clients
/// </summary>
/// <param name="id">The message id</param>
/// <param name="val">Integer information to include in the message</param>
/// <param name="bytes">byte[] information to include in the message</param>
public void ScheduleMessage(string id, int val, byte[] bytes)
{
ScheduleMessage(NetMessage.Create(id, "", "", val, bytes));
}
void GotoView(NetMessage msg)
{
Co.YieldWhileTrue(() => { return(Animating); }, () => {
Co.WaitForSeconds(0.5f, () => {
switch (msg.str1)
{
case "deck":
if (Hosting)
{
PressRadioButton("deck_list", "Civic");
}
break;
case "pot":
case "bio":
case "agenda":
case "question":
case "think_instructions":
case "pitch_instructions":
case "deliberate_instructions":
case "winner":
case "agenda_item_accept":
case "agenda_item_reject":
case "scoreboard":
PressNext();
break;
case "roles":
if (IsDecider)
{
PressButton("play");
}
break;
case "think":
if (IsDecider)
{
PressTimerButton();
}
break;
case "pitch":
if (IsDecider)
{
PressTimerButton();
}
else
{
Co.YieldWhileTrue(() => { return(Game.Views.CurrView != "extra_time"); }, () => {
GotoView(NetMessage.Create("GotoView", "extra_time"));
});
}
break;
case "extra_time":
case "extra_time_deliberate":
PressButton("decline");
break;
case "deliberate":
if (IsDecider)
{
PressTimerButton();
}
else
{
Co.YieldWhileTrue(() => { return(Game.Views.CurrView != "extra_time_deliberate"); }, () => {
GotoView(NetMessage.Create("GotoView", "extra_time_deliberate"));
});
}
break;
case "decide":
if (IsDecider)
{
PressListButton("peer_list", Game.Controller.PeerNames[0]);
PressButton("confirm");
}
break;
case "agenda_item":
if (IsDecider)
{
bool accept = Random.value > 0.5f;
if (accept)
{
PressButton("accept");
}
else
{
PressButton("reject");
}
}
break;
}
});
});
}
