kami_itunes_june/AppleBatch_June.Utils/ProxyAccountCache.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;

namespace AppleBatch_June.Utils
{
	public class ProxyAccountCache
	{
		[Serializable]
		public class LockCounts
		{
			public int Count { get; set; }
		}

		public static ConcurrentDictionary<string, ProxyAccountModel> proxyAccountCacheInfos = new ConcurrentDictionary<string, ProxyAccountModel>();

		public static readonly Dictionary<string, LockCounts> objReddemLockS = new Dictionary<string, LockCounts>();

		public static int maxAddCount = 50;

		public static void addwebProxyIp(string appleId, string ip, string userAgent, string iframeId)
		{
			if (string.IsNullOrEmpty(appleId) || AppSysConfig.isLowMemoryModel || proxyAccountCacheInfos.Count >= maxAddCount)
			{
				return;
			}
			initLock(appleId);
			lock (objReddemLockS[appleId.Trim()])
			{
				if (proxyAccountCacheInfos.ContainsKey(appleId.Trim()))
				{
					proxyAccountCacheInfos[appleId.Trim()].ProxyIp = ip;
					return;
				}
				ProxyAccountModel ReddemUserInfos = new ProxyAccountModel
				{
					ProxyIp = ip,
					accountWebUserAgent = userAgent
				};
				proxyAccountCacheInfos.AddOrUpdate(appleId.Trim(), ReddemUserInfos, (string c, ProxyAccountModel d) => ReddemUserInfos);
			}
		}

		public static void addProxyIp(string appleId, string ip)
		{
			if (string.IsNullOrEmpty(appleId) || AppSysConfig.isLowMemoryModel)
			{
				return;
			}
			initLock(appleId);
			lock (objReddemLockS[appleId.Trim()])
			{
				if (proxyAccountCacheInfos.ContainsKey(appleId.Trim()))
				{
					proxyAccountCacheInfos[appleId.Trim()].ProxyIp = ip;
					return;
				}
				ProxyAccountModel ReddemUserInfos = new ProxyAccountModel
				{
					ProxyIp = ip
				};
				proxyAccountCacheInfos.AddOrUpdate(appleId.Trim(), ReddemUserInfos, (string c, ProxyAccountModel d) => ReddemUserInfos);
			}
		}

		public static List<ProxyAccountModel> GetProxyAccountModel(string oldIp)
		{
			List<ProxyAccountModel> list = new List<ProxyAccountModel>();
			if (!string.IsNullOrEmpty(oldIp) && !AppSysConfig.isLowMemoryModel)
			{
				lock (objReddemLockS)
				{
					foreach (KeyValuePair<string, ProxyAccountModel> item in proxyAccountCacheInfos.Where((KeyValuePair<string, ProxyAccountModel> c) => c.Value.ProxyIp == oldIp))
					{
						if (item.Key != null)
						{
							list.Add(item.Value);
						}
					}
					return list;
				}
			}
			return list;
		}

		public static void ReclassifyAccountAll()
		{
			lock (objReddemLockS)
			{
				foreach (KeyValuePair<string, ProxyAccountModel> proxyAccountCacheInfo in proxyAccountCacheInfos)
				{
					string proxyIp = "rest_ip," + proxyAccountCacheInfo.Key.ToLower();
					proxyAccountCacheInfo.Value.ProxyIp = proxyIp;
					proxyAccountCacheInfo.Value.expirationTime = null;
				}
			}
		}

		public static void ReclassifyAccountIp(string appleId)
		{
			if (string.IsNullOrEmpty(appleId))
			{
				return;
			}
			lock (objReddemLockS)
			{
				if (proxyAccountCacheInfos.ContainsKey(appleId.Trim()))
				{
					string proxyIp = "rest_ip," + appleId.ToLower();
					proxyAccountCacheInfos[appleId.Trim()].ProxyIp = proxyIp;
					proxyAccountCacheInfos[appleId.Trim()].expirationTime = null;
				}
			}
		}

		public static ProxyAccountModel getProxyAccountInfo(string appleId, int maxCount = 0)
		{
			ProxyAccountModel proxyAccountModel = null;
			string text = "";
			if (!string.IsNullOrEmpty(appleId) && !AppSysConfig.isLowMemoryModel)
			{
				initLock(appleId.Trim());
				lock (objReddemLockS[appleId.Trim()])
				{
					if (proxyAccountCacheInfos.ContainsKey(appleId.Trim()))
					{
						proxyAccountModel = proxyAccountCacheInfos[appleId.Trim()];
						if (proxyAccountModel != null)
						{
							if (maxCount > 0 && proxyAccountModel.getIpCount > maxCount)
							{
								string proxyIp = "rest_ip," + appleId.ToLower();
								proxyAccountModel.expirationTime = null;
								proxyAccountModel.ProxyIp = proxyIp;
								return proxyAccountModel;
							}
							proxyAccountModel.getIpCount++;
							if (proxyAccountModel.expirationTime.HasValue)
							{
								if (!(proxyAccountModel.expirationTime.Value.AddSeconds(-15.0) > DateTime.Now))
								{
									string proxyIp2 = "rest_ip," + appleId.ToLower();
									proxyAccountModel.ProxyIp = proxyIp2;
									return proxyAccountModel;
								}
								text = proxyAccountModel.ProxyIp;
							}
							else
							{
								text = proxyAccountModel.ProxyIp;
							}
						}
					}
				}
				if (!string.IsNullOrEmpty(text))
				{
					lock (objReddemLockS[appleId.Trim()])
					{
						using Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
						string[] array = text.Substring(text.IndexOf('@') + 1).Split(':');
						if (array.Length != 2)
						{
							return proxyAccountModel;
						}
						if (!array[0].Contains("|"))
						{
							string ipString = array[0];
							int port = Tools.ToInt(array[1].Trim(), 0);
							if (socket.BeginConnect(new IPEndPoint(IPAddress.Parse(ipString), port), null, null).AsyncWaitHandle.WaitOne(2000, exitContext: true))
							{
								return proxyAccountModel;
							}
							string proxyIp3 = "rest_ip," + appleId.ToLower();
							lock (objReddemLockS[appleId.Trim()])
							{
								if (proxyAccountCacheInfos.ContainsKey(appleId.Trim()))
								{
									proxyAccountCacheInfos[appleId.Trim()].ProxyIp = proxyIp3;
									proxyAccountCacheInfos[appleId.Trim()].expirationTime = null;
								}
							}
							return proxyAccountModel;
						}
						return proxyAccountModel;
					}
				}
			}
			return proxyAccountModel;
		}

		public static string getProxyAccountIP(string appleId, int maxCount = 0)
		{
			try
			{
				ProxyAccountModel proxyAccountInfo = getProxyAccountInfo(appleId.Trim(), maxCount);
				if (proxyAccountInfo != null)
				{
					return proxyAccountInfo.ProxyIp;
				}
			}
			catch (Exception ex)
			{
				APIUtlis.ApiSeriveError(ex);
			}
			return "";
		}

		public static void RestAllot(string newIp)
		{
			if (string.IsNullOrEmpty(newIp))
			{
				return;
			}
			lock (objReddemLockS)
			{
				KeyValuePair<string, ProxyAccountModel> keyValuePair = proxyAccountCacheInfos.Where((KeyValuePair<string, ProxyAccountModel> c) => c.Value.ProxyIp == "").FirstOrDefault();
				if (keyValuePair.Key != null)
				{
					keyValuePair.Value.ProxyIp = newIp;
				}
			}
		}

		public static void removeReddemUserInfo(string appleId)
		{
			if (string.IsNullOrEmpty(appleId))
			{
				return;
			}
			lock (objReddemLockS)
			{
				if (proxyAccountCacheInfos.ContainsKey(appleId.Trim()))
				{
					proxyAccountCacheInfos.TryRemove(appleId, out var _);
				}
			}
			removeLock(appleId);
		}

		private static void removeLock(string appleId)
		{
			if (string.IsNullOrEmpty(appleId))
			{
				return;
			}
			lock (objReddemLockS)
			{
				if (objReddemLockS.ContainsKey(appleId.Trim()))
				{
					objReddemLockS.Remove(appleId.Trim());
				}
			}
		}

		private static LockCounts initLock(string appleId)
		{
			if (!string.IsNullOrEmpty(appleId.Trim()))
			{
				lock (objReddemLockS)
				{
					if (!objReddemLockS.ContainsKey(appleId.Trim()))
					{
						LockCounts lockCounts = new LockCounts
						{
							Count = 0
						};
						objReddemLockS.Add(appleId.Trim(), lockCounts);
						return lockCounts;
					}
					return objReddemLockS[appleId.Trim()];
				}
			}
			return null;
		}
	}
}