/// <summary>
/// 验证并预处理请求参数
/// </summary>
/// <param name="request"></param>
private static void InvalidRequest(ESB.Core.Schema.服务请求 request)
{
if (String.IsNullOrEmpty(request.主机名称))
{
throw LogUtil.ExceptionAndLog("主机名称必须填写！", "", request);
}
if (String.IsNullOrEmpty(request.服务名称))
{
throw LogUtil.ExceptionAndLog("服务名称必须填写！", "", request);
}
if (String.IsNullOrEmpty(request.方法名称))
{
EntityList<BindingTemplate> bindings = GetBindings(request);
if(bindings == null)
throw LogUtil.ExceptionAndLog("方法名称必须填写！", "", request);
else
throw LogUtil.ExceptionAndLog("方法名称必须填写！", "", bindings[0], request);
}
//--如果用户没有传递请求时间，或则传入时间无效，则默认为当前时间
if (request.请求时间.Year != DateTime.Now.Year)
request.请求时间 = DateTime.Now;
if (String.IsNullOrEmpty(request.消息内容))
request.消息内容 = String.Empty;
if (String.IsNullOrEmpty(request.密码))
request.密码 = String.Empty;
}
public void Login()
{
var fm = this.RequestMeta.AsFormMeta();
object[] ps = new object[] { fm.Get("DDLServer"), fm.Get("DDLAcc"), fm.Get("EditUser"), fm.Get("EditPass"), string.Empty };
bool loginSucc = ESB.GetService <ServiceLogin>().Invoke(ps).Value.TryParseToBool();
string msg = ps[4] as string;
if (loginSucc)
{
Ajax.ShowMessage(AjaxType.Succ);
}
else
{
Session.Abandon();
if (!string.IsNullOrEmpty(msg))
{
Ajax.ShowMessage(AjaxType.Fail, msg);
}
else
{
Ajax.ShowMessage(AjaxType.Fail, "登录失败,错误的用户名或密码!");
}
}
}
public static BOOL EnableScrollBar(IHandle hWnd, SB wSBflags, ESB wArrows)
{
BOOL result = EnableScrollBar(hWnd.Handle, wSBflags, wArrows);
GC.KeepAlive(hWnd);
return(result);
}
public IActionResult Soa()
{
var tickSnapshot = DateTime.Now.Ticks;
var result = ESB.GetSquareRoot(GetRandomNumber());
SetResult("Monolith", result, DateTime.Now.Ticks - tickSnapshot);
return(View("WebApplication"));
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, BindingTemplate binding
, DateTime reqBeginTime
, DateTime reqEndTime
, DateTime callBeginTime
, DateTime callEndTime
, String message
, ESB.Core.Schema.服务请求 request)
{
return AddAuditLog(status, binding.TemplateID.ToString(), binding.ServiceID.ToString(), binding.Address.ToString()
, reqBeginTime, reqEndTime, callBeginTime, callEndTime
, message, request);
}
public const String COMPANY_URL = "http://mb.com";//--公司网址,用于SOAP协议中的基地址
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ESB.Core.Schema.服务响应 DynamicalCallWebService(
Boolean needResponse
, ESB.Core.Schema.服务请求 request)
{
//--记录接收时间并放在请求结束时间中，用于判读ESB在接到请求到开始调用的耗时
DateTime receiveDateTime = DateTime.Now;
//--验证并预处理请求参数
InvalidRequest(request);
//--获取到请求对应服务的绑定
EntityList<BindingTemplate> bindings = GetBindings(request);
//--如果只有一个绑定，且需要返回结果
if (bindings.Count == 1 && needResponse == true)
{
CallState state = new CallState()
{
Binding = bindings[0],
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime
};
return CallService(state);
}
else //--如果有多个绑定则默认为发布、订阅模式，不需要将每个订阅则的结果都放回给调用方，或者指明是不需要返回结果的情况（单向调用）
{
foreach (BindingTemplate binding in bindings)
{
CallState state = new CallState()
{
Binding = binding,
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime
};
ThreadPoolX.QueueUserWorkItem(() => CallService(state));
}
return GetMultiResponse();
}
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, String bindingTemplateID
, String serviceID
, String address
, DateTime reqBeginTime
, DateTime reqEndTime
, DateTime callBeginTime
, DateTime callEndTime
, String message
, ESB.Core.Schema.服务请求 request)
{
AuditBusiness log = new AuditBusiness()
{
OID = Guid.NewGuid().ToString(),
HostName = request.主机名称,
ServiceName = request.服务名称,
MethodName = request.方法名称,
ReqBeginTime = reqBeginTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
ReqEndTime = reqEndTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
Status = status,
MessageID = Guid.NewGuid().ToString(),
MessageBody = request.消息内容,
CallBeginTime = callBeginTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
CallEndTime = callEndTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
BindingTemplateID = bindingTemplateID,
ServiceID = serviceID,
BindingAddress = address,
ReturnMessageBody = message,
BusinessName = "",
BusinessID = ""
};
//log.Insert();
MQUtil.SendMessage<AuditBusiness>(log, @"WIN-02UQME9JGZD\Private$\EsbAuditQueue");
return log.MessageID;
}
/// <summary>
/// 动态调用WebService主函数
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static ESB.Core.Schema.服务响应 DynamicalCallWebService(
Boolean needResponse
, ESB.Core.Schema.服务请求 request
, List<BindingTemplate> bindings
, Int32 version
, EsbView_ServiceConfig serviceConfig
, AdvanceInvokeParam invokeParam)
{
//--记录接收时间并放在请求结束时间中，用于判读ESB在接到请求到开始调用的耗时
DateTime receiveDateTime = DateTime.Now;
//--验证并预处理请求参数
InvalidRequest(request);
//--获取跟踪上下文
ESBTraceContext esbTraceContext = GetEsbTraceContext();
//--获取到请求对应服务的绑定
BindingTemplate binding = LoadBalance.GetBinding(bindings, serviceConfig.HBPolicy);
//--构造调用参数
CallState state = new CallState()
{
Binding = binding,
ServiceConfig = serviceConfig,
InvokeParam = invokeParam,
Request = request,
RequestBeginTime = request.请求时间,
RequestEndTime = receiveDateTime,
TraceContext = esbTraceContext,
ServiceVersion = version,
MessageID = Guid.NewGuid().ToString()
};
return CallService(state);
}
/// <summary>
/// 根据服务请求获取到对应的URL绑定信息
/// </summary>
/// <param name="serviceName"></param>
/// <returns></returns>
private static EntityList<BindingTemplate> GetBindings(ESB.Core.Schema.服务请求 request)
{
String serviceName = request.服务名称;
BusinessService service = BusinessService.FindByServiceName(serviceName);
if (service == null)
throw LogUtil.ExceptionAndLog(String.Format("服务【{0}】尚未注册！", serviceName), "", request);
//--查找某个服务下所有启用状态的绑定
EntityList<BindingTemplate> bings = BindingTemplate.FindAllByServiceID(service.ServiceID);
if (bings == null || bings.Count == 0)
{
throw LogUtil.ExceptionAndLog(String.Format("服务【{0}】尚未绑定任何路由地址！", serviceName), "", request);
}
return bings;
}
/// <summary>
/// 获取到服务的图表数据
/// </summary>
/// <param name="serviceName"></param>
/// <returns></returns>
private String GetServiceData(String serviceName, ESB.ServiceMonitor[] lstSM, DateTime now)
{
StringBuilder sbServiceData = new StringBuilder();
///Random random = new Random(serviceName.Length * DateTime.Now.Millisecond);
sbServiceData.Append("[");
List<ESB.ServiceMonitor> lstSMService = lstSM.Where(x => x.ServiceName == serviceName).ToList();
for (int i = 0; i < 30; i++)
{
Int32 invokeTimeSpan = 0;
Int32 callSuccessNum = 0;
Int32 callFailureNum = 0;
Int32 callLevel1Num = 0;
Int32 callLevel2Num = 0;
Int32 callLevel3Num = 0;
if (lstSMService != null || lstSMService.Count > 0)
{
DateTime dtStat = now.AddMinutes(i - 30 + 1);
ESB.ServiceMonitor sm = lstSMService.FirstOrDefault(x => x.Hour == dtStat.Hour && x.Minute == dtStat.Minute);
if (sm != null)
{
invokeTimeSpan = (Int32)sm.MaxInovkeTimeSpan;
callSuccessNum = sm.CallSuccessNum;
callFailureNum = sm.CallFailureNum;
callLevel1Num = sm.CallLevel1Num;
callLevel2Num = sm.CallLevel2Num;
callLevel3Num = sm.CallLevel3Num;
}
}
if(i == 29)
sbServiceData.AppendFormat(@"[{0}, {1}, {2}]", i + 1, invokeTimeSpan, callLevel2Num + callLevel3Num);
else
sbServiceData.AppendFormat(@"[{0}, {1}, {2}],", i + 1, invokeTimeSpan, callLevel2Num + callLevel3Num);
}
sbServiceData.Append("]");
return sbServiceData.ToString();
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, String bindingTemplateID
, String serviceID
, String address
, CallState callState
, String message
, ESB.Core.Schema.服务请求 request
, Int32 isCache = 0)
{
callState.RequestEndTime = DateTime.Now;
TimeSpan ReqTimeSpan = callState.RequestEndTime.Subtract(callState.RequestBeginTime);
ConfigurationManager cm = ConfigurationManager.GetInstance();
String consumerIP = cm.LocalIP;
if (callState.InvokeParam != null && !String.IsNullOrWhiteSpace(callState.InvokeParam.ConsumerIP))
consumerIP = callState.InvokeParam.ConsumerIP;
Int32 isQueue = 0;
if (callState.InvokeParam != null)
isQueue = callState.InvokeParam.IsQueue;
AuditBusiness log = new AuditBusiness()
{
OID = Guid.NewGuid().ToString(),
HostName = request.主机名称,
ServiceName = request.服务名称,
MethodName = request.方法名称,
ReqBeginTime = callState.RequestBeginTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
ReqEndTime = callState.RequestEndTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
Status = status,
MessageID = callState.MessageID,
MessageBody = request.消息内容,
CallBeginTime = callState.CallBeginTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
CallEndTime = callState.CallEndTime.ToString("yyyy-MM-dd HH:mm:ss.ffffff"),
BindingTemplateID = bindingTemplateID,
ServiceID = serviceID,
BindingAddress = address,
ReturnMessageBody = message,
BusinessName = "",
BusinessID = "",
ServiceBeginTime = callState.ServiceBeginTime,
ServiceEndTime = callState.ServiceEndTime,
TraceID = callState.TraceContext.TraceID,
InvokeLevel = callState.TraceContext.InvokeLevel,
InvokeOrder = callState.TraceContext.InvokeOrder,
InvokeID = callState.TraceContext.InvokeID,
InvokeTimeSpan = ReqTimeSpan.TotalMilliseconds,
ConsumerIP = consumerIP,
Version = callState.ServiceVersion,
IsCache = isCache,
IsQueue = isQueue
};
//log.Insert();
//String mqHost = ESBProxy.GetInstance().ESBConfig.Monitor[0].Uri;
//MSMQUtil.SendMessage<AuditBusiness>(log, String.Format(@"FormatName:DIRECT=TCP:{0}\Private$\EsbAuditQueue", "192.168.56.2"));
ESBProxy.GetInstance().MessageQueueClient.SendAuditMessage(log);
//--每调用完一次需要增加调用次数
callState.TraceContext.IncreaseInvokeOrder();
return log.OID;
}
/// <summary>
/// 抛出异常并写日志
/// </summary>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
public static Exception ExceptionAndLog(String exceptionDesc, String message, BindingTemplate binding, ESB.Core.Schema.服务请求 request)
{
CallState state = new CallState()
{
RequestBeginTime = DateTime.Now,
RequestEndTime = DateTime.Now,
CallBeginTime = DateTime.Now,
CallEndTime = DateTime.Now
};
return ExceptionAndLog(state, exceptionDesc, message, binding, request);
}
public static partial BOOL EnableScrollBar(IntPtr hWnd, SB wSBflags, ESB wArrows);
public static extern BOOL EnableScrollBar(IntPtr hWnd, SB wSBflags, ESB wArrows);
private static bool TxEnableScrollBar(IntPtr pThis, SB fuSBFlags, ESB fuArrowflags) => GetHost(pThis).TxEnableScrollBar(fuSBFlags, fuArrowflags);
/// <summary>
/// 将请求消息转换成目标服务的输入参数
/// </summary>
/// <param name="asm"></param>
/// <param name="request"></param>
/// <returns></returns>
private static Object GetRequest(SoapClientItem soapClient, ESB.Core.Schema.服务请求 request)
{
object target = null;
try
{
target = soapClient.CreateRequestObject();
if (target != null)
{
soapClient.SetReqObjProperty(target, "主机名称", request.主机名称);
soapClient.SetReqObjProperty(target, "服务名称", request.服务名称);
soapClient.SetReqObjProperty(target, "方法名称", request.方法名称);
soapClient.SetReqObjProperty(target, "消息内容", request.消息内容);
soapClient.SetReqObjProperty(target, "密码", request.密码);
soapClient.SetReqObjProperty(target, "请求时间", request.请求时间);
}
}
catch (Exception ex)
{
XTrace.WriteLine("构造请求参数失败：" + ex.Message);
}
return target;
}
/// <summary>
/// 抛出异常并写日志
/// </summary>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
/// <returns></returns>
public static Exception ExceptionAndLog(String exceptionDesc, String message, ESB.Core.Schema.服务请求 request)
{
return ExceptionAndLog(exceptionDesc, message, null, request);
}
public void ChangePW(string pw, string newpw)
{
Ajax.WriteRaw(ESB.GetService <UIP>().ChangePW(pw, newpw).ToString());
}
/// <summary>
/// 抛出异常并写日志, 并需要记录异常的时间
/// </summary>
/// <param name="message"></param>
/// <param name="binding"></param>
/// <param name="request"></param>
public static Exception ExceptionAndLog(CallState state, String exceptionDesc, String message, BindingTemplate binding, ESB.Core.Schema.服务请求 request)
{
String messageID = String.Empty;
String exceptionMessage = String.Format("{0}：{1}", exceptionDesc, message);
if (state.CallBeginTime.Year != DateTime.Now.Year) state.CallBeginTime = DateTime.Now;
if (state.CallEndTime.Year != DateTime.Now.Year) state.CallEndTime = DateTime.Now;
if (binding != null)
messageID = AddAuditLog(0, binding, state , exceptionMessage, request);
else
messageID = AddAuditLog(0, "00000000-0000-0000-0000-000000000000"
, String.Empty, string.Empty, state, exceptionMessage, request);
ExceptionCoreTb exception = new ExceptionCoreTb()
{
ExceptionID = Guid.NewGuid().ToString(),
BindingTemplateID = binding == null ? "" : binding.TemplateID,
BindingType = 0,
Description = exceptionDesc,
ExceptionCode = String.Empty,
ExceptionInfo = exceptionMessage,
ExceptionLevel = 0,
ExceptionStatus = 0,
ExceptionTime = DateTime.Now,
ExceptionType = 0,
HostName = request.主机名称,
MessageBody = request.消息内容,
MessageID = messageID,
MethodName = request.方法名称,
RequestPwd = request.密码,
RequestType = 0
};
//exception.Insert();
ESBProxy.GetInstance().MessageQueueClient.SendExceptionMessage(exception);
return new Exception(message);
}
/// <summary>
/// 订阅注册中心的服务变化事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RegistryConsumerClient_OnServiceConfigChange(object sender, ESB.Core.Registry.RegistryEventArgs e)
{
m_EsbConfig = e.ESBConfig;
ConfigQueueThread();
}
/// <summary>
/// 增加审计日志
/// </summary>
public static String AddAuditLog(int status
, BindingTemplate binding
, CallState callState
, String message
, ESB.Core.Schema.服务请求 request
, Int32 isCache = 0)
{
return AddAuditLog(status, binding.TemplateID, binding.ServiceID, binding.Address
, callState
, message, request, isCache);
}
private void button1_Click(object sender, EventArgs e)
{
ESB.SolicitarServicio(id);
}
