public bool GetIPInBeOperation(TMSKSocket socket, IPOperaType type)
{
if (type == IPOperaType.BanConnect)
{
this.processEvent(new IpEventBase(49, socket.AcceptIpAsInt, socket.UserID));
}
long ipAsInt = Global.GetIpAsIntSafe(socket);
lock (IPStatisticsManager.dictOperaMothod)
{
IPOperaData oldData = null;
if (!IPStatisticsManager.dictOperaMothod.TryGetValue(ipAsInt, out oldData))
{
return(false);
}
if (oldData.recvTicks + (long)(oldData.OperaTime[(int)type] * 1000) > TimeUtil.NOW())
{
if (type != IPOperaType.BanConnect)
{
string userID = socket.UserID;
if (!string.IsNullOrEmpty(userID))
{
if (this.CheckUserIdValue(userID, "ThisIPPass"))
{
return(false);
}
}
}
LogManager.WriteLog(LogTypes.IPStatistics, string.Format("Operation {0} ip={1}", type.ToString(), Global.GetIPAddress(socket)), null, true);
return(true);
}
}
return(false);
}
private IPOperaData checkIP(IPStatisticsData ipData, bool local)
{
IPOperaData operaData = null;
foreach (StatisticsControl config in IPStatisticsPersistence.Instance._IPControlList)
{
if (config.Local == local && !this.checkIP(ipData, config))
{
if (!IPStatisticsPersistence.Instance.isCanPassIP(ipData.ipAsInt))
{
if (null == operaData)
{
operaData = new IPOperaData();
}
operaData.ipAsInt = ipData.ipAsInt;
if (config.OperaType >= 0)
{
if (config.OperaParam > operaData.OperaTime[config.OperaType])
{
operaData.OperaTime[config.OperaType] = config.OperaParam;
}
if (ipData.IPInfoParams[config.ParamType] > operaData.OperaParam[config.OperaType])
{
operaData.OperaParam[config.OperaType] = ipData.IPInfoParams[config.ParamType];
}
}
string logmsg = string.Format("cant pass ip={0}:{1} ruleid={2} paramValue={3}", new object[]
{
operaData.ipAsInt,
IpHelper.IntToIp(operaData.ipAsInt),
config.ID,
ipData.IPInfoParams[config.ParamType]
});
if (config.ComParamType >= 0)
{
logmsg += string.Format(" comParamValue={0}", ipData.IPInfoParams[config.ComParamType]);
}
LogManager.WriteLog(LogTypes.IPStatistics, logmsg, null, true);
}
}
}
return(operaData);
}
public void RequestResult()
{
long currTicks = TimeUtil.NOW();
List <long> needDelIPList = new List <long>();
lock (IPStatisticsManager.dictOperaMothod)
{
foreach (KeyValuePair <long, IPOperaData> ipData in IPStatisticsManager.dictOperaMothod)
{
bool needDel = true;
if (this.isCanPassIP(ipData.Key))
{
needDel = true;
}
else
{
for (int i = 0; i < 4; i++)
{
if (ipData.Value.recvTicks + (long)(ipData.Value.OperaTime[i] * 1000) > currTicks)
{
needDel = false;
break;
}
}
}
if (needDel)
{
needDelIPList.Add(ipData.Key);
}
}
foreach (long ip in needDelIPList)
{
IPStatisticsManager.dictOperaMothod.Remove(ip);
}
}
List <IPOperaData> resultList = IPStatisticsClient.getInstance().GetIPStatisticsResult();
LogManager.WriteLog(LogTypes.IPStatistics, string.Format("request ip data minite={0} count={1}", IPStatisticsManager.lastMinite, (resultList == null) ? 0 : resultList.Count), null, true);
if (resultList != null && resultList.Count > 0)
{
lock (IPStatisticsManager.dictOperaMothod)
{
foreach (IPOperaData ipData2 in resultList)
{
if (!this.isCanPassIP(ipData2.ipAsInt))
{
IPOperaData oldData = null;
if (IPStatisticsManager.dictOperaMothod.TryGetValue(ipData2.ipAsInt, out oldData))
{
for (int i = 0; i < 4; i++)
{
if (currTicks + (long)(ipData2.OperaTime[i] * 1000) > oldData.recvTicks + (long)(oldData.OperaTime[i] * 1000))
{
oldData.recvTicks = currTicks;
oldData.OperaTime[i] = ipData2.OperaTime[i];
}
}
}
else
{
ipData2.recvTicks = currTicks;
IPStatisticsManager.dictOperaMothod.Add(ipData2.ipAsInt, ipData2);
}
LogManager.WriteLog(LogTypes.IPStatistics, string.Format("recv need ip minite={0} ip={1}:{2} ", IPStatisticsManager.lastMinite, ipData2.ipAsInt, IpHelper.IntToIp(ipData2.ipAsInt)), null, true);
}
}
}
}
}
private void IPStatisticsProc()
{
Dictionary <int, List <IPStatisticsData> > lastData = new Dictionary <int, List <IPStatisticsData> >();
lock (IPStatisticsService.dictCurrData)
{
foreach (KeyValuePair <int, List <IPStatisticsData> > item in IPStatisticsService.dictCurrData)
{
lastData.Add(item.Key, item.Value);
}
IPStatisticsService.dictCurrData.Clear();
}
Dictionary <long, HashSet <int> > ip2serveridDict = new Dictionary <long, HashSet <int> >();
Dictionary <long, IPStatisticsData> totalDataDict = new Dictionary <long, IPStatisticsData>();
Dictionary <int, List <IPOperaData> > IPOperaDataDict = new Dictionary <int, List <IPOperaData> >();
foreach (KeyValuePair <int, List <IPStatisticsData> > ipDataList in lastData)
{
foreach (IPStatisticsData ipData in ipDataList.Value)
{
try
{
IPOperaData operaData = this.checkIP(ipData, true);
if (null != operaData)
{
List <IPOperaData> opList;
if (!IPOperaDataDict.TryGetValue(ipDataList.Key, out opList))
{
opList = new List <IPOperaData>();
IPOperaDataDict[ipDataList.Key] = opList;
}
opList.Add(operaData);
}
if (ip2serveridDict.ContainsKey(ipData.ipAsInt))
{
ip2serveridDict[ipData.ipAsInt].Add(ipDataList.Key);
}
else
{
HashSet <int> hashServerID = new HashSet <int>();
hashServerID.Add(ipDataList.Key);
ip2serveridDict.Add(ipData.ipAsInt, hashServerID);
}
}
catch (Exception ex)
{
LogManager.WriteLog(LogTypes.Error, "IPStatisticsProc", ex, false);
}
IPStatisticsData tmpIPData = null;
if (totalDataDict.TryGetValue(ipData.ipAsInt, out tmpIPData))
{
tmpIPData += ipData;
}
else
{
totalDataDict.Add(ipData.ipAsInt, ipData);
}
}
}
List <IPOperaData> resultList = new List <IPOperaData>();
foreach (KeyValuePair <long, IPStatisticsData> ipData2 in totalDataDict)
{
IPOperaData operaData = this.checkIP(ipData2.Value, false);
if (null != operaData)
{
resultList.Add(operaData);
}
}
this.AddOpList(IPOperaDataDict, resultList, ip2serveridDict);
lock (IPStatisticsService.dictIPOperaData)
{
IPStatisticsService.dictIPOperaData = IPOperaDataDict;
}
}
