private void OnUpdateHandler(object state)
{
mUpdateTimer.Change(-1, -1);
try
{
var modules = mUpdateItems.Keys;
foreach (string module in modules)
{
if (mUpdateItems.TryGetValue(module, out UpdateItem item))
{
if (Server.BaseServer.GetRunTime() - item.Time > 10 * 1000)
{
try
{
Load(item.Module);
Server.Log(EventArgs.LogType.Info, $"{item.Module} upgrades success");
}
catch (Exception e_)
{
Server.Log(EventArgs.LogType.Error, $"{item.Module} upgrades error {e_.Message} {e_.StackTrace}");
}
finally
{
mUpdateItems.TryRemove(module, out item);
}
}
}
}
}
catch (Exception e_)
{
Server.Log(EventArgs.LogType.Error, $"upgrades module error {e_.Message} {e_.StackTrace}");
}
finally
{
mUpdateTimer.Change(5000, 5000);
}
}
/// <summary>
/// Tries to make a mapobject leave the map.
/// </summary>
/// <param name="MapObject">The map object.</param>
/// <returns>Returns true if the map object left.</returns>
public bool LeaveMap(Maps.IMapObject MapObject)
{
if (MapObject is Data.GroundItem)
{
if (!Items.ContainsKey(MapObject.EntityUID))
{
return(false);
}
Maps.IMapObject rObject;
return(Items.TryRemove(MapObject.EntityUID, out rObject));
}
else
{
MapObject.LastMapID = this.MapID;
if (!MapObjects.ContainsKey(MapObject.EntityUID))
{
if (MapObject is Entities.GameClient)
{
(MapObject as Entities.GameClient).NetworkClient.Disconnect("Not in the map.");
}
return(false);
}
Maps.IMapObject rObject;
if (!MapObjects.TryRemove(MapObject.EntityUID, out rObject))
{
if (MapObject is Entities.GameClient)
{
(MapObject as Entities.GameClient).NetworkClient.Disconnect("Could not be removed.");
}
return(false);
}
}
return(true);
}
/// <summary>
/// 删除已发布的配置
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool RemoveDeployCfg(Int64 key)
{
MethodAroundBizModel model;
return(_deployconfigures.TryRemove(key, out model));
}
public bool Remove(TKey key)
{
var value = default(TValue);
return(_map.TryRemove(key, out value));
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task Process(RequestDataMart reqDM)
{
//wait a small random amount of time before processing to try to avoid collision with webfarm containing multiple API
System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(RandomGenerator.NextDouble() * 1500));
var ifAdvaceStatuses = new[] {
RoutingStatus.Completed,
RoutingStatus.ResultsModified,
RoutingStatus.RequestRejected,
RoutingStatus.ResponseRejectedBeforeUpload,
RoutingStatus.ResponseRejectedAfterUpload,
RoutingStatus.AwaitingResponseApproval,
RoutingStatus.Draft
};
var routes = await DB.RequestDataMarts.Where(x => x.RequestID == reqDM.RequestID).ToArrayAsync();
if (routes.All(x => ifAdvaceStatuses.Contains(x.Status)))
{
if (ActiveProcessingRequests.ContainsKey(reqDM.RequestID))
{
return;
}
ActiveProcessingRequests.TryAdd(reqDM.RequestID, DateTime.UtcNow);
try
{
var matrixDoc = await(from d in DB.Documents.AsNoTracking()
where d.ItemID == reqDM.RequestID &&
d.FileName == TrustMatrixFileAndExtension &&
d.Kind == TrustMatrixKind
select new { d.ID }).FirstOrDefaultAsync();
if (matrixDoc != null)
{
using (var docDB = new DataContext())
using (var sr = new StreamReader(LocalDiskCache.Instance.GetStream(DB, matrixDoc.ID)))
{
TrustMatrix = JsonConvert.DeserializeObject <TrustMatrix[]>(sr.ReadToEnd());
sr.Close();
}
}
int incrementedCount = (from res in DB.Responses
join rdm in DB.RequestDataMarts on res.RequestDataMartID equals rdm.ID
where rdm.RequestID == reqDM.RequestID
select res.Count).Max() + 1;
var routeIDs = routes.Select(x => x.ID);
var currentTask = await PmnTask.GetActiveTaskForRequestActivityAsync(reqDM.Request.ID, reqDM.Request.WorkFlowActivityID.Value, DB);
List <DTO.QueryComposer.DistributedRegressionAnalysisCenterManifestItem> manifestItems = new List <DTO.QueryComposer.DistributedRegressionAnalysisCenterManifestItem>();
var q = from rd in DB.RequestDocuments
join rsp in DB.Responses on rd.ResponseID equals rsp.ID
join rdm in DB.RequestDataMarts on rsp.RequestDataMartID equals rdm.ID
join dm in DB.DataMarts on rdm.DataMartID equals dm.ID
join doc in DB.Documents on rd.RevisionSetID equals doc.RevisionSetID
where rsp.Count == (incrementedCount - 1) &&
rdm.RequestID == reqDM.Request.ID &&
routeIDs.Contains(reqDM.ID) &&
rd.DocumentType == RequestDocumentType.Output &&
doc.ItemID == rsp.ID &&
doc.ID == DB.Documents.Where(dd => dd.RevisionSetID == doc.RevisionSetID && doc.ItemID == rsp.ID).OrderByDescending(dd => dd.MajorVersion).ThenByDescending(dd => dd.MinorVersion).ThenByDescending(dd => dd.BuildVersion).ThenByDescending(dd => dd.RevisionVersion).Select(dd => dd.ID).FirstOrDefault()
select new
{
DocumentID = doc.ID,
DocumentKind = doc.Kind,
DocumentFileName = doc.FileName,
ResponseID = rd.ResponseID,
RevisionSetID = rd.RevisionSetID,
RequestDataMartID = rsp.RequestDataMartID,
DataMartID = rdm.DataMartID,
DataPartnerIdentifier = dm.DataPartnerIdentifier,
DataMart = dm.Name
};
var documents = await(q).ToArrayAsync();
if (documents.Any(d => d.DocumentKind == StopProcessingTriggerDocumentKind))
{
var openRoutes = await DB.RequestDataMarts.Where(x => x.RequestID == reqDM.RequestID &&
(x.Status == RoutingStatus.Submitted || x.Status == RoutingStatus.Resubmitted || x.Status == RoutingStatus.Draft)
).ToArrayAsync();
foreach (var route in openRoutes)
{
route.Status = RoutingStatus.Canceled;
}
currentTask.Status = TaskStatuses.Complete;
currentTask.EndOn = DateTime.UtcNow;
currentTask.PercentComplete = 100d;
reqDM.Request.WorkFlowActivityID = CompletedActivityID;
await DB.SaveChangesAsync();
}
else
{
List <KeyValuePair <string, Guid> > docsToSend = new List <KeyValuePair <string, Guid> >();
var fileListFiles = documents.Where(d => !string.IsNullOrEmpty(d.DocumentKind) && string.Equals("DistributedRegression.FileList", d.DocumentKind, StringComparison.OrdinalIgnoreCase));
var requestDataMarts = await(from dm in DB.DataMarts
join rdm in DB.RequestDataMarts on dm.ID equals rdm.DataMartID
where rdm.RequestID == reqDM.Request.ID
select new DTO.QueryComposer.DistributedRegressionManifestDataPartner
{
DataMartID = dm.ID,
DataMartIdentifier = dm.DataPartnerIdentifier,
DataMartCode = dm.DataPartnerCode,
RouteType = rdm.RoutingType.Value
}).ToArrayAsync();
foreach (var fileListFile in fileListFiles)
{
//only include the files indicated in the filelist document
using (var stream = LocalDiskCache.Instance.GetStream(DB, fileListFile.DocumentID))
using (var reader = new System.IO.StreamReader(stream))
{
//read the header line
reader.ReadLine();
string line, filename;
bool includeInDistribution = false;
while (!reader.EndOfStream)
{
line = reader.ReadLine();
string[] split = line.Split(',');
if (split.Length > 0)
{
filename = split[0].Trim();
if (split.Length > 1)
{
includeInDistribution = string.Equals(split[1].Trim(), "1");
}
else
{
includeInDistribution = false;
}
if (includeInDistribution == false)
{
continue;
}
if (!string.IsNullOrEmpty(filename))
{
Guid?revisionSetID = documents.Where(d => string.Equals(d.DocumentFileName, filename, StringComparison.OrdinalIgnoreCase) && d.DataMartID == fileListFile.DataMartID).Select(d => d.RevisionSetID).FirstOrDefault();
if (revisionSetID.HasValue)
{
foreach (var dp in split[2].Trim().Split(' '))
{
List <Guid> dmIDs = new List <Guid>();
dmIDs.Add(fileListFile.DataMartID);
dmIDs.Add(requestDataMarts.Where(x => x.DataMartCode == dp).Select(x => x.DataMartID).FirstOrDefault());
var isAllowed = TrustMatrix.Where(x => dmIDs.Contains(x.DataPartner1ID) && dmIDs.Contains(x.DataPartner2ID)).Select(x => x.Trusted).FirstOrDefault();
if (TrustMatrix.Length == 0 || isAllowed)
{
docsToSend.Add(new KeyValuePair <string, Guid>(dp, revisionSetID.Value));
manifestItems.AddRange(documents.Where(d => d.RevisionSetID == revisionSetID.Value).Select(d => new DTO.QueryComposer.DistributedRegressionAnalysisCenterManifestItem
{
DocumentID = d.DocumentID,
DataMart = d.DataMart,
DataMartID = d.DataMartID,
DataPartnerIdentifier = d.DataPartnerIdentifier,
RequestDataMartID = d.RequestDataMartID,
ResponseID = d.ResponseID,
RevisionSetID = d.RevisionSetID
}).ToArray());
}
}
}
}
}
}
reader.Close();
}
}
foreach (var dp in docsToSend.GroupBy(x => x.Key))
{
var dataMart = await(from dm in DB.DataMarts
join rdm in DB.RequestDataMarts on dm.ID equals rdm.DataMartID
where rdm.RequestID == reqDM.Request.ID &&
rdm.Status != RoutingStatus.Canceled &&
dm.DataPartnerCode == dp.Key
select rdm).Include(rdm => rdm.Responses).FirstOrDefaultAsync();
if (dataMart != null)
{
var response = dataMart.AddResponse(IdentityID, incrementedCount);
await DB.SaveChangesAsync();
await DB.Entry(dataMart).ReloadAsync();
List <DTO.QueryComposer.DistributedRegressionAnalysisCenterManifestItem> filteredManifestItems = new List <DTO.QueryComposer.DistributedRegressionAnalysisCenterManifestItem>();
foreach (var revisionSet in dp)
{
DB.RequestDocuments.Add(new RequestDocument {
DocumentType = RequestDocumentType.Input, ResponseID = response.ID, RevisionSetID = revisionSet.Value
});
filteredManifestItems.Add(manifestItems.Where(x => x.RevisionSetID == revisionSet.Value).FirstOrDefault());
}
byte[] buffer;
using (var ms = new System.IO.MemoryStream())
using (var sw = new System.IO.StreamWriter(ms))
using (var jw = new Newtonsoft.Json.JsonTextWriter(sw))
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(jw, new DTO.QueryComposer.DistributedRegressionManifestFile {
Items = filteredManifestItems, DataPartners = requestDataMarts
});
jw.Flush();
buffer = ms.ToArray();
}
Document analysisCenterManifest = DB.Documents.Add(new Document
{
Description = "Contains information about the input documents and the datamart they came from.",
Name = "Internal: Routing Manifest",
FileName = "manifest.json",
ItemID = currentTask.ID,
Kind = DocumentKind.SystemGeneratedNoLog,
UploadedByID = IdentityID,
Viewable = false,
MimeType = "application/json",
Length = buffer.Length
});
analysisCenterManifest.RevisionSetID = analysisCenterManifest.ID;
DB.RequestDocuments.Add(new RequestDocument {
DocumentType = RequestDocumentType.Input, ResponseID = response.ID, RevisionSetID = analysisCenterManifest.RevisionSetID.Value
});
await DB.SaveChangesAsync();
analysisCenterManifest.SetData(DB, buffer);
dataMart.Status = dataMart.Responses.Count > 1 ? RoutingStatus.Resubmitted : RoutingStatus.Submitted;
await DB.SaveChangesAsync();
}
}
}
}
catch (Exception ex)
{
Logger.Error($"Error processing DEC switch for requestID:{reqDM.RequestID}", ex);
throw;
}
finally
{
DateTime startTime;
ActiveProcessingRequests.TryRemove(reqDM.RequestID, out startTime);
}
}
}
protected void Application_BeginRequest(object sender, EventArgs e)
{
Uri url = HttpContext.Current.Request.Url;
string domain = url.Authority,
path = url.AbsolutePath.ToLower().Substring(1),
file = string.Empty;
string method = HttpContext.Current.Request.HttpMethod;
switch (method)
{
case "GET":
switch (path)
{
case "login":
HttpContext.Current.RewritePath("~/public/login.html");
break;
case "admin":
HttpContext.Current.RewritePath("~/public/admin.html");
break;
default:
if (mDomains.ContainsKey(domain))
{
int id = 0;
if (mDomains.TryGetValue(domain, out id) && id > 0)
{
string fileName = (path.Length == 0 ? "index.html" : path);
if (!fileName.EndsWith(".html"))
{
fileName += ".html";
}
file = "~/public/" + id.ToString() + "/" + fileName;
string f = Server.MapPath(file);
if (!System.IO.File.Exists(f))
{
file = string.Empty;
}
}
if (file.Length > 0)
{
HttpContext.Current.RewritePath(file);
}
}
break;
}
break;
case "POST":
bool ok = false;
string text, json,
username = string.Empty,
result = string.Empty, token = string.Empty;
switch (path)
{
case "login":
try
{
var stream = new System.IO.StreamReader(Request.InputStream);
text = stream.ReadToEnd();
json = HttpUtility.UrlDecode(text);
var jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
var dict = (Dictionary <string, object>)jsSerializer.DeserializeObject(json);
if (dict.ContainsKey("username") && dict.ContainsKey("password"))
{
username = dict["username"] as string;
if (!string.IsNullOrWhiteSpace(username))
{
string line = string.Format("{0}.{1}", username, dict["password"]);
string valid = mPass.FirstOrDefault(x => x == line);
ok = !string.IsNullOrWhiteSpace(valid);
}
}
result = @"{""Ok"":false}";
if (ok)
{
token = createToken(username);
string temp = string.Empty;
if (mTokens.ContainsKey(username))
{
mTokens.TryRemove(username, out temp);
}
string userJson = "{}";
string fileUser = Server.MapPath("~/data/user/" + username + ".json");
if (System.IO.File.Exists(fileUser))
{
userJson = System.IO.File.ReadAllText(fileUser);
}
result = @"{""Ok"":true, ""Data"":" + userJson + @", ""Token"":""" + token + @"""}";
mTokens.TryAdd(username, token);
}
}
catch { }
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.ContentType = "application/json";
HttpContext.Current.Response.Write(result);
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.End();
break;
case "admin":
break;
default:
break;
}
break;
}
}
/// <summary>
/// Removes an authority from the list of allowed authorities.
/// </summary>
/// <param name="authority"></param>
public void RemoveAuthority(string authority)
{
string unused = null;
_AllowedAuthorities.TryRemove(authority, out unused);
}
public bool RemoveSessionModel(string sessionToken)
{
ViewModels.SessionVM session;
return _sessionCache.TryRemove(sessionToken, out session);
}
public void Start(string ip = "0.0.0.0", int port = 30300, int backlog = 10)
{
if (socket?.IsBound == true)
{
throw new Exception("已经运行");
}
var endpoint = new IPEndPoint(IPAddress.Parse(ip), port);
socket = new Socket(endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(endpoint);
//同一个时间点过来10个客户端，排队
socket.Listen(backlog);
_task = System.Threading.Tasks.Task.Run(() =>
{
while (socket.IsBound)
{
try
{
//创建通信用的Socket
Socket tSocket = socket.Accept();
var connection = new TcpServerClientConnection(tSocket);
var session = new ArduinoSession(connection, timeOut: 5000);
//var ss = session.GetFirmware();
dic.AddOrUpdate(connection.Name, f => session, (f1, f2) => session);
System.Threading.Tasks.Task.Run(() =>
{
try
{
AddArduinoSession?.Invoke(this, session);
}
catch (Exception) { }
});
}
catch (Exception)
{
break;
}
}
});
_task2 = System.Threading.Tasks.Task.Run(async() =>
{
while (socket.IsBound)
{
foreach (var item in dic.Values)
{
if (item.Connection.IsOpen)
{
try
{
_ = await item.GetProtocolVersionAsync();
}
catch (Exception ex)
{
item.Connection.Close();
dic.TryRemove(item.Connection.Name, out var _);
try
{
RemoveArduinoSession?.Invoke(this, item, "心跳超时");
}
catch (Exception) { }
}
}
else
{
item.Connection.Close();
dic.TryRemove(item.Connection.Name, out var _);
try
{
RemoveArduinoSession?.Invoke(this, item, "连接断开");
}
catch (Exception) { }
}
}
System.Threading.Thread.Sleep(TimeSpan);
}
});
}
public static async Task <long> FindFiles(string path, bool dryrun)
{
// building a tree of size, small size checksum, full size
// only moving on to the next step if current step has duplicate
var tasks = new System.Collections.Concurrent.ConcurrentBag <Task>();
var knownHardLinks = new System.Collections.Concurrent.ConcurrentDictionary <string, byte>();
long totalItemsTraversed = 0;
var runStart = DateTime.UtcNow;
var dir = new DirectoryInfo(path);
var stripPath = dir.FullName;
var root = Path.GetPathRoot(stripPath);
if (stripPath.StartsWith(root))
{
stripPath = @"\" + stripPath.Substring(root.Length);
}
char pChar = 's';
// if file is known among hardlinks then there is no need to check it further
bool HasNoLink(FileInfo fi)
{
if (Interlocked.Increment(ref totalItemsTraversed) % (pChar == '.' ? 5000 : 100) == 0)
{
Console.Write(pChar);
pChar = '.';
}
var k = fi.FullName.Substring(path.Length);
var isKnownLink = knownHardLinks.ContainsKey(k);
if (isKnownLink)
{
knownHardLinks.TryRemove(k, out var b); // faster to only check this? since it returns true if removed successfully?
pChar = '-';
}
return(!isKnownLink);
}
void DoLinks(DupItem d)
{
var hl = d.GetHardLinks(stripPath);
var k = d.FileInfo.FullName.Substring(path.Length);
foreach (var l in hl.Except(new[] { k }))
{
knownHardLinks.TryAdd(l, (byte)0);
}
}
Tuple <DupItem, TreeNodeDupMd5Full> AddDupInt(FileInfo fi)
{
return(AddDup(fi, DoLinks));
}
Tools.EnumerateFilesParallel(dir)
.Where(HasNoLink)
.Where(fi => fi.LastWriteTimeUtc < runStart.AddHours(-1))
.Select(AddDupInt)
.ForAll(dnTpl =>
{
var tNode = dnTpl.Item2;
if (tNode == null)
{
return; // not duplicate
}
var d = dnTpl.Item1;
try
{
if (d.HasHardLink)
{
pChar = 'x';
var existing = tNode.Existing;
if (existing.HasHardLink)
{
pChar = 'r';
return;
}
tNode.Existing = d;
d = existing;
}
// TODO if we have 2 identical files, and both of them has links (not same), what to do? (to avoid having 2 separate identical sets)
// TODO there is a limit on how many references can be done to the same data?
pChar = 'l';
Console.WriteLine($" {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss.fff} Duplicate {d}");
var linkItem = tNode.Existing;
if (!dryrun)
{
linkItem.FileInfo.CreateHardLink(d.FileInfo.FullName);
}
}
catch (Exception ex)
{
Console.WriteLine($"Exception {d.FileInfo.FullName} " + ex.ToString());
}
});
await Task.WhenAll(tasks);
return(totalItemsTraversed);
}
public bool TryRemove(TKey key)
{
TValue value;
return(_dictionary.TryRemove(key, out value));
}
/// <summary>
/// 检查竞彩订单频繁投注
/// </summary>
private void CheckJCRepeatBetting(string currUserId, Sports_BetingInfo info, bool isYouHua = false)
{
try
{
if (!_sportsBettingListInfo.ContainsKey(currUserId))
{
info.CurrentBetTime = DateTime.Now;
_sportsBettingListInfo.TryAdd(currUserId, info);
return;
}
}
catch (Exception)
{
}
lock (_sportsBettingListInfo)
{
try
{
Sports_BetingInfo value = _sportsBettingListInfo[currUserId];
if (isYouHua)//奖金优化
{
//不重复
if (!info.Equals(value))
{
_sportsBettingListInfo.TryRemove(currUserId, out value);
info.CurrentBetTime = DateTime.Now;
_sportsBettingListInfo.TryAdd(currUserId, info);
return;
}
//重复投注
if (value.Amount == info.Amount && value.GameCode.ToUpper() == info.GameCode.ToUpper() && value.PlayType == info.PlayType && value.TotalMoney == info.TotalMoney && value.Attach == info.Attach)
{
info.IsRepeat = true;
}
//重复投注
if (info.IsRepeat)
{
var timeSpan = DateTime.Now - value.CurrentBetTime;
if (timeSpan.TotalSeconds > 5)
{
//大于间隔时间
_sportsBettingListInfo.TryRemove(currUserId, out value);
info.CurrentBetTime = DateTime.Now;
_sportsBettingListInfo.TryAdd(currUserId, info);
return;
}
else
{
throw new LogicException("Repeat");
}
}
}
else
{
//不重复
if (!info.Equals(value))
{
_sportsBettingListInfo.TryRemove(currUserId, out value);
info.CurrentBetTime = DateTime.Now;
_sportsBettingListInfo.TryAdd(currUserId, info);
return;
}
//重复投注
if (value.Amount == info.Amount && value.GameCode.ToUpper() == info.GameCode.ToUpper() && value.PlayType == info.PlayType && value.TotalMoney == info.TotalMoney)
{
info.IsRepeat = true;
}
//重复投注
if (info.IsRepeat)
{
var timeSpan = DateTime.Now - value.CurrentBetTime;
if (timeSpan.TotalSeconds > 5)
{
//大于间隔时间
_sportsBettingListInfo.TryRemove(currUserId, out value);
info.CurrentBetTime = DateTime.Now;
_sportsBettingListInfo.TryAdd(currUserId, info);
return;
}
else
{
throw new LogicException("Repeat");
}
}
}
}
catch
{
_sportsBettingListInfo.Clear();
return;
}
}
}
public void Remove(Models.MicroServiceSettings item)
{
_list.TryRemove(item.ServiceName, out var removed);
}
async void MessageProcesser()
{
//recv
try
{
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(1024 * 1024))
{
byte[] buf = new byte[1024];
ArraySegment <byte> buffer = new ArraySegment <byte>(buf);
while (websocket.State == System.Net.WebSockets.WebSocketState.Open)
{
var recv = await websocket.ReceiveAsync(buffer, System.Threading.CancellationToken.None);
//Task.WaitAll(_recv);
//var recv = _recv.Result;
ms.Write(buf, 0, recv.Count);
if (recv.EndOfMessage)
{
var count = ms.Position;
ms.Position = 0;
var msg = NetMessage.Unpack(ms);
var posend = ms.Position;
if (posend != count)
{
throw new Exception("error msg.");
}
//重置pos
ms.Position = 0;
var iddata = msg.Params["_id"];
ulong id = BitConverter.ToUInt64(iddata, 0);
if (mapRecv.TryRemove(id, out OnClientRecv onRecvOnce))
{
await onRecvOnce(msg);
}
else
{
await OnRecv(msg);// .onEvent(httpserver.WebsocketEventType.Recieve, websocket, bytes);
}
}
//Console.WriteLine("recv=" + recv.Count + " end=" + recv.EndOfMessage);
}
}
}
catch (Exception err)
{
Console.CursorLeft = 0;
Console.WriteLine("error on recv." + err.Message);
}
//disconnect
try
{
await this?.OnDisconnect();
}
catch (Exception err)
{
Console.CursorLeft = 0;
Console.WriteLine("error on disconnect." + err.Message);
}
finally
{
this.Connected = false;
}
}
private async Task BatchSendAsync()
{
var outstandingSendTasks = new System.Collections.Concurrent.ConcurrentDictionary<Task, Task>();
while (_asyncCollection.IsCompleted == false || _asyncCollection.Count > 0)
{
List<TopicMessage> batch = null;
try
{
try
{
await _asyncCollection.OnHasDataAvailable(_stopToken.Token).ConfigureAwait(false);
batch = await _asyncCollection.TakeAsync(BatchSize, BatchDelayTime, _stopToken.Token).ConfigureAwait(false);
}
catch (OperationCanceledException ex)
{
//TODO log that the operation was canceled, this only happens during a dispose
}
if (_asyncCollection.IsCompleted && _asyncCollection.Count > 0)
{
batch = batch ?? new List<TopicMessage>(_asyncCollection.Count);
//Drain any messages remaining in the queue and add them to the send batch
batch.AddRange(_asyncCollection.Drain());
}
//we want to fire the batch without blocking and then move on to fire another one
var sendTask = ProduceAndSendBatchAsync(batch, _stopToken.Token);
outstandingSendTasks.TryAdd(sendTask, sendTask);
var sendTaskCleanup = sendTask.ContinueWith(result =>
{
if (result.IsFaulted && batch != null)
{
batch.ForEach(x => x.Tcs.TrySetException(result.ExtractException()));
}
//TODO add statistics tracking
outstandingSendTasks.TryRemove(sendTask, out sendTask);
});
}
catch (Exception ex)
{
if (batch != null)
{
batch.ForEach(x => x.Tcs.TrySetException(ex));
}
}
}
var referenceToOutstanding = outstandingSendTasks.Values.ToList();
if (referenceToOutstanding.Count > 0)
{
await Task.WhenAll(referenceToOutstanding).ConfigureAwait(false);
}
}
/// <exception cref="ArgumentNullException">thrown, if key is null.</exception>
public TValue Remove(string key)
{
TValue value;
return(_cache.TryRemove(key, out value) ? value : default(TValue));
}
/// <summary>
/// Method to actually get the tile from the <see cref="_provider"/>.
/// </summary>
/// <param name="parameter">The parameter, usually a <see cref="TileInfo"/> and a <see cref="AutoResetEvent"/></param>
private void GetTileOnThread(object parameter)
{
var @params = (object[])parameter;
var tileInfo = (TileInfo)@params[0];
byte[] result = null;
//Try get the tile
try
{
_openTileRequests.TryAdd(tileInfo.Index, 1);
result = _provider.GetTile(tileInfo);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
//Try at least once again
if (result == null)
{
try
{
result = _provider.GetTile(tileInfo);
}
catch
{
if (!AsyncMode)
{
var are = (AutoResetEvent)@params[1];
are.Set();
}
}
}
//Remove the tile info request
int one;
if (!_activeTileRequests.TryRemove(tileInfo.Index, out one))
{
//try again
_activeTileRequests.TryRemove(tileInfo.Index, out one);
}
if (!_openTileRequests.TryRemove(tileInfo.Index, out one))
{
//try again
_openTileRequests.TryRemove(tileInfo.Index, out one);
}
if (result != null)
{
//Add to the volatile cache
_volatileCache.Add(tileInfo.Index, result);
//Add to the perma cache
_permaCache.Add(tileInfo.Index, result);
if (AsyncMode)
{
//Raise the event
OnTileReceived(new TileReceivedEventArgs(tileInfo, result));
}
else
{
var are = (AutoResetEvent)@params[1];
are.Set();
}
}
}
/// <summary>
/// Removes a specific redirect from the cache.
/// </summary>
/// <param name="originalUri">The uri to remove the redirect for.</param>
public void RemoveRedirect(Uri originalUri)
{
Uri reserved;
_CachedRedirects.TryRemove(originalUri, out reserved);
}
internal static void ClearAttachments(object parent)
{
WeakAttachmentsInfo info;
Attachments.TryRemove(parent, out info);
}
public static void ExecuteJob(object stateInfo)
{
WebBackgroundJob job = (WebBackgroundJob)stateInfo;
if (job.Key != "" && job.Key != null)
{
// Пробуем вставить в таблицу ключей
//, если вставка неудачна, значит фоновое задание уже выполняется
if (!jobsKeys.TryAdd(job.Key, job.Key))
{
// Такое значение уже есть в списке, не запускаем задание?
throw new RuntimeException("Фоновое задание с таким значением ключа уже выполняется");
}
}
// Заполняем значения работы и вставляем ее в список
jobs.TryAdd(job.UUID, job);
job.Begin = DateTime.Now;
AspNetHostEngine engine = null;
try
{
if (!AspNetHostEngine.Pool.TryDequeue(out engine))
{
throw new RuntimeException("cannot deque engine");
}
engine.Engine.EngineInstance.Environment.LoadMemory(MachineInstance.Current);
engine.CallCommonModuleProcedure(job.MethodName, job.ExecutionParameters);
job.State = BackgroundJobState.Completed;
job.ExecutionParameters = null;
}
catch (ScriptEngine.ScriptException ex)
{
job.ErrorInfo = new ExceptionInfoContext(ex);
job.State = BackgroundJobState.Failed;
System.IO.TextWriter logWriter = AspNetLog.Open();
AspNetLog.Write(logWriter, "Error executing background job ");
AspNetLog.Write(logWriter, ex.ToString());
AspNetLog.Close(logWriter);
}
catch (Exception ex)
{
job.State = BackgroundJobState.Failed;
System.IO.TextWriter logWriter = AspNetLog.Open();
AspNetLog.Write(logWriter, "Error executing background job ");
AspNetLog.Write(logWriter, ex.ToString());
AspNetLog.Close(logWriter);
}
finally
{
job.End = DateTime.Now;
if (engine != null)
{
AspNetHostEngine.Pool.Enqueue(engine);
}
try
{
WebBackgroundJob outjob;
jobs.TryRemove(job.UUID, out outjob);
}
catch { /* Ничего не делаем*/ }
try
{
string outStr;
if (job.Key != null && job.Key != "")
{
jobsKeys.TryRemove(job.Key, out outStr);
}
}
catch { /* Ничего не делаем*/ }
}
}
public override void RemoveCache(int key)
{
cache.TryRemove(key, out ActionResult actionResult);
}
/// <summary>
/// Sends and configures a <see cref="IPacket"/>.
/// </summary>
/// <param name="packet">packet</param>
/// <param name="cancellationToken">cancellation</param>
/// <returns><see cref="Task"/> containing an Ack, if one was returned and required.</returns>
public async Task <IAck> Send(IPacket packet, CancellationToken cancellationToken)
{
//TODO: This should return an IPacket, not an IAck, that way we don't have to deserialize it fully
// Maybe, and IAck could share whatever required property we need so we can deserialize it
// like a SerailizedPacket. So possibly merge an IAck with an IPacket
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
if (packet is Packet fullPacket)
{
fullPacket.Sent = DateTimeOffset.Now;
}
if (packet is IAck packetAsAck && packetAsAck.PacketId <= 0)
{
throw new InvalidOperationException($"Ack doesn't have response ID.");
}
ulong packetId;
lock (_idLocker)
packetId = _nextPacketId++;
TaskCompletionSource <Packet> ackCompletion = null;
try {
if (packet.Flags.HasFlag(PacketFlag.AckRequired))
{
ackCompletion = new TaskCompletionSource <Packet>(TaskCreationOptions.RunContinuationsAsynchronously);
_awaitingAck.AddOrUpdate(packetId, ackCompletion, (_, __) => ackCompletion);
}
Log.TracePacketSending(this, packet);
if (packet.Sent == null)
{
throw new InvalidOperationException($"{this}: Sent is null");
}
byte[] packetData = null;
if (packet is Packet regularPacket)
{
packetData = SerializedPacket.Create(regularPacket, Serializer)
?? throw new InvalidOperationException($"{this}: Packet serialization returned null");
}
else if (packet is SerializedPacket serializedPacket)
{
packetData = serializedPacket.Data;
}
else
{
throw new InvalidOperationException($"{this}: Packet of type {packet.GetType().Name} is not supported.");
}
try {
await SendImpl(packetId, packetData, cancellationToken);
} catch (DisconnectedException ex) {
if (ex.InnerException != null)
{
Log.Warn($"Disconnected sending packet {packet}: {ex.InnerException}");
}
TransitionState(ConnectionState.Closed);
throw;
}
// Don't log this unless the send actually happens
Log.TracePacketSent(this, packet);
if (ackCompletion == null)
{
// No ack required
return(null);
}
else
{
// Wait for the ack
using (var combinedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, ClosedCancellationToken)) {
var cancellationTask = Task.Delay(-1, combinedCancellationTokenSource.Token);
Log.TraceWaitingForAck(this, packetId);
var result = await Task.WhenAny(ackCompletion.Task, Task.Delay(WaitForResponseTimeout), cancellationTask);
if (result == ackCompletion.Task)
{
var ack = (IAck)ackCompletion.Task.Result;
Log.TraceAckReceived(this, ack);
return(ack);
}
if (result == cancellationTask)
{
if (cancellationToken.IsCancellationRequested)
{
throw new OperationCanceledException(cancellationToken);
}
if (ClosedCancellationToken.IsCancellationRequested)
{
throw new NotConnectedException($"{this}: Could not send {packet}, the connection is closed.");
}
}
throw new TimeoutException($"{this}: Timed out waiting for Ack from {packet}");
}
}
} finally {
if (ackCompletion != null)
{
ackCompletion.TrySetCanceled();
_awaitingAck.TryRemove(packetId, out _);
}
}
}
internal static void Remove <T, V>(System.Collections.Concurrent.ConcurrentDictionary <T, V> tv, T t)
{
V v;
tv.TryRemove(t, out v);
}
/// <summary>
/// Removes a content type from the list of allowed content types.
/// </summary>
/// <param name="mediaType"></param>
public void RemoveContentMediaType(string mediaType)
{
string unused = null;
_AllowedMediaTypes.TryRemove(mediaType, out unused);
}
public static bool TryRemove <TKey, TValue>(this System.Collections.Concurrent.ConcurrentDictionary <TKey, TValue> self, TKey key)
{
TValue ignored;
return(self.TryRemove(key, out ignored));
}
public static void UnRegisterContextAllocation(JsonOperationContext context)
{
string _;
ContextAllocations.TryRemove(context, out _);
}
private void onCompleted(object sender, SocketAsyncEventArgs args)
{
//try
{
switch (args.LastOperation)
{
case SocketAsyncOperation.Accept:
{
var info = new SocketInfo(args.AcceptSocket, true);
Connects[info.Handle] = info;
//直接复用
args.AcceptSocket = null;
listenSocket.AcceptAsync(args);
onSocketIn?.Invoke(info.Handle);
SetRecivce(info);
}
break;
case SocketAsyncOperation.Connect:
{
if (args.SocketError != SocketError.Success)
{
onSocketLinkedError?.Invoke(args.UserToken as Socket);
}
else
{
var info = new SocketInfo(args.ConnectSocket, false);
Connects[info.Handle] = info;
onSocketLinked?.Invoke(info.Handle);
SetRecivce(info);
}
//connect 的这个args不能复用
}
break;
case SocketAsyncOperation.Disconnect:
{
var hash = (args.UserToken as SocketInfo).Handle;
SocketInfo socket = null;
Connects.TryRemove(hash, out socket);
socket.Socket.Dispose();
freeEventArgs.Push(args); //这个是可以复用的
}
break;
case SocketAsyncOperation.Receive:
{
var hash = (args.UserToken as SocketInfo).Handle;
byte[] recv = new byte[args.BytesTransferred];
Buffer.BlockCopy(args.Buffer, 0, recv, 0, args.BytesTransferred);
onSocketRecv?.Invoke(hash, recv);
freeEventArgs.Push(args); //这个是可以复用的
}
break;
default:
{
}
break;
}
}
//catch (Exception err)
//{
//}
}
internal static void RemoveFromRuntimeList(UserData ud)
{
g_attached_custom_user_datas.TryRemove(ud.m_serial_number, out ud);
}
public static bool TryRemove <TKey, TValue>(this System.Collections.Concurrent.ConcurrentDictionary <TKey, TValue> src, TKey key)
{
TValue old;
return(src.TryRemove(key, out old));
}
private async Task BatchSendAsync()
{
var outstandingSendTasks = new System.Collections.Concurrent.ConcurrentDictionary <Task, Task>();
while (_asyncCollection.IsCompleted == false || _asyncCollection.Count > 0)
{
List <TopicMessage> batch = null;
try
{
try
{
await _asyncCollection.OnHasDataAvailable(_stopToken.Token).ConfigureAwait(false);
batch = await _asyncCollection.TakeAsync(BatchSize, BatchDelayTime, _stopToken.Token).ConfigureAwait(false);
}
catch (OperationCanceledException ex)
{
//TODO log that the operation was canceled, this only happens during a dispose
}
if (_asyncCollection.IsCompleted && _asyncCollection.Count > 0)
{
batch = batch ?? new List <TopicMessage>(_asyncCollection.Count);
//Drain any messages remaining in the queue and add them to the send batch
batch.AddRange(_asyncCollection.Drain());
}
//we want to fire the batch without blocking and then move on to fire another one
var sendTask = ProduceAndSendBatchAsync(batch, _stopToken.Token);
outstandingSendTasks.TryAdd(sendTask, sendTask);
var sendTaskCleanup = sendTask.ContinueWith(result =>
{
if (result.IsFaulted && batch != null)
{
batch.ForEach(x => x.Tcs.TrySetException(result.ExtractException()));
}
//TODO add statistics tracking
outstandingSendTasks.TryRemove(sendTask, out sendTask);
});
}
catch (Exception ex)
{
if (batch != null)
{
batch.ForEach(x => x.Tcs.TrySetException(ex));
}
}
}
var referenceToOutstanding = outstandingSendTasks.Values.ToList();
if (referenceToOutstanding.Count > 0)
{
await Task.WhenAll(referenceToOutstanding).ConfigureAwait(false);
}
}
/// <summary>
/// Use this API to remove a dynamic template.
/// WARNING: using this API doesn't really help you if the
/// template is already cached.
/// So will need to invalidate the cache as well.
/// </summary>
/// <param name="key"></param>
public void RemoveDynamic(ITemplateKey key)
{
ITemplateSource source;
_dynamicTemplates.TryRemove(key, out source);
}
