/// <summary>
/// Turns result data into a rpc response
/// </summary>
/// <param name="id">Rpc request id</param>
/// <param name="serializer">Json serializer function to use for objects for the response</param>
/// <returns>Rpc response for request</returns>
public RpcResponse ToRpcResponse(RpcId id, Func <object, JToken> serializer)
{
JToken data = this.Data == null ? null : serializer(this.Data);
RpcError error = new RpcError(this.ErrorCode, this.Message, data);
return(new RpcResponse(id, error));
}
private RpcRequestParseResult(RpcId id, string?method, RpcParameters?parameters, RpcError?error)
{
this.Id = id;
this.Method = method;
this.Parameters = parameters;
this.Error = error;
}
public virtual PhpValue call(Context ctx, PhpString name, PhpArray args)
{
string responseJson = null;
try
{
// 创建ID
RpcId rpcId = new RpcId(Guid.NewGuid().ToString());
// 将List<object>或者Dictionary<string, object>隐式转换成RpcParameters
RpcParameters rpcParameters = ArrayUtil.array2collection(ctx, args);
// 构建请求
RpcRequest rpcRequest = new RpcRequest(rpcId, name.ToString(ctx), rpcParameters);
// 发送请求
RpcResponse rpcResponse = _client.SendRequestAsync(rpcRequest, "").Result;
// 获取响应
PhpValue returnJson = JsonSerialization.json_decode(ctx, new PhpString(rpcResponse.Result.ToString()), true);
return(PhpValue.Create(new PhpArray()
{
{ new IntStringKey("id"), PhpValue.Create(rpcResponse.Id.StringValue) },
{ new IntStringKey("jsonrpc"), PhpValue.Create("2.0") },
{ new IntStringKey("result"), !returnJson.IsArray ? PhpValue.FromClr(rpcResponse.Result) : returnJson },
}));
}
catch (Exception ex)
{
if (ex.InnerException is RpcClientInvalidStatusCodeException)
{
responseJson = (ex.InnerException as RpcClientInvalidStatusCodeException)?.Content;
}
}
return(String.IsNullOrEmpty(responseJson) ? PhpValue.False : JsonSerialization.json_decode(ctx, new PhpString(responseJson), true));
}
public virtual RpcRequest ToRpcRequest()
{
if (!string.IsNullOrWhiteSpace(_secret))
{
AddParam(_secret);
}
PrepareParam();
var id = new RpcId(Guid.ToString());
return(new RpcRequest(id, MethodName, _parameters));
}
public void When_writing_id_and_is_a_string_then_write_correctly()
{
var id = Autofixture.Create <int>();
var rpcId = new RpcId(id.ToString(), RpcIdKind.String);
// Act
var result = JsonConvert.SerializeObject(rpcId);
// Assert
result.Should().Be($"\"{id}\"");
}
public void ParseRequests_Valid(string json, object id, string method, object[] parameters)
{
DefaultRpcParser parser = new DefaultRpcParser(null, Options.Create(new RpcServerConfiguration()));
ParsingResult result = parser.ParseRequests(json);
Assert.NotNull(result);
Assert.Equal(1, result.RequestCount);
Assert.Single(result.Requests);
Assert.Equal(RpcId.FromObject(id), result.Requests[0].Id);
Assert.Equal(method, result.Requests[0].Method);
ParserTests.CompareParameters(parameters, result.Requests[0].Parameters);
Assert.False(result.IsBulkRequest);
}
private static void CompareId(object id, RpcId jId)
{
if (!jId.HasValue)
{
Assert.Null(id);
return;
}
if (jId.IsString)
{
Assert.Equal(id, jId.StringValue);
return;
}
id = Convert.ToDouble(id);
Assert.Equal(id, jId.NumberValue);
}
public void Test_Receive()
{
StreamBuffer buffer = new StreamBuffer(100);
InputStream inputStream = new InputStream(buffer);
OutputStream outputStream = new OutputStream(buffer);
outputStream.write((int)1);
outputStream.write((short)2);
outputStream.write("abcd");
RpcId rpcId = new RpcId(RpcController.makeRpcName("TestRpc", "rpcReceive", 3));
_rpcNetwork.handleRpc(rpcId.value, inputStream);
Assert.AreEqual(2, _rpcImpl.receiveRpcCount);
}
public override int GetHashCode()
{
int hash = 1;
if (RpcId != 0)
{
hash ^= RpcId.GetHashCode();
}
if (Status != 0)
{
hash ^= Status.GetHashCode();
}
hash ^= payloads_.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
private static void CompareId(object id, RpcId jId)
{
if (!jId.HasValue)
{
Assert.Null(id);
return;
}
switch (jId.Type)
{
case RpcIdType.Number:
id = Convert.ToDouble(id);
Assert.Equal(id, jId.NumberValue);
break;
case RpcIdType.String:
Assert.Equal(id, jId.StringValue);
break;
default:
throw new ArgumentOutOfRangeException(nameof(jId.Type));
}
}
public static void FinishedRequest(this ILogger logger, RpcId id)
{
LoggerExtensions.finishedRequest(logger, id, null);
}
public static void InvokingRequest(this ILogger logger, RpcId id)
{
LoggerExtensions.invokingRequest(logger, id, null);
}
private RpcRequestParseResult ParseResult(ref Utf8JsonReader jsonReader, Memory <byte> bytes)
{
RpcId id = default;
string? method = null;
RpcParameters?parameters = null;
string? rpcVersion = null;
try
{
if (jsonReader.TokenType == JsonTokenType.StartObject)
{
jsonReader.Read();
}
while (jsonReader.TokenType != JsonTokenType.EndObject)
{
string propertyName = jsonReader.GetString();
jsonReader.Read();
switch (propertyName)
{
case JsonRpcContants.IdPropertyName:
switch (jsonReader.TokenType)
{
case JsonTokenType.String:
id = new RpcId(jsonReader.GetString());
break;
case JsonTokenType.Number:
if (!jsonReader.TryGetInt64(out long longId))
{
var idError = new RpcError(RpcErrorCode.ParseError, "Unable to parse rpc id as an integer");
return(RpcRequestParseResult.Fail(id, idError));
}
id = new RpcId(longId);
break;
default:
var error = new RpcError(RpcErrorCode.ParseError, "Unable to parse rpc id as a string or an integer");
return(RpcRequestParseResult.Fail(id, error));
}
break;
case JsonRpcContants.VersionPropertyName:
rpcVersion = jsonReader.GetString();
break;
case JsonRpcContants.MethodPropertyName:
method = jsonReader.GetString();
break;
case JsonRpcContants.ParamsPropertyName:
RpcParameters ps;
switch (jsonReader.TokenType)
{
case JsonTokenType.StartArray:
jsonReader.Read();
var list = new List <IRpcParameter>();
while (jsonReader.TokenType != JsonTokenType.EndArray)
{
IRpcParameter parameter = this.GetParameter(ref jsonReader, bytes);
list.Add(parameter);
}
//TODO array vs list?
ps = new RpcParameters(list.ToArray());
break;
case JsonTokenType.StartObject:
jsonReader.Read();
var dict = new Dictionary <string, IRpcParameter>();
while (jsonReader.TokenType != JsonTokenType.EndObject)
{
string key = jsonReader.GetString();
jsonReader.Read();
IRpcParameter parameter = this.GetParameter(ref jsonReader, bytes);
dict.Add(key, parameter);
}
ps = new RpcParameters(dict);
break;
default:
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, "The request parameter format is invalid.")));
}
parameters = ps;
break;
}
jsonReader.Read();
}
if (string.IsNullOrWhiteSpace(method))
{
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, "The request method is required.")));
}
if (string.IsNullOrWhiteSpace(rpcVersion))
{
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, "The jsonrpc version must be specified.")));
}
if (!string.Equals(rpcVersion, "2.0", StringComparison.OrdinalIgnoreCase))
{
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, $"The jsonrpc version '{rpcVersion}' is not supported. Supported versions: '2.0'")));
}
return(RpcRequestParseResult.Success(id, method !, parameters));
}
catch (Exception ex)
{
RpcError error;
if (ex is RpcException rpcException)
{
error = rpcException.ToRpcError(this.serverConfig.Value.ShowServerExceptions);
}
else
{
error = new RpcError(RpcErrorCode.ParseError, "Failed to parse request.", ex);
}
return(RpcRequestParseResult.Fail(id, error));
}
}
/// <summary>
/// Turns result data into a rpc response
/// </summary>
/// <param name="id">Rpc request id</param>
/// <param name="serializer">Json serializer function to use for objects for the response</param>
/// <returns>Rpc response for request</returns>
public RpcResponse ToRpcResponse(RpcId id)
{
return(new RpcResponse(id, this.ReturnObject, this.ReturnObject?.GetType()));
}
public override void forward(RpcId rpcId, params object[] args)
{
this.isForwarded = true;
this.rpcId = rpcId;
this.paramCount = args.Length;
}
/// <param name="id">Request id</param>
/// <param name="error">Request error</param>
public RpcResponse(RpcId id, RpcError error) : this(id)
{
this.Error = error;
}
/// <summary>
/// Turns result data into a rpc response
/// </summary>
/// <param name="id">Rpc request id</param>
/// <param name="serializer">Json serializer function to use for objects for the response</param>
/// <returns>Rpc response for request</returns>
public RpcResponse ToRpcResponse(RpcId id, Func <object, JToken> serializer)
{
JToken jToken = this.ReturnObject == null ? null : serializer(this.ReturnObject);
return(new RpcResponse(id, jToken));
}
private RpcRequestParseResult(RpcId id, RpcRequest request, RpcError error)
{
this.Id = id;
this.Request = request;
this.Error = error;
}
public static RpcRequestParseResult Fail(RpcId id, RpcError error)
{
return(new RpcRequestParseResult(id, null, error));
}
public RpcResponse DeserializeResponse(JToken token, IDictionary <RpcId, Type> typeMap)
{
JToken?idToken = token[JsonRpcContants.IdPropertyName];
if (idToken == null)
{
throw new RpcClientParseException("Unable to parse request id.");
}
RpcId id;
switch (idToken.Type)
{
case JTokenType.Null:
id = new RpcId();
break;
case JTokenType.Integer:
id = new RpcId(idToken.Value <long>());
break;
case JTokenType.String:
case JTokenType.Guid:
id = new RpcId(idToken.Value <string>());
break;
default:
throw new RpcClientParseException("Unable to parse rpc id as string or integer.");
}
if (!typeMap.TryGetValue(id, out Type type))
{
throw new RpcClientParseException("Unable to detect result type, cannot deserialize.");
}
JToken?errorToken = token[JsonRpcContants.ErrorPropertyName];
if (errorToken != null && errorToken.HasValues)
{
int code = errorToken.Value <int>(JsonRpcContants.ErrorCodePropertyName);
string message = errorToken.Value <string>(JsonRpcContants.ErrorMessagePropertyName);
JToken?dataToken = errorToken[JsonRpcContants.ErrorDataPropertyName];
object?data = null;
if (dataToken != null)
{
if (this.errorTypes != null && this.errorTypes.TryGetValue(code, out Type errorCodeType))
{
data = dataToken.ToObject(errorCodeType);
}
else
{
data = dataToken.ToString();
}
}
var error = new RpcError(code, message, data: data);
return(new RpcResponse(id, error));
}
else
{
object?result;
if (this.jsonSerializerSettings == null)
{
result = token[JsonRpcContants.ResultPropertyName]?.ToObject(type);
}
else
{
//TODo cache serializer?
JsonSerializer serializer = JsonSerializer.Create(this.jsonSerializerSettings);
result = token[JsonRpcContants.ResultPropertyName]?.ToObject(type, serializer);
}
return(new RpcResponse(id, result));
}
}
public RpcRequest(RpcId id, string method, RpcParameters?parameters = null)
{
this.Id = id;
this.Method = method;
this.Parameters = parameters;
}
/// <summary>
/// Turns result data into a rpc response
/// </summary>
/// <param name="id">Rpc request id</param>
/// <param name="serializer">Json serializer function to use for objects for the response</param>
/// <returns>Rpc response for request</returns>
public RpcResponse ToRpcResponse(RpcId id)
{
RpcError error = new RpcError(this.ErrorCode, this.Message, this.Data);
return(new RpcResponse(id, error));
}
/// <summary>
/// Turns result data into a rpc response
/// </summary>
/// <param name="id">Rpc request id</param>
/// <param name="serializer">Json serializer function to use for objects for the response</param>
/// <returns>Rpc response for request</returns>
public RpcResponse ToRpcResponse(RpcId id)
{
return(new RpcResponse(id, this.ReturnObject));
}
public RpcResponse <T> GetResponse <T>(RpcId id)
{
return(RpcResponse <T> .FromResponse(this.responses[id]));
}
public RpcResponse(RpcId id, T result)
: base(id, result)
{
}
public RpcResponse(RpcId id, RpcError error)
: base(id, error)
{
}
/// <param name="id">Request id</param>
protected RpcResponse(RpcId id)
{
this.Id = id;
}
private RpcRequestParseResult ParseResult(JsonElement.ObjectEnumerator objectEnumerator)
{
RpcId id = default;
string? method = null;
RpcParameters?parameters = null;
string? rpcVersion = null;
try
{
foreach (JsonProperty property in objectEnumerator)
{
switch (property.Name)
{
case JsonRpcContants.IdPropertyName:
switch (property.Value.ValueKind)
{
case JsonValueKind.String:
id = new RpcId(property.Value.GetString());
break;
case JsonValueKind.Number:
if (!property.Value.TryGetInt64(out long longId))
{
var idError = new RpcError(RpcErrorCode.ParseError, "Unable to parse rpc id as an integer");
return(RpcRequestParseResult.Fail(id, idError));
}
id = new RpcId(longId);
break;
default:
var error = new RpcError(RpcErrorCode.ParseError, "Unable to parse rpc id as a string or an integer");
return(RpcRequestParseResult.Fail(id, error));
}
break;
case JsonRpcContants.VersionPropertyName:
rpcVersion = property.Value.GetString();
break;
case JsonRpcContants.MethodPropertyName:
method = property.Value.GetString();
break;
case JsonRpcContants.ParamsPropertyName:
RpcParameters ps;
switch (property.Value.ValueKind)
{
case JsonValueKind.Array:
IRpcParameter[] items = property.Value
.EnumerateArray()
.Select(this.GetParameter)
.Cast <IRpcParameter>()
.ToArray();
//TODO array vs list?
ps = new RpcParameters(items);
break;
case JsonValueKind.Object:
Dictionary <string, IRpcParameter> dict = property.Value
.EnumerateObject()
.ToDictionary(j => j.Name, j => (IRpcParameter)this.GetParameter(j.Value));
ps = new RpcParameters(dict);
break;
default:
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, "The request parameter format is invalid.")));
}
parameters = ps;
break;
}
}
if (string.IsNullOrWhiteSpace(method))
{
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, "The request method is required.")));
}
if (string.IsNullOrWhiteSpace(rpcVersion))
{
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, "The jsonrpc version must be specified.")));
}
if (!string.Equals(rpcVersion, "2.0", StringComparison.OrdinalIgnoreCase))
{
return(RpcRequestParseResult.Fail(id, new RpcError(RpcErrorCode.InvalidRequest, $"The jsonrpc version '{rpcVersion}' is not supported. Supported versions: '2.0'")));
}
return(RpcRequestParseResult.Success(id, method !, parameters));
}
catch (Exception ex)
{
RpcError error;
if (ex is RpcException rpcException)
{
error = rpcException.ToRpcError(this.serverConfig.Value.ShowServerExceptions);
}
else
{
error = new RpcError(RpcErrorCode.ParseError, "Failed to parse request.", ex);
}
return(RpcRequestParseResult.Fail(id, error));
}
}
/// <param name="id">Request id</param>
/// <param name="result">Response result object</param>
public RpcResponse(RpcId id, object?result) : this(id)
{
this.Result = result;
}
public RpcResponse DeserializeResponse(JToken token, Func <RpcId, Type> resultTypeResolver = null)
{
RpcId id = null;
JToken idToken = token[JsonRpcContants.IdPropertyName];
if (idToken == null)
{
throw new RpcClientParseException("Unable to parse request id.");
}
switch (idToken.Type)
{
case JTokenType.Null:
break;
case JTokenType.Integer:
case JTokenType.Float:
id = new RpcId(idToken.Value <double>());
break;
case JTokenType.String:
case JTokenType.Guid:
id = new RpcId(idToken.Value <string>());
break;
default:
throw new RpcClientParseException("Unable to parse rpc id as string or number.");
}
JToken errorToken = token[JsonRpcContants.ErrorPropertyName];
if (errorToken != null && errorToken.HasValues)
{
int code = errorToken.Value <int>(JsonRpcContants.ErrorCodePropertyName);
string message = errorToken.Value <string>(JsonRpcContants.ErrorMessagePropertyName);
JToken dataToken = errorToken[JsonRpcContants.ErrorDataPropertyName];
object data = null;
if (dataToken != null)
{
data = this.errorDataSerializer.Deserialize(code, dataToken.ToString());
}
var error = new RpcError(code, message, data: data);
return(new RpcResponse(id, error));
}
else
{
Type resultType = resultTypeResolver?.Invoke(id);
object result;
if (resultType == null)
{
//dont deserialize
//TODO tostring?
result = token[JsonRpcContants.ResultPropertyName].ToString();
}
else if (this.jsonSerializerSettings == null)
{
result = token[JsonRpcContants.ResultPropertyName].ToObject(resultType);
}
else
{
//TODo cache serializer?
JsonSerializer serializer = JsonSerializer.Create(this.jsonSerializerSettings);
result = token[JsonRpcContants.ResultPropertyName].ToObject(resultType, serializer);
}
return(new RpcResponse(id, result, resultType));
}
}
