/// <summary>
/// 是否包含服务上下文对应的消息发布对象
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public bool Contains(ServiceContext context)
{
ServiceRequest request = context.Request;
bool sessionRequired = context.SessionRequired;
ServicePublisher pub = null;
string key = request.ServiceUrl;
return(dict.ContainsKey(key));
}
/// <summary>
/// 获取出版商，如果没有，则创建一个（享元模式）
/// </summary>
/// <param name="request">服务请求对象</param>
/// <returns>出版商</returns>
public ServicePublisher GetPublisher(IServiceContext context)
{
ServiceRequest request = context.Request;
bool sessionRequired = context.SessionRequired;
string key = "";
if (request.RequestModel == RequestModel.ServiceEvent)
{
key = request.ServiceUrl;
}
else
{
key = string.Format("Publish://{0}/{1}", request.ServiceName, request.MethodName);
}
if (dict.ContainsKey(key))
{
return(dict[key]);
}
else
{
lock (_syncLock)
{
if (dict.ContainsKey(key))
{
return(dict[key]);
}
else
{
ServicePublisher pub = null;
if (request.RequestModel == RequestModel.ServiceEvent)
{
pub = new EventServicePublisher(key, context);
}
else
{
if (sessionRequired)
{
pub = new SessionServicePublisher(key);
}
else
{
pub = new NoneSessionServicePublisher(key);
}
}
dict[key] = pub;
return(pub);
}
}
}
}
/// <summary>
/// 获取出版商，如果没有，则创建一个（享元模式）
/// </summary>
/// <param name="request">服务请求对象</param>
/// <returns>出版商</returns>
public ServicePublisher GetPublisher(ServiceContext context)
{
ServiceRequest request = context.Request;
bool sessionRequired = context.SessionRequired;
ServicePublisher pub = null;
string key = request.ServiceUrl;
//if (request.RequestModel == RequestModel.ServiceEvent)
// key = request.ServiceUrl;
//else
// key = string.Format("Publish://{0}/{1}", request.ServiceName, request.MethodName);
if (dict.ContainsKey(key))
{
pub = dict[key];
}
else
{
lock (_syncLock)
{
if (dict.ContainsKey(key))
{
pub = dict[key];
}
else
{
if (request.RequestModel == RequestModel.ServiceEvent)
{
pub = new EventServicePublisher(key, context);
}
else
{
if (sessionRequired)
{
pub = new SessionServicePublisher(key);
}
else
{
pub = new NoneSessionServicePublisher(key);
}
pub.Context = context;
}
dict[key] = pub;
}
}
}
pub.AddProcessedRequest(request);
return(pub);
}
protected override void Process()
{
if (this.Message.StartsWith("[CMD]"))
{
string cmdString = this.Message.Substring("[CMD]".Length);
switch (cmdString)
{
case "DeSubscribeService":
SubscriberInfo objSubInfo;
ServicePublisher publisher = PublisherFactory.Instance.Find(this.SubscriberInfo, out objSubInfo);
if (publisher != null)
{
publisher.DeSubscribe(objSubInfo);
}
break;
case "UpdateServiceHost":
string tempPath = System.IO.Path.GetTempPath();
DirectoryInfo info = new DirectoryInfo(tempPath);
string servicesTempFolder = Path.Combine(info.FullName, "_TartGetTempFolder_Services");
Console.WriteLine("接收到[服务升级]命令，准备调用批处理程序...");
System.Diagnostics.Process.Start(".\\UpdateService.bat", servicesTempFolder);
Console.WriteLine("批处理程序启动成功，主程序即将退出。");
Console.Out.Flush();
System.Environment.Exit(0);
break;
case "RemoteConsoleOutput": //远程控制台输出
MessageListener currLstn = MessageCenter.Instance.GetListener(this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort);
Program.RemoteConsoleListener = currLstn;
break;
}
}
////取消订阅的服务方法
//if (this.Message.Substring("[CMD]".Length) == "DeSubscribeService")
//{
// SubscriberInfo objSubInfo;
// ServicePublisher publisher = PublisherFactory.Instance.Find(this.SubscriberInfo, out objSubInfo);
// if (publisher != null)
// publisher.DeSubscribe(objSubInfo);
//}
////UpdateServiceHost 升级服务器
}
/// <summary>
/// 根据订阅者信息，查找它所在的发布者
/// </summary>
/// <param name="sourceSubInfo"></param>
/// <returns></returns>
public ServicePublisher Find(SubscriberInfo sourceSubInfo, out SubscriberInfo objSubInfo)
{
objSubInfo = null;
foreach (string key in dict.Keys)
{
ServicePublisher item = dict[key];
var tempSubinfo = item.SubscriberInfoList.ToArray().FirstOrDefault(p => p.FromIP == sourceSubInfo.FromIP &&
p.FromPort == sourceSubInfo.FromPort &&
p.MessageID == sourceSubInfo.MessageID);
if (tempSubinfo != null)
{
objSubInfo = tempSubinfo;
return(item);
}
}
return(null);
}
/// <summary>
/// 为当前监听器开启一个工作线程，不断处理请求，并将处理结果送给监听器
/// </summary>
/// <param name="listener"></param>
/// <param name="messageId"></param>
/// <param name="context"></param>
private void StartPublishWorker(ServiceContext context)
{
//ServiceRequest request = context.Request;
//request.ClientIP = this.SubscriberInfo.FromIP;
//request.ClientPort = this.SubscriberInfo.FromPort;
//request.ClientIdentity = this.SubscriberInfo.Identity;
this.SubscriberInfo.Request = context.Request;
ServicePublisher publisher = PublisherFactory.Instance.GetPublisher(context);
if (publisher.SubscriberInfoList.Count == 0)
{
publisher.PublisherErrorEvent += new EventHandler <ServiceErrorEventArgs>(publisher_PublisherErrorEvent);
}
publisher.Host = context.Host;
publisher.ParallelExecute = context.ParallelExecute;
publisher.BatchInterval = context.BatchInterval;
publisher.SubscriberInfoList.Add(this.SubscriberInfo);//监听器可能存在端口复用的情况，因此需要及时释放SubscriberInfoList 的元素
publisher.StartWork(context.Request.RequestModel == RequestModel.ServiceEvent);
}
protected override void Process()
{
string message = this.Message;
string identity = this.SubscriberInfo.Identity;
string processMesssage = string.Empty;
DateTime beginTime = DateTime.Now;
processMesssage = string.Format("[{0}]正在处理服务请求--From: {1}:{2},Identity:{3}\r\n>>[PMID:{4}]{5}",
beginTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort, identity,
this.SubscriberInfo.MessageID,
this.Message.Length > 256 ? this.Message.Substring(0, 256) : this.Message);
Console.WriteLine(processMesssage);
int msgId = this.SubscriberInfo.MessageID;//执行完服务方法后，MessageID 可能被另外一个线程改变
//执行服务方法的时候，由服务方法指名是否需要维持会话状态
ServiceContext context = new ServiceContext(message);
//如果当前请求是 发布-订阅模式，多个订阅端使用一个发布对象实例
if (context.Request.RequestModel == RequestModel.Publish || context.Request.RequestModel == RequestModel.ServiceEvent)
{
if (PublisherFactory.Instance.Contains(context)) //已经订阅过
{
ServicePublisher publisher = PublisherFactory.Instance.GetPublisher(context);
if (publisher.TaskIsRunning)
{
publisher.SubscriberInfoList.Add(this.SubscriberInfo);
processMesssage = string.Format("\r\n[{0}]当前监听器已经加入消息发布线程， {1}:{2},Identity:{3}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort, this.SubscriberInfo.Identity);
Console.WriteLine(processMesssage);
return;
}
}
}
context.Host = Program.Host;
context.ServiceErrorEvent += new EventHandler <ServiceErrorEventArgs>(context_ServiceErrorEvent);
context.Request.ClientIP = this.SubscriberInfo.FromIP;
context.Request.ClientPort = this.SubscriberInfo.FromPort;
context.Request.ClientIdentity = this.SubscriberInfo.Identity;
context.User = MessageProcessBase.GetServiceIdentity(this.SubscriberInfo._innerListener);
context.GetMessageFun = strPara =>
{
MessageListener currLst = MessageCenter.Instance.GetListener(this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort);
if (currLst == null)
{
throw new NullReferenceException("监听器不存在！");
}
return(currLst.CallBackFunction(msgId, strPara));
};
context.PreGetMessageFun = strPara =>
{
MessageListener currLst = MessageCenter.Instance.GetListener(this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort);
if (currLst == null)
{
throw new NullReferenceException("监听器不存在！");
}
return(currLst.PreCallBackFunction(msgId, strPara));
};
string result = string.Empty;
bool noResult = false;
context.InitRequestParameters();
if (!context.HasError)
{
//Console.WriteLine("Process Service begin...");
context.ProcessService(this.SubscriberInfo.SessionID);
//Console.WriteLine("Process Service ok...");
result = context.Response.AllText;
noResult = context.NoResultRecord(result);
}
else
{
result = ServiceConst.CreateServiceErrorMessage(context.ErrorMessage);
//base.OnServiceError(context, new ServiceErrorEventArgs(context.ErrorMessage));
}
DateTime endTime = DateTime.Now;
processMesssage = string.Format("[{0}]请求处理完毕({1}ms)--To: {2}:{3},Identity:{4}\r\n>>[PMID:{5}]消息长度：{6} -------",
endTime.ToString("yyyy-MM-dd HH:mm:ss.fff"),
endTime.Subtract(beginTime).TotalMilliseconds,
this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort, identity,
this.SubscriberInfo.MessageID,
noResult ? "[Empty Result]" : result.Length.ToString("###,###") + "字节");
Console.WriteLine(processMesssage);
//此处内容可能很大，不能全程输出
if (context.Response.ResultType == typeof(byte[]))
{
Console.WriteLine("[byte Content]");
}
else
{
Console.WriteLine("result:{0}", result.Length > 100 ? result.Substring(0, 100) + " ..." : result);
}
MessageListener currLstn = MessageCenter.Instance.GetListener(this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort);
if (currLstn == null)
{
processMesssage = "Error:监听器未找到，已取消发送消息。请求源：" + this.SubscriberInfo.Message;
Console.WriteLine(processMesssage);
return;
}
if (context.Request.RequestModel == RequestModel.GetService)
{
//对于请求-响应模式，处理完服务以后，始终会回调客户端的方法（如果提供的话）
if (MessageCenter.Instance.ResponseMessage(currLstn, msgId, result))
{
Console.WriteLine("Reponse Message OK.");
}
}
else
{
//订阅模式，仅在服务处理有结果的情况下，才给客户端发布数据。
if (!noResult)
{
if (MessageCenter.Instance.NotifyOneMessage(currLstn, msgId, result))
{
Console.WriteLine("Publish Message OK.");
}
else
{
Console.WriteLine("Publish no result.");
}
}
if (!context.HasError)
{
StartPublishWorker(context);//把Host传递进去
processMesssage = string.Format("\r\n[{0}]当前监听器已经加入工作线程， {1}:{2},Identity:{3}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), this.SubscriberInfo.FromIP, this.SubscriberInfo.FromPort, this.SubscriberInfo.Identity);
Console.WriteLine(processMesssage);
}
}
}
