public void Send()
{
var message = new RpcMessage();
controller.Send(message);
channel.Verify(c => c.Send(message));
}
internal virtual void Receive(RpcMessage message)
{
if (message.CallMessage != null)
Server.ReceiveCall(message);
else
Client.ReceiveResult(message);
}
public void ReceiveResult()
{
var message = new RpcMessage();
message.ResultMessage = new RpcMessage.Result();
controller.Receive(message);
client.Verify(c => c.ReceiveResult(message));
}
public void ReceiveCall()
{
var message = new RpcMessage();
message.CallMessage = new RpcMessage.Call();
controller.Receive(message);
server.Verify(s => s.ReceiveCall(message));
}
public void SendAndReceive()
{
var message = new RpcMessage();
channel.Send(message);
controller.Verify(c => c.Receive(message));
}
public static bool IsEquivalentTo(this RpcMessage.Call message, RpcMessage.Call otherMessage)
{
if (message.Service != otherMessage.Service|| message.Method != otherMessage.Method
|| message.ExpectsResult != otherMessage.ExpectsResult)
return false;
if (message.Parameters.Count != otherMessage.Parameters.Count)
return false;
for (int i = 0; i < message.Parameters.Count; ++i )
{
if (!message.Parameters[i].IsEquivalentTo(otherMessage.Parameters[i]))
return false;
}
return true;
}
public void Init()
{
controller = new Mock<RpcController>();
readStream = new MemoryStream();
writeStream = new MemoryStream();
testMessage = new RpcMessage();
testMessage.Id = 42;
testMessage.CallMessage = new RpcMessage.Call();
testMessage.CallMessage.Service = "testService";
testMessage.CallMessage.Method = "testMethod";
var param = new RpcMessage.Parameter();
param.ProtoParam = new byte[] { 1, 2, 3 };
testMessage.CallMessage.Parameters.Add(param);
}
public void Init()
{
controller = new Mock<RpcController>();
client = new RpcClient(controller.Object);
defaultResult = new RpcMessage();
defaultResult.ResultMessage = new RpcMessage.Result();
defaultResult.ResultMessage.CallResult = new RpcMessage.Parameter();
defaultResult.ResultMessage.CallResult.IntParam = 100;
controller.Setup(c => c.Send(It.IsAny<RpcMessage>()))
.Callback((RpcMessage m) =>
{
defaultResult.Id = m.Id;
if (m.CallMessage.ExpectsResult)
client.ReceiveResult(defaultResult);
});
}
public static bool IsEquivalentTo(this RpcMessage message, RpcMessage otherMessage)
{
if (message.Id != otherMessage.Id)
return false;
if ((message.CallMessage == null && otherMessage.CallMessage != null)
|| (message.CallMessage != null && otherMessage.CallMessage == null))
return false;
if ((message.ResultMessage == null && otherMessage.ResultMessage != null)
|| (message.ResultMessage != null && otherMessage.ResultMessage == null))
return false;
if (message.CallMessage != null)
{
if (!message.CallMessage.IsEquivalentTo(otherMessage.CallMessage))
return false;
}
if (message.ResultMessage != null)
{
if (!message.ResultMessage.IsEquivalentTo(otherMessage.ResultMessage))
return false;
}
return true;
}
public void RpcMessage()
{
// try setting value with constructor
RpcMessage message = new RpcMessage
{
netId = 42,
componentIndex = 4,
functionHash = 0xABCDEF,
payload = new ArraySegment <byte>(new byte[] { 0x01, 0x02 })
};
byte[] arr = MessagePackingTest.PackToByteArray(message);
RpcMessage fresh = MessagePackingTest.UnpackFromByteArray <RpcMessage>(arr);
Assert.That(fresh.netId, Is.EqualTo(message.netId));
Assert.That(fresh.componentIndex, Is.EqualTo(message.componentIndex));
Assert.That(fresh.functionHash, Is.EqualTo(message.functionHash));
Assert.That(fresh.payload.Count, Is.EqualTo(message.payload.Count));
for (int i = 0; i < fresh.payload.Count; ++i)
{
Assert.That(fresh.payload.Array[fresh.payload.Offset + i],
Is.EqualTo(message.payload.Array[message.payload.Offset + i]));
}
}
public static void Run()
{
Console.WriteLine("TestSprotoRpc.Run ...");
string c2s =
@".package {
type 0 : integer
session 1 : integer
}
foobar 1 {
request {
what 0 : string
}
response {
ok 0 : boolean
}
}
foo 2 {
response {
ok 0 : boolean
}
}
bar 3 {
response nil
}
blackhole 4 {
}
";
string s2c =
@".package {
type 0 : integer
session 1 : integer
}
";
SprotoMgr S2C = SprotoParser.Parse(s2c);
SprotoMgr C2S = SprotoParser.Parse(c2s);
SprotoRpc Client = new SprotoRpc(S2C, C2S);
SprotoRpc Server = new SprotoRpc(C2S, S2C);
// test proto foobar
SprotoObject request = Client.C2S.NewSprotoObject("foobar.request");
request["what"] = "foo";
RpcPackage request_package = Client.PackRequest("foobar", request, 1);
Console.WriteLine("Client request foobar: data={0},size={1}", request_package.data, request_package.size);
RpcMessage message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "foobar");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request != null);
SprotoHelper.Assert(message.request["what"] == "foo");
SprotoHelper.Assert(message.session == 1);
SprotoObject response = Client.C2S.NewSprotoObject("foobar.response");
response["ok"] = true;
RpcPackage response_package = Server.PackResponse(message.proto, response, message.session);
Console.WriteLine("Server resonse foobar: data={0},size={1}", response_package.data, response_package.size);
message = Client.UnpackMessage(response_package.data, response_package.size);
SprotoHelper.Assert(message.proto == "foobar");
SprotoHelper.Assert(message.type == "response", "not a response");
SprotoHelper.Assert(message.response != null);
SprotoHelper.Assert(message.response["ok"] == true);
SprotoHelper.Assert(message.session == 1);
// test proto foo
request_package = Client.PackRequest("foo", null, 2);
Console.WriteLine("Client request foo: data={0},size={1}", request_package.data, request_package.size);
message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "foo");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request == null); // no request data
SprotoHelper.Assert(message.session == 2);
response = Client.C2S.NewSprotoObject("foo.response");
response["ok"] = false;
response_package = Server.PackResponse(message.proto, response, message.session);
Console.WriteLine("Server resonse foo: data={0},size={1}", response_package.data, response_package.size);
message = Client.UnpackMessage(response_package.data, response_package.size);
SprotoHelper.Assert(message.proto == "foo");
SprotoHelper.Assert(message.type == "response", "not a response");
SprotoHelper.Assert(message.response != null);
SprotoHelper.Assert(message.response["ok"] == false);
SprotoHelper.Assert(message.session == 2);
// test proto bar
request_package = Client.PackRequest("bar", null, 3);
Console.WriteLine("Client request bar: data={0},size={1}", request_package.data, request_package.size);
message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "bar");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request == null); // no request data
SprotoHelper.Assert(message.session == 3);
response_package = Server.PackResponse(message.proto, null, message.session);
Console.WriteLine("Server resonse bar: data={0},size={1}", response_package.data, response_package.size);
message = Client.UnpackMessage(response_package.data, response_package.size);
SprotoHelper.Assert(message.proto == "bar");
SprotoHelper.Assert(message.type == "response", "not a response");
SprotoHelper.Assert(message.response == null); // no response data
SprotoHelper.Assert(message.session == 3);
// test proto blackhole
request_package = Client.PackRequest("blackhole", null, 0);
Console.WriteLine("Client request blackhole: data={0},size={1}", request_package.data, request_package.size);
message = Server.UnpackMessage(request_package.data, request_package.size);
SprotoHelper.Assert(message.proto == "blackhole");
SprotoHelper.Assert(message.type == "request", "not a request");
SprotoHelper.Assert(message.request == null); // no request data
SprotoHelper.Assert(message.session == 0);
// session == 0 mean: can donn't response
Client.C2S.Dump();
Console.WriteLine("TestSprotoRpc.Run ok");
}
public virtual void DoBeforeRequest(string remoteAddr, RpcMessage request)
{
RpcStatus.BeginCount(remoteAddr);
}
public void ProgramMismatch()
{
RpcMessage reply = this.GenerateProgramMismatch(this.lowVersion, this.highVersion);
reply.WriteTo(this.xdrWriter);
}
public Task <RpcMessage> Handle(byte[] body)
{
Response = RpcMessages.FromByte(body);
return(Task.FromResult(Response));
}
void listView_ItemClick(object sender, AdapterView.ItemClickEventArgs e)
{
Object listObj = _msgAdapter[e.Position];
if (listObj is RpcLogMessage)
{
LayoutInflater requestJSON = (LayoutInflater)this.Activity.GetSystemService(Context.LayoutInflaterService);
View jsonLayout = requestJSON.Inflate(Resource.Layout.consolelogpreview, null);
EditText jsonText = (EditText)jsonLayout.FindViewById(Resource.Id.consoleLogPreview_jsonContent);
RpcMessage message = ((RpcLogMessage)listObj).getMessage();
AlertDialog.Builder builder = new AlertDialog.Builder(this.Activity);
string rawJSON = "";
int corrId = -1;
string methodName = "";
jsonText.Focusable = false;
if (message is RpcRequest)
{
corrId = ((RpcRequest)message).getId();
methodName = ((RpcRequest)message).method;
}
else if (message is RpcResponse)
{
corrId = ((RpcResponse)message).getId();
methodName = ((HmiApiLib.Base.Result)((RpcResponse)message).result).method;
}
else if (message is RpcNotification)
{
methodName = ((RpcNotification)message).method;
}
else if (message is RequestNotifyMessage)
{
methodName = ((RequestNotifyMessage)message).method;
}
try
{
rawJSON = JsonConvert.SerializeObject(message, Formatting.Indented);
builder.SetTitle("Raw JSON" + (corrId != -1 ? " (Corr ID " + corrId + ")" : ""));
}
catch (Exception ex)
{
try
{
rawJSON = methodName +
" (" + message.getRpcMessageFlow().ToString().ToLower() + " " + message.getRpcMessageType().ToString().ToLower() + ")";
}
catch (Exception e1)
{
rawJSON = "Undefined";
}
}
string finalJSON = rawJSON;
jsonText.Text = finalJSON;
builder.SetView(jsonLayout);
builder.SetPositiveButton("Getters", (senderAlert, args) =>
{
string sInfo = RpcMessageGetterInfo.viewDetails(message, false, 0);
Boolean isRpcResendAllowed = false;
if (message.rpcMessageFlow == HmiApiLib.Common.Enums.RpcMessageFlow.OUTGOING)
{
isRpcResendAllowed = true;
}
showDialogWithBack("GetterInfo", sInfo, isRpcResendAllowed, builder, jsonLayout);
});
builder.SetNeutralButton("Resend", (senderAlert, args) =>
{
AppInstanceManager.Instance.sendRpc(message);
});
builder.SetNegativeButton("Cancel", (senderAlert, args) =>
{
builder.Dispose();
});
AlertDialog ad = builder.Create();
ad.Show();
Button resendRpc = ad.GetButton((int)DialogButtonType.Neutral);
if (message.rpcMessageFlow == HmiApiLib.Common.Enums.RpcMessageFlow.OUTGOING)
{
resendRpc.Enabled = true;
}
else
{
resendRpc.Enabled = false;
}
}
else if (listObj is StringLogMessage)
{
AlertDialog.Builder builder = new AlertDialog.Builder(this.Activity);
string sMessageText = ((StringLogMessage)listObj).getData();
if (sMessageText == "")
{
sMessageText = ((StringLogMessage)listObj).getMessage();
}
builder.SetMessage(sMessageText);
builder.SetPositiveButton("OK", (senderAlert, args) =>
{
builder.Dispose();
});
AlertDialog ad = builder.Create();
ad.Show();
}
}
public static bool IsEquivalentTo(this RpcMessage.Result message, RpcMessage.Result otherMessage)
{
if (!message.CallResult.IsEquivalentTo(otherMessage.CallResult))
return false;
return true;
}
private void HandleSetOK(SprotoTcpSocket client, RpcMessage message)
{
_log("set ok");
}
public static void Run()
{
string c2s =
@"
.package {
type 0 : integer
session 1 : integer
}
.Person {
id 0 : integer # int type
name 1 : string # string type
age 2 : integer # int type
isman 3 : boolean # bool type
emails 4 : *string # string list
children 5 : *Person # Person list
luckydays 6 : *integer # integer list
}
get 1 {
request {
id 0 : integer
}
response Person
}
";
string s2c =
@"
.package {
type 0 : integer
session 1 : integer
}
";
SprotoMgr S2C = SprotoParser.Parse(s2c);
SprotoMgr C2S = SprotoParser.Parse(c2s);
SprotoRpc Client = new SprotoRpc(S2C, C2S);
SprotoRpc Server = new SprotoRpc(C2S, S2C);
// create a request
SprotoObject request = Client.C2S.NewSprotoObject("get.request");
request["id"] = 1;
RpcPackage request_package = Client.PackRequest("get", request, 1);
RpcMessage message = Server.UnpackMessage(request_package.data, request_package.size);
// create a response
//SprotoObject response = Client.C2S.NewSprotoObject("Person");
SprotoObject response = Server.S2C.NewSprotoObject("Person");
response["id"] = 1;
response["name"] = "sundream";
response["age"] = 26;
response["emails"] = new List <string> {
"*****@*****.**",
};
//List<SprotoObject> children = new List<SprotoObject>();
// no children
//response["children"] = children;
response["luckydays"] = new List <Int64> {
0, 6
};
RpcPackage response_package = Server.PackResponse("get", response, 1);
message = Client.UnpackMessage(response_package.data, response_package.size);
Console.WriteLine("proto={0},tag={1},ud={2},session={3},type={4},request={5},response={6}",
message.proto, message.tag, message.ud, message.session, message.type, message.request, message.response);
}
/// <summary>
/// Handles a message which has been received. Can be called by multiple threads concurrently, it is up to the
/// RpcClient and RpcServer to ensure they are thread-safe.
/// </summary>
/// <returns></returns>
protected void Receive(RpcMessage message)
{
controller.Receive(message);
}
private static bool IsSquareParamArrayCorrect(RpcMessage.Parameter[] parameters)
{
if (parameters.Length != 1)
return false;
if (parameters[0].IntParam != 10)
return false;
return true;
}
/// <summary>
/// Runs the sending operations in a loop, as long as the websocket is open.
/// It is sending both the results from remote calls and its own calls.
/// It also handles closing requests from this side (triggered by calling <see cref="Stop"/>).
/// </summary>
private async Task SendLoop()
{
try {
var messagePart = new StringBuilder();
while (connection.IsOpen())
{
bool didSomething = false;
// Result in the queue? Then send it.
if (resultsQueue.TryDequeue(out var queuedResult))
{
Log.Trace($"Sending result {queuedResult.MethodID} to {RemotePeer}");
await connection.Send(RpcMessage.Encode(queuedResult), cancellationToken.Token);
didSomething = true;
}
// Current call ran into a timeout?
if (currentCall != null && currentCall.Result == null &&
currentCall.StartTime + GetTimeoutMs(currentCall) < TimeNowMs())
{
currentCall.Result = RpcResult.Timeout(currentCall.Method.ID);
}
// Current call finished?
if (currentCall != null && currentCall.Result is RpcResult result)
{
string logMsg = $"Method {currentCall.Method.ID} {currentCall.Method.Name} finished " +
(result.Failure != null ? "with failure " + result.Failure?.Type : "successfully");
if (result.IsRetryNeeded() && currentCall.IsRetryable())
{
Log.Trace(logMsg + ", trying it again");
currentCall.ResetStartTimeAndResult();
}
else
{
var discarded = await callsQueue.Dequeue();
Log.Trace(logMsg + $", dequeuing [{discarded?.Method.ID}]");
}
if (result.Failure?.Type == RpcFailureType.Timeout)
{
// When we receive a timeout, we immediately close the connection.
// Maybe the connection does not exist any more, although the network lib thinks that it exists.
// We experienced this problem when the router switched routes, e.g. from LAN to mobile net
Log.Info("Closing connection because of timeout");
cancellationToken.Cancel();
await connection.Close();
break;
}
if (openCalls.TryGetValue(result.MethodID, out var callExecution))
{
callExecution.Finish(result);
}
currentCall = null; // Take next call from queue
}
// Next call already queued? Then see if we can send it already.
if (currentCall == null && await callsQueue.Peek() is RpcCall call)
{
// Send it. Do not dequeue it yet, only after is has been finished.
var method = RpcMessage.Encode(call.Method);
Log.Trace($"Sending method {call.Method.ID} {call.Method.Name} to {RemotePeer}, {method.Data.Length} bytes");
currentCall = call;
await connection.Send(method, cancellationToken.Token);
didSomething = true;
}
// Close nicely, when locally requested
if (cancellationToken.IsCancellationRequested)
{
await connection.Close();
didSomething = true;
}
// When we had something to do, immediately continue. Otherwise, wait a short moment
// or until we get notified that the next item is here
if (false == didSomething)
{
sendingWaiter = CreateAsyncTaskCompletionSource <bool>(); // async continuation is crucial
await Task.WhenAny(Task.Delay(100), sendingWaiter.Task);
}
}
Log.Debug($"SendLoop: Connection to {RemotePeer} closed.");
} catch (Exception ex) {
Log.Debug($"Unexpectedly closed connection to {RemotePeer}: {ex.Message}");
}
}
public abstract byte[] Serialize(RpcMessage msg);
public static bool IsEquivalentTo(this RpcMessage.Parameter message, RpcMessage.Parameter otherMessage)
{
if (!message.ProtoParam.SequenceEqual(otherMessage.ProtoParam))
return false;
return true;
}
internal abstract void Send(RpcMessage message);
internal virtual void Send(RpcMessage message)
{
Channel.Send(message);
}
public void Decode_RpcResult_Success()
{
var actual = RpcMessage.FromData(testResultSuccessBytes).DecodeRpcResult();
Assert.AreEqual(testResultSuccess, actual);
}
internal abstract void Send(RpcMessage message);
public void Init()
{
controller = new Mock<RpcController>();
squareCallMessage = new RpcMessage();
squareCallMessage.Id = 42;
squareCallMessage.CallMessage = new RpcMessage.Call();
squareCallMessage.CallMessage.Service = "ISampleService";
squareCallMessage.CallMessage.Method = "GetSquare";
squareCallMessage.CallMessage.ExpectsResult = true;
squareCallMessage.CallMessage.Parameters.Add(new RpcMessage.Parameter { IntParam = 5 });
doStuffCallMessage = new RpcMessage();
doStuffCallMessage.Id = 43;
doStuffCallMessage.CallMessage = new RpcMessage.Call();
doStuffCallMessage.CallMessage.Service = "ISampleService";
doStuffCallMessage.CallMessage.Method = "DoStuff";
doStuffCallMessage.CallMessage.Parameters.Add(new RpcMessage.Parameter { StringParam = "Hello" });
testParamCallMessage = new RpcMessage();
testParamCallMessage.Id = 44;
testParamCallMessage.CallMessage = new RpcMessage.Call();
testParamCallMessage.CallMessage.Service = "ISampleService";
testParamCallMessage.CallMessage.ExpectsResult = true;
server = new RpcServer(controller.Object);
sampleService = new SampleService();
server.RegisterService(sampleService);
}
private void AnRpcMessageIsSent()
{
_messageText = Guid.NewGuid().ToString();
_response = _client.RpcExec(_queueName, _messageText).Result;
}
private bool IsDoStuffResultMessageCorrect(RpcMessage message)
{
if (message == null || message.Id != doStuffCallMessage.Id || message.ResultMessage == null)
return false;
if (message.ResultMessage.IsFailed)
return false;
if (message.ResultMessage.CallResult != null)
return false;
return true;
}
private void HandleHandshake(SprotoTcpSocket client, RpcMessage message)
{
_log(message.response["msg"]);
}
private bool IsFailureResultMessage(RpcMessage message)
{
if (message == null || message.Id != squareCallMessage.Id || message.ResultMessage == null)
return false;
if (!message.ResultMessage.IsFailed)
return false;
return true;
}
public void Encode_RpcResult_Success()
{
byte[] actual = RpcMessage.Encode(testResultSuccess).Data;
CollectionAssert.AreEqual(testResultSuccessBytes, actual);
}
private bool IsSquareResultMessageCorrect(RpcMessage message)
{
if (message == null || message.Id != squareCallMessage.Id || message.ResultMessage == null)
return false;
if (message.ResultMessage.IsFailed || message.ResultMessage.CallResult == null)
return false;
if (message.ResultMessage.CallResult.IntParam != 25)
return false;
return true;
}
public void Fire(RpcMessage message)
{
//Client.Log($"Fire: \"{message.Event}\" with {message.Payloads.Count} payload(s):");
BaseScript.TriggerServerEvent(message.Event, message.Build());
}
private bool IsTestParamResultMessageCorrect(RpcMessage message)
{
if (message == null || message.Id != testParamCallMessage.Id || message.ResultMessage == null)
return false;
if (message.ResultMessage.IsFailed || message.ResultMessage.CallResult == null)
return false;
return true;
}
public async Task Send(RpcMessage message, CancellationToken cancellationToken) =>
await webSocket.SendAsync(new ArraySegment <byte>(message.Data),
WebSocketMessageType.Binary, endOfMessage : true, cancellationToken);
private bool IsTestProtoParamResultMessageCorrect(RpcMessage message)
{
if (message == null || message.Id != testParamCallMessage.Id || message.ResultMessage == null)
return false;
if (message.ResultMessage.IsFailed || message.ResultMessage.CallResult == null)
return false;
var memStream = new MemoryStream(message.ResultMessage.CallResult.ProtoParam);
MultiplyOutput output = ProtoBuf.Serializer.Deserialize<MultiplyOutput>(memStream);
if (output.ResultNumber != 42 || output.ResultString != "Answer is 42")
return false;
return true;
}
public void ProcedureUnavailable()
{
RpcMessage reply = this.GenerateReply(AcceptStatus.ProcedureUnavailable);
reply.WriteTo(this.xdrWriter);
}
public async Task Run()
{
while (true)
{
lock (outerInstance.mergeLock)
{
try
{
Monitor.Wait(outerInstance.mergeLock, TimeSpan.FromMilliseconds(MAX_MERGE_SEND_MILLS));
}
catch (Exception)
{
}
}
outerInstance.isSending = true;
// send batch message is sync request, but there is no need to get the return value.
// Since the messageFuture has been created before the message is placed in basketMap,
// the return value will be obtained in ClientOnResponseProcessor.
// fast fail
foreach (var item in outerInstance.basketMap)
{
var address = item.Key;
if (item.Value.Count <= 0)
{
return;
}
var mergeMessage = new MergedWarpMessage();
while (item.Value.Count > 0)
{
RpcMessage msg = item.Value.Take();
mergeMessage.msgs.Add((AbstractMessage)msg.Body);
mergeMessage.msgIds.Add(msg.Id);
}
if (mergeMessage.msgIds.Count > 1)
{
PrintMergeMessageLog(mergeMessage);
}
IChannel sendChannel = null;
try
{
sendChannel = await outerInstance.clientChannelManager.AcquireChannel(address);
await outerInstance.SendAsyncRequest(sendChannel, mergeMessage);
}
catch (FrameworkException e)
{
if (e.Errcode == FrameworkErrorCode.ChannelIsNotWritable && sendChannel != null)
{
await outerInstance.DestroyChannel(address, sendChannel);
}
foreach (int msgId in mergeMessage.msgIds)
{
if (outerInstance._futures.TryRemove(msgId, out MessageFuture messageFuture) && messageFuture != null)
{
messageFuture.ResultMessage = null;
}
}
Logger().LogError(e, $"client merge call failed: {e.Message}");
}
}
outerInstance.isSending = false;
}
}
public virtual async Task Process(IChannelHandlerContext ctx, RpcMessage rpcMessage)
{
await OnRegTmMessage(ctx, rpcMessage);
}
internal override void Send(RpcMessage message)
{
Receive(message);
}
public virtual void DoAfterResponse(string remoteAddr, RpcMessage request, object response)
{
RpcStatus.EndCount(remoteAddr);
}
internal override void Send(RpcMessage message)
{
Receive(message);
}
public object DecodeFrame(IByteBuffer frame)
{
byte b0 = frame.ReadByte();
byte b1 = frame.ReadByte();
if (ProtocolConstants.MAGIC_CODE_BYTES[0] != b0 ||
ProtocolConstants.MAGIC_CODE_BYTES[1] != b1)
{
throw new ArgumentException("Unknown magic code: " + b0 + ", " + b1);
}
byte version = frame.ReadByte();
// TODO check version compatible here
int fullLength = frame.ReadInt();
short headLength = frame.ReadShort();
byte messageType = frame.ReadByte();
byte codecType = frame.ReadByte();
byte compressorType = frame.ReadByte();
int requestId = frame.ReadInt();
var rpcMessage = new RpcMessage
{
Id = requestId,
Codec = codecType,
Compressor = compressorType,
MessageType = messageType
};
// direct read head with zero-copy
int headMapLength = headLength - ProtocolConstants.V1_HEAD_LENGTH;
if (headMapLength > 0)
{
var map = HeadMapSerializer.getInstance().Decode(frame, headMapLength);
rpcMessage.HeadMap.PutAll(map);
}
// read body
if (messageType == ProtocolConstants.MSGTYPE_HEARTBEAT_REQUEST)
{
rpcMessage.Body = HeartbeatMessage.PING;
}
else if (messageType == ProtocolConstants.MSGTYPE_HEARTBEAT_RESPONSE)
{
rpcMessage.Body = HeartbeatMessage.PONG;
}
else
{
int bodyLength = fullLength - headLength;
if (bodyLength > 0)
{
byte[] bs = new byte[bodyLength];
frame.ReadBytes(bs);
ICompressor compressor = CompressorFactory.GetCompressor(compressorType);
bs = compressor.Decompress(bs);
ISerializer serializer = EnhancedServiceLoader.Load <ISerializer>(((SerializerType)rpcMessage.Codec).ToString());
rpcMessage.Body = serializer.Deserialize <AbstractMessage>(bs);
}
}
if (Logger().IsEnabled(LogLevel.Debug))
{
Logger().LogDebug(rpcMessage.ToString());
}
return(rpcMessage);
}
protected bool HandleRemoteMessage(TChannel channel, byte[] data, RpcMessage msg)
{
switch (msg.Type)
{
case RpcMessageType.CallMethod:
{
Exception resultException = null;
RpcCallResultMessage resultMessage;
IRpcServerContextObject remoteRpcServerContextObject = null;
var m = msg as RpcMethodCallMessage ?? Serializer.DeserializeMessage <RpcMethodCallMessage>(data);
try
{
LogTrace($"Received method call '{m.MethodName}' with instance id '{m.InstanceId}'");
var obj = LocalRepository.GetInstance(m.InstanceId);
MethodInfo targetMethod;
try
{
targetMethod = obj.GetType().GetMethod(m.MethodName,
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
}
catch (AmbiguousMatchException)
{
targetMethod = obj.GetType()
.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
.SingleOrDefault(fm =>
fm.Name == m.MethodName && fm.GetParameters().Length == m.Arguments.Length);
}
if (targetMethod == null)
{
targetMethod = FindExplicitInterfaceImplementation(obj.GetType(), m.MethodName);
}
if (targetMethod == null)
{
throw new MissingMethodException(obj.GetType().FullName, m.MethodName);
}
LogTrace($"Resolved method '{targetMethod}' on object '{obj.GetType()}'");
var targetParameterTypes = targetMethod.GetParameters().Select(p => p.ParameterType).ToArray();
var args = new object[m.Arguments.Length];
var remoteRepository = GetRemoteRepository(channel);
var rpcChannel = GetRpcChannelForClient(channel);
for (int i = 0; i < m.Arguments.Length; i++)
{
args[i] = MessageFactory.DecodeRpcArgument(rpcChannel, LocalRepository, remoteRepository,
Serializer, m.Arguments[i], targetParameterTypes[i]);
}
remoteRpcServerContextObject = obj as IRpcServerContextObject;
if (remoteRpcServerContextObject != null)
{
LogTrace($"Object {m.InstanceId} implements IRpcServerContextObject, setting context");
remoteRpcServerContextObject.RpcChannel = channel;
}
var result = targetMethod.Invoke(obj, args);
LogTrace("Method called without exception.");
resultMessage = MessageFactory.CreateCallResultMessage(channel, LocalRepository, m, targetMethod, result);
}
catch (TargetInvocationException ex)
{
LogTrace($"Method call resulted in exception: {ex}");
resultException = ex.InnerException;
resultMessage = MessageFactory.CreateExceptionResultMessage(m, ex.InnerException);
}
catch (Exception ex)
{
_logger?.LogError($"Failed to process message call: {ex}");
resultException = ex;
resultMessage = MessageFactory.CreateExceptionResultMessage(m, ex);
}
finally
{
if (remoteRpcServerContextObject != null)
{
LogTrace($"Object {m.InstanceId} implements IRpcServerContextObject, removing context");
remoteRpcServerContextObject.RpcChannel = null;
}
}
LogTrace("Serializing response.");
byte[] response;
try
{
response = Serializer.SerializeMessage(resultMessage);
}
catch (Exception ex)
{
if (resultMessage.Type == RpcMessageType.Exception)
{
_logger?.LogError(ex, $"Failed to serialize result exception of type '{resultException?.GetType()}'");
// if the exception is not serializable, do our best
resultMessage = MessageFactory.CreateExceptionResultMessage(m,
new Exception(resultException?.Message ?? "Internal Error"));
response = Serializer.SerializeMessage(resultMessage);
}
else
{
throw;
}
}
LogTrace("Sending response.");
SendMessage(channel.GetStream(), response);
LogTrace("Sent response");
return(true);
}
case RpcMessageType.RemoveInstance:
{
var m = Serializer.DeserializeMessage <RpcRemoveInstanceMessage>(data);
LogTrace($"Removing instance '{m.InstanceId}'");
LocalRepository.RemoveInstance(m.InstanceId);
var response = Serializer.SerializeMessage(new RpcMessage
{
CallId = m.CallId,
Type = RpcMessageType.Ok
});
SendMessage(channel.GetStream(), response);
return(true);
}
}
return(false);
}
public override View GetView(int position, View convertView, ViewGroup parent)
{
ViewHolder holder = null;
TextView lblTop = null;
TextView lblBottom = null;
TextView lblTime = null;
ViewGroup rowView = (ViewGroup)convertView;
if (rowView == null)
{
rowView = (ViewGroup)vi.Inflate(Resource.Layout.row, null);
lblTop = (TextView)rowView.FindViewById(Resource.Id.toptext);
lblBottom = (TextView)rowView.FindViewById(Resource.Id.bottomtext);
lblTime = (TextView)rowView.FindViewById(Resource.Id.text_date_time);
holder = new ViewHolder();
holder.lblTop = lblTop;
holder.lblBottom = lblBottom;
holder.lblTime = lblTime;
rowView.Tag = holder;
}
else
{
holder = rowView.Tag as ViewHolder;
lblTop = holder.lblTop;
lblBottom = holder.lblBottom;
lblTime = holder.lblTime;
lblBottom.Visibility = ViewStates.Visible;
lblBottom.Text = "";
lblTop.SetTextColor(rowView.Context.Resources.GetColor(
Resource.Color.log_regular_text_color));
lblTop.Text = "";
}
LogMessage rpcObj = items[position];
if (rpcObj != null)
{
lblBottom.Visibility = ViewStates.Gone;
if (rpcObj is StringLogMessage)
{
StringLogMessage myStringLog = (StringLogMessage)rpcObj;
lblTop.Text = myStringLog.getMessage();
lblTime.Text = rpcObj.getDate();
lblTop.SetTextColor(Color.Black);
}
else if (rpcObj is RpcLogMessage)
{
RpcMessage func = ((RpcLogMessage)rpcObj).getMessage();
if (func.getRpcMessageType() == RpcMessageType.REQUEST)
{
lblTop.SetTextColor(ContextCompat.GetColorStateList(rowView.Context, Resource.Color.log_request_text_color));
lblTop.Text = rpcObj.getPrependComment() + ((RpcRequest)func).method + " (" + func.getRpcMessageFlow().ToString().ToLower() + " " + func.getRpcMessageType().ToString().ToLower() + ")";
}
else if (func.getRpcMessageType() == RpcMessageType.RESPONSE)
{
lblBottom.Visibility = ViewStates.Visible;
HmiApiLib.Common.Enums.Result resultCode = (HmiApiLib.Common.Enums.Result)((HmiApiLib.Base.Result)((RpcResponse)func).result).code;
lblTop.Text = rpcObj.getPrependComment() + ((HmiApiLib.Base.Result)((RpcResponse)func).result).method + " (" + func.getRpcMessageFlow().ToString().ToLower() + " " + func.getRpcMessageType().ToString().ToLower() + ")";
if ((resultCode == HmiApiLib.Common.Enums.Result.SUCCESS) ||
(resultCode == HmiApiLib.Common.Enums.Result.WARNINGS))
{
lblTop.SetTextColor(ContextCompat.GetColorStateList(rowView.Context, Resource.Color.log_response_success_text_color));
lblBottom.SetTextColor(ContextCompat.GetColorStateList(rowView.Context, Resource.Color.log_response_success_text_color));
}
else
{
lblTop.SetTextColor(ContextCompat.GetColorStateList(rowView.Context, Resource.Color.log_response_failure_text_color));
lblBottom.SetTextColor(ContextCompat.GetColorStateList(rowView.Context, Resource.Color.log_response_failure_text_color));
}
lblBottom.Text = (resultCode).ToString();
}
else if ((func.getRpcMessageType() == RpcMessageType.NOTIFICATION) || (func.getRpcMessageType() == RpcMessageType.REQUEST_NOTIFY))
{
if (func.getRpcMessageType() == RpcMessageType.NOTIFICATION)
{
lblTop.Text = rpcObj.getPrependComment() + ((RpcNotification)func).method + " (" + func.getRpcMessageFlow().ToString().ToLower() + " " + func.getRpcMessageType().ToString().ToLower() + ")";
}
else
{
lblTop.Text = rpcObj.getPrependComment() + ((RequestNotifyMessage)func).method + " (" + func.getRpcMessageFlow().ToString().ToLower() + " " + func.getRpcMessageType().ToString().ToLower() + ")";
}
lblTop.SetTextColor(ContextCompat.GetColorStateList(rowView.Context, Resource.Color.log_notification_text_color));
}
lblTime.Text = rpcObj.getDate();
}
}
return(rowView);
}
protected bool HandleReceivedData(byte[] data, RpcMessage msg)
{
return(HandleRemoteMessage(TransportChannel, data, msg));
}
/// <summary>
/// Handles a message which has been received. Can be called by multiple threads concurrently, it is up to the
/// RpcClient and RpcServer to ensure they are thread-safe.
/// </summary>
/// <returns></returns>
protected void Receive(RpcMessage message)
{
controller.Receive(message);
}
// timeout - msec , 0 means waiting infinitely
public string echo(string text, int timeout, Dictionary <string, string> props)
{
bool r_1 = false;
RpcMessage m_2 = new RpcMessage(RpcMessage.CALL);
m_2.ifidx = 2;
m_2.opidx = 0;
m_2.paramsize = 1;
m_2.extra.setProperties(props);
try{
MemoryStream bos_3 = new MemoryStream();
BinaryWriter dos_4 = new BinaryWriter(bos_3);
RpcBinarySerializer.writeString(text, dos_4);
m_2.paramstream = bos_3.ToArray();
m_2.prx = this;
}catch (Exception e) {
RpcCommunicator.instance().logger.error(e.ToString());
throw new RpcException(RpcException.RPCERROR_DATADIRTY, e.ToString());
}
r_1 = this.conn.sendMessage(m_2);
if (!r_1)
{
throw new RpcException(RpcException.RPCERROR_SENDFAILED);
}
bool _rc_5 = false;
try{
if (timeout > 0)
{
_rc_5 = m_2.ev.WaitOne(timeout);
}
else
{
_rc_5 = m_2.ev.WaitOne(RpcCommunicator.instance().getProperty_DefaultCallWaitTime());
}
}catch (Exception e) {
RpcCommunicator.instance().logger.error(e.ToString());
throw new RpcException(RpcException.RPCERROR_INTERNAL_EXCEPTION, e.ToString());
}
if (_rc_5 == false)
{
throw new RpcException(RpcException.RPCERROR_TIMEOUT);
}
if (m_2.errcode != RpcException.RPCERROR_SUCC)
{
throw new RpcException(m_2.errcode);
}
if (m_2.result == null)
{
throw new RpcException(RpcException.RPCERROR_TIMEOUT, "response is null");
}
string b_6 = "";
try{
RpcMessage m2_7 = (RpcMessage)m_2.result;
MemoryStream d_8 = new MemoryStream(m2_7.paramstream);
BinaryReader _reader_9 = new BinaryReader(d_8);
b_6 = RpcBinarySerializer.readString(_reader_9);
}catch (Exception e) {
RpcCommunicator.instance().logger.error(e.ToString());
throw new RpcException(RpcException.RPCERROR_DATADIRTY);
}
return(b_6); //regardless if unmarshalling is okay
}
public static bool OnCreateContract(JToken id, string method, JArray parameters, out JToken result)
{
result = new JObject();
if (parameters == null || parameters.Count != 2)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, "Invalid parameters");
return(false);
}
try
{
IMessage contract = null;
ContractType contract_type = (ContractType)parameters[0].ToObject <int>();
switch (contract_type)
{
case ContractType.AccountCreateContract:
contract = AccountCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.TransferContract:
contract = TransferContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.TransferAssetContract:
contract = TransferAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.VoteAssetContract:
contract = VoteAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.VoteWitnessContract:
contract = VoteWitnessContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.WitnessCreateContract:
contract = WitnessCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.AssetIssueContract:
contract = AssetIssueContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.WitnessUpdateContract:
contract = WitnessUpdateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ParticipateAssetIssueContract:
contract = ParticipateAssetIssueContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.AccountUpdateContract:
contract = AccountUpdateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.FreezeBalanceContract:
contract = FreezeBalanceContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UnfreezeBalanceContract:
contract = UnfreezeBalanceContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.WithdrawBalanceContract:
contract = WithdrawBalanceContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UnfreezeAssetContract:
contract = UnfreezeAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UpdateAssetContract:
contract = UpdateAssetContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ProposalCreateContract:
contract = ProposalCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ProposalApproveContract:
contract = ProposalApproveContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ProposalDeleteContract:
contract = ProposalDeleteContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.SetAccountIdContract:
contract = SetAccountIdContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.CreateSmartContract:
contract = CreateSmartContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.TriggerSmartContract:
contract = TriggerSmartContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UpdateSettingContract:
contract = UpdateSettingContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeCreateContract:
contract = ExchangeCreateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeInjectContract:
contract = ExchangeInjectContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeWithdrawContract:
contract = ExchangeWithdrawContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.ExchangeTransactionContract:
contract = ExchangeTransactionContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.UpdateEnergyLimitContract:
contract = UpdateEnergyLimitContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.AccountPermissionUpdateContract:
contract = AccountPermissionUpdateContract.Parser.ParseFrom(parameters[1].ToObject <byte[]>());
break;
case ContractType.CustomContract:
case ContractType.GetContract:
case ContractType.ClearAbicontract:
default:
break;
}
TransactionExtention transaction_extention = RpcApiService.CreateTransactionExtention(contract, contract_type);
result = JToken.FromObject(transaction_extention.ToByteArray());
}
catch (System.Exception e)
{
result = RpcMessage.CreateErrorResult(id, RpcMessage.INVALID_PARAMS, e.Message);
return(false);
}
return(true);
}
internal virtual void Send(RpcMessage message)
{
Channel.Send(message);
}
