public static ReadOnlyMemory <byte> Decode(string words, out bool parityError)
{
var split = words.Split(" ", StringSplitOptions.RemoveEmptyEntries);
if (split.Length % 6 != 0)
{
throw new ArgumentException("RFC1751 works in 6 word blocks", "words");
}
parityError = false;
if (split.Length == 0)
{
return(new byte[0]);
}
var builder = new System.Buffers.ArrayBufferWriter <byte>(8);
for (int i = 0; i < split.Length; i += 6)
{
var bits = Decode(split[i], split[i + 1], split[i + 2], split[i + 3], split[i + 4], split[i + 5], out var parity);
parityError |= parity;
var span = builder.GetSpan(8);
BinaryPrimitives.WriteUInt64LittleEndian(span, bits);
builder.Advance(8);
}
return(builder.WrittenMemory);
}
protected Api()
{
jsonBuffer = new System.Buffers.ArrayBufferWriter <byte>();
var jsonOptions = new System.Text.Json.JsonWriterOptions()
{
SkipValidation = true
};
jsonWriter = new System.Text.Json.Utf8JsonWriter(jsonBuffer, jsonOptions);
}
private static T ToObject <T>(JsonElement element, JsonSerializerOptions options = null)
{
var bufferWriter = new System.Buffers.ArrayBufferWriter <byte>();
using (var writer = new Utf8JsonWriter(bufferWriter))
{
element.WriteTo(writer);
}
return(JsonSerializer.Deserialize <T>(bufferWriter.WrittenSpan, options));
}
public static async Task <Message> Deserialize(Stream stream, CancellationToken cancellationToken)
{
// TypeModel.DeserializeWithLengthPrefix does not work. We'll do it ourselves.
const int BufferCapacity = 256; // This is arbitrary.
var bufferWriter = new System.Buffers.ArrayBufferWriter <byte>();
var expectedLength = await GetMessageLength(stream, cancellationToken).ConfigureAwait(false);
while (bufferWriter.WrittenCount < expectedLength)
{
var buffer = bufferWriter.GetMemory(BufferCapacity);
var byteCount = await stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
bufferWriter.Advance(byteCount);
}
Debug.Assert(bufferWriter.WrittenCount == expectedLength, $"Expected {expectedLength}, but got {bufferWriter.WrittenCount}");
return(TypeModel.Deserialize <Message>(bufferWriter.WrittenMemory));
}
private static ReadOnlyMemory <byte> CreateJws()
{
var descriptor = new JweDescriptor(encryptionKey1, KeyManagementAlgorithm.A128KW, EncryptionAlgorithm.A128CbcHS256)
{
Payload = new JwsDescriptor(signingKey1, SignatureAlgorithm.HS256)
{
Payload = new JwtPayload
{
{ JwtClaimNames.Iat, 1500000000L },
{ JwtClaimNames.Exp, 2000000000L },
{ JwtClaimNames.Iss, "https://idp.example.com/" },
{ JwtClaimNames.Aud, "636C69656E745F6964" },
{ JwtClaimNames.Sub, "*****@*****.**" },
{ JwtClaimNames.Jti, "12345667890" }
}
}
};
var bufferWriter = new System.Buffers.ArrayBufferWriter <byte>();
var context = new EncodingContext(bufferWriter, null, 0, false);
descriptor.Encode(context);
return(bufferWriter.WrittenMemory);
}
public static object ToOutputData(DefTable table, List <Record> records, string dataType)
{
switch (dataType)
{
case "data_bin":
{
var buf = ThreadLocalTemporalByteBufPool.Alloc(1024 * 1024);
BinaryExportor.Ins.WriteList(table, records, buf);
var bytes = buf.CopyData();
ThreadLocalTemporalByteBufPool.Free(buf);
return(bytes);
}
case "data_json":
case "data_json2":
{
// data_json与data_json2格式区别在于
// data_json的map格式是 [[key1,value1],[] ..]
// data_json2的map格式是 { key1:value1, ...}
var ss = new MemoryStream();
var jsonWriter = new Utf8JsonWriter(ss, new JsonWriterOptions()
{
Indented = !table.Assembly.OutputCompactJson,
SkipValidation = false,
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All),
});
if (dataType == "data_json")
{
JsonExportor.Ins.WriteAsArray(records, jsonWriter);
}
else
{
Json2Exportor.Ins.WriteAsObject(table, records, jsonWriter);
}
jsonWriter.Flush();
return(DataUtil.StreamToBytes(ss));
}
case "data_lua":
{
var content = new StringBuilder();
switch (table.Mode)
{
case ETableMode.ONE:
{
LuaExportor.Ins.ExportTableSingleton(table, records[0], content);
break;
}
case ETableMode.MAP:
{
LuaExportor.Ins.ExportTableMap(table, records, content);
break;
}
case ETableMode.LIST:
{
LuaExportor.Ins.ExportTableList(table, records, content);
break;
}
default:
{
throw new NotSupportedException();
}
}
return(string.Join('\n', content));
}
case "data_protobuf_bin":
{
var ms = new MemoryStream();
ProtobufBinExportor.Ins.WriteList(table, records, ms);
return(DataUtil.StreamToBytes(ms));
}
case "data_protobuf_json":
{
var ss = new MemoryStream();
var jsonWriter = new Utf8JsonWriter(ss, new JsonWriterOptions()
{
Indented = !table.Assembly.OutputCompactJson,
SkipValidation = false,
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All),
});
ProtobufJsonExportor.Ins.WriteAsTable(records, jsonWriter);
jsonWriter.Flush();
return(DataUtil.StreamToBytes(ss));
}
case "data_msgpack":
{
var ms = new System.Buffers.ArrayBufferWriter <byte>();
var writer = new MessagePackWriter(ms);
MsgPackExportor.Ins.WriteList(table, records, ref writer);
writer.Flush();
return(ms.WrittenSpan.ToArray());
}
case "data_flatbuffers_json":
{
var ss = new MemoryStream();
var jsonWriter = new Utf8JsonWriter(ss, new JsonWriterOptions()
{
Indented = !table.Assembly.OutputCompactJson,
SkipValidation = false,
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All),
});
FlatBuffersJsonExportor.Ins.WriteAsTable(records, jsonWriter);
jsonWriter.Flush();
return(DataUtil.StreamToBytes(ss));
}
//case "data_erlang":
//{
// var content = new StringBuilder();
// switch (table.Mode)
// {
// case ETableMode.ONE:
// {
// ErlangExport.Ins.ExportTableSingleton(table, records[0], content);
// break;
// }
// case ETableMode.MAP:
// {
// ErlangExport.Ins.ExportTableMap(table, records, content);
// break;
// }
// default:
// {
// throw new NotSupportedException();
// }
// }
// return content.ToString();
//}
default:
{
throw new ArgumentException($"not support datatype:{dataType}");
}
}
}
private async Task ReceiveLoop()
{
var response = new System.Buffers.ArrayBufferWriter <byte>();
while (!cancellationTokenSource.IsCancellationRequested)
{
var buffer = response.GetMemory();
try
{
var result = await socket.ReceiveAsync(buffer, cancellationTokenSource.Token);
response.Advance(result.Count);
if (result.EndOfMessage)
{
var json = System.Text.Json.JsonDocument.Parse(response.WrittenMemory);
var type = json.RootElement.GetProperty("type").GetString();
if (type == "response")
{
var id = json.RootElement.GetProperty("id").GetUInt32();
var status = json.RootElement.GetProperty("status").GetString();
if (status == "success")
{
lock (responses)
{
if (responses.TryGetValue(id, out var task))
{
responses.Remove(id);
task.SetResult(json.RootElement.GetProperty("result").Clone());
}
}
}
else if (status == "error")
{
var error = json.RootElement.GetProperty("error").GetString();
var request = json.RootElement.GetProperty("request").Clone();
RippleException exception;
if (json.RootElement.TryGetProperty("error_exception", out var element))
{
exception = new RippleSubmitRequestException(error, element.GetString(), request);
}
else
{
exception = new RippleRequestException(error, request);
}
lock (responses)
{
if (responses.TryGetValue(id, out var task))
{
responses.Remove(id);
task.SetException(exception);
}
}
}
else
{
lock (responses)
{
if (responses.TryGetValue(id, out var task))
{
responses.Remove(id);
task.SetException(new NotSupportedException(string.Format("{0} not a supported status", status)));
}
}
}
}
else if (type == "path_find")
{
var id = json.RootElement.GetProperty("id").GetUInt32();
var pathFindResponse = new PathFindResponse(json.RootElement);
try
{
OnPathFind?.Invoke(this, id, pathFindResponse);
}
catch (Exception exc)
{
// TODO: We don't want user exceptions from the OnPathFind event to tear down this thread but we should bubble them up somehow.
}
}
response.Clear();
}
}
catch (TaskCanceledException taskCanceledException)
{
if (taskCanceledException.CancellationToken == cancellationTokenSource.Token)
{
// We canceled the receive, while loop will now terminate and task completes successfully
}
else
{
// Something else unexpected was cancelled, rethrow
throw;
}
}
}
socket.Dispose();
}
