private async Task LocalExecute(MicroEntry entry, InvokeMessage invokeMessage, MessageResult messageResult)
{
try
{
//if (_logger.IsEnabled(LogLevel.Debug))
// _logger.LogDebug(JsonConvert.SerializeObject(invokeMessage));
if (entry.IsNotify)
{
await entry.Invoke(invokeMessage.Parameters);
}
else
{
var data = await entry.Invoke(invokeMessage.Parameters);
if (!(data is Task task))
{
messageResult.Content = data;// new DynamicMessage(data);
}
else
{
await task;
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
var prop = taskType.GetProperty("Result");
if (prop != null)
{
messageResult.Content = prop.GetValue(task); // new DynamicMessage(prop.GetValue(task));
}
}
}
}
/// <summary>
/// 调用方法
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public InvokeData CallMethod(InvokeMessage message)
{
#region 设置请求信息
RequestMessage reqMsg = new RequestMessage();
reqMsg.InvokeMethod = true;
reqMsg.AppName = appName; //应用名称
reqMsg.HostName = hostName; //客户端名称
reqMsg.IPAddress = ipAddress; //客户端IP地址
reqMsg.ServiceName = message.ServiceName; //服务名称
reqMsg.MethodName = message.MethodName; //方法名称
reqMsg.ReturnType = typeof(string); //返回类型
reqMsg.TransactionId = Guid.NewGuid(); //传输ID号
#endregion
//给参数赋值
reqMsg.Parameters["InvokeParameter"] = message.Parameters;
//调用服务
var resMsg = service.CallService(reqMsg);
//如果有异常，向外抛出
if (resMsg.IsError)
{
throw resMsg.Error;
}
//返回数据
return(resMsg.Value as InvokeData);
}
/// <summary>
/// 调用分布式服务
/// </summary>
/// <param name="node"></param>
/// <param name="message"></param>
/// <returns></returns>
public InvokeData Invoke(ServerNode node, InvokeMessage message)
{
if (node == null)
{
throw new WarningException("Server node can't for empty!");
}
//获取本地服务
IService service = GetLocalService(message);
if (service == null)
{
if (singleton.proxies.ContainsKey(node.Key.ToLower()))
{
service = singleton.proxies[node.Key.ToLower()];
}
else
{
if (node.Format == TransferType.Json)
{
service = new InvokeProxy(node, container);
}
else
{
service = new RemoteProxy(node, container);
}
}
}
//获取服务内容
return(GetInvokeData(message, service));
}
private Stream EncodeMessage(InvokeMessage message)
{
var outStream = new MemoryStream();
using (BinaryWriter writer = new BinaryWriter(outStream, Encoding.UTF8, true))
{
writer.Write(long.MaxValue);
writer.Write(message.Id.ToByteArray());
writer.Write((byte)MessageType.Message);
//---
writer.Write(message.SubObjectId);
//---
writer.Write(message.MethodName);
//---
writer.Write(JsonConvert.SerializeObject(message.Args));
//---
foreach (var keyStream in message.Streams)
{
writer.Write(keyStream.Key);
WriteStream(writer, keyStream.Value);
}
outStream.Position = 0;
writer.Write(outStream.Length - sizeof(long));
}
return(outStream);
}
/// <summary> 执行请求 </summary>
/// <param name="endPoint"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task <ResultMessage> InvokeAsync(EndPoint endPoint, InvokeMessage message)
{
var client = _clientFactory.CreateClient(endPoint);
var result = await client.Send(message);
return(result);
}
private InvokeData AsyncCaller(InvokeMessage message)
{
InvokeResponse data;
//开始计时
var watch = Stopwatch.StartNew();
try
{
//调用服务
var invokeData = CastleFactory.Create().Invoke(node, message);
data = new InvokeResponse(invokeData);
}
catch (Exception ex)
{
data = new InvokeResponse {
Exception = ex
};
}
watch.Stop();
data.ElapsedMilliseconds = watch.ElapsedMilliseconds;
return(data);
}
/// <summary>
/// 消息数据处理
/// </summary>
private void ProcessData()
{
while (IsAvailable)
{
try
{
byte[] data = null;
lock (MessageLine)
{
if (MessageLine.Count > 0)
{
data = MessageLine.Dequeue();
}
else
{
ProcessFlag = true;
Monitor.Wait(MessageLine);
}
}
if (data != null)
{
InvokeMessage?.Invoke(data);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Dispose("ProcessData " + e.Message);
}
}
}
/// <summary>
/// 通用方法
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
public InvokeMessage Invoke(InvokeMessage msg)
{
string resultResponse = "";
if (msg == null)
{
return(null);
}
try
{
if (DataFormatter == "Xml")
{
string xmlString = TurnToXml(typeof(InvokeMessage), msg);
HttpContent httpContent = new StringContent(xmlString, Encoding.UTF8);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
var response = _client.PutAsync("/DataService/webapi/Invoke", httpContent).Result;
if (response.IsSuccessStatusCode)
{
resultResponse = response.Content.ReadAsStringAsync().Result;
string newXml = Regex.Replace(resultResponse, @"(xmlns:?[^=]*=[""][^""]*[""])", "", RegexOptions.IgnoreCase |
RegexOptions.Multiline);
using (StringReader sr = new StringReader(newXml))
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(InvokeMessage)); //去掉命名空间
return((InvokeMessage)xmlSerializer.Deserialize(sr));
}
}
else
{
msg.IsSuccess = false;
msg.ErrorMsg = "通讯错误";
return(msg);
}
}
if (DataFormatter == "Json")
{
string jsonString = JsonSerialize(msg);
//设置Json格式，把参数以Json格式上传
HttpContent httpContent = new StringContent(jsonString, Encoding.UTF8);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = _client.PostAsync("/DataService/webapi/Invoke", httpContent).Result;
if (response.IsSuccessStatusCode)
{
resultResponse = response.Content.ReadAsStringAsync().Result;
return(JsonConvert.DeserializeObject <InvokeMessage>(resultResponse));
}
else
{
msg.IsSuccess = false;
msg.ErrorMsg = "通讯错误";
return(msg);
}
}
return(null);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <MessageResult> Send(InvokeMessage message)
{
var watch = Stopwatch.StartNew();
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("准备发送消息");
}
var callback = RegistCallbackAsync(message.Id);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"{_sender.GetType()}:send :{JsonConvert.SerializeObject(message)}");
}
//发送
await _sender.Send(message);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug("消息发送成功");
}
return(await callback);
}
finally
{
watch.Stop();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"send message {watch.ElapsedMilliseconds} ms");
}
}
}
/// <summary>
/// 获取调用的数据
/// </summary>
/// <param name="message"></param>
/// <param name="service"></param>
/// <returns></returns>
private InvokeData GetInvokeData(InvokeMessage message, IService service)
{
//调用分布式服务
var caller = new InvokeCaller(config.AppName, service);
return(caller.CallMethod(message));
}
public object Invoke(InvokeMessage message, Func <long, Type, object> hardbjectFor)
{
var targetMethod = GetTargetMethod(message.MethodName)
?? throw new Exception($"Method {message.MethodName} was not found");
var parameters = GetArguments(message, hardbjectFor, targetMethod);
return(targetMethod.Invoke(instance, parameters));
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
IBufferReader reader = NettyBufferManager.CreateBufferReader(input);
InvokeMessage message = this._codecs.Decode(reader);
if (message != null)
{
output.Add(message);
}
reader = null;
}
/// <summary>
/// 调用分布式服务
/// </summary>
/// <param name="nodeKey"></param>
/// <param name="message"></param>
/// <returns></returns>
public InvokeData Invoke(string nodeKey, InvokeMessage message)
{
nodeKey = GetNodeKey(nodeKey);
var node = GetServerNodes().FirstOrDefault(p => string.Compare(p.Key, nodeKey, true) == 0);
if (node == null)
{
throw new WarningException(string.Format("Did not find the node {0}!", nodeKey));
}
return(Invoke(node, message));
}
private void button1_Click(object sender, EventArgs e)
{
if (txtParameters.Count > 0)
{
if (MessageBox.Show("请确认参数是否全部填写正确！", "系统提示",
MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.Cancel)
{
return;
}
}
button1.Enabled = false;
label5.Text = "正在调用服务，请稍候...";
label5.Refresh();
var jValue = new JObject();
if (txtParameters.Count > 0)
{
foreach (var p in txtParameters)
{
var text = p.Value.Text.Trim();
if (!string.IsNullOrEmpty(text))
{
var info = p.Value.Tag as ParameterInfo;
try
{
jValue[p.Key] = JToken.Parse(text);
}
catch
{
jValue[p.Key] = text;
}
}
}
}
//提交的参数信息
string parameter = jValue.ToString(Newtonsoft.Json.Formatting.None);
var message = new InvokeMessage
{
ServiceName = serviceName,
MethodName = methodName,
Parameters = parameter
};
//启用线程进行数据填充
var caller = new AsyncMethodCaller(AsyncCaller);
var ar = caller.BeginInvoke(message, AsyncComplete, caller);
}
/// <summary>
/// 调用分布式服务
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public InvokeData Invoke(InvokeMessage message)
{
if (proxies.Count == 0)
{
//获取本地服务
IService service = GetLocalService(message);
if (service != null)
{
return(GetInvokeData(message, service));
}
throw new WarningException(string.Format("Did not find the service {0}!", message.ServiceName));
}
return(Invoke(config.Default, message));
}
public async Task SendMessage(InvokeMessage message)
{
await semaphoreSlim.WaitAsync();
try
{
logger.LogDebug($"sending message {message.Id}");
var streamToOut = EncodeMessage(message);
streamToOut.Position = 0;
await streamToOut.CopyToAsync(tcpClient.GetStream());
}
finally
{
semaphoreSlim.Release();
}
}
/// <summary>
/// 订阅报警记录，返回报警ID，返回-1表示调用失败
/// </summary>
/// <returns></returns>
public long SubscribeAlarm()
{
try
{
var msg = new InvokeMessage(MethodType.Alarm, "SubscribeAlarm");
var res = Invoke(msg);
if (!res.IsSuccess)
{
return(-1);
}
return(Convert.ToInt64(res.ReturnBody));
}
catch (Exception ex)
{
return(-1);
}
}
/// <summary>
/// 通过订阅ID获取报警记录集合
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public List <AlarmRecord> GetAlarms(long id)
{
try
{
var msg = new InvokeMessage(MethodType.Alarm, "GetAlarmRecords");
msg.Paras = new dynamic[] { id };
var res = Invoke(msg);
if (!res.IsSuccess)
{
return(null);
}
return(JsonDeserialize <List <AlarmRecord> >(res.ReturnBody));
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// 通过id取消订阅报警
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool RemoverSubscribeAlarm(long id)
{
try
{
var msg = new InvokeMessage(MethodType.Alarm, "RemoveSubcribe");
msg.Paras = new dynamic[] { id };
var res = Invoke(msg);
if (!res.IsSuccess)
{
return(false);
}
return(Convert.ToBoolean(res.ReturnBody));
}
catch (Exception)
{
return(false);
}
}
private async Task LocalExecute(InvokeMessage invokeMessage, ResultMessage result)
{
try
{
_logger.LogDebug(JsonConvert.SerializeObject(invokeMessage));
var service = _entryFactory.Find(invokeMessage.ServiceId);
var args = new List <object>();
var parameters = invokeMessage.Parameters ?? new Dictionary <string, object>();
foreach (var parameter in service.GetParameters())
{
if (parameters.ContainsKey(parameter.Name))
{
var parameterType = parameter.ParameterType;
var arg = parameters[parameter.Name].CastTo(parameterType);
args.Add(arg);
}
else
{
args.Add(parameter.DefaultValue);
}
}
var instance = _provider.GetService(service.DeclaringType);
var data = service.Invoke(instance, args.ToArray());
if (!(data is Task task))
{
result.Data = data;
}
else
{
await task;
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
var prop = taskType.GetProperty("Result");
if (prop != null)
{
result.Data = prop.GetValue(task);
}
}
}
}
private InvokeMessage Create(MethodInfo targetMethod, IDictionary <string, object> args)
{
var localIp = Constants.LocalIp();
var headers = new Dictionary <string, string>
{
{ MicroClaimTypes.HeaderForward, localIp },
{ MicroClaimTypes.HeaderRealIp, localIp },
{ MicroClaimTypes.HeaderUserAgent, "spear-client" }
//{MicroClaimTypes.HeaderReferer, string.Empty}
};
var session = _provider.GetService <IMicroSession>();
if (session != null)
{
if (session.UserId != null)
{
headers.Add(MicroClaimTypes.HeaderUserId, session.GetUserId <string>());
headers.Add(MicroClaimTypes.HeaderUserName,
HttpUtility.UrlEncode(session.UserName ?? string.Empty));
headers.Add(MicroClaimTypes.HeaderRole, HttpUtility.UrlEncode(session.Role ?? string.Empty));
}
if (session.TenantId != null)
{
headers.Add(MicroClaimTypes.HeaderTenantId, session.GetTenantId <string>());
}
}
var serviceId = targetMethod.ServiceKey();
var invokeMessage = new InvokeMessage
{
ServiceId = serviceId,
Parameters = args,
Headers = headers
};
var type = targetMethod.ReturnType;
if (type == typeof(void) || type == typeof(Task))
{
invokeMessage.IsNotice = true;
}
return(invokeMessage);
}
/// <summary>
/// 获取本地服务
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
private IService GetLocalService(InvokeMessage message)
{
IService service = null;
string serviceKey = "Service_" + message.ServiceName;
if (config.Type != CastleFactoryType.Remote)
{
if (container.Kernel.HasComponent(serviceKey))
{
service = container.Resolve <IService>(serviceKey);
}
if (service == null && config.Type == CastleFactoryType.Local)
{
throw new WarningException(string.Format("Local not find service ({0}).", message.ServiceName));
}
}
return(service);
}
private static InvokeMessage Create(MethodInfo targetMethod, object[] args)
{
var remoteIp = AcbHttpContext.RemoteIpAddress;
var headers = new Dictionary <string, string>
{
{ "X-Forwarded-For", remoteIp },
{ "X-Real-IP", remoteIp },
{
"User-Agent", AcbHttpContext.Current == null ? "micro_service_client" : AcbHttpContext.UserAgent
},
{ "referer", AcbHttpContext.RawUrl }
};
var methodType = targetMethod.DeclaringType;
var serviceId = $"{methodType?.FullName}.{targetMethod.Name}";
var dict = new Dictionary <string, object>();
var parameters = targetMethod.GetParameters();
if (parameters.Any())
{
for (var i = 0; i < parameters.Length; i++)
{
dict.Add(parameters[i].Name, args[i]);
}
serviceId += "_" + string.Join("_", parameters.Select(i => i.Name));
}
var invokeMessage = new InvokeMessage
{
ServiceId = serviceId,
Parameters = dict,
Headers = headers
};
var type = targetMethod.ReturnType;
if (type == typeof(void) || type == typeof(Task))
{
invokeMessage.IsNotice = true;
}
return(invokeMessage);
}
private InvokeMessage DecodeMessage(MemoryStream contentStream, Guid id)
{
InvokeMessage message = new InvokeMessage();
using (var reader = new BinaryReader(contentStream, Encoding.UTF8))
{
message.Id = id;
message.SubObjectId = reader.ReadInt64();
message.MethodName = reader.ReadString();
message.Args = JsonConvert.DeserializeObject <Dictionary <string, Value> >(reader.ReadString());
message.Streams = new Dictionary <string, Stream>();
while (contentStream.Position != contentStream.Length)
{
var streamName = reader.ReadString();
var size = (int)reader.ReadInt64();
var innerStream = new MemoryStream();
contentStream.CopyPart(innerStream, size).Wait();
innerStream.Position = 0;
message.Streams[streamName] = innerStream;
}
}
return(message);
}
private static InvokeMessage Create(MethodInfo targetMethod, IDictionary <string, object> args)
{
var remoteIp = Constants.LocalIp();
var headers = new Dictionary <string, string>
{
{ "X-Forwarded-For", remoteIp },
{ "X-Real-IP", remoteIp },
{ "User-Agent", "spear-client" }
};
var serviceId = targetMethod.ServiceKey();
var invokeMessage = new InvokeMessage
{
ServiceId = serviceId,
Parameters = args,
Headers = headers
};
var type = targetMethod.ReturnType;
if (type == typeof(void) || type == typeof(Task))
{
invokeMessage.IsNotice = true;
}
return(invokeMessage);
}
private object[] GetArguments(InvokeMessage message, Func <long, Type, object> hardbjectFor, MethodInfo methodInfo)
{
var args = new List <object>();
foreach (var param in methodInfo.GetParameters())
{
if (message.Args.TryGetValue(param.Name, out var token))
{
switch (token.Type)
{
case Messages.ValueType.Null:
args.Add(null);
break;
case Messages.ValueType.Primitive:
args.Add(token.Data.ToObject(param.ParameterType));
break;
case Messages.ValueType.HardObject:
args.Add(hardbjectFor(token.Data.ToObject <long>(),
param.ParameterType));
break;
}
}
else
if (message.Streams.TryGetValue(param.Name, out var stream))
{
args.Add(stream);
}
else
{
throw new Exception($"Parameter {param.Name} was not found in InvokeMessage");
}
}
return(args.ToArray());
}
private InvokeResult GetInvokationResult(InvokeMessage message)
{
object data;
try
{
data = invoker.Invoke(message, CreateRemoteInvoker);
}
catch (Exception ex)
{
return(InvokeResult.Exception(message.Id, ex));
}
if (data == null)
{
return(InvokeResult.Null(message.Id));
}
if (data is Stream stream)
{
return(InvokeResult.Stream(message.Id, stream));
}
if (PrimitiveTypes.Contains(data.GetType()))
{
return(InvokeResult.Primitive(message.Id, JToken.FromObject(data)));
}
var codeInvoker = new CodeInvoker(data, data.GetType());
long newId;
//TODO lock need?
lock (subWrappers)
{
newId = ++lastId;
subWrappers[newId] = new InstanceWrapper(codeInvoker);
}
return(InvokeResult.HardObject(message.Id, newId));
}
private async Task LocalExecute(InvokeMessage invokeMessage, ResultMessage result)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug(JsonConvert.SerializeObject(invokeMessage));
}
var entry = _entryFactory.Find(invokeMessage.ServiceId);
if (entry.IsNotify)
{
await entry.Invoke(invokeMessage.Parameters);
}
else
{
var data = await entry.Invoke(invokeMessage.Parameters);
if (!(data is Task task))
{
result.Data = data;
}
else
{
await task;
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
var prop = taskType.GetProperty("Result");
if (prop != null)
{
result.Data = prop.GetValue(task);
}
}
}
}
/// <summary> 执行请求 </summary>
/// <param name="serviceAddress"></param>
/// <param name="message"></param>
/// <returns></returns>
private async Task <ResultMessage> ClientInvokeAsync(ServiceAddress serviceAddress, InvokeMessage message)
{
//获取不同协议的客户端工厂
var clientFactory = _provider.GetService <IMicroClientFactory>(serviceAddress.Protocol);
var client = clientFactory.CreateClient(serviceAddress);
var result = await client.Send(message);
return(result);
}
/// <summary>
/// 调用服务，并返回字符串
/// </summary>
/// <param name="name"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public string CallMethod(string name, string parameters)
{
if (callers.ContainsKey(name))
{
var caller = callers[name];
var message = new InvokeMessage
{
ServiceName = caller.Service.FullName,
MethodName = caller.Method.ToString(),
Parameters = parameters
};
string thisKey = string.Format("{0}${1}${2}", message.ServiceName, message.MethodName, message.Parameters);
var cacheKey = string.Format("HttpServiceCaller_{0}", IoCHelper.GetMD5String(thisKey));
var invokeData = CacheHelper.Get <InvokeData>(cacheKey);
if (invokeData == null)
{
//获取当前调用者信息
var appCaller = new AppCaller
{
AppPath = AppDomain.CurrentDomain.BaseDirectory,
AppName = "HttpServer",
HostName = DnsHelper.GetHostName(),
IPAddress = DnsHelper.GetIPAddress(),
ServiceName = message.ServiceName,
MethodName = message.MethodName,
Parameters = message.Parameters,
CallTime = DateTime.Now
};
//创建服务
var service = CreateService(appCaller);
//初始化上下文
SetOperationContext(appCaller);
try
{
//使用Invoke方式调用
var invoke = new InvokeCaller(appCaller.AppName, service);
invokeData = invoke.CallMethod(message);
//插入缓存
if (invokeData != null && caller.CacheTime > 0)
{
CacheHelper.Insert(cacheKey, invokeData, caller.CacheTime);
}
}
finally
{
//初始化上下文
OperationContext.Current = null;
}
}
//如果缓存不为null，则返回缓存数据
if (invokeData != null)
{
return(invokeData.Value);
}
}
return("null");
}
