private static void MonitorProc()
{
while (true)
{
try {
//
// 总觉着1s太短，为cpu感到累得慌，忍不住改了
Thread.Sleep(5 * 1000);
_currentTicks = Environment.TickCount;
foreach (var k in _txPool.Items)
{
var tx = k.Value;
if (tx == null)
{
continue;
}
//
// 判断链接已经断开
if (tx.GetSocket().Closed)
{
//
// 无论怎么样，先移走
_txPool.Remove(k.Key);
try {
tx.Callback(RpcResponse.Create(RpcErrorCode.ConnectionBroken, null));
_tracing.ErrorFmt("ConnectionBroken in {0} begin {1}: tx: {2}",
tx.GetSocket().RemoteUri,
tx.GetSocket().ConnectedTime,
ObjectHelper.DumpObject(tx));
} catch (Exception ex) {
_tracing.ErrorFmt(ex, "RpcTcpTransactionManager.MonitorProc Failed");
}
}
//
// 判断事务超时
if (tx.Timeout > 0 && (_currentTicks - tx.Ticks) > tx.Timeout)
{
//
// 无论怎么样，先移走
// 原先如果Callback出了exception的话，会没有移走value，再次循环到此还是一样的情况，pool中value会累积
_txPool.Remove(k.Key);
try {
k.Value.Callback(RpcResponse.Create(RpcErrorCode.TransactionTimeout, null));
} catch (Exception ex) {
_tracing.ErrorFmt(ex, "RpcTcpTransactionManager.MonitorProc Failed");
}
}
}
//RpcTcpClientPerfCounter.Instance.ActiveTransactions.SetRawValue(_txPool.Count);
} catch (ThreadAbortException) {
Thread.ResetAbort();
return;
} catch (Exception ex) {
_tracing.ErrorFmt(ex, "RpcTcpTransactionManager.MonitorProc Failed");
}
}
}
public void BeginReceive()
{
Socket s = _socket;
if (s != null)
{
try
{
s.BeginReceive(_recvBuffer, 0, _recvBufferSize, SocketFlags.None, new AsyncCallback(BeginReceiveCallback), _socket);
}
catch (SocketException ex)
{
Socket sEx = _socket;
_tracing.ErrorFmt(ex, "SocketDataTransceiver接收数据发生异常，SocketErrorCode：{0}，RemoteEndPoint：{1}，SocketDataTransceiver将被迫关闭！", ex.SocketErrorCode, sEx == null ? "null" : ((IPEndPoint)(_socket.RemoteEndPoint)).ToString());
Close();
}
catch (ObjectDisposedException ex)
{
_tracing.Error(ex, "因为socket已释放，SocketDataTransceiver接收数据发生异常，SocketDataTransceiver将被迫关闭！");
Close();
}
catch (Exception ex)
{
_tracing.Error(ex, "SocketDataTransceiver接收数据发生异常，SocketDataTransceiver将被迫关闭！");
Close();
}
}
}
internal void OnException(DatabaseOperationContext ctx, Exception ex)
{
ctx.Ex = ex;
_perfCounters.CommandFailedTotal.Increment();
_tracing.ErrorFmt(ex, "{0} Failed in {1} \r\n{2}",
ctx.Info,
_configItem.Name,
ctx.Operation.FormatSql(ctx.SpName, ctx.Parameters, ctx.Values));
}
/// <summary>
/// 启动接受客户端连接
/// </summary>
private void StartAccept()
{
if (isListening)
{
bool asyAccept = false;
try
{
asyAccept = listener.AcceptAsync(accpetEventArgs);
}
catch (SocketException ex)
{
_tracing.ErrorFmt(ex, "AcceptAsync发生Sokcet异常，ErrorCode：{0}，StartAccept被迫中止", ex.ErrorCode);
return;
}
catch (ObjectDisposedException ex)
{
_tracing.Error(ex, "AcceptAsync发生异常，监听socket已释放，StartAccept被迫中止");
return;
}
catch (Exception ex)
{
_tracing.Error(ex, "AcceptAsync发生异常，StartAccept被迫中止");
return;
}
if (!asyAccept)
{
ProcessAccept(accpetEventArgs);
}
}
}
/// <summary>
/// 不关心返回结果的调用, 但错误会被Trace系统记录
/// </summary>
/// <param name="methodName">方法名</param>
/// <typeparam name="TArgs">调用的参数类型</typeparam>
/// <param name="args">调用的参数</param>
/// <remarks></remarks>
public void InvokeOneway <TArgs>(string methodName, TArgs args)
{
BeginInvoke <TArgs>(methodName, args,
delegate(RpcClientContext ctx) {
try {
ctx.EndInvoke();
} catch (Exception ex) {
_tracing.ErrorFmt(ex, "InvokeOneway Failed");
}
}
);
}
internal void NewTransaction(TccTransaction <TContext> trans)
{
_counter.ActiveTransaction.Increment();
_counter.TransOpenPerSec.Increment();
lock (_syncRoot) {
_activeTrans.Add(trans.TxId, trans);
}
if (_persister != null)
{
try
{
_persister.NewTransaction(trans.GetData());
}
catch (Exception ex)
{
_tracing.ErrorFmt(ex, "Tcc Persister Failed");
}
}
}
internal void RunAction(TContext context, TccAction nextAction, Action <Exception> callback)
{
Action <TccWorkUnitContext <TContext> > Proc;
TccWorkState succState;
TccWorkState failState;
Tracing.InfoFmt("WorkUnit<{0}>.Run{1} State:{2}", _workName, nextAction, _state);
switch (nextAction)
{
case TccAction.Try:
if (_state != TccWorkState.None)
{
throw new Exception("Unexcepted WorkUnit State:" + _state);
}
_state = TccWorkState.Trying;
Proc = Try;
succState = TccWorkState.Tryed;
failState = TccWorkState.TryFailed;
break;
case TccAction.Confirm:
if (_state != TccWorkState.Tryed)
{
throw new Exception("Unexcepted WorkUnit State:" + _state);
}
Proc = Confirm;
_state = TccWorkState.Confirming;
succState = TccWorkState.Confirmed;
failState = TccWorkState.ConfirmFailed;
break;
case TccAction.Cancel:
if (_state != TccWorkState.Tryed && _state != TccWorkState.TryFailed)
{
throw new Exception("Unexcepted WorkUnit State:" + _state);
}
Proc = Cancel;
_state = TccWorkState.Cancelling;
succState = TccWorkState.Cancelled;
failState = TccWorkState.CancelFailed;
break;
default:
throw new Exception("NeverGoHere");
}
int hasReturned = 0;
TccWorkUnitContext <TContext> ctx = new TccWorkUnitContext <TContext>(
context,
delegate(Exception ex) {
if (ex != null)
{
Tracing.ErrorFmt(ex, "WorkUnit<{0}>.Run{1} Failed in callback.", _workName, nextAction);
}
else
{
Tracing.InfoFmt("WorkUnit<{0}>.Run{1} ok.", _workName, nextAction);
}
if (Interlocked.CompareExchange(ref hasReturned, 1, 0) == 0)
{
if (ex == null)
{
_state = succState;
callback(null);
}
else
{
_error = ex;
_state = failState;
callback(ex);
}
}
else
{
Tracing.ErrorFmt("WorkUnit<{0}>.Run{1} callback return more than once.", _workName, nextAction);
}
}
);
try {
Proc(ctx);
} catch (Exception ex) {
if (Interlocked.CompareExchange(ref hasReturned, 1, 0) == 0)
{
Tracing.ErrorFmt(ex, "WorkUnit<{0}>.Run{1} Failed.", _workName, nextAction);
_error = ex;
_state = failState;
callback(ex);
}
else
{
Tracing.ErrorFmt("WorkUnit<{0}>.Run{1} return more than once.", _workName, nextAction);
}
}
}
/// <summary>
/// Send mail to user.
/// </summary>
/// <param name="template"></param>
public void SendMailAsync(DefaultMailTemplate template, UserTask taskItem, Action <Exception, UserTask> callback)
{
List <LinkedResource> resList = new List <LinkedResource>();
List <IDisposable> resourceList = new List <IDisposable>();
try
{
taskItem.beginTicks = DateTime.Now.Ticks;
template.Process();
SmtpClient client = new SmtpClient(template.mailConfig.Host, template.mailConfig.Port);
resourceList.Add(client);
client.Timeout = EDMMSConfigSection.Current.MailClientTimeout;
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential(template.mailConfig.UserName, template.mailConfig.Password);
MailMessage message = new MailMessage();
resourceList.Add(message);
message.From = new MailAddress(template.mailConfig.From, template.mailConfig.FromFriendlyName);
foreach (string to in template.ToList)
{
message.To.Add(to);
}
message.Subject = template.Subject;
string bodyString = template.tempBodyString;
foreach (string stub in template.resourceIdDic.Keys)
{
MemoryStream ms = new MemoryStream(template.resourceIdDic[stub]);
resourceList.Add(ms);
LinkedResource imageResource = new LinkedResource(ms, "image/jpeg");
resourceList.Add(imageResource);
resList.Add(imageResource);
bodyString = bodyString.Replace(stub, imageResource.ContentId);
}
AlternateView htmlView = AlternateView.CreateAlternateViewFromString(bodyString, null, "text/html");
resourceList.Add(htmlView);
foreach (LinkedResource res in resList)
{
htmlView.LinkedResources.Add(res);
}
//
message.AlternateViews.Add(htmlView);
client.SendCompleted += (s, e) =>
{
try
{
MailMessage msg = e.UserState as MailMessage;
if (msg != null)
{
msg.Dispose();
}
SmtpClient mailClient = s as SmtpClient;
if (mailClient != null)
{
mailClient.Dispose();
}
if (callback != null)
{
callback(e.Error, taskItem);
}
}
catch (Exception inEx)
{
tracing.ErrorFmt(inEx, "client.SendCompleted failed with unexpected error.");
}
};
client.SendAsync(message, message);
}
catch (Exception)
{
foreach (IDisposable item in resourceList)
{
item.Dispose();
}
throw;
}
}
