/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList <IMessage> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Owner as IExtend;
var pc = ss["Codec"] as PacketCodec;
if (pc == null)
{
ss["Codec"] = pc = new PacketCodec {
GetLength = DefaultMessage.GetLength
}
}
;
var pks = pc.Parse(pk);
var list = pks.Select(e =>
{
var msg = new DefaultMessage();
if (!msg.Read(e))
{
return(null);
}
return(msg as IMessage);
}).ToList();
return(list);
}
/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList <IMessage> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Owner as IExtend;
if (ss["Codec"] is not PacketCodec pc)
{
ss["Codec"] = pc = new PacketCodec
{
GetLength = DefaultMessage.GetLength,
Tracer = (context.Owner as ISocket)?.Tracer
};
}
var pks = pc.Parse(pk);
var list = pks.Select(e =>
{
var msg = new DefaultMessage();
if (!msg.Read(e))
{
return(null);
}
return(msg as IMessage);
}).ToList();
return(list);
}
public void StringDecode()
{
{
var msg = new DefaultMessage();
var rs = msg.Decode("4,1,1:Open");
Assert.True(rs);
Assert.Equal(1, msg.Sequence);
Assert.Equal(1, msg.Flag);
Assert.Equal("Open", msg.Payload.ToStr());
}
{
var msg = new DefaultMessage();
var rs = msg.Decode("12,1,129:执行成功");
Assert.True(rs);
Assert.Equal(1, msg.Sequence);
Assert.Equal(0x81, msg.Flag);
Assert.Equal("执行成功", msg.Payload.ToStr());
}
{
var msg = new DefaultMessage();
var rs = msg.Decode("12,1,129:执行成功".GetBytes());
Assert.True(rs);
Assert.Equal(1, msg.Sequence);
Assert.Equal(0x81, msg.Flag);
Assert.Equal("执行成功", msg.Payload.ToStr());
}
}
private void AssertThrows(Func <DefaultMessage, object> func, string message, Exception innerException)
{
var defaultMessage = DefaultMessage.New("Default message.");
AssertException(Assert.Throws <TestException>(() => func(defaultMessage)));
defaultMessage = null;
AssertException(Assert.Throws <TestException>(() => func(defaultMessage)));
void AssertException(Exception exception)
{
if (message is null)
{
Assert.NotNull(exception.Message);
if (defaultMessage != null)
{
Assert.NotEqual(defaultMessage.ToString(), exception.Message);
}
}
else
{
Assert.Equal(message, exception.Message);
}
if (innerException is null)
{
Assert.Null(exception.InnerException);
}
else
{
Assert.Equal(innerException, exception.InnerException);
}
}
}
static void Test4()
{
//var buf = "hello".GetBytes();
var ms = new MemoryStream();
var writer = new BinaryWriter(ms);
writer.Write("hello");
writer.Write(0);
var msg = new DefaultMessage();
msg.Payload = ms.ToArray();
var buf = msg.ToPacket().ToArray();
XTrace.WriteLine(buf.ToHex());
var udp = new UdpClient();
udp.Send(buf, buf.Length, new IPEndPoint(IPAddress.Broadcast, 5500));
IPEndPoint ep = null;
var rs = udp.Receive(ref ep);
XTrace.WriteLine(ep + "");
XTrace.WriteLine(rs.ToStr());
}
/// <summary>调用</summary>
/// <param name="host"></param>
/// <param name="session"></param>
/// <param name="action">服务操作</param>
/// <param name="args">参数</param>
/// <param name="flag">标识</param>
/// <returns></returns>
public static Boolean Invoke(IApiHost host, IApiSession session, String action, Object args, Byte flag = 0)
{
if (session == null)
{
return(false);
}
host.StatSend?.Increment();
// 编码请求
var pk = EncodeArgs(host.Encoder, action, args);
// 构造消息
var msg = new DefaultMessage
{
OneWay = true,
Payload = pk,
};
if (flag > 0)
{
msg.Flag = flag;
}
return(session.Send(msg));
}
/// <summary>编码请求</summary>
/// <param name="action"></param>
/// <param name="args"></param>
/// <returns></returns>
public IMessage Encode(String action, Object args)
{
var ms = new MemoryStream();
ms.Seek(4, SeekOrigin.Begin);
// 写入服务名
var writer = new BinaryWriter(ms);
writer.Write(action);
// 写入参数
if (args != null)
{
if (args is Packet pk)
{
pk.WriteTo(ms);
}
else
{
var bn = new Binary {
Stream = ms
};
bn.Write(args);
}
}
// 构造消息
var msg = new DefaultMessage
{
Payload = new Packet(ms.GetBuffer(), 4, (Int32)ms.Length - 4)
};
return(msg);
}
public async Task PublisheAndConsumeDefault()
{
//Arrange
var subscriber = GetService <IRabbitMQSubscriber>();
bool publishWithSuccess = false;
var message = new DefaultMessage
{
Campo = "PublisheAndConsumeDefault"
};
var options = RabbitMQExchangeOptions.Build <DefaultMessage>();
//Act
subscriber.StartConsume <DefaultMessage>((msg) =>
{
publishWithSuccess = msg.Campo == message.Campo;
return(true);
});
await _publisher.PublishAsync(message);
Thread.Sleep(2000);
subscriber.Dispose();
//Assert
options.QueueName.ShouldNotBeNullOrWhiteSpace();
var queueGenerated = await _rabbitExplorer.GetQueue(options.QueueName);
queueGenerated.ShouldNotBeNull();
queueGenerated.name.ShouldBe(options.QueueName);
queueGenerated.durable.ShouldBe(options.Durable);
publishWithSuccess.ShouldBeTrue();
}
/// <summary>写入数据</summary>
/// <param name="context"></param>
/// <param name="message"></param>
/// <returns></returns>
public override Object Write(IHandlerContext context, Object message)
{
if (UserPacket && message is Packet pk)
message = new DefaultMessage { Payload = pk, Sequence = (Byte)Interlocked.Increment(ref _gid) };
else if (message is DefaultMessage msg && !msg.Reply && msg.Sequence == 0)
msg.Sequence = (Byte)Interlocked.Increment(ref _gid);
return base.Write(context, message);
}
async Task DiscoverUdp(IPAddress local, IPEndPoint ep)
{
XTrace.WriteLine("DiscoverUdp: {0} -> {1}", local, ep);
// 构建请求
var enc = new JsonEncoder();
var msg = enc.CreateRequest("Api/Info", null);
var req = msg.ToPacket().ReadBytes();
var udp = new UdpClient(ep.AddressFamily)
{
EnableBroadcast = true
};
if (local != null)
{
udp.Client.Bind(new IPEndPoint(local, Rand.Next(1000, 60000)));
}
// 发送
udp.Send(req, req.Length, ep);
// 多次接收
while (true)
{
try
{
var source = new CancellationTokenSource(3_000);
var rs = await udp.ReceiveAsync(source.Token);
if (rs.Buffer != null)
{
msg = new DefaultMessage();
msg.Read(rs.Buffer);
if (enc.Decode(msg, out var action, out var code, out var data) && code == 0)
{
// 解码结果
var result = enc.DecodeResult(action, data, msg);
XTrace.WriteLine("Receive[{0}] {1}", udp.Client.LocalEndPoint, result.ToJson());
var ai = enc.Convert(result, typeof(ApiItem)) as ApiItem;
if (ai != null)
{
Invoke(() => ShowItem(ai));
}
}
}
}
catch (OperationCanceledException)
{
break;
}
}
}
/// <inheritdoc />
TSource IConditionResultOption <TSource> .ThrowOrDefault <TException>(DefaultMessage defaultMessage, Type[] parameterTypes, object[] parameters)
{
try
{
return(((IConditionResultOption <TSource>) this).Throw <TException>(parameterTypes, parameters));
}
catch (CouldNotCreateInstanceException)
{
throw CreateDefault <TException>(defaultMessage);
}
}
public IPacket Encode(ISession session, object obj)
{
var message = obj as DefaultMessage;
if (message != null)
{
return(new DefaultPacket(DefaultMessage.ToBuffer(message, _messageBodyEncoder)));
}
return(null);
}
private Model.DefaultMessage GetModel(int type, string number)
{
Model.DefaultMessage def = new DefaultMessage();
def.OldId = BLL.CommonClass.CommonDataBLL.getManageID(type);
def.NewId = number;
def.OperateIp = BLL.CommonClass.CommonDataBLL.OperateIP;
def.OperateNum = Session["Company"].ToString();
def.UpdateTime = DateTime.Now.ToUniversalTime();
def.ExpectNum = BLL.CommonClass.CommonDataBLL.getMaxqishu();
def.Type = type;
return(def);
}
/// <summary>加载消息</summary>
/// <param name="pk"></param>
/// <returns></returns>
public override IMessage LoadMessage(Packet pk)
{
if (pk == null || pk.Count == 0)
{
return(null);
}
var msg = new DefaultMessage();
msg.Read(pk);
return(msg);
}
static void Test2()
{
// 默认装饰
MessageComponent defaultMessage = new DefaultMessage();
// email装饰添加职责
var emailDecorator = new EmailDecorator(defaultMessage);
// SMS装饰添加职责
var smsDecorator = new SMSDecorator(emailDecorator);//把emailDecorator添加到sms后，同时它集成了defaultMessage
smsDecorator.Send("测试发送...");
}
/// <summary>创建消息</summary>
/// <param name="pk">数据包</param>
/// <returns></returns>
public override IMessage CreateMessage(Packet pk)
{
var msg = new DefaultMessage {
Payload = pk
};
// 序列号避开0
if (_seq == 0)
{
_seq++;
}
msg.Sequence = _seq++;
return(msg);
}
private TException CreateDefault <TException>(DefaultMessage defaultMessage)
where TException : Exception, new()
{
var exception = new TException();
if (defaultMessage is null)
{
return(exception);
}
var exceptionMessageField = typeof(TException).GetField("_message", BindingFlags.Instance | BindingFlags.NonPublic);
exceptionMessageField?.SetValue(exception, defaultMessage.ToString());
throw exception;
}
/// <summary>调用</summary>
/// <param name="host"></param>
/// <param name="session"></param>
/// <param name="action">服务操作</param>
/// <param name="args">参数</param>
/// <param name="flag">标识</param>
/// <returns></returns>
public static Boolean Invoke(IApiHost host, Object session, String action, Object args, Byte flag = 0)
{
if (session == null)
{
return(false);
}
// 性能计数器，次数、TPS、平均耗时
//host.StatSend?.Increment();
var st = host.StatInvoke;
// 编码请求
var pk = EncodeArgs(host.Encoder, action, args);
// 构造消息
var msg = new DefaultMessage
{
OneWay = true,
Payload = pk,
};
if (flag > 0)
{
msg.Flag = flag;
}
var sw = st.StartCount();
try
{
if (session is IApiSession ss)
{
return(ss.Send(msg));
}
else if (session is ISocketRemote client)
{
return(client.SendMessage(msg));
}
else
{
throw new InvalidOperationException();
}
}
finally
{
st.StopCount(sw);
}
}
/// <summary>
/// Get Exam List from Server.
/// </summary>
/// <returns></returns>
private bool GetExamList()
{
var v = new DefaultMessage(Command.SendExamList);
//wait three connection attempts
for (int i = 0; i < 3; i++)
{
if (_client.SendPacket(v))
{
return(true);
}
i++;
Thread.Sleep(200);
}
return(false);
}
/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList<IMessage> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Session;
var mcp = ss["CodecItem"] as CodecItem;
if (mcp == null) ss["CodecItem"] = mcp = new CodecItem();
var pks = Parse(pk, mcp, DefaultMessage.GetLength);
var list = pks.Select(e =>
{
var msg = new DefaultMessage();
if (!msg.Read(e)) return null;
return msg as IMessage;
}).ToList();
return list;
}
/// <summary>
/// Start Exame
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnStartTest_Click(object sender, EventArgs e)
{
if (_testStarted)
{
String UserName = txtUsername.Text;
String ExameStartedAt = DateTime.Now.ToString("yyyy.MM.dd HH:mm:ss");
String SelectedExame = comboExamSelection.Text;
DefaultMessage m = new DefaultMessage(Command.SendExercises);
m.MessageString = SelectedExame;
_client.SendPacket(m);
m = new DefaultMessage(Command.SetUserName);
m.MessageString = UserName;
_client.SendPacket(m);
}
}
public void BinaryEncode()
{
var msg = new DefaultMessage
{
Sequence = 1,
Payload = "Open".GetBytes(),
};
var pk = msg.ToPacket();
Assert.Equal(1, pk[0]);
Assert.Equal(1, pk[1]);
Assert.Equal(4, pk[2]);
Assert.Equal(0, pk[3]);
Assert.Equal("Open", pk.Slice(4).ToStr());
var msgd = new DefaultMessage();
var rs = msgd.Read(pk);
Assert.True(rs);
Assert.Equal(msg.Flag, msgd.Flag);
Assert.Equal(msg.Sequence, msgd.Sequence);
Assert.Equal(msg.Payload.ToStr(), msgd.Payload.ToStr());
var msg2 = new DefaultMessage
{
Reply = true,
Sequence = 1,
Payload = "执行成功".GetBytes(),
};
var pk2 = msg2.ToPacket();
Assert.Equal(0x81, pk2[0]);
Assert.Equal(1, pk2[1]);
Assert.Equal(12, pk2[2]);
Assert.Equal(0, pk2[3]);
Assert.Equal("执行成功", pk2.Slice(4).ToStr());
var msgd2 = new DefaultMessage();
var rs2 = msgd2.Read(pk2);
Assert.True(rs2);
Assert.Equal(msg2.Flag, msgd2.Flag);
Assert.Equal(msg2.Sequence, msgd2.Sequence);
Assert.Equal(msg2.Payload.ToStr(), msgd2.Payload.ToStr());
}
public static async Task PrepareAsync(this IEventPublisher eventPublisher, string routeKey, object content, object metaData, IDbConnection dbConnection, IDbTransaction dbTransaction, string exchange = "default.exchange@feiniubus", object args = null)
{
var message = new DefaultMessage(content);
var anonyObj = new AnonymousObject(metaData);
var anonyMembers = anonyObj.GetProperties().Where(member => member.MemberType == System.Reflection.MemberTypes.Property)
.Select(member => new { MemberName = member.MemberName, Value = anonyObj.GetValue(member.DeclaringType, member.MemberName) });
if (anonyMembers.Any())
{
var md = new MetaData();
foreach (var member in anonyMembers)
{
md.Set(member.MemberName, member.Value.ToString());
}
message.MetaData.Contact(md);
}
await eventPublisher.PrepareAsync(new EventDescriptor(routeKey, message, exchange, args), dbConnection, dbTransaction);
}
public void StringEncodeNoFlag()
{
var msg = new DefaultMessage
{
Sequence = 1,
Payload = "Open".GetBytes(),
};
var str = msg.Encode(null, false);
Assert.Equal("4,1:Open", str);
var msg2 = new DefaultMessage
{
Reply = true,
Sequence = 1,
Payload = "执行成功".GetBytes(),
};
var str2 = msg2.Encode(null, false);
Assert.Equal("12,1:执行成功", str2);
}
//
// GET: /Home/
public ActionResult Home()
{
DefaultMessage response = new DefaultMessage();
try
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.StartInfo.FileName = AppDomain.CurrentDomain.BaseDirectory + "AllLocalCopy\\combine.bat";
proc.StartInfo.WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory + "AllLocalCopy";
proc.StartInfo.RedirectStandardError = true;
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.UseShellExecute = false;
proc.Start();
response.Success = true;
}
catch (Exception exception)
{
//Log.Error(exception.Message, exception);
}
return View(response);
}
/// <summary>创建请求</summary>
/// <param name="action"></param>
/// <param name="args"></param>
/// <returns></returns>
public virtual IMessage CreateRequest(String action, Object args)
{
// 二进制优先
if (args is Packet pk)
{
}
else if (args is Byte[] buf)
{
pk = new Packet(buf);
}
else
{
pk = Encode(action, 0, args);
}
pk = Encode(action, 0, pk);
var msg = new DefaultMessage {
Payload = pk,
};
return(msg);
}
/// <summary>解码</summary>
/// <param name="context"></param>
/// <param name="pk"></param>
/// <returns></returns>
protected override IList <IMessage> Decode(IHandlerContext context, Packet pk)
{
var ss = context.Owner as IExtend;
var mcp = ss["CodecItem"] as CodecItem;
if (mcp == null)
{
ss["CodecItem"] = mcp = new CodecItem();
}
var pks = Parse(pk, mcp, DefaultMessage.GetLength);
var list = pks.Select(e =>
{
var msg = new DefaultMessage();
if (!msg.Read(e))
{
return(null);
}
return(msg as IMessage);
}).ToList();
return(list);
}
/// <summary>调用</summary>
/// <param name="host"></param>
/// <param name="session"></param>
/// <param name="resultType">结果类型</param>
/// <param name="action">服务操作</param>
/// <param name="args">参数</param>
/// <param name="flag">标识</param>
/// <returns></returns>
public static async Task <Object> InvokeAsync(IApiHost host, Object session, Type resultType, String action, Object args, Byte flag)
{
if (session == null)
{
return(null);
}
// 性能计数器，次数、TPS、平均耗时
//host.StatSend?.Increment();
var st = host.StatInvoke;
var sw = st.StartCount();
// 编码请求
var enc = host.Encoder;
var pk = EncodeArgs(enc, action, args);
// 构造消息
var msg = new DefaultMessage {
Payload = pk,
};
if (flag > 0)
{
msg.Flag = flag;
}
IMessage rs = null;
try
{
if (session is IApiSession ss)
{
rs = await ss.SendAsync(msg);
}
else if (session is ISocketRemote client)
{
rs = (await client.SendMessageAsync(msg)) as IMessage;
}
else
{
throw new InvalidOperationException();
}
//rs = await session.SendAsync(msg);
if (rs == null)
{
return(null);
}
}
catch (AggregateException aggex)
{
var ex = aggex.GetTrue();
if (ex is TaskCanceledException)
{
throw new TimeoutException($"请求[{action}]超时！", ex);
}
throw aggex;
}
catch (TaskCanceledException ex)
{
throw new TimeoutException($"请求[{action}]超时！", ex);
}
finally
{
st.StopCount(sw);
}
// 特殊返回类型
if (resultType == typeof(IMessage))
{
return(rs);
}
//if (resultType == typeof(Packet)) return rs.Payload;
if (!Decode(rs, out var act, out var code, out var data))
{
throw new InvalidOperationException();
}
// 是否成功
if (code != 0)
{
throw new ApiException(code, data.ToStr());
}
if (data == null)
{
return(null);
}
if (resultType == typeof(Packet))
{
return(data);
}
// 解码结果
var result = enc.Decode(action, data);
if (resultType == typeof(Object))
{
return(result);
}
// 返回
return(enc.Convert(result, resultType));
}
/// <summary>调用</summary>
/// <param name="host"></param>
/// <param name="session"></param>
/// <param name="resultType">结果类型</param>
/// <param name="action">服务操作</param>
/// <param name="args">参数</param>
/// <param name="flag">标识</param>
/// <returns></returns>
public static async Task <Object> InvokeAsync(IApiHost host, IApiSession session, Type resultType, String action, Object args, Byte flag)
{
if (session == null)
{
return(null);
}
host.StatSend?.Increment();
// 编码请求
var enc = host.Encoder;
var pk = EncodeArgs(enc, action, args);
// 构造消息
var msg = new DefaultMessage {
Payload = pk,
};
if (flag > 0)
{
msg.Flag = flag;
}
var rs = await session.SendAsync(msg);
if (rs == null)
{
return(null);
}
// 特殊返回类型
if (resultType == typeof(IMessage))
{
return(rs);
}
//if (resultType == typeof(Packet)) return rs.Payload;
if (!Decode(rs, out var act, out var code, out var data))
{
throw new InvalidOperationException();
}
// 是否成功
if (code != 0)
{
throw new ApiException(code, data.ToStr());
}
if (data == null)
{
return(null);
}
if (resultType == typeof(Packet))
{
return(data);
}
// 解码结果
var result = enc.Decode(action, data);
if (resultType == typeof(Object))
{
return(result);
}
// 返回
return(enc.Convert(result, resultType));
}
private static DefaultMessage GenerateDiscordMessage(IDictionary <string, string> queryParameters, dynamic data)
{
DefaultMessage discordMessage = null;
string eventType = data.eventType;
switch (eventType)
{
case "build.complete":
discordMessage = new BuildCompleteMessage(queryParameters, data);
break;
case "git.push":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "git.pullrequest.created":
discordMessage = new PullRequestCreatedMessage(queryParameters, data);
break;
case "git.pullrequest.updated":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "git.pullrequest.merged":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "tfvc.checkin":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "workitem.created":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "workitem.commented":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "workitem.updated":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "workitem.deleted":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "workitem.restored":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "ms.vss-release.release-created-event":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "ms.vss-release.release-abandoned-event":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "ms.vss-release.deployment-approval-completed-event":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "ms.vss-release.deployment-approval-pending-event":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "ms.vss-release.deployment-started-event":
discordMessage = new DefaultMessage(queryParameters, data);
break;
case "ms.vss-release.deployment-completed-event":
discordMessage = new DefaultMessage(queryParameters, data);
break;
default:
discordMessage = new DefaultMessage(queryParameters, data);
break;
}
return(discordMessage);
}
public object Decode(ISession session, IPacket packet)
{
return(DefaultMessage.FromBuffer(packet.Buffer, _messageBodyDecoder));
}
