/// <summary>
/// 构造函数-资源模式[数据资源-文件-流]
/// </summary>
/// <param name="message"></param>
/// <param name="tmpDir"></param>
/// <param name="threadCount"></param>
internal ReceiveDataItem(SendDataNotifyMessage message, string tmpDir, int threadCount)
: base(message.Timeout)
{
this._isResourceMod = true;
this._streamArr = new Stream[threadCount];
if (message.ResourceType == ResourceTypeConstant.ResourceData)
{
try
{
this.InitMemoryStream((int)message.Size);
}
catch (OutOfMemoryException)
{
//内存不足了,写文件
this.InitFileStream(tmpDir, null);
}
}
else if (message.ResourceType == ResourceTypeConstant.ResourceFile)
{
this.InitFileStream(tmpDir, message.FileName);
}
else if (message.ResourceType == ResourceTypeConstant.ResourceStream)
{
this.InitFileStream(tmpDir, null);
}
else
{
throw new NotImplementedException($"未实现的数据资源类型:{message.ResourceType}");
}
this.NotifyMessage = message;
}
/// <summary>
/// 构造函数-消息模式
/// </summary>
/// <param name="message"></param>
internal ReceiveDataItem(SendDataNotifyMessage message)
: base(message.Timeout)
{
this._isResourceMod = false;
var data = new byte[message.Data.Length];
Array.Copy(message.Data, data, data.Length);
this.Data = data;
this.NotifyMessage = message;
this._flag = true;
}
private bool ProMessageMode(SendDataNotifyMessage message)
{
var receiveDataItem = new ReceiveDataItem(message);
if (!this._revItemDic.TryAdd(message.Header.Rid, receiveDataItem))
{
receiveDataItem.Close(true);
Loger.Error("this._revItemDic.TryAdd失败");
return(false);
}
this.SendTransferCompletedMessage(message);
return(true);
}
private void SendTransferCompletedMessage(SendDataNotifyMessage notifyMessage)
{
var transferCompletedMessage = new TransferCompletedMessage(notifyMessage);
var buffer = transferCompletedMessage.GenerateBuffer();
var id = CacheKeyGenerator.GenerateWaitTransferCompletedAckMessageEventWaitHandleId(notifyMessage.Header.Rid);
var eventHandleInfo = AutoEventWaitHandleManager.CreateEventWaitHandle(id);
try
{
long beginTs = TimeEx.GetTimestamp();
long endTs = beginTs;
while (!notifyMessage.IsTimeout(beginTs, endTs))
{
try
{
int rto = TransferParaManager.GetRto(notifyMessage.SrcEndPoint);
this._net.Send(buffer, notifyMessage.SrcEndPoint);
if (eventHandleInfo.EventWaitHandle.WaitOne(rto))
{
break;
}
else
{
TransferParaManager.AdjustUpRto(notifyMessage.SrcEndPoint);
}
}
catch (SendDataException)
{
break;
}
catch (Exception ex)
{
Loger.Error(ex, "发送传输完成消息异常");
}
endTs = TimeEx.GetTimestamp();
}
}
finally
{
AutoEventWaitHandleManager.RemoveEventWaitHandle(id);
eventHandleInfo.EventWaitHandle.Dispose();
}
//注:如果一直都没有收到确认消息,则超时线程处理
}
internal void Send()
{
var sendDataNotifyMessage = new SendDataNotifyMessage(this._resoucesInfo);
byte[] buffer = sendDataNotifyMessage.GenerateBuffer();
var beginSendDataTimestamp = this._resoucesInfo.LastAccessTimestamp;
this._net.Send(buffer, this._resoucesInfo.Policy.RemoteEP);
int repeatCount = 0;
while (this._net.Status)
{
repeatCount++;
try
{
if (this._transferCompletedAckEventWaitHandle.WaitOne(this._resoucesInfo.Policy.MillisecondsTimeout))
{
break;
}
else
{
//超时一次请求数据或传输完成通知都未收到过,重新发送数据
if (beginSendDataTimestamp == this._resoucesInfo.LastAccessTimestamp)
{
this._net.Send(buffer, this._resoucesInfo.Policy.RemoteEP);
}
}
}
catch (ObjectDisposedException)
{
throw new TimeoutException("发送超时");
}
if (!this._net.Status)
{
//发送取消,已停止
break;
}
if (this._resoucesInfo.IsTimeout() && repeatCount >= this._resoucesInfo.Policy.RepeatCount)
{
throw new TimeoutException("发送超时");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="reqDataThreads"></param>
/// <param name="millisecondsTimeout">超时时长,单位毫秒</param>
public TransferReqDataSchduleInfoManager(SendDataNotifyMessage message, ThreadEx[] reqDataThreads, int millisecondsTimeout)
: base(millisecondsTimeout)
{
this._notifyMessage = message;
var length = message.Size;
var segLength = length / reqDataThreads.Length;
int lastSegIndex = reqDataThreads.Length - 1;
long postion = 0;
for (var i = 0; i < reqDataThreads.Length; i++)
{
if (i == lastSegIndex)
{
segLength = length - postion;
}
this._reqDataSchduleInfoDic.Add(reqDataThreads[i].ManagedThreadId, new TransferReqDataSchduleInfo(postion, segLength, this.UpdateLastAccessTimestamp));
postion += segLength;
}
}
internal void ProSendNotify(SendDataNotifyMessage message)
{
try
{
bool proResult;
switch (message.ResourceType)
{
case ResourceTypeConstant.Message:
proResult = this.ProMessageMode(message);
break;
case ResourceTypeConstant.ResourceData:
case ResourceTypeConstant.ResourceStream:
case ResourceTypeConstant.ResourceFile:
proResult = this.ProResourceMode(message);
break;
default:
Loger.Warn($"未知的发送模式{message.ResourceType}");
proResult = false;
break;
}
if (proResult)
{
try
{
this._revNewDataNoyifyEventHandle.Set();
}
catch (ObjectDisposedException)
{ }
}
}
catch (Exception ex)
{
Loger.Error(ex, "ProSendNotify发生异常");
}
}
private bool ProResourceMode(SendDataNotifyMessage message)
{
lock (this._revItemDicLock)
{
var rid = message.Header.Rid;
ReceiveDataItem receiveDataItem;
if (this._revItemDic.TryGetValue(rid, out receiveDataItem))
{
receiveDataItem.UpdateLastAccessTimestamp();
//Loger.Warn($"[RID:{rid}]的接收项已存在,忽略");
return(false);
}
if (MemoryCacheEx.Get(CacheKeyGenerator.GenerateRevTimeoutKey(rid)) != null)
{
//Loger.Warn($"[RID:{rid}]接收已超时,忽略");
return(false);
}
//Loger.Warn($"处理RID[{rid}]发送通知");
receiveDataItem = new ReceiveDataItem(message, this._config.LocalFileDirectory, this._config.TransferThreadCount);
if (!this._revItemDic.TryAdd(rid, receiveDataItem))
{
receiveDataItem.Close(true);
Loger.Error("this._revItemDic.TryAdd失败,原因未知");
return(false);
}
int millisecondsTimeout;
var revItemCount = this._revItemDic.Count;
if (revItemCount < 1)
{
millisecondsTimeout = message.Timeout / this._config.TimeoutHeartMul;
}
else
{
millisecondsTimeout = message.Timeout / (revItemCount * this._config.TimeoutHeartMul);
}
var reqDataSchduleInfoManager = new TransferReqDataSchduleInfoManager(message, this._reqDataThreads, millisecondsTimeout);
TransferResourceManager resourceTransferManager;
var priority = message.Priority;
if (this._priorityResourceTransferManagerSortedList.ContainsKey(priority))
{
resourceTransferManager = this._priorityResourceTransferManagerSortedList[priority];
}
else
{
lock (this._priorityResourceTransferManagerSortedListLock)
{
if (this._priorityResourceTransferManagerSortedList.ContainsKey(priority))
{
resourceTransferManager = this._priorityResourceTransferManagerSortedList[priority];
}
else
{
resourceTransferManager = new TransferResourceManager();
this._priorityResourceTransferManagerSortedList.Add(priority, resourceTransferManager);
}
}
}
if (resourceTransferManager.AddReqDataSchduleInfoManager(reqDataSchduleInfoManager))
{
this.SendReqDataThreadsEventHandleNotify();
return(true);
}
else
{
Loger.Error("AddReqDataSchduleInfoManager失败,原因未知");
if (!this._revItemDic.TryRemove(rid, out receiveDataItem))
{
receiveDataItem.Close(true);
}
return(false);
}
}
}
/// <summary>
/// 创建
/// </summary>
/// <param name="sendDataNotifyMessage"></param>
public TransferCompletedMessage(SendDataNotifyMessage sendDataNotifyMessage)
: base(new CommonHeader(TransferCommands.TransferCompleted, TimeEx.GetTimestamp(), sendDataNotifyMessage.Header.Rid))
{
}
