Compare commits
467 Commits
2022.01.27
...
release/pr
Author | SHA1 | Date | |
---|---|---|---|
95eb73da6e | |||
6ec0a24ca2 | |||
|
03b5b8b143 | ||
|
005a8b050d | ||
|
2c99f7b48e | ||
|
13d4ec3033 | ||
|
e6cdae5a6b | ||
|
d69a9ecf56 | ||
|
b6c32181b0 | ||
|
2017eebeba | ||
|
3192fe35e6 | ||
|
c1dace4af6 | ||
|
5c6ae3146a | ||
|
2e99db2275 | ||
|
79eec08590 | ||
|
69691f75f4 | ||
|
648eec25f2 | ||
|
80774853b6 | ||
|
08edbf9bd4 | ||
|
e472468c02 | ||
|
d4e266ed94 | ||
|
4e02e7841f | ||
|
dc707f75b3 | ||
|
41efe26a48 | ||
|
4740479ace | ||
|
6f28bc5b0b | ||
|
47ed505fae | ||
|
e2c07daece | ||
|
28fd712a63 | ||
|
3f11a4fe9f | ||
|
bcb063730c | ||
|
789981346a | ||
|
f79ba6466c | ||
|
871f8d75df | ||
|
ad89ecb39d | ||
|
2340e30c2d | ||
|
e7f5e6a841 | ||
|
50593f5a93 | ||
|
5a22a759a8 | ||
|
eb8ea5e222 | ||
|
3f0bdfe3a9 | ||
|
2fcbab9a37 | ||
|
e843f839f5 | ||
|
e4535e09a0 | ||
|
b4f93602ef | ||
|
bc34211e43 | ||
|
7323c6e3d7 | ||
|
ebdad2768d | ||
|
58e8d54373 | ||
|
3f71bc96f4 | ||
|
84ed9c8d8f | ||
|
81e2a2f6d4 | ||
|
088f7a51be | ||
|
7d436ac0c5 | ||
|
c26489d71f | ||
|
7f4eb230be | ||
|
003945c241 | ||
|
ba911f26ec | ||
|
d6d2717771 | ||
|
35f9eb5933 | ||
|
4233aab1ee | ||
|
cdf9485903 | ||
|
108dddb5cc | ||
|
399e082b61 | ||
|
35c4bbd2d5 | ||
|
cae77357ca | ||
|
f186e3ae4d | ||
|
1e88f5bac0 | ||
|
ce054c173e | ||
|
740df7c3ee | ||
|
466ae96874 | ||
|
6ae15261c9 | ||
|
72df5c9902 | ||
|
994dbe142e | ||
|
ed3f9f750f | ||
|
9b56ff520f | ||
|
123d84088f | ||
|
ddfcf6e138 | ||
|
92992dfb13 | ||
|
c53e0de7d0 | ||
|
29d0686f73 | ||
|
caddc06c70 | ||
|
75b93bb972 | ||
|
b022b08bc7 | ||
|
bb8f3fbe5b | ||
|
c3be7f7de5 | ||
|
520a76a15e | ||
|
e8ab56cd9b | ||
|
5490d6b358 | ||
|
5d53c2559b | ||
|
22af762a9d | ||
|
c550d424dd | ||
|
f4ded4cc1f | ||
|
d8c0cd47f5 | ||
|
1f77d10eed | ||
|
222f2ba5f8 | ||
|
8c48151ab6 | ||
|
c5a283a02e | ||
|
d0911b7b8a | ||
|
388434133b | ||
|
6bb97c7d83 | ||
|
c348283c94 | ||
|
a434420951 | ||
|
19bbdede45 | ||
|
129e70c82c | ||
|
c6c7ca6305 | ||
|
12ddb87fc2 | ||
|
bc0ec6c050 | ||
|
99e0990770 | ||
|
af2925287d | ||
|
ffb32ccc45 | ||
|
e558d912cf | ||
|
2e6a1efb47 | ||
|
4442826bcf | ||
|
6db1f6db07 | ||
|
d9d5a56ab0 | ||
|
f41ce39180 | ||
|
2e726ea9ed | ||
|
6fa172d757 | ||
|
da54c5d327 | ||
|
fb82cbe6f2 | ||
|
5f5c0f1cfb | ||
|
5f5fb8230e | ||
|
51fae05a73 | ||
|
c14042a109 | ||
|
fab3cf95d6 | ||
|
ad20572879 | ||
|
3364473ce2 | ||
|
710382d432 | ||
|
b258d51863 | ||
|
782201b086 | ||
|
676589a3e0 | ||
|
6c9ac1f7bb | ||
|
e8bdde70fb | ||
|
dab429776d | ||
|
5e32536821 | ||
|
59e3813fa7 | ||
|
66c0561e7f | ||
|
7b8f6421aa | ||
|
4ba56b53a4 | ||
|
a50e61318c | ||
|
83207b4b40 | ||
|
ba9e393363 | ||
|
2688790736 | ||
|
8fc47ec6c4 | ||
|
12e3fd9238 | ||
|
6edf3f1ae9 | ||
|
8f20a2e2cd | ||
|
b002991686 | ||
|
ba40478d11 | ||
|
c89314667c | ||
|
b14d7b6865 | ||
|
dabad54872 | ||
|
74e792bfdc | ||
|
eac8483885 | ||
|
0ebd582532 | ||
|
31e3e98d06 | ||
|
9ef189d303 | ||
|
ae101f1c3a | ||
|
ef5e36b224 | ||
|
d0f72390fb | ||
|
8bcc9354fd | ||
|
0674ef800b | ||
|
1349cf84b7 | ||
|
b311ecefc2 | ||
|
16739ce455 | ||
|
b5b01cba4c | ||
|
797642f3e6 | ||
|
6fa15d3dcc | ||
|
7d6bf88bfd | ||
|
2e149ddafd | ||
|
a16986f7a3 | ||
|
dbca3675ba | ||
|
973ea83ab9 | ||
|
69cb4bf9df | ||
|
9a08997825 | ||
|
9cf91d030d | ||
|
c06b0982a7 | ||
|
f4e7d5daf9 | ||
|
f6b3eb04f2 | ||
|
565f22b42e | ||
|
7c1c2e719b | ||
|
f50d067c73 | ||
|
a3fa5212f5 | ||
|
12357fd9f7 | ||
|
3367c5c22f | ||
|
3295315339 | ||
|
cf51b83cdd | ||
|
76925a78d4 | ||
|
7b869a3f43 | ||
|
0ce9dec3ea | ||
|
069e6a0517 | ||
|
778feb8024 | ||
|
44f22dae3a | ||
|
cf3209e1d0 | ||
|
a15da15d3e | ||
|
3b83729457 | ||
|
407ce2bc8f | ||
|
24d91f228b | ||
|
53cbd11008 | ||
|
186db53bad | ||
|
40466f84c4 | ||
|
bdb5a1c5f8 | ||
|
5d9e2b3bf1 | ||
|
1cf99869f6 | ||
|
12da0f463b | ||
|
e88071684d | ||
|
cd6097d133 | ||
|
d5cf4451a2 | ||
|
1e1e8bbe7b | ||
|
dadd236069 | ||
|
2380f23dbe | ||
|
3cffdfdd9d | ||
|
400c5d1f4d | ||
|
ca35fbb19f | ||
|
809cb0b7f4 | ||
|
18f23fd07d | ||
|
7526f86dab | ||
|
527ffbaced | ||
|
6f086ac565 | ||
|
cf4dd6a868 | ||
|
3efafa24ff | ||
|
fe919251fb | ||
|
a67f7f9351 | ||
|
e99ca3c140 | ||
|
ccedb01e8d | ||
|
841bcf6156 | ||
|
b381af5fba | ||
|
444c06e65e | ||
|
561909158f | ||
|
cd12c3f26e | ||
|
c817f9a810 | ||
|
b27ae1517e | ||
|
507688a175 | ||
|
d2cfd50e39 | ||
|
51e8b31e42 | ||
|
fa1567d3f5 | ||
|
f97e266c24 | ||
|
506b17dbb3 | ||
|
bef8c08d90 | ||
|
b78c467539 | ||
|
c3e042521a | ||
|
cb5f490d3b | ||
|
0a55c54c42 | ||
|
f43f7b5040 | ||
|
540cf7489d | ||
|
1a72faee60 | ||
|
4e44bb5ea1 | ||
|
9e17bcc38f | ||
|
4b33b33d01 | ||
|
6f1bc7ab90 | ||
|
63e1774cb6 | ||
|
61df873bb1 | ||
|
052eeb0615 | ||
|
88e67747fe | ||
|
5db94723aa | ||
|
ea8216ecdf | ||
|
6abbcbe464 | ||
|
57484690b6 | ||
|
7a022a1973 | ||
|
7108e23a03 | ||
|
77d25890da | ||
|
2fca68a7ea | ||
|
a6c0a94f6c | ||
|
71abaac9e1 | ||
|
e07651b931 | ||
|
5a2ee36df9 | ||
|
2daa4991d1 | ||
|
775c0a91b5 | ||
|
55bccc7d3d | ||
|
4322e8d882 | ||
|
a92f9fc29c | ||
|
fbf424c77d | ||
|
b8e001fcfe | ||
|
5ab5b73ecf | ||
|
4534d24fe6 | ||
|
73c8d0da33 | ||
|
16d75470b5 | ||
|
f02552faa1 | ||
|
a4923d03f9 | ||
|
8ae6561f4e | ||
|
deeb1dea87 | ||
|
9ab34614c5 | ||
|
2cff25d6b3 | ||
|
df3e226dc9 | ||
|
ef3db63ba7 | ||
|
49fe4520ff | ||
|
6587187a34 | ||
|
b337e232a2 | ||
|
a44b4e9475 | ||
|
ffb0e5cac1 | ||
|
ecc2b5bf54 | ||
|
2ac9cc4379 | ||
|
215037095f | ||
|
5433d7d1d2 | ||
|
0446fe1ec5 | ||
|
cf2a00e5b3 | ||
|
ab494a22cb | ||
|
b690579154 | ||
|
acc967e50a | ||
|
c493fbe13d | ||
|
ee56a5db1f | ||
|
f235d0fafd | ||
|
7ecf516278 | ||
|
210f1ca336 | ||
|
a38789adb9 | ||
|
e459b2fcde | ||
|
26853a0005 | ||
|
ee14306db9 | ||
|
169105e849 | ||
|
7c10e0e3de | ||
|
2f7eb07e39 | ||
|
0f9f4f597b | ||
|
880f9333d9 | ||
|
31da5d352e | ||
|
83a469cae3 | ||
|
1f13f9122c | ||
|
dd8c4f438f | ||
|
2230036d45 | ||
|
1700b7da91 | ||
|
fab97ccad4 | ||
|
0bf0d033f7 | ||
|
2bbabcb9e8 | ||
|
1995dbd080 | ||
|
a3b94b50e3 | ||
|
bc38b36e4a | ||
|
e346aa037e | ||
|
389c687420 | ||
|
074e36413e | ||
|
104d9bdc4c | ||
|
c51d28937b | ||
|
ffa8a46feb | ||
|
91c46dbdd4 | ||
|
ff0d22c142 | ||
|
3ad4aa2196 | ||
|
d462892467 | ||
|
cabedb6f0b | ||
|
5b7f5160b2 | ||
|
0a8e415af8 | ||
|
7b3ddd58c6 | ||
|
ed1032415e | ||
|
35b43e7438 | ||
|
284c2e9726 | ||
|
fd049edb3f | ||
|
4884abee76 | ||
|
1df76b6ac3 | ||
|
4c42a1d511 | ||
|
27635a6dd3 | ||
|
0175425708 | ||
|
5e12bf60b5 | ||
|
2f10ca8599 | ||
|
62ec18309e | ||
|
87361bf3d7 | ||
|
dc45136077 | ||
|
21b0a7998d | ||
|
20b8f0b99a | ||
|
314ff96e71 | ||
|
d7c4f5452c | ||
|
3cb50635e5 | ||
|
4fbe0ee0ed | ||
|
4023ca37d4 | ||
|
425ec2621d | ||
|
15c3ca53e2 | ||
|
6097ca504c | ||
|
70cd01eafb | ||
|
a2d5e37c6f | ||
|
19bd47d0f4 | ||
|
dc97956bc3 | ||
|
89fdc00f9b | ||
|
039a05d9ad | ||
|
25fb5fdc14 | ||
|
1e67f6e86c | ||
|
7dbdf87728 | ||
|
180a4911bc | ||
|
31123d9a33 | ||
|
3cf0f54ceb | ||
|
eafd7cb530 | ||
|
770785e979 | ||
|
92d713d188 | ||
|
34e531ef8d | ||
|
724992ef33 | ||
|
557cc1614f | ||
|
f90cdbef16 | ||
|
a863f78678 | ||
|
c93f896bc5 | ||
|
ccc8316a2f | ||
|
497c15a6a8 | ||
|
7be096e0b6 | ||
|
20858991e1 | ||
|
85d44b0eb0 | ||
|
51ef67ae9c | ||
|
63b04be4c7 | ||
|
36eb45bb2e | ||
|
04a4dcf153 | ||
|
b46b1eb5e7 | ||
|
287635fa36 | ||
|
f567a03fa7 | ||
|
1b6d8107ae | ||
|
1e8f06f3a3 | ||
|
064879fead | ||
|
e32e97b9e6 | ||
|
42313b7816 | ||
|
9f4d06c265 | ||
|
acf66da4ca | ||
|
59ca399045 | ||
|
ef70496546 | ||
|
e6e56d8d14 | ||
|
55b0caf900 | ||
|
a4c3f9c2d1 | ||
|
241aa0a5f6 | ||
|
ec0f59cdb1 | ||
|
59d69bd22b | ||
|
e9c8ead829 | ||
|
58d48a211e | ||
|
edf8e03b04 | ||
|
de2e804b84 | ||
|
b087d4c8de | ||
|
bd6c0dd5be | ||
|
4ace476242 | ||
|
bb7215dbb6 | ||
|
88bd47f3ae | ||
|
39a1066c74 | ||
|
18f3c59b9b | ||
|
0d88b6293f | ||
|
a6b56ceded | ||
|
78ef977268 | ||
|
d527a86911 | ||
|
2e531c4a50 | ||
|
45059fcfd9 | ||
|
482cd9c339 | ||
|
51667159a2 | ||
|
ea18a286b2 | ||
|
9a6d7c6a20 | ||
|
adcb75319c | ||
|
037fac5786 | ||
|
f4b892d8f4 | ||
|
3640d1df54 | ||
|
f3c6b10a35 | ||
|
4dec284b31 | ||
|
c9cf7be341 | ||
|
aa6ae0ab8d | ||
|
12dfd8c558 | ||
|
07f675eadc | ||
|
576d7015fa | ||
|
b1a1aae6c0 | ||
|
a0f4ceccfe | ||
|
b7a76cc4a2 | ||
|
261da918c7 | ||
|
2ed5e00bcb | ||
|
6ca94f8da8 | ||
|
3b532cf1f7 | ||
|
40966ed74d | ||
|
45eacabc28 | ||
|
0b02b7627a | ||
|
fc3a24ca17 | ||
|
209cb6cdd0 | ||
|
cfd4296f5c | ||
|
b275fbaced | ||
|
b2a3625288 | ||
|
0d3e2cb0bc | ||
|
505a2c4c2d | ||
|
8730a3fab8 | ||
|
3539101a40 | ||
|
7ccdee7d1b | ||
|
f4b160b735 | ||
|
73036dc1c7 | ||
|
6cfcce23cc |
1
.gitignore
vendored
1
.gitignore
vendored
@ -224,7 +224,6 @@ bootstrap-custom.min.css
|
||||
bootstrap-custom.css
|
||||
**/Master/static
|
||||
**/Master/dev_env
|
||||
/WebfrontCore/Views/Plugins/*
|
||||
/WebfrontCore/wwwroot/**/dds
|
||||
/WebfrontCore/wwwroot/images/radar/*
|
||||
|
||||
|
@ -1,7 +1,7 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using IW4MAdmin.Application.Plugin;
|
||||
using Newtonsoft.Json;
|
||||
using RestEase;
|
||||
using SharedLibraryCore.Helpers;
|
||||
|
55
Application/Alerts/AlertExtensions.cs
Normal file
55
Application/Alerts/AlertExtensions.cs
Normal file
@ -0,0 +1,55 @@
|
||||
using System;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Alerts;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
|
||||
namespace IW4MAdmin.Application.Alerts;
|
||||
|
||||
public static class AlertExtensions
|
||||
{
|
||||
public static Alert.AlertState BuildAlert(this EFClient client, Alert.AlertCategory? type = null)
|
||||
{
|
||||
return new Alert.AlertState
|
||||
{
|
||||
RecipientId = client.ClientId,
|
||||
Category = type ?? Alert.AlertCategory.Information
|
||||
};
|
||||
}
|
||||
|
||||
public static Alert.AlertState WithCategory(this Alert.AlertState state, Alert.AlertCategory category)
|
||||
{
|
||||
state.Category = category;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState OfType(this Alert.AlertState state, string type)
|
||||
{
|
||||
state.Type = type;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState WithMessage(this Alert.AlertState state, string message)
|
||||
{
|
||||
state.Message = message;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState ExpiresIn(this Alert.AlertState state, TimeSpan expiration)
|
||||
{
|
||||
state.ExpiresAt = DateTime.Now.Add(expiration);
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState FromSource(this Alert.AlertState state, string source)
|
||||
{
|
||||
state.Source = source;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState FromClient(this Alert.AlertState state, EFClient client)
|
||||
{
|
||||
state.Source = client.Name.StripColors();
|
||||
state.SourceId = client.ClientId;
|
||||
return state;
|
||||
}
|
||||
}
|
172
Application/Alerts/AlertManager.cs
Normal file
172
Application/Alerts/AlertManager.cs
Normal file
@ -0,0 +1,172 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using SharedLibraryCore.Alerts;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Alerts;
|
||||
|
||||
public class AlertManager : IAlertManager
|
||||
{
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly ConcurrentDictionary<int, List<Alert.AlertState>> _states = new();
|
||||
private readonly List<Func<Task<IEnumerable<Alert.AlertState>>>> _staticSources = new();
|
||||
private readonly SemaphoreSlim _onModifyingAlerts = new(1, 1);
|
||||
|
||||
public AlertManager(ApplicationConfiguration appConfig)
|
||||
{
|
||||
_appConfig = appConfig;
|
||||
_states.TryAdd(0, new List<Alert.AlertState>());
|
||||
}
|
||||
|
||||
public EventHandler<Alert.AlertState> OnAlertConsumed { get; set; }
|
||||
|
||||
public async Task Initialize()
|
||||
{
|
||||
foreach (var source in _staticSources)
|
||||
{
|
||||
var alerts = await source();
|
||||
foreach (var alert in alerts)
|
||||
{
|
||||
AddAlert(alert);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public IEnumerable<Alert.AlertState> RetrieveAlerts(EFClient client)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
var alerts = Enumerable.Empty<Alert.AlertState>();
|
||||
if (client.Level > Data.Models.Client.EFClient.Permission.Trusted)
|
||||
{
|
||||
alerts = alerts.Concat(_states[0].Where(alert =>
|
||||
alert.MinimumPermission is null || alert.MinimumPermission <= client.Level));
|
||||
}
|
||||
|
||||
if (_states.ContainsKey(client.ClientId))
|
||||
{
|
||||
alerts = alerts.Concat(_states[client.ClientId].AsReadOnly());
|
||||
}
|
||||
|
||||
return alerts.OrderByDescending(alert => alert.OccuredAt).ToList();
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void MarkAlertAsRead(Guid alertId)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
foreach (var items in _states.Values)
|
||||
{
|
||||
var matchingEvent = items.FirstOrDefault(item => item.AlertId == alertId);
|
||||
|
||||
if (matchingEvent is null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
items.Remove(matchingEvent);
|
||||
OnAlertConsumed?.Invoke(this, matchingEvent);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void MarkAllAlertsAsRead(int recipientId)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
foreach (var items in _states.Values)
|
||||
{
|
||||
items.RemoveAll(item =>
|
||||
{
|
||||
if (item.RecipientId != null && item.RecipientId != recipientId)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
OnAlertConsumed?.Invoke(this, item);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void AddAlert(Alert.AlertState alert)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
if (alert.RecipientId is null)
|
||||
{
|
||||
_states[0].Add(alert);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!_states.ContainsKey(alert.RecipientId.Value))
|
||||
{
|
||||
_states[alert.RecipientId.Value] = new List<Alert.AlertState>();
|
||||
}
|
||||
|
||||
if (_appConfig.MinimumAlertPermissions.ContainsKey(alert.Type))
|
||||
{
|
||||
alert.MinimumPermission = _appConfig.MinimumAlertPermissions[alert.Type];
|
||||
}
|
||||
|
||||
_states[alert.RecipientId.Value].Add(alert);
|
||||
|
||||
PruneOldAlerts();
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void RegisterStaticAlertSource(Func<Task<IEnumerable<Alert.AlertState>>> alertSource)
|
||||
{
|
||||
_staticSources.Add(alertSource);
|
||||
}
|
||||
|
||||
|
||||
private void PruneOldAlerts()
|
||||
{
|
||||
foreach (var value in _states.Values)
|
||||
{
|
||||
value.RemoveAll(item => item.ExpiresAt < DateTime.UtcNow);
|
||||
}
|
||||
}
|
||||
}
|
@ -24,18 +24,21 @@
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Jint" Version="3.0.0-beta-1632" />
|
||||
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.1">
|
||||
<PackageReference Include="Jint" Version="3.0.0-beta-2049" />
|
||||
<PackageReference Include="MaxMind.GeoIP2" Version="5.1.0" />
|
||||
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.8">
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
</PackageReference>
|
||||
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
|
||||
<PackageReference Include="RestEase" Version="1.5.5" />
|
||||
<PackageReference Include="RestEase" Version="1.5.7" />
|
||||
<PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
|
||||
<PackageReference Include="System.CommandLine.DragonFruit" Version="0.4.0-alpha.22272.1" />
|
||||
<PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
|
||||
</ItemGroup>
|
||||
|
||||
<PropertyGroup>
|
||||
<ServerGarbageCollection>false</ServerGarbageCollection>
|
||||
<ServerGarbageCollection>true</ServerGarbageCollection>
|
||||
<ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
|
||||
<TieredCompilation>true</TieredCompilation>
|
||||
<LangVersion>Latest</LangVersion>
|
||||
@ -63,6 +66,9 @@
|
||||
<None Update="Configuration\LoggingConfiguration.json">
|
||||
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
|
||||
</None>
|
||||
<None Update="Resources\GeoLite2-Country.mmdb">
|
||||
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
|
||||
</None>
|
||||
</ItemGroup>
|
||||
|
||||
<Target Name="PreBuild" BeforeTargets="PreBuildEvent">
|
||||
|
@ -16,6 +16,7 @@ using System.Collections;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.Immutable;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
@ -23,11 +24,18 @@ using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Context;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using IW4MAdmin.Application.Migration;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using SharedLibraryCore.Events;
|
||||
using SharedLibraryCore.Events.Management;
|
||||
using SharedLibraryCore.Events.Server;
|
||||
using SharedLibraryCore.Formatting;
|
||||
using SharedLibraryCore.Interfaces.Events;
|
||||
using static SharedLibraryCore.GameEvent;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using ObsoleteLogger = SharedLibraryCore.Interfaces.ILogger;
|
||||
@ -46,8 +54,10 @@ namespace IW4MAdmin.Application
|
||||
|
||||
public IList<IRConParser> AdditionalRConParsers { get; }
|
||||
public IList<IEventParser> AdditionalEventParsers { get; }
|
||||
public IList<Func<GameEvent, bool>> CommandInterceptors { get; set; } =
|
||||
new List<Func<GameEvent, bool>>();
|
||||
public ITokenAuthentication TokenAuthenticator { get; }
|
||||
public CancellationToken CancellationToken => _tokenSource.Token;
|
||||
public CancellationToken CancellationToken => _isRunningTokenSource.Token;
|
||||
public string ExternalIPAddress { get; private set; }
|
||||
public bool IsRestartRequested { get; private set; }
|
||||
public IMiddlewareActionHandler MiddlewareActionHandler { get; }
|
||||
@ -57,55 +67,56 @@ namespace IW4MAdmin.Application
|
||||
private readonly List<MessageToken> MessageTokens;
|
||||
private readonly ClientService ClientSvc;
|
||||
readonly PenaltyService PenaltySvc;
|
||||
private readonly IAlertManager _alertManager;
|
||||
public IConfigurationHandler<ApplicationConfiguration> ConfigHandler;
|
||||
readonly IPageList PageList;
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly TimeSpan _throttleTimeout = new TimeSpan(0, 1, 0);
|
||||
private readonly CancellationTokenSource _tokenSource;
|
||||
private CancellationTokenSource _isRunningTokenSource;
|
||||
private CancellationTokenSource _eventHandlerTokenSource;
|
||||
private readonly Dictionary<string, Task<IList>> _operationLookup = new Dictionary<string, Task<IList>>();
|
||||
private readonly ITranslationLookup _translationLookup;
|
||||
private readonly IConfigurationHandler<CommandConfiguration> _commandConfiguration;
|
||||
private readonly IGameServerInstanceFactory _serverInstanceFactory;
|
||||
private readonly IParserRegexFactory _parserRegexFactory;
|
||||
private readonly IEnumerable<IRegisterEvent> _customParserEvents;
|
||||
private readonly IEventHandler _eventHandler;
|
||||
private readonly ICoreEventHandler _coreEventHandler;
|
||||
private readonly IScriptCommandFactory _scriptCommandFactory;
|
||||
private readonly IMetaRegistration _metaRegistration;
|
||||
private readonly IScriptPluginServiceResolver _scriptPluginServiceResolver;
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
private readonly ChangeHistoryService _changeHistoryService;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
public ConcurrentDictionary<long, GameEvent> ProcessingEvents { get; } = new ConcurrentDictionary<long, GameEvent>();
|
||||
public ConcurrentDictionary<long, GameEvent> ProcessingEvents { get; } = new();
|
||||
|
||||
public ApplicationManager(ILogger<ApplicationManager> logger, IMiddlewareActionHandler actionHandler, IEnumerable<IManagerCommand> commands,
|
||||
ITranslationLookup translationLookup, IConfigurationHandler<CommandConfiguration> commandConfiguration,
|
||||
IConfigurationHandler<ApplicationConfiguration> appConfigHandler, IGameServerInstanceFactory serverInstanceFactory,
|
||||
IEnumerable<IPlugin> plugins, IParserRegexFactory parserRegexFactory, IEnumerable<IRegisterEvent> customParserEvents,
|
||||
IEventHandler eventHandler, IScriptCommandFactory scriptCommandFactory, IDatabaseContextFactory contextFactory, IMetaService metaService,
|
||||
ICoreEventHandler coreEventHandler, IScriptCommandFactory scriptCommandFactory, IDatabaseContextFactory contextFactory,
|
||||
IMetaRegistration metaRegistration, IScriptPluginServiceResolver scriptPluginServiceResolver, ClientService clientService, IServiceProvider serviceProvider,
|
||||
ChangeHistoryService changeHistoryService, ApplicationConfiguration appConfig, PenaltyService penaltyService)
|
||||
ChangeHistoryService changeHistoryService, ApplicationConfiguration appConfig, PenaltyService penaltyService, IAlertManager alertManager, IInteractionRegistration interactionRegistration, IEnumerable<IPluginV2> v2PLugins)
|
||||
{
|
||||
MiddlewareActionHandler = actionHandler;
|
||||
_servers = new ConcurrentBag<Server>();
|
||||
MessageTokens = new List<MessageToken>();
|
||||
ClientSvc = clientService;
|
||||
PenaltySvc = penaltyService;
|
||||
_alertManager = alertManager;
|
||||
ConfigHandler = appConfigHandler;
|
||||
StartTime = DateTime.UtcNow;
|
||||
PageList = new PageList();
|
||||
AdditionalEventParsers = new List<IEventParser>() { new BaseEventParser(parserRegexFactory, logger, _appConfig) };
|
||||
AdditionalRConParsers = new List<IRConParser>() { new BaseRConParser(serviceProvider.GetRequiredService<ILogger<BaseRConParser>>(), parserRegexFactory) };
|
||||
AdditionalEventParsers = new List<IEventParser> { new BaseEventParser(parserRegexFactory, logger, _appConfig) };
|
||||
AdditionalRConParsers = new List<IRConParser> { new BaseRConParser(serviceProvider.GetRequiredService<ILogger<BaseRConParser>>(), parserRegexFactory) };
|
||||
TokenAuthenticator = new TokenAuthentication();
|
||||
_logger = logger;
|
||||
_metaService = metaService;
|
||||
_tokenSource = new CancellationTokenSource();
|
||||
_isRunningTokenSource = new CancellationTokenSource();
|
||||
_commands = commands.ToList();
|
||||
_translationLookup = translationLookup;
|
||||
_commandConfiguration = commandConfiguration;
|
||||
_serverInstanceFactory = serverInstanceFactory;
|
||||
_parserRegexFactory = parserRegexFactory;
|
||||
_customParserEvents = customParserEvents;
|
||||
_eventHandler = eventHandler;
|
||||
_coreEventHandler = coreEventHandler;
|
||||
_scriptCommandFactory = scriptCommandFactory;
|
||||
_metaRegistration = metaRegistration;
|
||||
_scriptPluginServiceResolver = scriptPluginServiceResolver;
|
||||
@ -113,13 +124,17 @@ namespace IW4MAdmin.Application
|
||||
_changeHistoryService = changeHistoryService;
|
||||
_appConfig = appConfig;
|
||||
Plugins = plugins;
|
||||
InteractionRegistration = interactionRegistration;
|
||||
|
||||
IManagementEventSubscriptions.ClientPersistentIdReceived += OnClientPersistentIdReceived;
|
||||
}
|
||||
|
||||
public IEnumerable<IPlugin> Plugins { get; }
|
||||
public IInteractionRegistration InteractionRegistration { get; }
|
||||
|
||||
public async Task ExecuteEvent(GameEvent newEvent)
|
||||
{
|
||||
ProcessingEvents.TryAdd(newEvent.Id, newEvent);
|
||||
ProcessingEvents.TryAdd(newEvent.IncrementalId, newEvent);
|
||||
|
||||
// the event has failed already
|
||||
if (newEvent.Failed)
|
||||
@ -137,12 +152,12 @@ namespace IW4MAdmin.Application
|
||||
|
||||
catch (TaskCanceledException)
|
||||
{
|
||||
_logger.LogDebug("Received quit signal for event id {eventId}, so we are aborting early", newEvent.Id);
|
||||
_logger.LogDebug("Received quit signal for event id {EventId}, so we are aborting early", newEvent.IncrementalId);
|
||||
}
|
||||
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogDebug("Received quit signal for event id {eventId}, so we are aborting early", newEvent.Id);
|
||||
_logger.LogDebug("Received quit signal for event id {EventId}, so we are aborting early", newEvent.IncrementalId);
|
||||
}
|
||||
|
||||
// this happens if a plugin requires login
|
||||
@ -181,11 +196,11 @@ namespace IW4MAdmin.Application
|
||||
}
|
||||
|
||||
skip:
|
||||
if (newEvent.Type == EventType.Command && newEvent.ImpersonationOrigin == null)
|
||||
if (newEvent.Type == EventType.Command && newEvent.ImpersonationOrigin == null && newEvent.CorrelationId is not null)
|
||||
{
|
||||
var correlatedEvents =
|
||||
ProcessingEvents.Values.Where(ev =>
|
||||
ev.CorrelationId == newEvent.CorrelationId && ev.Id != newEvent.Id)
|
||||
ev.CorrelationId == newEvent.CorrelationId && ev.IncrementalId != newEvent.IncrementalId)
|
||||
.ToList();
|
||||
|
||||
await Task.WhenAll(correlatedEvents.Select(ev =>
|
||||
@ -194,14 +209,16 @@ namespace IW4MAdmin.Application
|
||||
|
||||
foreach (var correlatedEvent in correlatedEvents)
|
||||
{
|
||||
ProcessingEvents.Remove(correlatedEvent.Id, out _);
|
||||
ProcessingEvents.Remove(correlatedEvent.IncrementalId, out _);
|
||||
}
|
||||
}
|
||||
|
||||
// we don't want to remove events that are correlated to command
|
||||
if (ProcessingEvents.Values.ToList()?.Count(gameEvent => gameEvent.CorrelationId == newEvent.CorrelationId) == 1)
|
||||
if (ProcessingEvents.Values.Count(gameEvent =>
|
||||
newEvent.CorrelationId is not null && newEvent.CorrelationId == gameEvent.CorrelationId) == 1 ||
|
||||
newEvent.CorrelationId is null)
|
||||
{
|
||||
ProcessingEvents.Remove(newEvent.Id, out _);
|
||||
ProcessingEvents.Remove(newEvent.IncrementalId, out _);
|
||||
}
|
||||
|
||||
// tell anyone waiting for the output that we're done
|
||||
@ -221,84 +238,58 @@ namespace IW4MAdmin.Application
|
||||
|
||||
public IReadOnlyList<IManagerCommand> Commands => _commands.ToImmutableList();
|
||||
|
||||
public async Task UpdateServerStates()
|
||||
private Task UpdateServerStates()
|
||||
{
|
||||
// store the server hash code and task for it
|
||||
var runningUpdateTasks = new Dictionary<long, (Task task, CancellationTokenSource tokenSource, DateTime startTime)>();
|
||||
|
||||
while (!_tokenSource.IsCancellationRequested)
|
||||
var index = 0;
|
||||
return Task.WhenAll(_servers.Select(server =>
|
||||
{
|
||||
// select the server ids that have completed the update task
|
||||
var serverTasksToRemove = runningUpdateTasks
|
||||
.Where(ut => ut.Value.task.Status == TaskStatus.RanToCompletion ||
|
||||
ut.Value.task.Status == TaskStatus.Canceled || // we want to cancel if a task takes longer than 5 minutes
|
||||
ut.Value.task.Status == TaskStatus.Faulted || DateTime.Now - ut.Value.startTime > TimeSpan.FromMinutes(5))
|
||||
.Select(ut => ut.Key)
|
||||
.ToList();
|
||||
var thisIndex = index;
|
||||
Interlocked.Increment(ref index);
|
||||
return ProcessUpdateHandler(server, thisIndex);
|
||||
}));
|
||||
}
|
||||
|
||||
// this is to prevent the log reader from starting before the initial
|
||||
// query of players on the server
|
||||
if (serverTasksToRemove.Count > 0)
|
||||
{
|
||||
IsInitialized = true;
|
||||
}
|
||||
|
||||
// remove the update tasks as they have completed
|
||||
foreach (var serverId in serverTasksToRemove.Where(serverId => runningUpdateTasks.ContainsKey(serverId)))
|
||||
{
|
||||
if (!runningUpdateTasks[serverId].tokenSource.Token.IsCancellationRequested)
|
||||
{
|
||||
runningUpdateTasks[serverId].tokenSource.Cancel();
|
||||
}
|
||||
|
||||
runningUpdateTasks.Remove(serverId);
|
||||
}
|
||||
|
||||
// select the servers where the tasks have completed
|
||||
var serverIds = Servers.Select(s => s.EndPoint).Except(runningUpdateTasks.Select(r => r.Key)).ToList();
|
||||
foreach (var server in Servers.Where(s => serverIds.Contains(s.EndPoint)))
|
||||
{
|
||||
var tokenSource = new CancellationTokenSource();
|
||||
runningUpdateTasks.Add(server.EndPoint, (Task.Run(async () =>
|
||||
{
|
||||
try
|
||||
{
|
||||
if (runningUpdateTasks.ContainsKey(server.EndPoint))
|
||||
{
|
||||
await server.ProcessUpdatesAsync(_tokenSource.Token)
|
||||
.WithWaitCancellation(runningUpdateTasks[server.EndPoint].tokenSource.Token);
|
||||
}
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server.ToString()))
|
||||
{
|
||||
_logger.LogError(e, "Failed to update status");
|
||||
}
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
server.IsInitialized = true;
|
||||
}
|
||||
}, tokenSource.Token), tokenSource, DateTime.Now));
|
||||
}
|
||||
private async Task ProcessUpdateHandler(Server server, int index)
|
||||
{
|
||||
const int delayScalar = 50; // Task.Delay is inconsistent enough there's no reason to try to prevent collisions
|
||||
var timeout = TimeSpan.FromMinutes(2);
|
||||
|
||||
while (!_isRunningTokenSource.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
await Task.Delay(ConfigHandler.Configuration().RConPollRate, _tokenSource.Token);
|
||||
var delayFactor = Math.Min(_appConfig.RConPollRate, delayScalar * index);
|
||||
await Task.Delay(delayFactor, _isRunningTokenSource.Token);
|
||||
|
||||
using var timeoutTokenSource = new CancellationTokenSource();
|
||||
timeoutTokenSource.CancelAfter(timeout);
|
||||
using var linkedTokenSource =
|
||||
CancellationTokenSource.CreateLinkedTokenSource(timeoutTokenSource.Token,
|
||||
_isRunningTokenSource.Token);
|
||||
await server.ProcessUpdatesAsync(linkedTokenSource.Token);
|
||||
|
||||
await Task.Delay(Math.Max(1000, _appConfig.RConPollRate - delayFactor),
|
||||
_isRunningTokenSource.Token);
|
||||
}
|
||||
// if a cancellation is received, we want to return immediately after shutting down
|
||||
catch
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
foreach (var server in Servers.Where(s => serverIds.Contains(s.EndPoint)))
|
||||
// ignored
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server.Id))
|
||||
{
|
||||
await server.ProcessUpdatesAsync(_tokenSource.Token);
|
||||
_logger.LogError(ex, "Failed to update status");
|
||||
}
|
||||
break;
|
||||
}
|
||||
finally
|
||||
{
|
||||
server.IsInitialized = true;
|
||||
}
|
||||
}
|
||||
|
||||
// run the final updates to clean up server
|
||||
await server.ProcessUpdatesAsync(_isRunningTokenSource.Token);
|
||||
}
|
||||
|
||||
public async Task Init()
|
||||
@ -309,25 +300,34 @@ namespace IW4MAdmin.Application
|
||||
#region DATABASE
|
||||
_logger.LogInformation("Beginning database migration sync");
|
||||
Console.WriteLine(_translationLookup["MANAGER_MIGRATION_START"]);
|
||||
await ContextSeed.Seed(_serviceProvider.GetRequiredService<IDatabaseContextFactory>(), _tokenSource.Token);
|
||||
await DatabaseHousekeeping.RemoveOldRatings(_serviceProvider.GetRequiredService<IDatabaseContextFactory>(), _tokenSource.Token);
|
||||
await ContextSeed.Seed(_serviceProvider.GetRequiredService<IDatabaseContextFactory>(), _isRunningTokenSource.Token);
|
||||
await DatabaseHousekeeping.RemoveOldRatings(_serviceProvider.GetRequiredService<IDatabaseContextFactory>(), _isRunningTokenSource.Token);
|
||||
_logger.LogInformation("Finished database migration sync");
|
||||
Console.WriteLine(_translationLookup["MANAGER_MIGRATION_END"]);
|
||||
#endregion
|
||||
|
||||
#region EVENTS
|
||||
IGameServerEventSubscriptions.ServerValueRequested += OnServerValueRequested;
|
||||
IGameServerEventSubscriptions.ServerValueSetRequested += OnServerValueSetRequested;
|
||||
IGameServerEventSubscriptions.ServerCommandExecuteRequested += OnServerCommandExecuteRequested;
|
||||
await IManagementEventSubscriptions.InvokeLoadAsync(this, CancellationToken);
|
||||
# endregion
|
||||
|
||||
#region PLUGINS
|
||||
foreach (var plugin in Plugins)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (plugin is ScriptPlugin scriptPlugin)
|
||||
if (plugin is ScriptPlugin scriptPlugin && !plugin.IsParser)
|
||||
{
|
||||
await scriptPlugin.Initialize(this, _scriptCommandFactory, _scriptPluginServiceResolver);
|
||||
await scriptPlugin.Initialize(this, _scriptCommandFactory, _scriptPluginServiceResolver,
|
||||
_serviceProvider.GetService<IConfigurationHandlerV2<ScriptPluginConfiguration>>());
|
||||
scriptPlugin.Watcher.Changed += async (sender, e) =>
|
||||
{
|
||||
try
|
||||
{
|
||||
await scriptPlugin.Initialize(this, _scriptCommandFactory, _scriptPluginServiceResolver);
|
||||
await scriptPlugin.Initialize(this, _scriptCommandFactory, _scriptPluginServiceResolver,
|
||||
_serviceProvider.GetService<IConfigurationHandlerV2<ScriptPluginConfiguration>>());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
@ -355,10 +355,10 @@ namespace IW4MAdmin.Application
|
||||
// copy over default config if it doesn't exist
|
||||
if (!_appConfig.Servers?.Any() ?? true)
|
||||
{
|
||||
var defaultConfig = new BaseConfigurationHandler<DefaultSettings>("DefaultSettings").Configuration();
|
||||
//ConfigHandler.Set((ApplicationConfiguration)new ApplicationConfiguration().Generate());
|
||||
//var newConfig = ConfigHandler.Configuration();
|
||||
|
||||
var defaultHandler = new BaseConfigurationHandler<DefaultSettings>("DefaultSettings");
|
||||
await defaultHandler.BuildAsync();
|
||||
var defaultConfig = defaultHandler.Configuration();
|
||||
|
||||
_appConfig.AutoMessages = defaultConfig.AutoMessages;
|
||||
_appConfig.GlobalRules = defaultConfig.GlobalRules;
|
||||
_appConfig.DisallowedClientNames = defaultConfig.DisallowedClientNames;
|
||||
@ -393,13 +393,11 @@ namespace IW4MAdmin.Application
|
||||
if (string.IsNullOrEmpty(_appConfig.Id))
|
||||
{
|
||||
_appConfig.Id = Guid.NewGuid().ToString();
|
||||
await ConfigHandler.Save();
|
||||
}
|
||||
|
||||
if (string.IsNullOrEmpty(_appConfig.WebfrontBindUrl))
|
||||
{
|
||||
_appConfig.WebfrontBindUrl = "http://0.0.0.0:1624";
|
||||
await ConfigHandler.Save();
|
||||
}
|
||||
|
||||
#pragma warning disable 618
|
||||
@ -419,7 +417,7 @@ namespace IW4MAdmin.Application
|
||||
|
||||
if (!validationResult.IsValid)
|
||||
{
|
||||
throw new ConfigurationException("MANAGER_CONFIGURATION_ERROR")
|
||||
throw new ConfigurationException("Could not validate configuration")
|
||||
{
|
||||
Errors = validationResult.Errors.Select(_error => _error.ErrorMessage).ToArray(),
|
||||
ConfigurationFileName = ConfigHandler.FileName
|
||||
@ -444,8 +442,8 @@ namespace IW4MAdmin.Application
|
||||
|
||||
serverConfig.ModifyParsers();
|
||||
}
|
||||
await ConfigHandler.Save();
|
||||
}
|
||||
await ConfigHandler.Save();
|
||||
}
|
||||
|
||||
if (_appConfig.Servers.Length == 0)
|
||||
@ -470,7 +468,7 @@ namespace IW4MAdmin.Application
|
||||
#endregion
|
||||
|
||||
#region COMMANDS
|
||||
if (await ClientSvc.HasOwnerAsync(_tokenSource.Token))
|
||||
if (await ClientSvc.HasOwnerAsync(_isRunningTokenSource.Token))
|
||||
{
|
||||
_commands.RemoveAll(_cmd => _cmd.GetType() == typeof(OwnerCommand));
|
||||
}
|
||||
@ -517,6 +515,7 @@ namespace IW4MAdmin.Application
|
||||
#endregion
|
||||
|
||||
_metaRegistration.Register();
|
||||
await _alertManager.Initialize();
|
||||
|
||||
#region CUSTOM_EVENTS
|
||||
foreach (var customEvent in _customParserEvents.SelectMany(_events => _events.Events))
|
||||
@ -527,9 +526,10 @@ namespace IW4MAdmin.Application
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
|
||||
|
||||
Console.WriteLine(_translationLookup["MANAGER_COMMUNICATION_INFO"]);
|
||||
await InitializeServers();
|
||||
IsInitialized = true;
|
||||
}
|
||||
|
||||
private async Task InitializeServers()
|
||||
@ -543,26 +543,23 @@ namespace IW4MAdmin.Application
|
||||
try
|
||||
{
|
||||
// todo: this might not always be an IW4MServer
|
||||
var ServerInstance = _serverInstanceFactory.CreateServer(Conf, this) as IW4MServer;
|
||||
using (LogContext.PushProperty("Server", ServerInstance.ToString()))
|
||||
var serverInstance = _serverInstanceFactory.CreateServer(Conf, this) as IW4MServer;
|
||||
using (LogContext.PushProperty("Server", serverInstance!.ToString()))
|
||||
{
|
||||
_logger.LogInformation("Beginning server communication initialization");
|
||||
await ServerInstance.Initialize();
|
||||
await serverInstance.Initialize();
|
||||
|
||||
_servers.Add(ServerInstance);
|
||||
Console.WriteLine(Utilities.CurrentLocalization.LocalizationIndex["MANAGER_MONITORING_TEXT"].FormatExt(ServerInstance.Hostname.StripColors()));
|
||||
_logger.LogInformation("Finishing initialization and now monitoring [{Server}]", ServerInstance.Hostname);
|
||||
_servers.Add(serverInstance);
|
||||
Console.WriteLine(Utilities.CurrentLocalization.LocalizationIndex["MANAGER_MONITORING_TEXT"].FormatExt(serverInstance.Hostname.StripColors()));
|
||||
_logger.LogInformation("Finishing initialization and now monitoring [{Server}]", serverInstance.Hostname);
|
||||
}
|
||||
|
||||
// add the start event for this server
|
||||
var e = new GameEvent()
|
||||
QueueEvent(new MonitorStartEvent
|
||||
{
|
||||
Type = EventType.Start,
|
||||
Data = $"{ServerInstance.GameName} started",
|
||||
Owner = ServerInstance
|
||||
};
|
||||
|
||||
AddEvent(e);
|
||||
Server = serverInstance,
|
||||
Source = this
|
||||
});
|
||||
|
||||
successServers++;
|
||||
}
|
||||
|
||||
@ -584,27 +581,71 @@ namespace IW4MAdmin.Application
|
||||
throw lastException;
|
||||
}
|
||||
|
||||
if (successServers != config.Servers.Length)
|
||||
if (successServers != config.Servers.Length && !AppContext.TryGetSwitch("NoConfirmPrompt", out _))
|
||||
{
|
||||
if (!Utilities.PromptBool(Utilities.CurrentLocalization.LocalizationIndex["MANAGER_START_WITH_ERRORS"]))
|
||||
if (!Utilities.CurrentLocalization.LocalizationIndex["MANAGER_START_WITH_ERRORS"].PromptBool())
|
||||
{
|
||||
throw lastException;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task Start() => await UpdateServerStates();
|
||||
|
||||
public void Stop()
|
||||
public async Task Start()
|
||||
{
|
||||
_tokenSource.Cancel();
|
||||
_eventHandlerTokenSource = new CancellationTokenSource();
|
||||
|
||||
var eventHandlerThread = new Thread(() =>
|
||||
{
|
||||
_coreEventHandler.StartProcessing(_eventHandlerTokenSource.Token);
|
||||
})
|
||||
{
|
||||
Name = nameof(CoreEventHandler)
|
||||
};
|
||||
|
||||
eventHandlerThread.Start();
|
||||
await UpdateServerStates();
|
||||
_eventHandlerTokenSource.Cancel();
|
||||
eventHandlerThread.Join();
|
||||
}
|
||||
|
||||
public async Task Stop()
|
||||
{
|
||||
foreach (var plugin in Plugins.Where(plugin => !plugin.IsParser))
|
||||
{
|
||||
try
|
||||
{
|
||||
await plugin.OnUnloadAsync().WithTimeout(Utilities.DefaultCommandTimeout);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not cleanly unload plugin {PluginName}", plugin.Name);
|
||||
}
|
||||
}
|
||||
|
||||
_isRunningTokenSource.Cancel();
|
||||
|
||||
IsRunning = false;
|
||||
}
|
||||
|
||||
public void Restart()
|
||||
public async Task Restart()
|
||||
{
|
||||
IsRestartRequested = true;
|
||||
Stop();
|
||||
await Stop();
|
||||
|
||||
using var subscriptionTimeoutToken = new CancellationTokenSource();
|
||||
subscriptionTimeoutToken.CancelAfter(Utilities.DefaultCommandTimeout);
|
||||
|
||||
await IManagementEventSubscriptions.InvokeUnloadAsync(this, subscriptionTimeoutToken.Token);
|
||||
|
||||
IGameEventSubscriptions.ClearEventInvocations();
|
||||
IGameServerEventSubscriptions.ClearEventInvocations();
|
||||
IManagementEventSubscriptions.ClearEventInvocations();
|
||||
|
||||
_isRunningTokenSource.Dispose();
|
||||
_isRunningTokenSource = new CancellationTokenSource();
|
||||
|
||||
_eventHandlerTokenSource.Dispose();
|
||||
_eventHandlerTokenSource = new CancellationTokenSource();
|
||||
}
|
||||
|
||||
[Obsolete]
|
||||
@ -624,9 +665,9 @@ namespace IW4MAdmin.Application
|
||||
return _servers.SelectMany(s => s.Clients).ToList().Where(p => p != null).ToList();
|
||||
}
|
||||
|
||||
public EFClient FindActiveClient(EFClient client) =>client.ClientNumber < 0 ?
|
||||
public EFClient FindActiveClient(EFClient client) => client.ClientNumber < 0 ?
|
||||
GetActiveClients()
|
||||
.FirstOrDefault(c => c.NetworkId == client.NetworkId) ?? client :
|
||||
.FirstOrDefault(c => c.NetworkId == client.NetworkId && c.GameName == client.GameName) ?? client :
|
||||
client;
|
||||
|
||||
public ClientService GetClientService()
|
||||
@ -646,9 +687,14 @@ namespace IW4MAdmin.Application
|
||||
|
||||
public void AddEvent(GameEvent gameEvent)
|
||||
{
|
||||
_eventHandler.HandleEvent(this, gameEvent);
|
||||
_coreEventHandler.QueueEvent(this, gameEvent);
|
||||
}
|
||||
|
||||
public void QueueEvent(CoreEvent coreEvent)
|
||||
{
|
||||
_coreEventHandler.QueueEvent(this, coreEvent);
|
||||
}
|
||||
|
||||
public IPageList GetPageList()
|
||||
{
|
||||
return PageList;
|
||||
@ -683,14 +729,166 @@ namespace IW4MAdmin.Application
|
||||
|
||||
public void AddAdditionalCommand(IManagerCommand command)
|
||||
{
|
||||
if (_commands.Any(_command => _command.Name == command.Name || _command.Alias == command.Alias))
|
||||
lock (_commands)
|
||||
{
|
||||
throw new InvalidOperationException($"Duplicate command name or alias ({command.Name}, {command.Alias})");
|
||||
}
|
||||
if (_commands.Any(cmd => cmd.Name == command.Name || cmd.Alias == command.Alias))
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
$"Duplicate command name or alias ({command.Name}, {command.Alias})");
|
||||
}
|
||||
|
||||
_commands.Add(command);
|
||||
_commands.Add(command);
|
||||
}
|
||||
}
|
||||
|
||||
public void RemoveCommandByName(string commandName) => _commands.RemoveAll(_command => _command.Name == commandName);
|
||||
public IAlertManager AlertManager => _alertManager;
|
||||
|
||||
private async Task OnServerValueRequested(ServerValueRequestEvent requestEvent, CancellationToken token)
|
||||
{
|
||||
if (requestEvent.Server is not IW4MServer server)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Dvar<string> serverValue = null;
|
||||
try
|
||||
{
|
||||
if (requestEvent.DelayMs.HasValue)
|
||||
{
|
||||
await Task.Delay(requestEvent.DelayMs.Value, token);
|
||||
}
|
||||
|
||||
var waitToken = token;
|
||||
using var timeoutTokenSource = new CancellationTokenSource();
|
||||
using var linkedTokenSource =
|
||||
CancellationTokenSource.CreateLinkedTokenSource(timeoutTokenSource.Token, token);
|
||||
|
||||
if (requestEvent.TimeoutMs is not null)
|
||||
{
|
||||
timeoutTokenSource.CancelAfter(requestEvent.TimeoutMs.Value);
|
||||
waitToken = linkedTokenSource.Token;
|
||||
}
|
||||
|
||||
serverValue =
|
||||
await server.GetDvarAsync(requestEvent.ValueName, requestEvent.FallbackValue, waitToken);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
finally
|
||||
{
|
||||
QueueEvent(new ServerValueReceiveEvent
|
||||
{
|
||||
Server = server,
|
||||
Source = server,
|
||||
Response = serverValue ?? new Dvar<string> { Name = requestEvent.ValueName },
|
||||
Success = serverValue is not null
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private Task OnServerValueSetRequested(ServerValueSetRequestEvent requestEvent, CancellationToken token)
|
||||
{
|
||||
return ExecuteWrapperForServerQuery(requestEvent, token, async (innerEvent) =>
|
||||
{
|
||||
if (innerEvent.DelayMs.HasValue)
|
||||
{
|
||||
await Task.Delay(innerEvent.DelayMs.Value, token);
|
||||
}
|
||||
|
||||
if (innerEvent.TimeoutMs is not null)
|
||||
{
|
||||
using var timeoutTokenSource = new CancellationTokenSource(innerEvent.TimeoutMs.Value);
|
||||
using var linkedTokenSource =
|
||||
CancellationTokenSource.CreateLinkedTokenSource(timeoutTokenSource.Token, token);
|
||||
token = linkedTokenSource.Token;
|
||||
}
|
||||
|
||||
await innerEvent.Server.SetDvarAsync(innerEvent.ValueName, innerEvent.Value, token);
|
||||
}, (completed, innerEvent) =>
|
||||
{
|
||||
QueueEvent(new ServerValueSetCompleteEvent
|
||||
{
|
||||
Server = innerEvent.Server,
|
||||
Source = innerEvent.Server,
|
||||
Success = completed,
|
||||
Value = innerEvent.Value,
|
||||
ValueName = innerEvent.ValueName
|
||||
});
|
||||
return Task.CompletedTask;
|
||||
});
|
||||
}
|
||||
|
||||
private Task OnServerCommandExecuteRequested(ServerCommandRequestExecuteEvent executeEvent, CancellationToken token)
|
||||
{
|
||||
return ExecuteWrapperForServerQuery(executeEvent, token, async (innerEvent) =>
|
||||
{
|
||||
if (innerEvent.DelayMs.HasValue)
|
||||
{
|
||||
await Task.Delay(innerEvent.DelayMs.Value, token);
|
||||
}
|
||||
|
||||
if (innerEvent.TimeoutMs is not null)
|
||||
{
|
||||
using var timeoutTokenSource = new CancellationTokenSource(innerEvent.TimeoutMs.Value);
|
||||
using var linkedTokenSource =
|
||||
CancellationTokenSource.CreateLinkedTokenSource(timeoutTokenSource.Token, token);
|
||||
token = linkedTokenSource.Token;
|
||||
}
|
||||
|
||||
await innerEvent.Server.ExecuteCommandAsync(innerEvent.Command, token);
|
||||
}, (_, __) => Task.CompletedTask);
|
||||
}
|
||||
|
||||
private async Task ExecuteWrapperForServerQuery<TEventType>(TEventType serverEvent, CancellationToken token,
|
||||
Func<TEventType, Task> action, Func<bool, TEventType, Task> complete) where TEventType : GameServerEvent
|
||||
{
|
||||
if (serverEvent.Server is not IW4MServer)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var completed = false;
|
||||
try
|
||||
{
|
||||
await action(serverEvent);
|
||||
completed = true;
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
finally
|
||||
{
|
||||
await complete(completed, serverEvent);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task OnClientPersistentIdReceived(ClientPersistentIdReceiveEvent receiveEvent, CancellationToken token)
|
||||
{
|
||||
var parts = receiveEvent.PersistentId.Split(",");
|
||||
|
||||
if (parts.Length == 2 && int.TryParse(parts[0], out var high) &&
|
||||
int.TryParse(parts[1], out var low))
|
||||
{
|
||||
var guid = long.Parse(high.ToString("X") + low.ToString("X"), NumberStyles.HexNumber);
|
||||
|
||||
var penalties = await PenaltySvc
|
||||
.GetActivePenaltiesByIdentifier(null, guid, receiveEvent.Client.GameName);
|
||||
var banPenalty =
|
||||
penalties.FirstOrDefault(penalty => penalty.Type == EFPenalty.PenaltyType.Ban);
|
||||
|
||||
if (banPenalty is not null && receiveEvent.Client.Level != Data.Models.Client.EFClient.Permission.Banned)
|
||||
{
|
||||
_logger.LogInformation(
|
||||
"Banning {Client} as they have have provided a persistent clientId of {PersistentClientId}, which is banned",
|
||||
receiveEvent.Client, guid);
|
||||
receiveEvent.Client.Ban(_translationLookup["SERVER_BAN_EVADE"].FormatExt(guid),
|
||||
receiveEvent.Client.CurrentServer.AsConsoleClient(), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -7,6 +7,6 @@ foreach($localization in $localizations)
|
||||
{
|
||||
$url = "http://api.raidmax.org:5000/localization/{0}" -f $localization
|
||||
$filePath = "{0}Localization\IW4MAdmin.{1}.json" -f $OutputDir, $localization
|
||||
$response = Invoke-WebRequest $url
|
||||
$response = Invoke-WebRequest $url -UseBasicParsing
|
||||
Out-File -FilePath $filePath -InputObject $response.Content -Encoding utf8
|
||||
}
|
||||
}
|
||||
|
@ -47,6 +47,10 @@ echo making start scripts
|
||||
@(echo @echo off && echo @title IW4MAdmin && echo set DOTNET_CLI_TELEMETRY_OPTOUT=1 && echo dotnet Lib\IW4MAdmin.dll && echo pause) > "%PublishDir%\StartIW4MAdmin.cmd"
|
||||
@(echo #!/bin/bash&& echo export DOTNET_CLI_TELEMETRY_OPTOUT=1&& echo dotnet Lib/IW4MAdmin.dll) > "%PublishDir%\StartIW4MAdmin.sh"
|
||||
|
||||
echo copying update scripts
|
||||
copy "%SourceDir%\DeploymentFiles\UpdateIW4MAdmin.ps1" "%PublishDir%\UpdateIW4MAdmin.ps1"
|
||||
copy "%SourceDir%\DeploymentFiles\UpdateIW4MAdmin.sh" "%PublishDir%\UpdateIW4MAdmin.sh"
|
||||
|
||||
echo moving front-end library dependencies
|
||||
if not exist "%PublishDir%\wwwroot\font" mkdir "%PublishDir%\wwwroot\font"
|
||||
move "WebfrontCore\wwwroot\lib\open-iconic\font\fonts\*.*" "%PublishDir%\wwwroot\font\"
|
||||
|
52
Application/Commands/AddClientNoteCommand.cs
Normal file
52
Application/Commands/AddClientNoteCommand.cs
Normal file
@ -0,0 +1,52 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using IW4MAdmin.Application.Meta;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands;
|
||||
|
||||
public class AddClientNoteCommand : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public AddClientNoteCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(config, layout)
|
||||
{
|
||||
Name = "addnote";
|
||||
Description = _translationLookup["COMMANDS_ADD_CLIENT_NOTE_DESCRIPTION"];
|
||||
Alias = "an";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
|
||||
Required = true
|
||||
},
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_NOTE"],
|
||||
Required = false
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var note = new ClientNoteMetaResponse
|
||||
{
|
||||
Note = gameEvent.Data?.Trim(),
|
||||
OriginEntityId = gameEvent.Origin.ClientId,
|
||||
ModifiedDate = DateTime.UtcNow
|
||||
};
|
||||
await _metaService.SetPersistentMetaValue("ClientNotes", note, gameEvent.Target.ClientId);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_ADD_CLIENT_NOTE_SUCCESS"]);
|
||||
}
|
||||
}
|
64
Application/Commands/ClientTags/AddClientTagCommand.cs
Normal file
64
Application/Commands/ClientTags/AddClientTagCommand.cs
Normal file
@ -0,0 +1,64 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class AddClientTagCommand : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public AddClientTagCommand(ILogger<AddClientTagCommand> commandLogger, CommandConfiguration config,
|
||||
ITranslationLookup layout, IMetaServiceV2 metaService) :
|
||||
base(config, layout)
|
||||
{
|
||||
Name = "addclienttag";
|
||||
Description = layout["COMMANDS_ADD_CLIENT_TAG_DESC"];
|
||||
Alias = "act";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGUMENT_TAG"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
logger = commandLogger;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var existingTags = await _metaService.GetPersistentMetaValue<List<TagMeta>>(EFMeta.ClientTagNameV2) ??
|
||||
new List<TagMeta>();
|
||||
|
||||
var tagName = gameEvent.Data.Trim();
|
||||
|
||||
if (existingTags.Any(tag => tag.TagName == tagName))
|
||||
{
|
||||
logger.LogWarning("Tag with name {TagName} already exists", tagName);
|
||||
return;
|
||||
}
|
||||
|
||||
existingTags.Add(new TagMeta
|
||||
{
|
||||
Id = (existingTags.LastOrDefault()?.TagId ?? 0) + 1,
|
||||
Value = tagName
|
||||
});
|
||||
|
||||
await _metaService.SetPersistentMetaValue(EFMeta.ClientTagNameV2, existingTags,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_ADD_CLIENT_TAG_SUCCESS"].FormatExt(gameEvent.Data));
|
||||
}
|
||||
}
|
||||
}
|
@ -1,17 +1,19 @@
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace SharedLibraryCore.Commands
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class ListClientTags : Command
|
||||
{
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public ListClientTags(CommandConfiguration config, ITranslationLookup layout, IMetaService metaService) : base(
|
||||
public ListClientTags(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(
|
||||
config, layout)
|
||||
{
|
||||
Name = "listclienttags";
|
||||
@ -19,14 +21,18 @@ namespace SharedLibraryCore.Commands
|
||||
Alias = "lct";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = false;
|
||||
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var tags = await _metaService.GetPersistentMeta(EFMeta.ClientTagName);
|
||||
gameEvent.Origin.Tell(tags.Select(tag => tag.Value));
|
||||
var tags = await _metaService.GetPersistentMetaValue<List<TagMeta>>(EFMeta.ClientTagNameV2);
|
||||
|
||||
if (tags is not null)
|
||||
{
|
||||
await gameEvent.Origin.TellAsync(tags.Select(tag => tag.TagName),
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,16 +1,20 @@
|
||||
using System.Threading.Tasks;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Linq;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace SharedLibraryCore.Commands
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class RemoveClientTag : Command
|
||||
{
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public RemoveClientTag(CommandConfiguration config, ITranslationLookup layout, IMetaService metaService) : base(
|
||||
public RemoveClientTag(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(
|
||||
config, layout)
|
||||
{
|
||||
Name = "removeclienttag";
|
||||
@ -32,8 +36,13 @@ namespace SharedLibraryCore.Commands
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
await _metaService.RemovePersistentMeta(EFMeta.ClientTagName, gameEvent.Data);
|
||||
var existingMeta = await _metaService.GetPersistentMetaValue<List<TagMeta>>(EFMeta.ClientTagNameV2,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
existingMeta = existingMeta.Where(meta => meta.TagName != gameEvent.Data.Trim()).ToList();
|
||||
await _metaService.SetPersistentMetaValue(EFMeta.ClientTagNameV2, existingMeta,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_REMOVE_CLIENT_TAG_SUCCESS"].FormatExt(gameEvent.Data));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,18 +1,22 @@
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace SharedLibraryCore.Commands
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class SetClientTagCommand : Command
|
||||
{
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
|
||||
public SetClientTagCommand(CommandConfiguration config, ITranslationLookup layout, IMetaService metaService) :
|
||||
public SetClientTagCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) :
|
||||
base(config, layout)
|
||||
{
|
||||
Name = "setclienttag";
|
||||
@ -34,8 +38,10 @@ namespace SharedLibraryCore.Commands
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var availableTags = await _metaService.GetPersistentMeta(EFMeta.ClientTagName);
|
||||
var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == gameEvent.Data);
|
||||
var token = gameEvent.Owner.Manager.CancellationToken;
|
||||
|
||||
var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
|
||||
var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == gameEvent.Data.Trim());
|
||||
|
||||
if (matchingTag == null)
|
||||
{
|
||||
@ -44,8 +50,9 @@ namespace SharedLibraryCore.Commands
|
||||
}
|
||||
|
||||
gameEvent.Target.Tag = matchingTag.Value;
|
||||
await _metaService.AddPersistentMeta(EFMeta.ClientTag, string.Empty, gameEvent.Target, matchingTag);
|
||||
await _metaService.SetPersistentMetaForLookupKey(EFMeta.ClientTagV2, EFMeta.ClientTagNameV2, matchingTag.Id,
|
||||
gameEvent.Target.ClientId, token);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_SET_CLIENT_TAG_SUCCESS"].FormatExt(matchingTag.Value));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
13
Application/Commands/ClientTags/TagMeta.cs
Normal file
13
Application/Commands/ClientTags/TagMeta.cs
Normal file
@ -0,0 +1,13 @@
|
||||
using System.Text.Json.Serialization;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags;
|
||||
|
||||
public class TagMeta : ILookupValue<string>
|
||||
{
|
||||
[JsonIgnore] public int TagId => Id;
|
||||
[JsonIgnore] public string TagName => Value;
|
||||
|
||||
public int Id { get; set; }
|
||||
public string Value { get; set; }
|
||||
}
|
@ -1,17 +1,18 @@
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace SharedLibraryCore.Commands
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class UnsetClientTagCommand : Command
|
||||
{
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
|
||||
public UnsetClientTagCommand(CommandConfiguration config, ITranslationLookup layout, IMetaService metaService) :
|
||||
public UnsetClientTagCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) :
|
||||
base(config, layout)
|
||||
{
|
||||
Name = "unsetclienttag";
|
||||
@ -34,8 +35,9 @@ namespace SharedLibraryCore.Commands
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
gameEvent.Target.Tag = null;
|
||||
await _metaService.RemovePersistentMeta(EFMeta.ClientTag, gameEvent.Target);
|
||||
await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, gameEvent.Target.ClientId,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_UNSET_CLIENT_TAG_SUCCESS"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,4 +1,5 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
@ -33,7 +34,7 @@ namespace IW4MAdmin.Application.Commands
|
||||
};
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var searchTerm = gameEvent.Data.Trim();
|
||||
var availableCommands = gameEvent.Owner.Manager.Commands.Distinct().Where(command =>
|
||||
@ -70,24 +71,25 @@ namespace IW4MAdmin.Application.Commands
|
||||
});
|
||||
|
||||
var helpResponse = new StringBuilder();
|
||||
var messageList = new List<string>();
|
||||
|
||||
foreach (var item in commandStrings)
|
||||
{
|
||||
helpResponse.Append(item.response);
|
||||
|
||||
if (item.index == 0 || item.index % 4 != 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
gameEvent.Origin.Tell(helpResponse.ToString());
|
||||
messageList.Add(helpResponse.ToString());
|
||||
helpResponse = new StringBuilder();
|
||||
}
|
||||
|
||||
gameEvent.Origin.Tell(helpResponse.ToString());
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_HELP_MOREINFO"]);
|
||||
}
|
||||
messageList.Add(helpResponse.ToString());
|
||||
|
||||
return Task.CompletedTask;
|
||||
await gameEvent.Origin.TellAsync(messageList);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -29,9 +29,9 @@ namespace IW4MAdmin.Application.Commands
|
||||
$"[(Color::Accent){client.ClientPermission.Name}(Color::White){(string.IsNullOrEmpty(client.Tag) ? "" : $" {client.Tag}")}(Color::White)][(Color::Yellow)#{client.ClientNumber}(Color::White)] {client.Name}")
|
||||
.ToArray();
|
||||
|
||||
gameEvent.Origin.Tell(clientList);
|
||||
gameEvent.Origin.TellAsync(clientList, gameEvent.Owner.Manager.CancellationToken);
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -54,20 +54,8 @@ namespace IW4MAdmin.Application.Commands
|
||||
return;
|
||||
}
|
||||
|
||||
string map;
|
||||
string gametype;
|
||||
|
||||
if (match.Groups.Count > 3)
|
||||
{
|
||||
map = match.Groups[2].ToString();
|
||||
gametype = match.Groups[4].ToString();
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
map = match.Groups[1].ToString();
|
||||
gametype = match.Groups[3].ToString();
|
||||
}
|
||||
var map = match.Groups[1].Length > 0 ? match.Groups[1].ToString() : match.Groups[2].ToString();
|
||||
var gametype = match.Groups[3].Length > 0 ? match.Groups[3].ToString() : match.Groups[4].ToString();
|
||||
|
||||
var matchingMaps = gameEvent.Owner.FindMap(map);
|
||||
var matchingGametypes = _defaultSettings.FindGametype(gametype, gameEvent.Owner.GameName);
|
||||
@ -104,7 +92,7 @@ namespace IW4MAdmin.Application.Commands
|
||||
|
||||
_logger.LogDebug("Changing map to {Map} and gametype {Gametype}", map, gametype);
|
||||
|
||||
await gameEvent.Owner.SetDvarAsync("g_gametype", gametype);
|
||||
await gameEvent.Owner.SetDvarAsync("g_gametype", gametype, gameEvent.Owner.Manager.CancellationToken);
|
||||
gameEvent.Owner.Broadcast(_translationLookup["COMMANDS_MAP_SUCCESS"].FormatExt(map));
|
||||
await Task.Delay(gameEvent.Owner.Manager.GetApplicationSettings().Configuration().MapChangeDelaySeconds);
|
||||
|
||||
|
@ -1,11 +1,14 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models.Client;
|
||||
using Data.Models.Misc;
|
||||
using IW4MAdmin.Application.Alerts;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Alerts;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
@ -16,19 +19,66 @@ namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IAlertManager _alertManager;
|
||||
private const short MaxLength = 1024;
|
||||
|
||||
|
||||
public OfflineMessageCommand(CommandConfiguration config, ITranslationLookup layout,
|
||||
IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger) : base(config, layout)
|
||||
IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger, IAlertManager alertManager)
|
||||
: base(config, layout)
|
||||
{
|
||||
Name = "offlinemessage";
|
||||
Description = _translationLookup["COMMANDS_OFFLINE_MESSAGE_DESC"];
|
||||
Alias = "om";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = true;
|
||||
|
||||
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
_alertManager = alertManager;
|
||||
|
||||
_alertManager.RegisterStaticAlertSource(async () =>
|
||||
{
|
||||
var context = contextFactory.CreateContext(false);
|
||||
return await context.InboxMessages.Where(message => !message.IsDelivered)
|
||||
.Where(message => message.CreatedDateTime >= DateTime.UtcNow.AddDays(-7))
|
||||
.Where(message => message.DestinationClient.Level > EFClient.Permission.User)
|
||||
.Select(message => new Alert.AlertState
|
||||
{
|
||||
OccuredAt = message.CreatedDateTime,
|
||||
Message = message.Message,
|
||||
ExpiresAt = DateTime.UtcNow.AddDays(7),
|
||||
Category = Alert.AlertCategory.Message,
|
||||
Source = message.SourceClient.CurrentAlias.Name.StripColors(),
|
||||
SourceId = message.SourceClientId,
|
||||
RecipientId = message.DestinationClientId,
|
||||
ReferenceId = message.InboxMessageId,
|
||||
Type = nameof(EFInboxMessage)
|
||||
}).ToListAsync();
|
||||
});
|
||||
|
||||
_alertManager.OnAlertConsumed += (_, state) =>
|
||||
{
|
||||
if (state.Category != Alert.AlertCategory.Message || state.ReferenceId is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var context = contextFactory.CreateContext(true);
|
||||
foreach (var message in context.InboxMessages
|
||||
.Where(message => message.InboxMessageId == state.ReferenceId.Value).ToList())
|
||||
{
|
||||
message.IsDelivered = true;
|
||||
}
|
||||
|
||||
context.SaveChanges();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not update message state for alert {@Alert}", state);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
@ -38,23 +88,24 @@ namespace IW4MAdmin.Application.Commands
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_TOO_LONG"].FormatExt(MaxLength));
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (gameEvent.Target.ClientId == gameEvent.Origin.ClientId)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_SELF"].FormatExt(MaxLength));
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (gameEvent.Target.IsIngame)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_INGAME"].FormatExt(gameEvent.Target.Name));
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_INGAME"]
|
||||
.FormatExt(gameEvent.Target.Name));
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
var server = await context.Servers.FirstAsync(srv => srv.EndPoint == gameEvent.Owner.ToString());
|
||||
|
||||
var newMessage = new EFInboxMessage()
|
||||
var newMessage = new EFInboxMessage
|
||||
{
|
||||
SourceClientId = gameEvent.Origin.ClientId,
|
||||
DestinationClientId = gameEvent.Target.ClientId,
|
||||
@ -62,6 +113,12 @@ namespace IW4MAdmin.Application.Commands
|
||||
Message = gameEvent.Data,
|
||||
};
|
||||
|
||||
_alertManager.AddAlert(gameEvent.Target.BuildAlert(Alert.AlertCategory.Message)
|
||||
.WithMessage(gameEvent.Data.Trim())
|
||||
.FromClient(gameEvent.Origin)
|
||||
.OfType(nameof(EFInboxMessage))
|
||||
.ExpiresIn(TimeSpan.FromDays(7)));
|
||||
|
||||
try
|
||||
{
|
||||
context.Set<EFInboxMessage>().Add(newMessage);
|
||||
@ -75,4 +132,4 @@ namespace IW4MAdmin.Application.Commands
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -24,7 +24,7 @@ namespace IW4MAdmin.Application.Commands
|
||||
Name = "readmessage";
|
||||
Description = _translationLookup["COMMANDS_READ_MESSAGE_DESC"];
|
||||
Alias = "rm";
|
||||
Permission = EFClient.Permission.Flagged;
|
||||
Permission = EFClient.Permission.User;
|
||||
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
@ -49,20 +49,13 @@ namespace IW4MAdmin.Application.Commands
|
||||
return;
|
||||
}
|
||||
|
||||
var index = 1;
|
||||
foreach (var inboxItem in inboxItems)
|
||||
await gameEvent.Origin.TellAsync(inboxItems.Select((inboxItem, index) =>
|
||||
{
|
||||
await gameEvent.Origin.Tell(_translationLookup["COMMANDS_READ_MESSAGE_SUCCESS"]
|
||||
.FormatExt($"{index}/{inboxItems.Count}", inboxItem.SourceClient.CurrentAlias.Name))
|
||||
.WaitAsync();
|
||||
var header = _translationLookup["COMMANDS_READ_MESSAGE_SUCCESS"]
|
||||
.FormatExt($"{index + 1}/{inboxItems.Count}", inboxItem.SourceClient.CurrentAlias.Name);
|
||||
|
||||
foreach (var messageFragment in inboxItem.Message.FragmentMessageForDisplay())
|
||||
{
|
||||
await gameEvent.Origin.Tell(messageFragment).WaitAsync();
|
||||
}
|
||||
|
||||
index++;
|
||||
}
|
||||
return new[] { header }.Union(inboxItem.Message.FragmentMessageForDisplay());
|
||||
}).SelectMany(item => item));
|
||||
|
||||
inboxItems.ForEach(item => { item.IsDelivered = true; });
|
||||
|
||||
@ -76,4 +69,4 @@ namespace IW4MAdmin.Application.Commands
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
80
Application/Commands/SetLogLevelCommand.cs
Normal file
80
Application/Commands/SetLogLevelCommand.cs
Normal file
@ -0,0 +1,80 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using Serilog.Core;
|
||||
using Serilog.Events;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands;
|
||||
|
||||
public class SetLogLevelCommand : Command
|
||||
{
|
||||
private readonly Func<string, LoggingLevelSwitch> _levelSwitchResolver;
|
||||
|
||||
public SetLogLevelCommand(CommandConfiguration config, ITranslationLookup layout, Func<string, LoggingLevelSwitch> levelSwitchResolver) : base(config, layout)
|
||||
{
|
||||
_levelSwitchResolver = levelSwitchResolver;
|
||||
|
||||
Name = "loglevel";
|
||||
Alias = "ll";
|
||||
Description = "set minimum logging level";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
Arguments = new CommandArgument[]
|
||||
{
|
||||
new()
|
||||
{
|
||||
Name = "Log Level",
|
||||
Required = true
|
||||
},
|
||||
new()
|
||||
{
|
||||
Name = "Override",
|
||||
Required = false
|
||||
},
|
||||
new()
|
||||
{
|
||||
Name = "IsDevelopment",
|
||||
Required = false
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var args = gameEvent.Data.Split(" ");
|
||||
if (!Enum.TryParse<LogEventLevel>(args[0], out var minLevel))
|
||||
{
|
||||
await gameEvent.Origin.TellAsync(new[]
|
||||
{
|
||||
$"Valid log values: {string.Join(",", Enum.GetValues<LogEventLevel>())}"
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
var context = string.Empty;
|
||||
|
||||
if (args.Length > 1)
|
||||
{
|
||||
context = args[1];
|
||||
}
|
||||
|
||||
var loggingSwitch = _levelSwitchResolver(context);
|
||||
loggingSwitch.MinimumLevel = minLevel;
|
||||
|
||||
if (args.Length > 2 && (args[2] == "1" || args[2].ToLower() == "true"))
|
||||
{
|
||||
AppContext.SetSwitch("IsDevelop", true);
|
||||
}
|
||||
else
|
||||
{
|
||||
AppContext.SetSwitch("IsDevelop", false);
|
||||
}
|
||||
|
||||
await gameEvent.Origin.TellAsync(new[]
|
||||
{ $"Set minimum log level to {loggingSwitch.MinimumLevel.ToString()}" });
|
||||
}
|
||||
}
|
145
Application/CoreEventHandler.cs
Normal file
145
Application/CoreEventHandler.cs
Normal file
@ -0,0 +1,145 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Events;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Events.Management;
|
||||
using SharedLibraryCore.Events.Server;
|
||||
using SharedLibraryCore.Interfaces.Events;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
public class CoreEventHandler : ICoreEventHandler
|
||||
{
|
||||
private const int MaxCurrentEvents = 25;
|
||||
private readonly ILogger _logger;
|
||||
private readonly SemaphoreSlim _onProcessingEvents = new(MaxCurrentEvents, MaxCurrentEvents);
|
||||
private readonly ManualResetEventSlim _onEventReady = new(false);
|
||||
private readonly ConcurrentQueue<(IManager, CoreEvent)> _runningEventTasks = new();
|
||||
private CancellationToken _cancellationToken;
|
||||
private int _activeTasks;
|
||||
|
||||
private static readonly GameEvent.EventType[] OverrideEvents =
|
||||
{
|
||||
GameEvent.EventType.Connect,
|
||||
GameEvent.EventType.Disconnect,
|
||||
GameEvent.EventType.Quit,
|
||||
GameEvent.EventType.Stop
|
||||
};
|
||||
|
||||
public CoreEventHandler(ILogger<CoreEventHandler> logger)
|
||||
{
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public void QueueEvent(IManager manager, CoreEvent coreEvent)
|
||||
{
|
||||
_runningEventTasks.Enqueue((manager, coreEvent));
|
||||
_onEventReady.Set();
|
||||
}
|
||||
|
||||
public void StartProcessing(CancellationToken token)
|
||||
{
|
||||
_cancellationToken = token;
|
||||
|
||||
while (!_cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
_onEventReady.Reset();
|
||||
|
||||
try
|
||||
{
|
||||
_onProcessingEvents.Wait(_cancellationToken);
|
||||
|
||||
if (!_runningEventTasks.TryDequeue(out var coreEvent))
|
||||
{
|
||||
if (_onProcessingEvents.CurrentCount < MaxCurrentEvents)
|
||||
{
|
||||
_onProcessingEvents.Release(1);
|
||||
}
|
||||
|
||||
_onEventReady.Wait(_cancellationToken);
|
||||
continue;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Start processing event {Name} {SemaphoreCount} - {QueuedTasks}",
|
||||
coreEvent.Item2.GetType().Name, _onProcessingEvents.CurrentCount, _runningEventTasks.Count);
|
||||
|
||||
_ = Task.Factory.StartNew(() =>
|
||||
{
|
||||
Interlocked.Increment(ref _activeTasks);
|
||||
_logger.LogDebug("[Start] Active Tasks = {TaskCount}", _activeTasks);
|
||||
return HandleEventTaskExecute(coreEvent);
|
||||
});
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not enqueue event for processing");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleEventTaskExecute((IManager, CoreEvent) coreEvent)
|
||||
{
|
||||
try
|
||||
{
|
||||
await GetEventTask(coreEvent.Item1, coreEvent.Item2);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogWarning("Event timed out {Type}", coreEvent.Item2.GetType().Name);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not complete invoke for {EventType}",
|
||||
coreEvent.Item2.GetType().Name);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessingEvents.CurrentCount < MaxCurrentEvents)
|
||||
{
|
||||
_logger.LogDebug("Freeing up event semaphore for next event {SemaphoreCount}",
|
||||
_onProcessingEvents.CurrentCount);
|
||||
_onProcessingEvents.Release(1);
|
||||
}
|
||||
|
||||
Interlocked.Decrement(ref _activeTasks);
|
||||
_logger.LogDebug("[Complete] {Type}, Active Tasks = {TaskCount} - {Queue}", coreEvent.Item2.GetType(),
|
||||
_activeTasks, _runningEventTasks.Count);
|
||||
}
|
||||
}
|
||||
|
||||
private Task GetEventTask(IManager manager, CoreEvent coreEvent)
|
||||
{
|
||||
return coreEvent switch
|
||||
{
|
||||
GameEvent gameEvent => BuildLegacyEventTask(manager, coreEvent, gameEvent),
|
||||
GameServerEvent gameServerEvent => IGameServerEventSubscriptions.InvokeEventAsync(gameServerEvent,
|
||||
manager.CancellationToken),
|
||||
ManagementEvent managementEvent => IManagementEventSubscriptions.InvokeEventAsync(managementEvent,
|
||||
manager.CancellationToken),
|
||||
_ => Task.CompletedTask
|
||||
};
|
||||
}
|
||||
|
||||
private async Task BuildLegacyEventTask(IManager manager, CoreEvent coreEvent, GameEvent gameEvent)
|
||||
{
|
||||
if (manager.IsRunning || OverrideEvents.Contains(gameEvent.Type))
|
||||
{
|
||||
await manager.ExecuteEvent(gameEvent);
|
||||
await IGameEventSubscriptions.InvokeEventAsync(coreEvent, manager.CancellationToken);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Skipping event as we're shutting down {EventId}", gameEvent.IncrementalId);
|
||||
}
|
||||
}
|
||||
}
|
@ -69,6 +69,39 @@
|
||||
}
|
||||
],
|
||||
"Gametypes": [
|
||||
{
|
||||
"Game": "IW3",
|
||||
"Gametypes": [
|
||||
{
|
||||
"Name": "ctf",
|
||||
"Alias": "Capture The Flag"
|
||||
},
|
||||
{
|
||||
"Name": "dm",
|
||||
"Alias": "Free For All"
|
||||
},
|
||||
{
|
||||
"Name": "dom",
|
||||
"Alias": "Domination"
|
||||
},
|
||||
{
|
||||
"Name": "koth",
|
||||
"Alias": "Headquarters"
|
||||
},
|
||||
{
|
||||
"Name": "sab",
|
||||
"Alias": "Sabotage"
|
||||
},
|
||||
{
|
||||
"Name": "sd",
|
||||
"Alias": "Search & Destroy"
|
||||
},
|
||||
{
|
||||
"Name": "war",
|
||||
"Alias": "Team Deathmatch"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"Game": "IW4",
|
||||
"Gametypes": [
|
||||
@ -152,20 +185,24 @@
|
||||
{
|
||||
"Name": "twar",
|
||||
"Alias": "War"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Name": "cmp",
|
||||
"Alias": "Zombies"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"Game": "IW5",
|
||||
"Gametypes": [
|
||||
{
|
||||
"Name": "tdm",
|
||||
"Alias": "Team Deathmatch"
|
||||
},
|
||||
{
|
||||
"Name": "dom",
|
||||
"Alias": "Domination"
|
||||
},
|
||||
{
|
||||
"Name": "conf",
|
||||
"Alias": "Kill Confirmed"
|
||||
},
|
||||
{
|
||||
"Name": "ctf",
|
||||
"Alias": "Capture The Flag"
|
||||
@ -175,37 +212,29 @@
|
||||
"Alias": "Demolition"
|
||||
},
|
||||
{
|
||||
"Name": "dz",
|
||||
"Alias": "Drop Zone"
|
||||
},
|
||||
{
|
||||
"Name": "ffa",
|
||||
"Name": "dm",
|
||||
"Alias": "Free For All"
|
||||
},
|
||||
{
|
||||
"Name": "gg",
|
||||
"Alias": "Gun Game"
|
||||
"Name": "grnd",
|
||||
"Alias": "Drop Zone"
|
||||
},
|
||||
{
|
||||
"Name": "hq",
|
||||
"Alias": "Headquarters"
|
||||
"Name": "gun",
|
||||
"Alias": "Gun Game"
|
||||
},
|
||||
{
|
||||
"Name": "koth",
|
||||
"Alias": "Headquarters"
|
||||
},
|
||||
{
|
||||
"Name": "inf",
|
||||
"Name": "infect",
|
||||
"Alias": "Infected"
|
||||
},
|
||||
{
|
||||
"Name": "jug",
|
||||
"Name": "jugg",
|
||||
"Alias": "Juggernaut"
|
||||
},
|
||||
{
|
||||
"Name": "kc",
|
||||
"Alias": "Kill Confirmed"
|
||||
},
|
||||
{
|
||||
"Name": "oic",
|
||||
"Alias": "One In The Chamber"
|
||||
@ -223,8 +252,12 @@
|
||||
"Alias": "Team Defender"
|
||||
},
|
||||
{
|
||||
"Name": "tj",
|
||||
"Name": "tjugg",
|
||||
"Alias": "Team Juggernaut"
|
||||
},
|
||||
{
|
||||
"Name": "war",
|
||||
"Alias": "Team Deathmatch"
|
||||
}
|
||||
]
|
||||
},
|
||||
@ -278,6 +311,10 @@
|
||||
{
|
||||
"Name": "tdm",
|
||||
"Alias": "Team Deathmatch"
|
||||
},
|
||||
{
|
||||
"Name": "zom",
|
||||
"Alias": "Zombies"
|
||||
}
|
||||
]
|
||||
},
|
||||
@ -408,7 +445,15 @@
|
||||
{
|
||||
"Name": "tdm",
|
||||
"Alias": "Team Deathmatch"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Name": "zclassic",
|
||||
"Alias": "Zombies Classic"
|
||||
},
|
||||
{
|
||||
"Name": "zstandard",
|
||||
"Alias": "Zombies"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -509,7 +554,11 @@
|
||||
{
|
||||
"Name": "hc_tdm",
|
||||
"Alias": "Hardcore Team Deathmatch"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Name": "zclassic",
|
||||
"Alias": "Zombies Classic"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -564,7 +613,56 @@
|
||||
"Alias": "Momentum"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"Game": "H1",
|
||||
"Gametypes": [
|
||||
{
|
||||
"Name": "conf",
|
||||
"Alias": "Kill Confirmed"
|
||||
},
|
||||
{
|
||||
"Name": "ctf",
|
||||
"Alias": "Capture The Flag"
|
||||
},
|
||||
{
|
||||
"Name": "dd",
|
||||
"Alias": "Demolition"
|
||||
},
|
||||
{
|
||||
"Name": "dm",
|
||||
"Alias": "Free For All"
|
||||
},
|
||||
{
|
||||
"Name": "dom",
|
||||
"Alias": "Domination"
|
||||
},
|
||||
{
|
||||
"Name": "gun",
|
||||
"Alias": "Gun Game"
|
||||
},
|
||||
{
|
||||
"Name": "hp",
|
||||
"Alias": "Hardpoint"
|
||||
},
|
||||
{
|
||||
"Name": "koth",
|
||||
"Alias": "Headquarters"
|
||||
},
|
||||
{
|
||||
"Name": "sab",
|
||||
"Alias": "Sabotage"
|
||||
},
|
||||
{
|
||||
"Name": "sd",
|
||||
"Alias": "Search & Destroy"
|
||||
},
|
||||
{
|
||||
"Name": "war",
|
||||
"Alias": "Team Deathmatch"
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"Maps": [
|
||||
{
|
||||
@ -750,7 +848,23 @@
|
||||
{
|
||||
"Alias": "Upheaval",
|
||||
"Name": "mp_suburban"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Alias": "Nacht Der Untoten",
|
||||
"Name": "nazi_zombie_prototype"
|
||||
},
|
||||
{
|
||||
"Alias": "Verrückt",
|
||||
"Name": "nazi_zombie_asylum"
|
||||
},
|
||||
{
|
||||
"Alias": "Shi No Numa",
|
||||
"Name": "nazi_zombie_sumpf"
|
||||
},
|
||||
{
|
||||
"Alias": "Der Riese",
|
||||
"Name": "nazi_zombie_factory"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -935,7 +1049,83 @@
|
||||
{
|
||||
"Alias": "Village",
|
||||
"Name": "co_hunted"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Alias": "Broadcast",
|
||||
"Name": "mp_broadcast"
|
||||
},
|
||||
{
|
||||
"Alias": "Showdown",
|
||||
"Name": "mp_showdown"
|
||||
},
|
||||
{
|
||||
"Alias": "Ambush",
|
||||
"Name": "mp_convoy"
|
||||
},
|
||||
{
|
||||
"Alias": "District",
|
||||
"Name": "mp_citystreets"
|
||||
},
|
||||
{
|
||||
"Alias": "Backlot",
|
||||
"Name": "mp_backlot"
|
||||
},
|
||||
{
|
||||
"Alias": "Pipeline",
|
||||
"Name": "mp_pipeline"
|
||||
},
|
||||
{
|
||||
"Alias": "Chinatown",
|
||||
"Name": "mp_carentan"
|
||||
},
|
||||
{
|
||||
"Alias": "Winter Crash",
|
||||
"Name": "mp_crash_snow"
|
||||
},
|
||||
{
|
||||
"Alias": "Countdown",
|
||||
"Name": "mp_countdown"
|
||||
},
|
||||
{
|
||||
"Alias": "Downpour",
|
||||
"Name": "mp_farm"
|
||||
},
|
||||
{
|
||||
"Alias": "Dome",
|
||||
"Name": "mp_dome"
|
||||
},
|
||||
{
|
||||
"Alias": "Hardhat",
|
||||
"Name": "mp_hardhat"
|
||||
},
|
||||
{
|
||||
"Alias": "Resistance",
|
||||
"Name": "mp_paris"
|
||||
},
|
||||
{
|
||||
"Alias": "Seatown",
|
||||
"Name": "mp_seatown"
|
||||
},
|
||||
{
|
||||
"Alias": "Mission",
|
||||
"Name": "mp_bravo"
|
||||
},
|
||||
{
|
||||
"Alias": "Underground",
|
||||
"Name": "mp_underground"
|
||||
},
|
||||
{
|
||||
"Alias": "Arkaden",
|
||||
"Name": "mp_plaza2"
|
||||
},
|
||||
{
|
||||
"Alias": "Village",
|
||||
"Name": "mp_village"
|
||||
},
|
||||
{
|
||||
"Alias": "Lockdown",
|
||||
"Name": "mp_alpha"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -1044,7 +1234,47 @@
|
||||
{
|
||||
"Alias": "Zoo",
|
||||
"Name": "mp_zoo"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Alias": "Kino der Toten",
|
||||
"Name": "zombie_theater"
|
||||
},
|
||||
{
|
||||
"Alias": "Five",
|
||||
"Name": "zombie_pentagon"
|
||||
},
|
||||
{
|
||||
"Alias": "Ascension",
|
||||
"Name": "zombie_cosmodrome"
|
||||
},
|
||||
{
|
||||
"Alias": "Call of the Dead",
|
||||
"Name": "zombie_coast"
|
||||
},
|
||||
{
|
||||
"Alias": "Shangri-La",
|
||||
"Name": "zombie_temple"
|
||||
},
|
||||
{
|
||||
"Alias": "Moon",
|
||||
"Name": "zombie_moon"
|
||||
},
|
||||
{
|
||||
"Alias": "Nacht Der Untoten",
|
||||
"Name": "zombie_cod5_prototype"
|
||||
},
|
||||
{
|
||||
"Alias": "Verrückt",
|
||||
"Name": "zombie_cod5_asylum"
|
||||
},
|
||||
{
|
||||
"Alias": "Shi No Numa",
|
||||
"Name": "zombie_cod5_sumpf"
|
||||
},
|
||||
{
|
||||
"Alias": "Der Riese",
|
||||
"Name": "zombie_cod5_factory"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
@ -1491,6 +1721,70 @@
|
||||
{
|
||||
"Alias": "Outlaw",
|
||||
"Name": "mp_western"
|
||||
},
|
||||
{
|
||||
"Alias": "Fringe Night",
|
||||
"Name": "mp_veiled_heyday"
|
||||
},
|
||||
{
|
||||
"Alias": "Redwood Snow",
|
||||
"Name": "mp_redwood_ice"
|
||||
},
|
||||
{
|
||||
"Alias": "Shadows of Evil",
|
||||
"Name": "zm_zod"
|
||||
},
|
||||
{
|
||||
"Alias": "Der Eisendrache",
|
||||
"Name": "zm_castle"
|
||||
},
|
||||
{
|
||||
"Alias": "Zetsubou No Shima",
|
||||
"Name": "zm_island"
|
||||
},
|
||||
{
|
||||
"Alias": "Gorod Krovi",
|
||||
"Name": "zm_stalingrad"
|
||||
},
|
||||
{
|
||||
"Alias": "Revelations",
|
||||
"Name": "zm_genesis"
|
||||
},
|
||||
{
|
||||
"Alias": "Ascension",
|
||||
"Name": "zm_cosmodrome"
|
||||
},
|
||||
{
|
||||
"Alias": "Kino der Toten",
|
||||
"Name": "zm_theater"
|
||||
},
|
||||
{
|
||||
"Alias": "Moon",
|
||||
"Name": "zm_moon"
|
||||
},
|
||||
{
|
||||
"Alias": "Nacht der Untoten",
|
||||
"Name": "zm_prototype"
|
||||
},
|
||||
{
|
||||
"Alias": "Origins",
|
||||
"Name": "zm_tomb"
|
||||
},
|
||||
{
|
||||
"Alias": "Shangri-La",
|
||||
"Name": "zm_temple"
|
||||
},
|
||||
{
|
||||
"Alias": "Shi No Numa",
|
||||
"Name": "zm_sumpf"
|
||||
},
|
||||
{
|
||||
"Alias": "The Giant",
|
||||
"Name": "zm_factory"
|
||||
},
|
||||
{
|
||||
"Alias": "Verrückt",
|
||||
"Name": "zm_asylum"
|
||||
}
|
||||
]
|
||||
},
|
||||
@ -1768,6 +2062,103 @@
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"Game": "H1",
|
||||
"Maps": [
|
||||
{
|
||||
"Alias": "Ambush",
|
||||
"Name": "mp_convoy"
|
||||
},
|
||||
{
|
||||
"Alias": "Backlot",
|
||||
"Name": "mp_backlot"
|
||||
},
|
||||
{
|
||||
"Alias": "Bloc",
|
||||
"Name": "mp_bloc"
|
||||
},
|
||||
{
|
||||
"Alias": "Bog",
|
||||
"Name": "mp_bog"
|
||||
},
|
||||
{
|
||||
"Alias": "Countdown",
|
||||
"Name": "mp_countdown"
|
||||
},
|
||||
{
|
||||
"Alias": "Crash",
|
||||
"Name": "mp_crash"
|
||||
},
|
||||
{
|
||||
"Alias": "Crossfire",
|
||||
"Name": "mp_crossfire"
|
||||
},
|
||||
{
|
||||
"Alias": "District",
|
||||
"Name": "mp_citystreets"
|
||||
},
|
||||
{
|
||||
"Alias": "Downpour",
|
||||
"Name": "mp_farm"
|
||||
},
|
||||
{
|
||||
"Alias": "Overgrown",
|
||||
"Name": "mp_overgrown"
|
||||
},
|
||||
{
|
||||
"Alias": "Pipeline",
|
||||
"Name": "mp_pipeline"
|
||||
},
|
||||
{
|
||||
"Alias": "Shipment",
|
||||
"Name": "mp_shipment"
|
||||
},
|
||||
{
|
||||
"Alias": "Showdown",
|
||||
"Name": "mp_showdown"
|
||||
},
|
||||
{
|
||||
"Alias": "Strike",
|
||||
"Name": "mp_strike"
|
||||
},
|
||||
{
|
||||
"Alias": "Vacant",
|
||||
"Name": "mp_vacant"
|
||||
},
|
||||
{
|
||||
"Alias": "Wet Work",
|
||||
"Name": "mp_cargoship"
|
||||
},
|
||||
{
|
||||
"Alias": "Winter Crash",
|
||||
"Name": "mp_crash_snow"
|
||||
},
|
||||
{
|
||||
"Alias": "Broadcast",
|
||||
"Name": "mp_broadcast"
|
||||
},
|
||||
{
|
||||
"Alias": "Creek",
|
||||
"Name": "mp_creek"
|
||||
},
|
||||
{
|
||||
"Alias": "Chinatown",
|
||||
"Name": "mp_carentan"
|
||||
},
|
||||
{
|
||||
"Alias": "Killhouse",
|
||||
"Name": "mp_killhouse"
|
||||
},
|
||||
{
|
||||
"Alias": "Day Break",
|
||||
"Name": "mp_farm_spring"
|
||||
},
|
||||
{
|
||||
"Alias": "Beach Bog",
|
||||
"Name": "mp_bog_summer"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"Game": "CSGO",
|
||||
"Maps": [
|
||||
@ -2021,7 +2412,7 @@
|
||||
"barrett": "Barrett .50cal",
|
||||
"mp44": "MP44",
|
||||
"remington700": "R700",
|
||||
"rpd": "RDP",
|
||||
"rpd": "RPD",
|
||||
"saw": " M249 SAW",
|
||||
"usp": "USP .45",
|
||||
"winchester1200": "W1200",
|
||||
@ -2083,6 +2474,126 @@
|
||||
"type99rifle": "Arisaka",
|
||||
"mosinrifle": "Mosin-Nagant",
|
||||
"ptrs41": "PTRS-41"
|
||||
},
|
||||
|
||||
"T6" : {
|
||||
|
||||
"mp7": "MP7",
|
||||
"pdw57": "PDW-57",
|
||||
"vector": "Vector K10",
|
||||
"insas": "MSMC",
|
||||
"qcw05": "Chicom CQB",
|
||||
"evoskorpion": "Skorpion EVO",
|
||||
"peacekeeper": "Peacekeeper",
|
||||
|
||||
"tar21": "MTAR",
|
||||
"type95": "Type 25",
|
||||
"sig556": "SWAT-556",
|
||||
"sa58": "FAL-OSW",
|
||||
"hk416": "M27",
|
||||
"scar": "SCAR-H",
|
||||
"saritch": "SMR",
|
||||
"xm8": "M8A1",
|
||||
"an94": "AN-94",
|
||||
|
||||
"870mcs": "Remington-870 MCS",
|
||||
"saiga12": "S12",
|
||||
"ksg": "KSG",
|
||||
"srm1216": "M1216",
|
||||
|
||||
"mk48": "MK 48",
|
||||
"qbb95": "QBB LSW",
|
||||
"lsat": "LSAT",
|
||||
"hamr": "HAMR",
|
||||
|
||||
"svu": "SVU-AS",
|
||||
"dsr50": "DSR 50",
|
||||
"ballista": "Ballista",
|
||||
"as50": "XPR-50",
|
||||
|
||||
"fiveseven": "Five-Seven",
|
||||
"fnp45": "TAC-45",
|
||||
"beretta93r": "B23R",
|
||||
"judge": "Executioner",
|
||||
"kard": "KAP-40",
|
||||
|
||||
"smaw": "SMAW",
|
||||
"fhj18": "FHJ-18 AA",
|
||||
"usrpg": "RPG",
|
||||
|
||||
"riotshield": "Assault Shield",
|
||||
"crossbow": "Crossbow",
|
||||
"knife_ballistic": "Ballistic Knife",
|
||||
"knife_held": "Knife",
|
||||
"knife": "Knife",
|
||||
|
||||
"frag_grenade": "Grenade",
|
||||
"hatchet": "Combat Axe",
|
||||
"sticky_grenade": "Semtex",
|
||||
"satchel_charge": "C4",
|
||||
"bouncingbetty": "Bouncing Betty",
|
||||
"claymore": "Claymore",
|
||||
|
||||
"smoke_center": "Smoke Grenade",
|
||||
"concussion_grenade": "Concussion",
|
||||
"emp_grenade": "EMP Grenade",
|
||||
"sensor_grenade": "Sensor Grenade",
|
||||
"flash_grenade": "Flashbang",
|
||||
"proximity_grenade": "Shock Charge",
|
||||
"pda_hack": "Black Hat",
|
||||
"trophy_system": "Trophy System",
|
||||
"tactical_insertion": "Tactical Insertion",
|
||||
|
||||
"acog": "ACOG",
|
||||
"stalker": "Stock",
|
||||
"swayreduc": "Ballistics CPU",
|
||||
"ir": "Dual Band",
|
||||
"dw": "Dual Wield",
|
||||
"extclip": "Extended Clip",
|
||||
"halo": "EOTech",
|
||||
"dualclip": "Fast Mag",
|
||||
"fmj": "FMJ",
|
||||
"grip": "Fore Grip",
|
||||
"gl": "Grenade Launcher",
|
||||
"dualoptic": "Hybrid Optic",
|
||||
"is": "Iron Sights",
|
||||
"steadyaim": "Laser Sight",
|
||||
"extbarrel": "Long Barrel",
|
||||
"mms": "MMS",
|
||||
"fastads": "Quickdraw",
|
||||
"rf": "Rapid Fire",
|
||||
"reflex": "Reflex Sight",
|
||||
"sf": "Select Fire",
|
||||
"silencer": "Suppressor",
|
||||
"tacknife": "Tactical Knife",
|
||||
"stackfire": "Tri-Bolt",
|
||||
"rangefinder": "Target Finder",
|
||||
"vzoom": "Variable Zoom",
|
||||
|
||||
"spyplane": "UAV",
|
||||
"rcbomb": "RC-XD",
|
||||
"missile_drone": "Hunter Killer",
|
||||
"supplydrop": "Care Package",
|
||||
"counteruav": "Counter-UAV",
|
||||
"microwave_turret": "Guardian",
|
||||
"remote_missile": "Hellstorm Missile",
|
||||
"planemortar": "Lightning Strike",
|
||||
"auto_turret": "Sentry Gun",
|
||||
"minigun": "Death Machine",
|
||||
"m32": "War Machine",
|
||||
"qrdrone": "Dragonfire",
|
||||
"ai_tank_drop": "AGR",
|
||||
"comlink": "Stealth Chopper",
|
||||
"spyplane_direction": "Orbital VSAT",
|
||||
"helicopter_guard": "Escort Drone",
|
||||
"emp": "EMP",
|
||||
"straferun": "Warthog",
|
||||
"remote_mortar": "Lodestar",
|
||||
"player_gunner": "VTOL Warship",
|
||||
"dogs": "K9 Unit",
|
||||
"missile_swarm": "Swarm"
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
@ -7,6 +7,8 @@ using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Data.Models;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Events.Game;
|
||||
using static System.Int32;
|
||||
using static SharedLibraryCore.Server;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
@ -14,21 +16,26 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
{
|
||||
public class BaseEventParser : IEventParser
|
||||
{
|
||||
private readonly Dictionary<string, (string, Func<string, IEventParserConfiguration, GameEvent, GameEvent>)> _customEventRegistrations;
|
||||
private readonly Dictionary<string, (string, Func<string, IEventParserConfiguration, GameEvent, GameEvent>)>
|
||||
_customEventRegistrations;
|
||||
|
||||
private readonly ILogger _logger;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly Dictionary<ParserRegex, GameEvent.EventType> _regexMap;
|
||||
private readonly Dictionary<string, GameEvent.EventType> _eventTypeMap;
|
||||
|
||||
public BaseEventParser(IParserRegexFactory parserRegexFactory, ILogger logger, ApplicationConfiguration appConfig)
|
||||
public BaseEventParser(IParserRegexFactory parserRegexFactory, ILogger logger,
|
||||
ApplicationConfiguration appConfig)
|
||||
{
|
||||
_customEventRegistrations = new Dictionary<string, (string, Func<string, IEventParserConfiguration, GameEvent, GameEvent>)>();
|
||||
_customEventRegistrations =
|
||||
new Dictionary<string, (string, Func<string, IEventParserConfiguration, GameEvent, GameEvent>)>();
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
|
||||
Configuration = new DynamicEventParserConfiguration(parserRegexFactory)
|
||||
{
|
||||
GameDirectory = "main",
|
||||
LocalizeText = "\x15",
|
||||
};
|
||||
|
||||
Configuration.Say.Pattern = @"^(say|sayteam);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);([0-9]+);([^;]*);(.*)$";
|
||||
@ -50,7 +57,15 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
Configuration.Join.AddMapping(ParserRegex.GroupType.OriginClientNumber, 3);
|
||||
Configuration.Join.AddMapping(ParserRegex.GroupType.OriginName, 4);
|
||||
|
||||
Configuration.Damage.Pattern = @"^(D);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0)?;(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32})?;((?:[0-9]+|[a-z]+|_|\+)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.JoinTeam.Pattern = @"^(JT);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);([0-9]+);(\w+);(.+)$";
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginNetworkId, 2);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginClientNumber, 3);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginTeam, 4);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginName, 5);
|
||||
|
||||
Configuration.Damage.Pattern =
|
||||
@"^(D);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0)?;(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32})?;((?:[0-9]+|[a-z]+|_|\+)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.TargetNetworkId, 2);
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.TargetClientNumber, 3);
|
||||
@ -65,7 +80,8 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.MeansOfDeath, 12);
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.HitLocation, 13);
|
||||
|
||||
Configuration.Kill.Pattern = @"^(K);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0)?;(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32})?;((?:[0-9]+|[a-z]+|_|\+)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Kill.Pattern =
|
||||
@"^(K);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0)?;(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32})?;((?:[0-9]+|[a-z]+|_|\+)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.TargetNetworkId, 2);
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.TargetClientNumber, 3);
|
||||
@ -87,20 +103,24 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
|
||||
_regexMap = new Dictionary<ParserRegex, GameEvent.EventType>
|
||||
{
|
||||
{Configuration.Say, GameEvent.EventType.Say},
|
||||
{Configuration.Kill, GameEvent.EventType.Kill},
|
||||
{Configuration.MapChange, GameEvent.EventType.MapChange},
|
||||
{Configuration.MapEnd, GameEvent.EventType.MapEnd}
|
||||
{ Configuration.Say, GameEvent.EventType.Say },
|
||||
{ Configuration.Kill, GameEvent.EventType.Kill },
|
||||
{ Configuration.MapChange, GameEvent.EventType.MapChange },
|
||||
{ Configuration.MapEnd, GameEvent.EventType.MapEnd },
|
||||
{ Configuration.JoinTeam, GameEvent.EventType.JoinTeam }
|
||||
};
|
||||
|
||||
|
||||
_eventTypeMap = new Dictionary<string, GameEvent.EventType>
|
||||
{
|
||||
{"say", GameEvent.EventType.Say},
|
||||
{"sayteam", GameEvent.EventType.Say},
|
||||
{"K", GameEvent.EventType.Kill},
|
||||
{"D", GameEvent.EventType.Damage},
|
||||
{"J", GameEvent.EventType.PreConnect},
|
||||
{"Q", GameEvent.EventType.PreDisconnect},
|
||||
{ "say", GameEvent.EventType.Say },
|
||||
{ "sayteam", GameEvent.EventType.SayTeam },
|
||||
{ "chat", GameEvent.EventType.Say },
|
||||
{ "chatteam", GameEvent.EventType.SayTeam },
|
||||
{ "K", GameEvent.EventType.Kill },
|
||||
{ "D", GameEvent.EventType.Damage },
|
||||
{ "J", GameEvent.EventType.PreConnect },
|
||||
{ "JT", GameEvent.EventType.JoinTeam },
|
||||
{ "Q", GameEvent.EventType.PreDisconnect }
|
||||
};
|
||||
}
|
||||
|
||||
@ -114,28 +134,6 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
|
||||
public string Name { get; set; } = "Call of Duty";
|
||||
|
||||
private (GameEvent.EventType type, string eventKey) GetEventTypeFromLine(string logLine)
|
||||
{
|
||||
var lineSplit = logLine.Split(';');
|
||||
if (lineSplit.Length > 1)
|
||||
{
|
||||
var type = lineSplit[0];
|
||||
return _eventTypeMap.ContainsKey(type) ? (_eventTypeMap[type], type): (GameEvent.EventType.Unknown, lineSplit[0]);
|
||||
}
|
||||
|
||||
foreach (var (key, value) in _regexMap)
|
||||
{
|
||||
var result = key.PatternMatcher.Match(logLine);
|
||||
if (result.Success)
|
||||
{
|
||||
return (value, null);
|
||||
}
|
||||
}
|
||||
|
||||
return (GameEvent.EventType.Unknown, null);
|
||||
}
|
||||
|
||||
|
||||
public virtual GameEvent GenerateGameEvent(string logLine)
|
||||
{
|
||||
var timeMatch = Configuration.Time.PatternMatcher.Match(logLine);
|
||||
@ -143,7 +141,7 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
|
||||
if (timeMatch.Success)
|
||||
{
|
||||
if (timeMatch.Values[0].Contains(":"))
|
||||
if (timeMatch.Values[0].Contains(':'))
|
||||
{
|
||||
gameTime = timeMatch
|
||||
.Values
|
||||
@ -151,258 +149,54 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
// this converts the timestamp into seconds passed
|
||||
.Select((value, index) => long.Parse(value.ToString()) * (index == 0 ? 60 : 1))
|
||||
.Sum();
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
gameTime = long.Parse(timeMatch.Values[0]);
|
||||
}
|
||||
|
||||
|
||||
// we want to strip the time from the log line
|
||||
logLine = logLine.Substring(timeMatch.Values.First().Length).Trim();
|
||||
logLine = logLine[timeMatch.Values.First().Length..].Trim();
|
||||
}
|
||||
|
||||
var eventParseResult = GetEventTypeFromLine(logLine);
|
||||
var eventType = eventParseResult.type;
|
||||
var (eventType, eventKey) = GetEventTypeFromLine(logLine);
|
||||
|
||||
switch (eventType)
|
||||
{
|
||||
case GameEvent.EventType.Say or GameEvent.EventType.SayTeam:
|
||||
return ParseMessageEvent(logLine, gameTime, eventType) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.Kill:
|
||||
return ParseKillEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.Damage:
|
||||
return ParseDamageEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.PreConnect:
|
||||
return ParseClientEnterMatchEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.JoinTeam:
|
||||
return ParseJoinTeamEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.PreDisconnect:
|
||||
return ParseClientExitMatchEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.MapEnd:
|
||||
return ParseMatchEndEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.MapChange:
|
||||
return ParseMatchStartEvent(logLine, gameTime);
|
||||
}
|
||||
|
||||
_logger.LogDebug(logLine);
|
||||
|
||||
if (eventType == GameEvent.EventType.Say)
|
||||
if (logLine.StartsWith("GSE;"))
|
||||
{
|
||||
var matchResult = Configuration.Say.PatternMatcher.Match(logLine);
|
||||
|
||||
if (matchResult.Success)
|
||||
return new GameScriptEvent
|
||||
{
|
||||
var message = matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.Message]]
|
||||
.Replace("\x15", "")
|
||||
.Trim();
|
||||
|
||||
if (message.Length > 0)
|
||||
{
|
||||
var originIdString = matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginName]];
|
||||
|
||||
var originId = originIdString.IsBotGuid() ?
|
||||
originName.GenerateGuidFromString() :
|
||||
originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
var clientNumber = int.Parse(matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
if (message.StartsWith(_appConfig.CommandPrefix) || message.StartsWith(_appConfig.BroadcastCommandPrefix))
|
||||
{
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = message,
|
||||
Origin = new EFClient() { NetworkId = originId, ClientNumber = clientNumber },
|
||||
Message = message,
|
||||
Extra = logLine,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Say,
|
||||
Data = message,
|
||||
Origin = new EFClient() { NetworkId = originId, ClientNumber = clientNumber },
|
||||
Message = message,
|
||||
Extra = logLine,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType == GameEvent.EventType.Kill)
|
||||
{
|
||||
var match = Configuration.Kill.PatternMatcher.Match(logLine);
|
||||
|
||||
if (match.Success)
|
||||
{
|
||||
var originIdString = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var targetIdString = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetNetworkId]];
|
||||
var originName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginName]];
|
||||
var targetName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetName]];
|
||||
|
||||
var originId = originIdString.IsBotGuid() ?
|
||||
originName.GenerateGuidFromString() :
|
||||
originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
var targetId = targetIdString.IsBotGuid() ?
|
||||
targetName.GenerateGuidFromString() :
|
||||
targetIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
|
||||
var originClientNumber = int.Parse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
var targetClientNumber = int.Parse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetClientNumber]]);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Kill,
|
||||
Data = logLine,
|
||||
Origin = new EFClient() { NetworkId = originId, ClientNumber = originClientNumber },
|
||||
Target = new EFClient() { NetworkId = targetId, ClientNumber = targetClientNumber },
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin | GameEvent.EventRequiredEntity.Target,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType == GameEvent.EventType.Damage)
|
||||
{
|
||||
var match = Configuration.Damage.PatternMatcher.Match(logLine);
|
||||
|
||||
if (match.Success)
|
||||
{
|
||||
var originIdString = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var targetIdString = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetNetworkId]];
|
||||
var originName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginName]];
|
||||
var targetName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetName]];
|
||||
|
||||
var originId = originIdString.IsBotGuid() ?
|
||||
originName.GenerateGuidFromString() :
|
||||
originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
var targetId = targetIdString.IsBotGuid() ?
|
||||
targetName.GenerateGuidFromString() :
|
||||
targetIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
|
||||
var originClientNumber = int.Parse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
var targetClientNumber = int.Parse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetClientNumber]]);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Damage,
|
||||
Data = logLine,
|
||||
Origin = new EFClient() { NetworkId = originId, ClientNumber = originClientNumber },
|
||||
Target = new EFClient() { NetworkId = targetId, ClientNumber = targetClientNumber },
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin | GameEvent.EventRequiredEntity.Target,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType == GameEvent.EventType.PreConnect)
|
||||
{
|
||||
var match = Configuration.Join.PatternMatcher.Match(logLine);
|
||||
|
||||
if (match.Success)
|
||||
{
|
||||
var originIdString = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginName]];
|
||||
|
||||
var networkId = originIdString.IsBotGuid() ?
|
||||
originName.GenerateGuidFromString() :
|
||||
originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.PreConnect,
|
||||
Data = logLine,
|
||||
Origin = new EFClient()
|
||||
{
|
||||
CurrentAlias = new EFAlias()
|
||||
{
|
||||
Name = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginName]].TrimNewLine(),
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = Convert.ToInt32(match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]),
|
||||
State = EFClient.ClientState.Connecting,
|
||||
},
|
||||
Extra = originIdString,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
IsBlocking = true,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType == GameEvent.EventType.PreDisconnect)
|
||||
{
|
||||
var match = Configuration.Quit.PatternMatcher.Match(logLine);
|
||||
|
||||
if (match.Success)
|
||||
{
|
||||
var originIdString = match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginName]];
|
||||
|
||||
var networkId = originIdString.IsBotGuid() ?
|
||||
originName.GenerateGuidFromString() :
|
||||
originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.PreDisconnect,
|
||||
Data = logLine,
|
||||
Origin = new EFClient()
|
||||
{
|
||||
CurrentAlias = new EFAlias()
|
||||
{
|
||||
Name = match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginName]].TrimNewLine()
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = Convert.ToInt32(match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]),
|
||||
State = EFClient.ClientState.Disconnecting
|
||||
},
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
IsBlocking = true,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType == GameEvent.EventType.MapEnd)
|
||||
{
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.MapEnd,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
ScriptData = logLine,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
|
||||
if (eventType == GameEvent.EventType.MapChange)
|
||||
if (eventKey is null || !_customEventRegistrations.ContainsKey(eventKey))
|
||||
{
|
||||
var dump = logLine.Replace("InitGame: ", "");
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.MapChange,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
Extra = dump.DictionaryFromKeyValue(),
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
return GenerateDefaultEvent(logLine, gameTime);
|
||||
}
|
||||
|
||||
if (eventParseResult.eventKey == null || !_customEventRegistrations.ContainsKey(eventParseResult.eventKey))
|
||||
{
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Unknown,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
};
|
||||
}
|
||||
|
||||
var eventModifier = _customEventRegistrations[eventParseResult.eventKey];
|
||||
var eventModifier = _customEventRegistrations[eventKey];
|
||||
|
||||
try
|
||||
{
|
||||
@ -416,12 +210,17 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
});
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(e, "Could not handle custom event generation");
|
||||
_logger.LogError(ex, "Could not handle custom log event generation");
|
||||
}
|
||||
|
||||
return new GameEvent()
|
||||
return GenerateDefaultEvent(logLine, gameTime);
|
||||
}
|
||||
|
||||
private static GameEvent GenerateDefaultEvent(string logLine, long gameTime)
|
||||
{
|
||||
return new GameEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Unknown,
|
||||
Data = logLine,
|
||||
@ -433,8 +232,455 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
};
|
||||
}
|
||||
|
||||
private static GameEvent ParseMatchStartEvent(string logLine, long gameTime)
|
||||
{
|
||||
var dump = logLine.Replace("InitGame: ", "").DictionaryFromKeyValue();
|
||||
|
||||
return new MatchStartEvent
|
||||
{
|
||||
Type = GameEvent.EventType.MapChange,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
Extra = dump,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
SessionData = dump
|
||||
};
|
||||
}
|
||||
|
||||
private static GameEvent ParseMatchEndEvent(string logLine, long gameTime)
|
||||
{
|
||||
return new MatchEndEvent
|
||||
{
|
||||
Type = GameEvent.EventType.MapEnd,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
SessionData = logLine
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseClientExitMatchEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Quit.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString =
|
||||
match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var originClientNumber =
|
||||
Convert.ToInt32(
|
||||
match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
var networkId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new ClientExitMatchEvent
|
||||
{
|
||||
Type = GameEvent.EventType.PreDisconnect,
|
||||
Data = logLine,
|
||||
Origin = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = originName
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = originClientNumber,
|
||||
State = EFClient.ClientState.Disconnecting
|
||||
},
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
IsBlocking = true,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseJoinTeamEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.JoinTeam.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString =
|
||||
match.Values[Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var team = match.Values[Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginTeam]];
|
||||
var clientSlotNumber =
|
||||
Parse(match.Values[
|
||||
Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(team))
|
||||
{
|
||||
team = Configuration.TeamMapping[team].ToString();
|
||||
}
|
||||
|
||||
var networkId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new ClientJoinTeamEvent
|
||||
{
|
||||
Type = GameEvent.EventType.JoinTeam,
|
||||
Data = logLine,
|
||||
Origin = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = originName
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = clientSlotNumber,
|
||||
State = EFClient.ClientState.Connected,
|
||||
},
|
||||
Extra = team,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
TeamName = team,
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = clientSlotNumber
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseClientEnterMatchEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Join.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
.TrimNewLine();
|
||||
var originClientNumber =
|
||||
Convert.ToInt32(
|
||||
match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
var networkId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new ClientEnterMatchEvent
|
||||
{
|
||||
Type = GameEvent.EventType.PreConnect,
|
||||
Data = logLine,
|
||||
Origin = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = originName
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = originClientNumber,
|
||||
State = EFClient.ClientState.Connecting,
|
||||
},
|
||||
Extra = originIdString,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
IsBlocking = true,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber
|
||||
};
|
||||
}
|
||||
|
||||
#region DAMAGE
|
||||
|
||||
private GameEvent ParseDamageEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Damage.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var targetIdString = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetNetworkId]];
|
||||
|
||||
var originName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var targetName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetName]]
|
||||
?.TrimNewLine();
|
||||
|
||||
var originId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
var targetId = targetIdString.IsBotGuid()
|
||||
? targetName.GenerateGuidFromString()
|
||||
: targetIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
|
||||
var originClientNumber =
|
||||
Parse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
var targetClientNumber =
|
||||
Parse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetClientNumber]]);
|
||||
|
||||
var originTeamName =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginTeam]];
|
||||
var targetTeamName =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetTeam]];
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(originTeamName))
|
||||
{
|
||||
originTeamName = Configuration.TeamMapping[originTeamName].ToString();
|
||||
}
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(targetTeamName))
|
||||
{
|
||||
targetTeamName = Configuration.TeamMapping[targetTeamName].ToString();
|
||||
}
|
||||
|
||||
var weaponName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.Weapon]];
|
||||
TryParse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.Damage]],
|
||||
out var damage);
|
||||
var meansOfDeath =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.MeansOfDeath]];
|
||||
var hitLocation =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.HitLocation]];
|
||||
|
||||
return new ClientDamageEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Damage,
|
||||
Data = logLine,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = originClientNumber },
|
||||
Target = new EFClient { NetworkId = targetId, ClientNumber = targetClientNumber },
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin | GameEvent.EventRequiredEntity.Target,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber,
|
||||
AttackerTeamName = originTeamName,
|
||||
VictimClientName = targetName,
|
||||
VictimNetworkId = targetIdString,
|
||||
VictimClientSlotNumber = targetClientNumber,
|
||||
VictimTeamName = targetTeamName,
|
||||
WeaponName = weaponName,
|
||||
Damage = damage,
|
||||
MeansOfDeath = meansOfDeath,
|
||||
HitLocation = hitLocation
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseKillEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Kill.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var targetIdString = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetNetworkId]];
|
||||
|
||||
var originName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var targetName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetName]]
|
||||
?.TrimNewLine();
|
||||
|
||||
var originId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
var targetId = targetIdString.IsBotGuid()
|
||||
? targetName.GenerateGuidFromString()
|
||||
: targetIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
|
||||
var originClientNumber =
|
||||
Parse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
var targetClientNumber =
|
||||
Parse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetClientNumber]]);
|
||||
|
||||
var originTeamName =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginTeam]];
|
||||
var targetTeamName =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetTeam]];
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(originTeamName))
|
||||
{
|
||||
originTeamName = Configuration.TeamMapping[originTeamName].ToString();
|
||||
}
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(targetTeamName))
|
||||
{
|
||||
targetTeamName = Configuration.TeamMapping[targetTeamName].ToString();
|
||||
}
|
||||
|
||||
var weaponName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.Weapon]];
|
||||
TryParse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.Damage]],
|
||||
out var damage);
|
||||
var meansOfDeath =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.MeansOfDeath]];
|
||||
var hitLocation =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.HitLocation]];
|
||||
|
||||
return new ClientKillEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Kill,
|
||||
Data = logLine,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = originClientNumber },
|
||||
Target = new EFClient { NetworkId = targetId, ClientNumber = targetClientNumber },
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin | GameEvent.EventRequiredEntity.Target,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber,
|
||||
AttackerTeamName = originTeamName,
|
||||
VictimClientName = targetName,
|
||||
VictimNetworkId = targetIdString,
|
||||
VictimClientSlotNumber = targetClientNumber,
|
||||
VictimTeamName = targetTeamName,
|
||||
WeaponName = weaponName,
|
||||
Damage = damage,
|
||||
MeansOfDeath = meansOfDeath,
|
||||
HitLocation = hitLocation
|
||||
};
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region MESSAGE
|
||||
|
||||
private GameEvent ParseMessageEvent(string logLine, long gameTime, GameEvent.EventType eventType)
|
||||
{
|
||||
var matchResult = Configuration.Say.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!matchResult.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var message = new string(matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.Message]]
|
||||
.Where(c => !char.IsControl(c)).ToArray());
|
||||
|
||||
if (message.StartsWith("/"))
|
||||
{
|
||||
message = message[1..];
|
||||
}
|
||||
|
||||
if (String.IsNullOrEmpty(message))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString =
|
||||
matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var clientNumber =
|
||||
Parse(matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
var originId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
|
||||
if (message.StartsWith(_appConfig.CommandPrefix) || message.StartsWith(_appConfig.BroadcastCommandPrefix))
|
||||
{
|
||||
return new ClientCommandEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = message,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = clientNumber },
|
||||
Message = message,
|
||||
Extra = logLine,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
//V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = clientNumber,
|
||||
IsTeamMessage = eventType == GameEvent.EventType.SayTeam
|
||||
};
|
||||
}
|
||||
|
||||
return new ClientMessageEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Say,
|
||||
Data = message,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = clientNumber },
|
||||
Message = message,
|
||||
Extra = logLine,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
//V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = clientNumber,
|
||||
IsTeamMessage = eventType == GameEvent.EventType.SayTeam
|
||||
};
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
private (GameEvent.EventType type, string eventKey) GetEventTypeFromLine(string logLine)
|
||||
{
|
||||
var lineSplit = logLine.Split(';');
|
||||
if (lineSplit.Length > 1)
|
||||
{
|
||||
var type = lineSplit[0];
|
||||
return _eventTypeMap.ContainsKey(type)
|
||||
? (_eventTypeMap[type], type)
|
||||
: (GameEvent.EventType.Unknown, lineSplit[0]);
|
||||
}
|
||||
|
||||
foreach (var (key, value) in _regexMap)
|
||||
{
|
||||
var result = key.PatternMatcher.Match(logLine);
|
||||
if (result.Success)
|
||||
{
|
||||
return (value, null);
|
||||
}
|
||||
}
|
||||
|
||||
return (GameEvent.EventType.Unknown, null);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public void RegisterCustomEvent(string eventSubtype, string eventTriggerValue, Func<string, IEventParserConfiguration, GameEvent, GameEvent> eventModifier)
|
||||
public void RegisterCustomEvent(string eventSubtype, string eventTriggerValue,
|
||||
Func<string, IEventParserConfiguration, GameEvent, GameEvent> eventModifier)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(eventSubtype))
|
||||
{
|
||||
|
@ -1,6 +1,8 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Collections.Generic;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Globalization;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
|
||||
namespace IW4MAdmin.Application.EventParsers
|
||||
{
|
||||
@ -8,11 +10,13 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
/// generic implementation of the IEventParserConfiguration
|
||||
/// allows script plugins to generate dynamic configurations
|
||||
/// </summary>
|
||||
sealed internal class DynamicEventParserConfiguration : IEventParserConfiguration
|
||||
internal sealed class DynamicEventParserConfiguration : IEventParserConfiguration
|
||||
{
|
||||
public string GameDirectory { get; set; }
|
||||
public ParserRegex Say { get; set; }
|
||||
public string LocalizeText { get; set; }
|
||||
public ParserRegex Join { get; set; }
|
||||
public ParserRegex JoinTeam { get; set; }
|
||||
public ParserRegex Quit { get; set; }
|
||||
public ParserRegex Kill { get; set; }
|
||||
public ParserRegex Damage { get; set; }
|
||||
@ -22,10 +26,13 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
public ParserRegex MapEnd { get; set; }
|
||||
public NumberStyles GuidNumberStyle { get; set; } = NumberStyles.HexNumber;
|
||||
|
||||
public Dictionary<string, EFClient.TeamType> TeamMapping { get; set; } = new();
|
||||
|
||||
public DynamicEventParserConfiguration(IParserRegexFactory parserRegexFactory)
|
||||
{
|
||||
Say = parserRegexFactory.CreateParserRegex();
|
||||
Join = parserRegexFactory.CreateParserRegex();
|
||||
JoinTeam = parserRegexFactory.CreateParserRegex();
|
||||
Quit = parserRegexFactory.CreateParserRegex();
|
||||
Kill = parserRegexFactory.CreateParserRegex();
|
||||
Damage = parserRegexFactory.CreateParserRegex();
|
||||
|
@ -1,8 +1,8 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Linq;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
|
||||
|
28
Application/Extensions/ScriptPluginExtensions.cs
Normal file
28
Application/Extensions/ScriptPluginExtensions.cs
Normal file
@ -0,0 +1,28 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Data.Models.Client.Stats;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace IW4MAdmin.Application.Extensions;
|
||||
|
||||
public static class ScriptPluginExtensions
|
||||
{
|
||||
public static IEnumerable<object> GetClientsBasicData(
|
||||
this DbSet<Data.Models.Client.EFClient> set, int[] clientIds)
|
||||
{
|
||||
return set.Where(client => clientIds.Contains(client.ClientId))
|
||||
.Select(client => new
|
||||
{
|
||||
client.ClientId,
|
||||
client.CurrentAlias,
|
||||
client.Level,
|
||||
client.NetworkId
|
||||
}).ToList();
|
||||
}
|
||||
|
||||
public static IEnumerable<object> GetClientsStatData(this DbSet<EFClientStatistics> set, int[] clientIds,
|
||||
double serverId)
|
||||
{
|
||||
return set.Where(stat => clientIds.Contains(stat.ClientId) && stat.ServerId == (long)serverId).ToList();
|
||||
}
|
||||
}
|
@ -8,6 +8,7 @@ using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog;
|
||||
using Serilog.Core;
|
||||
using Serilog.Events;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
@ -17,7 +18,10 @@ namespace IW4MAdmin.Application.Extensions
|
||||
{
|
||||
public static class StartupExtensions
|
||||
{
|
||||
private static ILogger _defaultLogger = null;
|
||||
private static ILogger _defaultLogger;
|
||||
private static readonly LoggingLevelSwitch LevelSwitch = new();
|
||||
private static readonly LoggingLevelSwitch MicrosoftLevelSwitch = new();
|
||||
private static readonly LoggingLevelSwitch SystemLevelSwitch = new();
|
||||
|
||||
public static IServiceCollection AddBaseLogger(this IServiceCollection services,
|
||||
ApplicationConfiguration appConfig)
|
||||
@ -29,21 +33,37 @@ namespace IW4MAdmin.Application.Extensions
|
||||
.Build();
|
||||
|
||||
var loggerConfig = new LoggerConfiguration()
|
||||
.ReadFrom.Configuration(configuration)
|
||||
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning);
|
||||
.ReadFrom.Configuration(configuration);
|
||||
|
||||
LevelSwitch.MinimumLevel = Enum.Parse<LogEventLevel>(configuration["Serilog:MinimumLevel:Default"]);
|
||||
MicrosoftLevelSwitch.MinimumLevel = Enum.Parse<LogEventLevel>(configuration["Serilog:MinimumLevel:Override:Microsoft"]);
|
||||
SystemLevelSwitch.MinimumLevel = Enum.Parse<LogEventLevel>(configuration["Serilog:MinimumLevel:Override:System"]);
|
||||
|
||||
loggerConfig = loggerConfig.MinimumLevel.ControlledBy(LevelSwitch);
|
||||
loggerConfig = loggerConfig.MinimumLevel.Override("Microsoft", MicrosoftLevelSwitch)
|
||||
.MinimumLevel.Override("System", SystemLevelSwitch);
|
||||
|
||||
if (Utilities.IsDevelopment)
|
||||
{
|
||||
loggerConfig = loggerConfig.WriteTo.Console(
|
||||
outputTemplate:
|
||||
"[{Timestamp:yyyy-MM-dd HH:mm:ss.fff} {Server} {Level:u3}] {Message:lj}{NewLine}{Exception}")
|
||||
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
|
||||
.MinimumLevel.Debug();
|
||||
"[{Timestamp:HH:mm:ss} {Server} {Level:u3}] {Message:lj}{NewLine}{Exception}")
|
||||
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
|
||||
.MinimumLevel.Debug();
|
||||
}
|
||||
|
||||
_defaultLogger = loggerConfig.CreateLogger();
|
||||
}
|
||||
|
||||
services.AddSingleton((string context) =>
|
||||
{
|
||||
return context.ToLower() switch
|
||||
{
|
||||
"microsoft" => MicrosoftLevelSwitch,
|
||||
"system" => SystemLevelSwitch,
|
||||
_ => LevelSwitch
|
||||
};
|
||||
});
|
||||
services.AddLogging(builder => builder.AddSerilog(_defaultLogger, dispose: true));
|
||||
services.AddSingleton(new LoggerFactory()
|
||||
.AddSerilog(_defaultLogger, true));
|
||||
@ -94,7 +114,7 @@ namespace IW4MAdmin.Application.Extensions
|
||||
postgresqlOptions =>
|
||||
{
|
||||
postgresqlOptions.EnableRetryOnFailure();
|
||||
postgresqlOptions.SetPostgresVersion(new Version("9.4"));
|
||||
postgresqlOptions.SetPostgresVersion(new Version("12.9"));
|
||||
})
|
||||
.UseLoggerFactory(sp.GetRequiredService<ILoggerFactory>()).Options);
|
||||
return services;
|
||||
|
@ -1,4 +1,5 @@
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
@ -17,7 +18,17 @@ namespace IW4MAdmin.Application.Factories
|
||||
/// <returns></returns>
|
||||
public IConfigurationHandler<T> GetConfigurationHandler<T>(string name) where T : IBaseConfiguration
|
||||
{
|
||||
return new BaseConfigurationHandler<T>(name);
|
||||
var handler = new BaseConfigurationHandler<T>(name);
|
||||
handler.BuildAsync().Wait();
|
||||
return handler;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public async Task<IConfigurationHandler<T>> GetConfigurationHandlerAsync<T>(string name) where T : IBaseConfiguration
|
||||
{
|
||||
var handler = new BaseConfigurationHandler<T>(name);
|
||||
await handler.BuildAsync();
|
||||
return handler;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -18,14 +18,22 @@ namespace IW4MAdmin.Application.Factories
|
||||
public IGameLogReader CreateGameLogReader(Uri[] logUris, IEventParser eventParser)
|
||||
{
|
||||
var baseUri = logUris[0];
|
||||
if (baseUri.Scheme == Uri.UriSchemeHttp)
|
||||
if (baseUri.Scheme == Uri.UriSchemeHttp || baseUri.Scheme == Uri.UriSchemeHttps)
|
||||
{
|
||||
return new GameLogReaderHttp(logUris, eventParser, _serviceProvider.GetRequiredService<ILogger<GameLogReaderHttp>>());
|
||||
return new GameLogReaderHttp(logUris, eventParser,
|
||||
_serviceProvider.GetRequiredService<ILogger<GameLogReaderHttp>>());
|
||||
}
|
||||
|
||||
else if (baseUri.Scheme == Uri.UriSchemeFile)
|
||||
if (baseUri.Scheme == Uri.UriSchemeFile)
|
||||
{
|
||||
return new GameLogReader(baseUri.LocalPath, eventParser, _serviceProvider.GetRequiredService<ILogger<GameLogReader>>());
|
||||
return new GameLogReader(baseUri.LocalPath, eventParser,
|
||||
_serviceProvider.GetRequiredService<ILogger<GameLogReader>>());
|
||||
}
|
||||
|
||||
if (baseUri.Scheme == Uri.UriSchemeNetTcp)
|
||||
{
|
||||
return new NetworkGameLogReader(logUris, eventParser,
|
||||
_serviceProvider.GetRequiredService<ILogger<NetworkGameLogReader>>());
|
||||
}
|
||||
|
||||
throw new NotImplementedException($"No log reader implemented for Uri scheme \"{baseUri.Scheme}\"");
|
||||
|
@ -14,7 +14,7 @@ namespace IW4MAdmin.Application.Factories
|
||||
internal class GameServerInstanceFactory : IGameServerInstanceFactory
|
||||
{
|
||||
private readonly ITranslationLookup _translationLookup;
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
/// <summary>
|
||||
@ -23,7 +23,7 @@ namespace IW4MAdmin.Application.Factories
|
||||
/// <param name="translationLookup"></param>
|
||||
/// <param name="rconConnectionFactory"></param>
|
||||
public GameServerInstanceFactory(ITranslationLookup translationLookup,
|
||||
IMetaService metaService,
|
||||
IMetaServiceV2 metaService,
|
||||
IServiceProvider serviceProvider)
|
||||
{
|
||||
_translationLookup = translationLookup;
|
||||
@ -45,4 +45,4 @@ namespace IW4MAdmin.Application.Factories
|
||||
_serviceProvider.GetRequiredService<ILookupCache<EFServer>>());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,12 +1,13 @@
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
@ -30,17 +31,12 @@ namespace IW4MAdmin.Application.Factories
|
||||
|
||||
/// <inheritdoc/>
|
||||
public IManagerCommand CreateScriptCommand(string name, string alias, string description, string permission,
|
||||
bool isTargetRequired, IEnumerable<(string, bool)> args, Action<GameEvent> executeAction)
|
||||
bool isTargetRequired, IEnumerable<CommandArgument> args, Func<GameEvent, Task> executeAction, IEnumerable<Reference.Game> supportedGames)
|
||||
{
|
||||
var permissionEnum = Enum.Parse<EFClient.Permission>(permission);
|
||||
var argsArray = args.Select(_arg => new CommandArgument
|
||||
{
|
||||
Name = _arg.Item1,
|
||||
Required = _arg.Item2
|
||||
}).ToArray();
|
||||
|
||||
return new ScriptCommand(name, alias, description, isTargetRequired, permissionEnum, argsArray, executeAction,
|
||||
_config, _transLookup, _serviceProvider.GetRequiredService<ILogger<ScriptCommand>>());
|
||||
return new ScriptCommand(name, alias, description, isTargetRequired, permissionEnum, args, executeAction,
|
||||
_config, _transLookup, _serviceProvider.GetRequiredService<ILogger<ScriptCommand>>(), supportedGames);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,46 +0,0 @@
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Events;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
public class GameEventHandler : IEventHandler
|
||||
{
|
||||
private readonly EventLog _eventLog;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IEventPublisher _eventPublisher;
|
||||
private static readonly GameEvent.EventType[] overrideEvents = new[]
|
||||
{
|
||||
GameEvent.EventType.Connect,
|
||||
GameEvent.EventType.Disconnect,
|
||||
GameEvent.EventType.Quit,
|
||||
GameEvent.EventType.Stop
|
||||
};
|
||||
|
||||
public GameEventHandler(ILogger<GameEventHandler> logger, IEventPublisher eventPublisher)
|
||||
{
|
||||
_eventLog = new EventLog();
|
||||
_logger = logger;
|
||||
_eventPublisher = eventPublisher;
|
||||
}
|
||||
|
||||
public void HandleEvent(IManager manager, GameEvent gameEvent)
|
||||
{
|
||||
if (manager.IsRunning || overrideEvents.Contains(gameEvent.Type))
|
||||
{
|
||||
EventApi.OnGameEvent(gameEvent);
|
||||
_eventPublisher.Publish(gameEvent);
|
||||
Task.Factory.StartNew(() => manager.ExecuteEvent(gameEvent));
|
||||
}
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Skipping event as we're shutting down {eventId}", gameEvent.Id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
213
Application/IO/BaseConfigurationHandlerV2.cs
Normal file
213
Application/IO/BaseConfigurationHandlerV2.cs
Normal file
@ -0,0 +1,213 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.IO;
|
||||
|
||||
public class BaseConfigurationHandlerV2<TConfigurationType> : IConfigurationHandlerV2<TConfigurationType>
|
||||
where TConfigurationType : class
|
||||
{
|
||||
private readonly ILogger<BaseConfigurationHandlerV2<TConfigurationType>> _logger;
|
||||
private readonly ConfigurationWatcher _watcher;
|
||||
|
||||
private readonly JsonSerializerOptions _serializerOptions = new()
|
||||
{
|
||||
WriteIndented = true,
|
||||
Converters =
|
||||
{
|
||||
new JsonStringEnumConverter()
|
||||
},
|
||||
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
|
||||
};
|
||||
|
||||
private readonly SemaphoreSlim _onIo = new(1, 1);
|
||||
private TConfigurationType _configurationInstance;
|
||||
private string _path = string.Empty;
|
||||
private event Action<string> FileUpdated;
|
||||
|
||||
public BaseConfigurationHandlerV2(ILogger<BaseConfigurationHandlerV2<TConfigurationType>> logger,
|
||||
ConfigurationWatcher watcher)
|
||||
{
|
||||
_logger = logger;
|
||||
_watcher = watcher;
|
||||
FileUpdated += OnFileUpdated;
|
||||
}
|
||||
|
||||
~BaseConfigurationHandlerV2()
|
||||
{
|
||||
FileUpdated -= OnFileUpdated;
|
||||
_watcher.Unregister(_path);
|
||||
}
|
||||
|
||||
public async Task<TConfigurationType> Get(string configurationName,
|
||||
TConfigurationType defaultConfiguration = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(configurationName))
|
||||
{
|
||||
return defaultConfiguration;
|
||||
}
|
||||
|
||||
var cleanName = configurationName.Replace("\\", "").Replace("/", "");
|
||||
|
||||
if (string.IsNullOrWhiteSpace(configurationName))
|
||||
{
|
||||
return defaultConfiguration;
|
||||
}
|
||||
|
||||
_path = Path.Join(Utilities.OperatingDirectory, "Configuration", $"{cleanName}.json");
|
||||
TConfigurationType readConfiguration = null;
|
||||
|
||||
try
|
||||
{
|
||||
await _onIo.WaitAsync();
|
||||
await using var fileStream = File.OpenRead(_path);
|
||||
readConfiguration =
|
||||
await JsonSerializer.DeserializeAsync<TConfigurationType>(fileStream, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
_watcher.Register(_path, FileUpdated);
|
||||
|
||||
if (readConfiguration is null)
|
||||
{
|
||||
_logger.LogError("Could not parse configuration {Type} at {FileName}", typeof(TConfigurationType).Name,
|
||||
_path);
|
||||
|
||||
return defaultConfiguration;
|
||||
}
|
||||
}
|
||||
catch (FileNotFoundException)
|
||||
{
|
||||
if (defaultConfiguration is not null)
|
||||
{
|
||||
await InternalSet(defaultConfiguration, false);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not read configuration file at {Path}", _path);
|
||||
return defaultConfiguration;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onIo.CurrentCount == 0)
|
||||
{
|
||||
_onIo.Release(1);
|
||||
}
|
||||
}
|
||||
|
||||
return _configurationInstance ??= readConfiguration;
|
||||
}
|
||||
|
||||
public async Task Set(TConfigurationType configuration)
|
||||
{
|
||||
await InternalSet(configuration, true);
|
||||
}
|
||||
|
||||
public async Task Set()
|
||||
{
|
||||
if (_configurationInstance is not null)
|
||||
{
|
||||
await InternalSet(_configurationInstance, true);
|
||||
}
|
||||
}
|
||||
|
||||
public event Action<TConfigurationType> Updated;
|
||||
|
||||
private async Task InternalSet(TConfigurationType configuration, bool awaitSemaphore)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (awaitSemaphore)
|
||||
{
|
||||
await _onIo.WaitAsync();
|
||||
}
|
||||
|
||||
await using var fileStream = File.Create(_path);
|
||||
await JsonSerializer.SerializeAsync(fileStream, configuration, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
_configurationInstance = configuration;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not save configuration {Type} {Path}", configuration.GetType().Name, _path);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (awaitSemaphore && _onIo.CurrentCount == 0)
|
||||
{
|
||||
_onIo.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async void OnFileUpdated(string filePath)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onIo.WaitAsync();
|
||||
await using var fileStream = File.OpenRead(_path);
|
||||
var readConfiguration =
|
||||
await JsonSerializer.DeserializeAsync<TConfigurationType>(fileStream, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
|
||||
if (readConfiguration is null)
|
||||
{
|
||||
_logger.LogWarning("Could not parse updated configuration {Type} at {Path}",
|
||||
typeof(TConfigurationType).Name, filePath);
|
||||
}
|
||||
else
|
||||
{
|
||||
CopyUpdatedProperties(readConfiguration);
|
||||
Updated?.Invoke(readConfiguration);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Could not parse updated configuration {Type} at {Path}",
|
||||
typeof(TConfigurationType).Name, filePath);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onIo.CurrentCount == 0)
|
||||
{
|
||||
_onIo.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void CopyUpdatedProperties(TConfigurationType newConfiguration)
|
||||
{
|
||||
if (_configurationInstance is null)
|
||||
{
|
||||
_configurationInstance = newConfiguration;
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Updating existing config with new values {Type} at {Path}", typeof(TConfigurationType).Name,
|
||||
_path);
|
||||
|
||||
if (_configurationInstance is IDictionary configDict && newConfiguration is IDictionary newConfigDict)
|
||||
{
|
||||
configDict.Clear();
|
||||
foreach (var key in newConfigDict.Keys)
|
||||
{
|
||||
configDict.Add(key, newConfigDict[key]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var property in _configurationInstance.GetType().GetProperties()
|
||||
.Where(prop => prop.CanRead && prop.CanWrite))
|
||||
{
|
||||
property.SetValue(_configurationInstance, property.GetValue(newConfiguration));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
60
Application/IO/ConfigurationWatcher.cs
Normal file
60
Application/IO/ConfigurationWatcher.cs
Normal file
@ -0,0 +1,60 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using SharedLibraryCore;
|
||||
|
||||
namespace IW4MAdmin.Application.IO;
|
||||
|
||||
public sealed class ConfigurationWatcher : IDisposable
|
||||
{
|
||||
private readonly FileSystemWatcher _watcher;
|
||||
private readonly Dictionary<string, Action<string>> _registeredActions = new();
|
||||
|
||||
public ConfigurationWatcher()
|
||||
{
|
||||
_watcher = new FileSystemWatcher
|
||||
{
|
||||
Path = Path.Join(Utilities.OperatingDirectory, "Configuration"),
|
||||
Filter = "*.json",
|
||||
NotifyFilter = NotifyFilters.LastWrite
|
||||
};
|
||||
|
||||
_watcher.Changed += WatcherOnChanged;
|
||||
_watcher.EnableRaisingEvents = true;
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_watcher.Changed -= WatcherOnChanged;
|
||||
_watcher.Dispose();
|
||||
}
|
||||
|
||||
public void Register(string fileName, Action<string> fileUpdated)
|
||||
{
|
||||
if (_registeredActions.ContainsKey(fileName))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_registeredActions.Add(fileName, fileUpdated);
|
||||
}
|
||||
|
||||
public void Unregister(string fileName)
|
||||
{
|
||||
if (_registeredActions.ContainsKey(fileName))
|
||||
{
|
||||
_registeredActions.Remove(fileName);
|
||||
}
|
||||
}
|
||||
|
||||
private void WatcherOnChanged(object sender, FileSystemEventArgs eventArgs)
|
||||
{
|
||||
if (!_registeredActions.ContainsKey(eventArgs.FullPath) || eventArgs.ChangeType != WatcherChangeTypes.Changed ||
|
||||
new FileInfo(eventArgs.FullPath).Length == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_registeredActions[eventArgs.FullPath].Invoke(eventArgs.FullPath);
|
||||
}
|
||||
}
|
@ -21,7 +21,7 @@ namespace IW4MAdmin.Application.IO
|
||||
{
|
||||
_reader = gameLogReaderFactory.CreateGameLogReader(gameLogUris, server.EventParser);
|
||||
_server = server;
|
||||
_ignoreBots = server?.Manager.GetApplicationSettings().Configuration().IgnoreBots ?? false;
|
||||
_ignoreBots = server.Manager.GetApplicationSettings().Configuration()?.IgnoreBots ?? false;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
@ -69,7 +69,7 @@ namespace IW4MAdmin.Application.IO
|
||||
return;
|
||||
}
|
||||
|
||||
var events = await _reader.ReadEventsFromLog(fileDiff, previousFileSize);
|
||||
var events = await _reader.ReadEventsFromLog(fileDiff, previousFileSize, _server);
|
||||
|
||||
foreach (var gameEvent in events)
|
||||
{
|
||||
|
@ -28,7 +28,7 @@ namespace IW4MAdmin.Application.IO
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition)
|
||||
public async Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition, Server server = null)
|
||||
{
|
||||
// allocate the bytes for the new log lines
|
||||
List<string> logLines = new List<string>();
|
||||
|
@ -34,7 +34,7 @@ namespace IW4MAdmin.Application.IO
|
||||
|
||||
public int UpdateInterval => 500;
|
||||
|
||||
public async Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition)
|
||||
public async Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition, Server server = null)
|
||||
{
|
||||
var events = new List<GameEvent>();
|
||||
var response = await _logServerApi.Log(_safeLogPath, lastKey);
|
||||
|
163
Application/IO/NetworkGameLogReader.cs
Normal file
163
Application/IO/NetworkGameLogReader.cs
Normal file
@ -0,0 +1,163 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Integrations.Cod;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.IO
|
||||
{
|
||||
/// <summary>
|
||||
/// provides capability of reading log files over udp
|
||||
/// </summary>
|
||||
class NetworkGameLogReader : IGameLogReader
|
||||
{
|
||||
private readonly IEventParser _eventParser;
|
||||
private readonly ILogger _logger;
|
||||
private readonly Uri _uri;
|
||||
private static readonly NetworkLogState State = new();
|
||||
private bool _stateRegistered;
|
||||
private CancellationToken _token;
|
||||
|
||||
public NetworkGameLogReader(IReadOnlyList<Uri> uris, IEventParser parser, ILogger<NetworkGameLogReader> logger)
|
||||
{
|
||||
_eventParser = parser;
|
||||
_uri = uris[0];
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public long Length => -1;
|
||||
|
||||
public int UpdateInterval => 150;
|
||||
|
||||
public Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition,
|
||||
Server server = null)
|
||||
{
|
||||
// todo: other games might support this
|
||||
var serverEndpoint = (server?.RemoteConnection as CodRConConnection)?.Endpoint;
|
||||
|
||||
if (serverEndpoint is null)
|
||||
{
|
||||
return Task.FromResult(Enumerable.Empty<GameEvent>());
|
||||
}
|
||||
|
||||
if (!_stateRegistered && !State.EndPointExists(serverEndpoint))
|
||||
{
|
||||
try
|
||||
{
|
||||
var client = State.RegisterEndpoint(serverEndpoint, BuildLocalEndpoint()).Client;
|
||||
|
||||
_stateRegistered = true;
|
||||
_token = server.Manager.CancellationToken;
|
||||
|
||||
if (client == null)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server.ToString()))
|
||||
{
|
||||
_logger.LogInformation("Not registering {Name} socket because it is already bound",
|
||||
nameof(NetworkGameLogReader));
|
||||
}
|
||||
return Task.FromResult(Enumerable.Empty<GameEvent>());
|
||||
}
|
||||
|
||||
Task.Run(async () => await ReadNetworkData(client, _token), _token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not register {Name} endpoint {Endpoint}",
|
||||
nameof(NetworkGameLogReader), _uri);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
var events = new List<GameEvent>();
|
||||
|
||||
foreach (var logData in State.GetServerLogData(serverEndpoint)
|
||||
.Select(log => Utilities.EncodingType.GetString(log)))
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(logData))
|
||||
{
|
||||
return Task.FromResult(Enumerable.Empty<GameEvent>());
|
||||
}
|
||||
|
||||
var lines = logData
|
||||
.Split('\n')
|
||||
.Where(line => line.Length > 0 && !line.Contains('ÿ'));
|
||||
|
||||
foreach (var eventLine in lines)
|
||||
{
|
||||
try
|
||||
{
|
||||
// this trim end should hopefully fix the nasty runaway regex
|
||||
var gameEvent = _eventParser.GenerateGameEvent(eventLine.TrimEnd('\r'));
|
||||
events.Add(gameEvent);
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not properly parse event line from http {EventLine}",
|
||||
eventLine);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Task.FromResult((IEnumerable<GameEvent>)events);
|
||||
}
|
||||
|
||||
private async Task ReadNetworkData(UdpClient client, CancellationToken token)
|
||||
{
|
||||
while (!token.IsCancellationRequested)
|
||||
{
|
||||
// get more data
|
||||
IPEndPoint remoteEndpoint = null;
|
||||
byte[] bufferedData = null;
|
||||
|
||||
if (client == null)
|
||||
{
|
||||
// we already have a socket listening on this port for data, so we don't need to run another thread
|
||||
break;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var result = await client.ReceiveAsync(_token);
|
||||
remoteEndpoint = result.RemoteEndPoint;
|
||||
bufferedData = result.Buffer;
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogDebug("Stopping network log receive");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not receive lines for {LogReader}", nameof(NetworkGameLogReader));
|
||||
}
|
||||
|
||||
if (bufferedData != null)
|
||||
{
|
||||
State.QueueServerLogData(remoteEndpoint, bufferedData);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private IPEndPoint BuildLocalEndpoint()
|
||||
{
|
||||
try
|
||||
{
|
||||
return new IPEndPoint(Dns.GetHostAddresses(_uri.Host).First(), _uri.Port);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not setup {LogReader} endpoint", nameof(NetworkGameLogReader));
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
138
Application/IO/NetworkLogState.cs
Normal file
138
Application/IO/NetworkLogState.cs
Normal file
@ -0,0 +1,138 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Threading;
|
||||
|
||||
namespace IW4MAdmin.Application.IO;
|
||||
|
||||
public class NetworkLogState : Dictionary<IPEndPoint, UdpClientState>
|
||||
{
|
||||
public UdpClientState RegisterEndpoint(IPEndPoint serverEndpoint, IPEndPoint localEndpoint)
|
||||
{
|
||||
try
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
if (!ContainsKey(serverEndpoint))
|
||||
{
|
||||
Add(serverEndpoint, new UdpClientState { Client = new UdpClient(localEndpoint) });
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SocketException ex) when (ex.SocketErrorCode == SocketError.AddressAlreadyInUse)
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
// we don't add the udp client because it already exists (listening to multiple servers from one socket)
|
||||
Add(serverEndpoint, new UdpClientState());
|
||||
}
|
||||
}
|
||||
|
||||
return this[serverEndpoint];
|
||||
}
|
||||
|
||||
|
||||
public List<byte[]> GetServerLogData(IPEndPoint serverEndpoint)
|
||||
{
|
||||
try
|
||||
{
|
||||
var state = this[serverEndpoint];
|
||||
|
||||
if (state == null)
|
||||
{
|
||||
return new List<byte[]>();
|
||||
}
|
||||
|
||||
// it's possible that we could be trying to read and write to the queue simultaneously so we need to wait
|
||||
this[serverEndpoint].OnAction.Wait();
|
||||
|
||||
var data = new List<byte[]>();
|
||||
|
||||
while (this[serverEndpoint].AvailableLogData.Count > 0)
|
||||
{
|
||||
data.Add(this[serverEndpoint].AvailableLogData.Dequeue());
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (this[serverEndpoint].OnAction.CurrentCount == 0)
|
||||
{
|
||||
this[serverEndpoint].OnAction.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void QueueServerLogData(IPEndPoint serverEndpoint, byte[] data)
|
||||
{
|
||||
var endpoint = Keys.FirstOrDefault(key =>
|
||||
Equals(key.Address, serverEndpoint.Address) && key.Port == serverEndpoint.Port);
|
||||
|
||||
try
|
||||
{
|
||||
if (endpoint == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// currently our expected start and end characters
|
||||
var startsWithPrefix = StartsWith(data, "ÿÿÿÿprint\n");
|
||||
var endsWithDelimiter = data[^1] == '\n';
|
||||
|
||||
// we have the data we expected
|
||||
if (!startsWithPrefix || !endsWithDelimiter)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// it's possible that we could be trying to read and write to the queue simultaneously so we need to wait
|
||||
this[endpoint].OnAction.Wait();
|
||||
this[endpoint].AvailableLogData.Enqueue(data);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (endpoint != null && this[endpoint].OnAction.CurrentCount == 0)
|
||||
{
|
||||
this[endpoint].OnAction.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public bool EndPointExists(IPEndPoint serverEndpoint)
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
return ContainsKey(serverEndpoint);
|
||||
}
|
||||
}
|
||||
|
||||
private static bool StartsWith(byte[] sourceArray, string match)
|
||||
{
|
||||
if (sourceArray is null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (match.Length > sourceArray.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return !match.Where((t, i) => sourceArray[i] != (byte)t).Any();
|
||||
}
|
||||
}
|
||||
|
||||
public class UdpClientState
|
||||
{
|
||||
public UdpClient Client { get; set; }
|
||||
public Queue<byte[]> AvailableLogData { get; } = new();
|
||||
public SemaphoreSlim OnAction { get; } = new(1, 1);
|
||||
|
||||
~UdpClientState()
|
||||
{
|
||||
OnAction.Dispose();
|
||||
Client?.Dispose();
|
||||
}
|
||||
}
|
File diff suppressed because it is too large
Load Diff
@ -18,6 +18,7 @@ using SharedLibraryCore.Repositories;
|
||||
using SharedLibraryCore.Services;
|
||||
using Stats.Dtos;
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Net.Http;
|
||||
using System.Text;
|
||||
@ -26,15 +27,23 @@ using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Helpers;
|
||||
using Integrations.Source.Extensions;
|
||||
using IW4MAdmin.Application.Alerts;
|
||||
using IW4MAdmin.Application.Extensions;
|
||||
using IW4MAdmin.Application.IO;
|
||||
using IW4MAdmin.Application.Localization;
|
||||
using IW4MAdmin.Application.Plugin;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using IW4MAdmin.Application.QueryHelpers;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using IW4MAdmin.Plugins.Stats.Client.Abstractions;
|
||||
using IW4MAdmin.Plugins.Stats.Client;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
using Stats.Client.Abstractions;
|
||||
using Stats.Client;
|
||||
using Stats.Config;
|
||||
using Stats.Helpers;
|
||||
using WebfrontCore.QueryHelpers.Models;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
@ -43,15 +52,36 @@ namespace IW4MAdmin.Application
|
||||
public static BuildNumber Version { get; } = BuildNumber.Parse(Utilities.GetVersionAsString());
|
||||
private static ApplicationManager _serverManager;
|
||||
private static Task _applicationTask;
|
||||
private static ServiceProvider _serviceProvider;
|
||||
private static IServiceProvider _serviceProvider;
|
||||
|
||||
/// <summary>
|
||||
/// entrypoint of the application
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public static async Task Main(string[] args)
|
||||
public static async Task Main(bool noConfirm = false, int? maxConcurrentRequests = 25, int? requestQueueLimit = 25)
|
||||
{
|
||||
AppDomain.CurrentDomain.SetData("DataDirectory", Utilities.OperatingDirectory);
|
||||
AppDomain.CurrentDomain.AssemblyResolve += (sender, eventArgs) =>
|
||||
{
|
||||
var libraryName = eventArgs.Name.Split(",").First();
|
||||
|
||||
var overrides = new[] { nameof(SharedLibraryCore), nameof(Stats) };
|
||||
if (!overrides.Contains(libraryName))
|
||||
{
|
||||
return AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(asm => asm.FullName == eventArgs.Name);
|
||||
}
|
||||
// added to be a bit more permissive with plugin references
|
||||
return AppDomain.CurrentDomain.GetAssemblies()
|
||||
.FirstOrDefault(asm => asm.FullName?.StartsWith(libraryName) ?? false);
|
||||
};
|
||||
|
||||
if (noConfirm)
|
||||
{
|
||||
AppContext.SetSwitch("NoConfirmPrompt", true);
|
||||
}
|
||||
|
||||
Environment.SetEnvironmentVariable("MaxConcurrentRequests", (maxConcurrentRequests * Environment.ProcessorCount).ToString());
|
||||
Environment.SetEnvironmentVariable("RequestQueueLimit", requestQueueLimit.ToString());
|
||||
|
||||
Console.OutputEncoding = Encoding.UTF8;
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
@ -64,7 +94,7 @@ namespace IW4MAdmin.Application
|
||||
Console.WriteLine($" Version {Utilities.GetVersionAsString()}");
|
||||
Console.WriteLine("=====================================================");
|
||||
|
||||
await LaunchAsync(args);
|
||||
await LaunchAsync();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -75,8 +105,12 @@ namespace IW4MAdmin.Application
|
||||
/// <param name="e"></param>
|
||||
private static async void OnCancelKey(object sender, ConsoleCancelEventArgs e)
|
||||
{
|
||||
_serverManager?.Stop();
|
||||
if (_applicationTask != null)
|
||||
if (_serverManager is not null)
|
||||
{
|
||||
await _serverManager.Stop();
|
||||
}
|
||||
|
||||
if (_applicationTask is not null)
|
||||
{
|
||||
await _applicationTask;
|
||||
}
|
||||
@ -86,13 +120,13 @@ namespace IW4MAdmin.Application
|
||||
/// task that initializes application and starts the application monitoring and runtime tasks
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static async Task LaunchAsync(string[] args)
|
||||
private static async Task LaunchAsync()
|
||||
{
|
||||
restart:
|
||||
ITranslationLookup translationLookup = null;
|
||||
var logger = BuildDefaultLogger<Program>(new ApplicationConfiguration());
|
||||
Utilities.DefaultLogger = logger;
|
||||
logger.LogInformation("Begin IW4MAdmin startup. Version is {Version} {@Args}", Version, args);
|
||||
logger.LogInformation("Begin IW4MAdmin startup. Version is {Version}", Version);
|
||||
|
||||
try
|
||||
{
|
||||
@ -100,22 +134,23 @@ namespace IW4MAdmin.Application
|
||||
ConfigurationMigration.MoveConfigFolder10518(null);
|
||||
ConfigurationMigration.CheckDirectories();
|
||||
ConfigurationMigration.RemoveObsoletePlugins20210322();
|
||||
|
||||
logger.LogDebug("Configuring services...");
|
||||
var services = await ConfigureServices(args);
|
||||
_serviceProvider = services.BuildServiceProvider();
|
||||
var versionChecker = _serviceProvider.GetRequiredService<IMasterCommunication>();
|
||||
_serverManager = (ApplicationManager) _serviceProvider.GetRequiredService<IManager>();
|
||||
|
||||
var configHandler = new BaseConfigurationHandler<ApplicationConfiguration>("IW4MAdminSettings");
|
||||
await configHandler.BuildAsync();
|
||||
_serviceProvider = WebfrontCore.Program.InitializeServices(ConfigureServices,
|
||||
(configHandler.Configuration() ?? new ApplicationConfiguration()).WebfrontBindUrl);
|
||||
|
||||
_serverManager = (ApplicationManager)_serviceProvider.GetRequiredService<IManager>();
|
||||
translationLookup = _serviceProvider.GetRequiredService<ITranslationLookup>();
|
||||
|
||||
_applicationTask = RunApplicationTasksAsync(logger, services);
|
||||
var tasks = new[]
|
||||
{
|
||||
versionChecker.CheckVersion(),
|
||||
_serverManager.Init(),
|
||||
_applicationTask
|
||||
};
|
||||
await _serverManager.Init();
|
||||
|
||||
await Task.WhenAll(tasks);
|
||||
_applicationTask = RunApplicationTasksAsync(logger, _serverManager, _serviceProvider);
|
||||
|
||||
await _applicationTask;
|
||||
logger.LogInformation("Shutdown completed successfully");
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
@ -137,11 +172,8 @@ namespace IW4MAdmin.Application
|
||||
|
||||
if (e is ConfigurationException configException)
|
||||
{
|
||||
if (translationLookup != null)
|
||||
{
|
||||
Console.WriteLine(translationLookup[configException.Message]
|
||||
.FormatExt(configException.ConfigurationFileName));
|
||||
}
|
||||
Console.WriteLine("{{fileName}} contains an error."
|
||||
.FormatExt(Path.GetFileName(configException.ConfigurationFileName)));
|
||||
|
||||
foreach (var error in configException.Errors)
|
||||
{
|
||||
@ -154,6 +186,11 @@ namespace IW4MAdmin.Application
|
||||
Console.WriteLine(e.Message);
|
||||
}
|
||||
|
||||
if (_serverManager is not null)
|
||||
{
|
||||
await _serverManager?.Stop();
|
||||
}
|
||||
|
||||
Console.WriteLine(exitMessage);
|
||||
await Console.In.ReadAsync(new char[1], 0, 1);
|
||||
return;
|
||||
@ -163,21 +200,55 @@ namespace IW4MAdmin.Application
|
||||
{
|
||||
goto restart;
|
||||
}
|
||||
|
||||
await _serviceProvider.DisposeAsync();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// runs the core application tasks
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static async Task RunApplicationTasksAsync(ILogger logger, IServiceCollection services)
|
||||
private static Task RunApplicationTasksAsync(ILogger logger, ApplicationManager applicationManager,
|
||||
IServiceProvider serviceProvider)
|
||||
{
|
||||
var collectionService = serviceProvider.GetRequiredService<IServerDataCollector>();
|
||||
var versionChecker = serviceProvider.GetRequiredService<IMasterCommunication>();
|
||||
var masterCommunicator = serviceProvider.GetRequiredService<IMasterCommunication>();
|
||||
var webfrontLifetime = serviceProvider.GetRequiredService<IHostApplicationLifetime>();
|
||||
using var onWebfrontErrored = new ManualResetEventSlim();
|
||||
|
||||
var webfrontTask = _serverManager.GetApplicationSettings().Configuration().EnableWebFront
|
||||
? WebfrontCore.Program.Init(_serverManager, _serviceProvider, services, _serverManager.CancellationToken)
|
||||
? WebfrontCore.Program.GetWebHostTask(_serverManager.CancellationToken).ContinueWith(continuation =>
|
||||
{
|
||||
if (!continuation.IsFaulted)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
logger.LogCritical("Unable to start webfront task. {Message}",
|
||||
continuation.Exception?.InnerException?.Message);
|
||||
|
||||
logger.LogDebug(continuation.Exception, "Unable to start webfront task");
|
||||
|
||||
onWebfrontErrored.Set();
|
||||
|
||||
})
|
||||
: Task.CompletedTask;
|
||||
|
||||
var collectionService = _serviceProvider.GetRequiredService<IServerDataCollector>();
|
||||
if (_serverManager.GetApplicationSettings().Configuration().EnableWebFront)
|
||||
{
|
||||
try
|
||||
{
|
||||
onWebfrontErrored.Wait(webfrontLifetime.ApplicationStarted);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored when webfront successfully starts
|
||||
}
|
||||
|
||||
if (onWebfrontErrored.IsSet)
|
||||
{
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
// we want to run this one on a manual thread instead of letting the thread pool handle it,
|
||||
// because we can't exit early from waiting on console input, and it prevents us from restarting
|
||||
@ -188,18 +259,15 @@ namespace IW4MAdmin.Application
|
||||
|
||||
var tasks = new[]
|
||||
{
|
||||
applicationManager.Start(),
|
||||
versionChecker.CheckVersion(),
|
||||
webfrontTask,
|
||||
_serverManager.Start(),
|
||||
_serviceProvider.GetRequiredService<IMasterCommunication>()
|
||||
.RunUploadStatus(_serverManager.CancellationToken),
|
||||
masterCommunicator.RunUploadStatus(_serverManager.CancellationToken),
|
||||
collectionService.BeginCollectionAsync(cancellationToken: _serverManager.CancellationToken)
|
||||
};
|
||||
|
||||
logger.LogDebug("Starting webfront and input tasks");
|
||||
await Task.WhenAll(tasks);
|
||||
|
||||
logger.LogInformation("Shutdown completed successfully");
|
||||
Console.WriteLine(Utilities.CurrentLocalization.LocalizationIndex["MANAGER_SHUTDOWN_SUCCESS"]);
|
||||
return Task.WhenAll(tasks);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@ -276,7 +344,7 @@ namespace IW4MAdmin.Application
|
||||
|
||||
// register the native commands
|
||||
foreach (var commandType in typeof(SharedLibraryCore.Commands.QuitCommand).Assembly.GetTypes()
|
||||
.Concat(typeof(Program).Assembly.GetTypes().Where(type => type.Namespace == "IW4MAdmin.Application.Commands"))
|
||||
.Concat(typeof(Program).Assembly.GetTypes().Where(type => type.Namespace?.StartsWith("IW4MAdmin.Application.Commands") ?? false))
|
||||
.Where(command => command.BaseType == typeof(Command)))
|
||||
{
|
||||
defaultLogger.LogDebug("Registered native command type {Name}", commandType.Name);
|
||||
@ -287,8 +355,21 @@ namespace IW4MAdmin.Application
|
||||
var (plugins, commands, configurations) = pluginImporter.DiscoverAssemblyPluginImplementations();
|
||||
foreach (var pluginType in plugins)
|
||||
{
|
||||
defaultLogger.LogDebug("Registered plugin type {Name}", pluginType.FullName);
|
||||
serviceCollection.AddSingleton(typeof(IPlugin), pluginType);
|
||||
var isV2 = pluginType.GetInterface(nameof(IPluginV2), false) != null;
|
||||
|
||||
defaultLogger.LogDebug("Registering plugin type {Name}", pluginType.FullName);
|
||||
|
||||
serviceCollection.AddSingleton(!isV2 ? typeof(IPlugin) : typeof(IPluginV2), pluginType);
|
||||
|
||||
try
|
||||
{
|
||||
var registrationMethod = pluginType.GetMethod(nameof(IPluginV2.RegisterDependencies));
|
||||
registrationMethod?.Invoke(null, new object[] { serviceCollection });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
defaultLogger.LogError(ex, "Could not register plugin of type {Type}", pluginType.Name);
|
||||
}
|
||||
}
|
||||
|
||||
// register the plugin commands
|
||||
@ -309,10 +390,13 @@ namespace IW4MAdmin.Application
|
||||
serviceCollection.AddSingleton(genericInterfaceType, handlerInstance);
|
||||
}
|
||||
|
||||
// register any script plugins
|
||||
foreach (var scriptPlugin in pluginImporter.DiscoverScriptPlugins())
|
||||
var scriptPlugins = pluginImporter.DiscoverScriptPlugins();
|
||||
|
||||
foreach (var scriptPlugin in scriptPlugins)
|
||||
{
|
||||
serviceCollection.AddSingleton(scriptPlugin);
|
||||
serviceCollection.AddSingleton(scriptPlugin.Item1, sp =>
|
||||
sp.GetRequiredService<IScriptPluginFactory>()
|
||||
.CreateScriptPlugin(scriptPlugin.Item1, scriptPlugin.Item2));
|
||||
}
|
||||
|
||||
// register any eventable types
|
||||
@ -333,16 +417,27 @@ namespace IW4MAdmin.Application
|
||||
/// <summary>
|
||||
/// Configures the dependency injection services
|
||||
/// </summary>
|
||||
private static async Task<IServiceCollection> ConfigureServices(string[] args)
|
||||
private static void ConfigureServices(IServiceCollection serviceCollection)
|
||||
{
|
||||
// todo: this is a quick fix
|
||||
AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
|
||||
|
||||
// setup the static resources (config/master api/translations)
|
||||
var serviceCollection = new ServiceCollection();
|
||||
serviceCollection.AddConfiguration<ApplicationConfiguration>("IW4MAdminSettings")
|
||||
.AddConfiguration<DefaultSettings>()
|
||||
.AddConfiguration<CommandConfiguration>()
|
||||
.AddConfiguration<StatsConfiguration>("StatsPluginSettings");
|
||||
|
||||
// for legacy purposes. update at some point
|
||||
var appConfigHandler = new BaseConfigurationHandler<ApplicationConfiguration>("IW4MAdminSettings");
|
||||
var defaultConfigHandler = new BaseConfigurationHandler<DefaultSettings>("DefaultSettings");
|
||||
var defaultConfig = defaultConfigHandler.Configuration();
|
||||
appConfigHandler.BuildAsync().GetAwaiter().GetResult();
|
||||
var commandConfigHandler = new BaseConfigurationHandler<CommandConfiguration>("CommandConfiguration");
|
||||
commandConfigHandler.BuildAsync().GetAwaiter().GetResult();
|
||||
|
||||
if (appConfigHandler.Configuration()?.MasterUrl == new Uri("http://api.raidmax.org:5000"))
|
||||
{
|
||||
appConfigHandler.Configuration().MasterUrl = new ApplicationConfiguration().MasterUrl;
|
||||
}
|
||||
|
||||
var appConfig = appConfigHandler.Configuration();
|
||||
var masterUri = Utilities.IsDevelopment
|
||||
? new Uri("http://127.0.0.1:8080")
|
||||
@ -354,12 +449,12 @@ namespace IW4MAdmin.Application
|
||||
};
|
||||
var masterRestClient = RestClient.For<IMasterApi>(httpClient);
|
||||
var translationLookup = Configure.Initialize(Utilities.DefaultLogger, masterRestClient, appConfig);
|
||||
|
||||
|
||||
if (appConfig == null)
|
||||
{
|
||||
appConfig = (ApplicationConfiguration) new ApplicationConfiguration().Generate();
|
||||
appConfigHandler.Set(appConfig);
|
||||
await appConfigHandler.Save();
|
||||
appConfigHandler.Save().GetAwaiter().GetResult();
|
||||
}
|
||||
|
||||
// register override level names
|
||||
@ -372,18 +467,10 @@ namespace IW4MAdmin.Application
|
||||
}
|
||||
|
||||
// build the dependency list
|
||||
HandlePluginRegistration(appConfig, serviceCollection, masterRestClient);
|
||||
|
||||
serviceCollection
|
||||
.AddBaseLogger(appConfig)
|
||||
.AddSingleton(defaultConfig)
|
||||
.AddSingleton<IServiceCollection>(serviceCollection)
|
||||
.AddSingleton<IConfigurationHandler<DefaultSettings>, BaseConfigurationHandler<DefaultSettings>>()
|
||||
.AddSingleton((IConfigurationHandler<ApplicationConfiguration>) appConfigHandler)
|
||||
.AddSingleton(
|
||||
new BaseConfigurationHandler<CommandConfiguration>("CommandConfiguration") as
|
||||
IConfigurationHandler<CommandConfiguration>)
|
||||
.AddSingleton(appConfig)
|
||||
.AddSingleton<IConfigurationHandler<CommandConfiguration>>(commandConfigHandler)
|
||||
.AddSingleton(serviceProvider =>
|
||||
serviceProvider.GetRequiredService<IConfigurationHandler<CommandConfiguration>>()
|
||||
.Configuration() ?? new CommandConfiguration())
|
||||
@ -398,7 +485,10 @@ namespace IW4MAdmin.Application
|
||||
.AddSingleton<IScriptCommandFactory, ScriptCommandFactory>()
|
||||
.AddSingleton<IAuditInformationRepository, AuditInformationRepository>()
|
||||
.AddSingleton<IEntityService<EFClient>, ClientService>()
|
||||
#pragma warning disable CS0618
|
||||
.AddSingleton<IMetaService, MetaService>()
|
||||
#pragma warning restore CS0618
|
||||
.AddSingleton<IMetaServiceV2, MetaServiceV2>()
|
||||
.AddSingleton<ClientService>()
|
||||
.AddSingleton<PenaltyService>()
|
||||
.AddSingleton<ChangeHistoryService>()
|
||||
@ -412,6 +502,8 @@ namespace IW4MAdmin.Application
|
||||
UpdatedAliasResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ChatSearchQuery, MessageResponse>, ChatResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>, ConnectionsResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, PermissionLevelChangedResponse>, PermissionLevelChangedResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientResourceRequest, ClientResourceResponse>, ClientResourceQueryHelper>()
|
||||
.AddTransient<IParserPatternMatcher, ParserPatternMatcher>()
|
||||
.AddSingleton<IRemoteAssemblyHandler, RemoteAssemblyHandler>()
|
||||
.AddSingleton<IMasterCommunication, MasterCommunication>()
|
||||
@ -428,22 +520,22 @@ namespace IW4MAdmin.Application
|
||||
.AddSingleton(typeof(IDataValueCache<,>), typeof(DataValueCache<,>))
|
||||
.AddSingleton<IServerDataViewer, ServerDataViewer>()
|
||||
.AddSingleton<IServerDataCollector, ServerDataCollector>()
|
||||
.AddSingleton<IEventPublisher, EventPublisher>()
|
||||
.AddSingleton<IGeoLocationService>(new GeoLocationService(Path.Join(".", "Resources", "GeoLite2-Country.mmdb")))
|
||||
.AddSingleton<IAlertManager, AlertManager>()
|
||||
#pragma warning disable CS0618
|
||||
.AddTransient<IScriptPluginTimerHelper, ScriptPluginTimerHelper>()
|
||||
#pragma warning restore CS0618
|
||||
.AddSingleton<IInteractionRegistration, InteractionRegistration>()
|
||||
.AddSingleton<IRemoteCommandService, RemoteCommandService>()
|
||||
.AddSingleton(new ConfigurationWatcher())
|
||||
.AddSingleton(typeof(IConfigurationHandlerV2<>), typeof(BaseConfigurationHandlerV2<>))
|
||||
.AddSingleton<IScriptPluginFactory, ScriptPluginFactory>()
|
||||
.AddSingleton(translationLookup)
|
||||
.AddDatabaseContextOptions(appConfig);
|
||||
|
||||
if (args.Contains("serialevents"))
|
||||
{
|
||||
serviceCollection.AddSingleton<IEventHandler, SerialGameEventHandler>();
|
||||
}
|
||||
else
|
||||
{
|
||||
serviceCollection.AddSingleton<IEventHandler, GameEventHandler>();
|
||||
}
|
||||
|
||||
|
||||
serviceCollection.AddSingleton<ICoreEventHandler, CoreEventHandler>();
|
||||
serviceCollection.AddSource();
|
||||
|
||||
return serviceCollection;
|
||||
HandlePluginRegistration(appConfig, serviceCollection, masterRestClient);
|
||||
}
|
||||
|
||||
private static ILogger BuildDefaultLogger<T>(ApplicationConfiguration appConfig)
|
||||
|
@ -5,6 +5,7 @@ using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
@ -15,19 +16,28 @@ namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private ITranslationLookup _transLookup;
|
||||
private readonly IMetaService _metaService;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
private readonly IEntityService<EFClient> _clientEntityService;
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse> _receivedPenaltyHelper;
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse> _administeredPenaltyHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse>
|
||||
_administeredPenaltyHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> _updatedAliasHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>
|
||||
_connectionHistoryHelper;
|
||||
|
||||
public MetaRegistration(ILogger<MetaRegistration> logger, IMetaService metaService, ITranslationLookup transLookup, IEntityService<EFClient> clientEntityService,
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, PermissionLevelChangedResponse>
|
||||
_permissionLevelHelper;
|
||||
|
||||
public MetaRegistration(ILogger<MetaRegistration> logger, IMetaServiceV2 metaService,
|
||||
ITranslationLookup transLookup, IEntityService<EFClient> clientEntityService,
|
||||
IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse> receivedPenaltyHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse> administeredPenaltyHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> updatedAliasHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse> connectionHistoryHelper)
|
||||
IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse> connectionHistoryHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, PermissionLevelChangedResponse> permissionLevelHelper)
|
||||
{
|
||||
_logger = logger;
|
||||
_transLookup = transLookup;
|
||||
@ -37,21 +47,31 @@ namespace IW4MAdmin.Application.Meta
|
||||
_administeredPenaltyHelper = administeredPenaltyHelper;
|
||||
_updatedAliasHelper = updatedAliasHelper;
|
||||
_connectionHistoryHelper = connectionHistoryHelper;
|
||||
_permissionLevelHelper = permissionLevelHelper;
|
||||
}
|
||||
|
||||
public void Register()
|
||||
{
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, InformationResponse>(MetaType.Information, GetProfileMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, ReceivedPenaltyResponse>(MetaType.ReceivedPenalty, GetReceivedPenaltiesMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, AdministeredPenaltyResponse>(MetaType.Penalized, GetAdministeredPenaltiesMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, UpdatedAliasResponse>(MetaType.AliasUpdate, GetUpdatedAliasMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, ConnectionHistoryResponse>(MetaType.ConnectionHistory, GetConnectionHistoryMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, InformationResponse>(MetaType.Information,
|
||||
GetProfileMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, ReceivedPenaltyResponse>(MetaType.ReceivedPenalty,
|
||||
GetReceivedPenaltiesMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, AdministeredPenaltyResponse>(MetaType.Penalized,
|
||||
GetAdministeredPenaltiesMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, UpdatedAliasResponse>(MetaType.AliasUpdate,
|
||||
GetUpdatedAliasMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, ConnectionHistoryResponse>(MetaType.ConnectionHistory,
|
||||
GetConnectionHistoryMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, PermissionLevelChangedResponse>(
|
||||
MetaType.PermissionLevel, GetPermissionLevelMeta);
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<InformationResponse>> GetProfileMeta(ClientPaginationRequest request)
|
||||
private async Task<IEnumerable<InformationResponse>> GetProfileMeta(ClientPaginationRequest request,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var metaList = new List<InformationResponse>();
|
||||
var lastMapMeta = await _metaService.GetPersistentMeta("LastMapPlayed", new EFClient() { ClientId = request.ClientId });
|
||||
var lastMapMeta =
|
||||
await _metaService.GetPersistentMeta("LastMapPlayed", request.ClientId, cancellationToken);
|
||||
|
||||
if (lastMapMeta != null)
|
||||
{
|
||||
@ -63,12 +83,12 @@ namespace IW4MAdmin.Application.Meta
|
||||
Value = lastMapMeta.Value,
|
||||
ShouldDisplay = true,
|
||||
Type = MetaType.Information,
|
||||
Column = 1,
|
||||
Order = 6
|
||||
});
|
||||
}
|
||||
|
||||
var lastServerMeta = await _metaService.GetPersistentMeta("LastServerPlayed", new EFClient() { ClientId = request.ClientId });
|
||||
var lastServerMeta =
|
||||
await _metaService.GetPersistentMeta("LastServerPlayed", request.ClientId, cancellationToken);
|
||||
|
||||
if (lastServerMeta != null)
|
||||
{
|
||||
@ -80,8 +100,7 @@ namespace IW4MAdmin.Application.Meta
|
||||
Value = lastServerMeta.Value,
|
||||
ShouldDisplay = true,
|
||||
Type = MetaType.Information,
|
||||
Column = 0,
|
||||
Order = 6
|
||||
Order = 7
|
||||
});
|
||||
}
|
||||
|
||||
@ -89,7 +108,7 @@ namespace IW4MAdmin.Application.Meta
|
||||
|
||||
if (client == null)
|
||||
{
|
||||
_logger.LogWarning("No client found with id {clientId} when generating profile meta", request.ClientId);
|
||||
_logger.LogWarning("No client found with id {ClientId} when generating profile meta", request.ClientId);
|
||||
return metaList;
|
||||
}
|
||||
|
||||
@ -99,8 +118,7 @@ namespace IW4MAdmin.Application.Meta
|
||||
Key = _transLookup["WEBFRONT_PROFILE_META_PLAY_TIME"],
|
||||
Value = TimeSpan.FromHours(client.TotalConnectionTime / 3600.0).HumanizeForCurrentCulture(),
|
||||
ShouldDisplay = true,
|
||||
Column = 1,
|
||||
Order = 0,
|
||||
Order = 8,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
@ -110,8 +128,7 @@ namespace IW4MAdmin.Application.Meta
|
||||
Key = _transLookup["WEBFRONT_PROFILE_META_FIRST_SEEN"],
|
||||
Value = (DateTime.UtcNow - client.FirstConnection).HumanizeForCurrentCulture(),
|
||||
ShouldDisplay = true,
|
||||
Column = 1,
|
||||
Order = 1,
|
||||
Order = 9,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
@ -121,8 +138,7 @@ namespace IW4MAdmin.Application.Meta
|
||||
Key = _transLookup["WEBFRONT_PROFILE_META_LAST_SEEN"],
|
||||
Value = (DateTime.UtcNow - client.LastConnection).HumanizeForCurrentCulture(),
|
||||
ShouldDisplay = true,
|
||||
Column = 1,
|
||||
Order = 2,
|
||||
Order = 10,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
@ -130,10 +146,10 @@ namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_CONNECTIONS"],
|
||||
Value = client.Connections.ToString("#,##0", new System.Globalization.CultureInfo(Utilities.CurrentLocalization.LocalizationName)),
|
||||
Value = client.Connections.ToString("#,##0",
|
||||
new System.Globalization.CultureInfo(Utilities.CurrentLocalization.LocalizationName)),
|
||||
ShouldDisplay = true,
|
||||
Column = 1,
|
||||
Order = 3,
|
||||
Order = 11,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
@ -141,38 +157,50 @@ namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_MASKED"],
|
||||
Value = client.Masked ? Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_TRUE"] : Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_FALSE"],
|
||||
Value = client.Masked
|
||||
? Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_TRUE"]
|
||||
: Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_FALSE"],
|
||||
IsSensitive = true,
|
||||
Column = 1,
|
||||
Order = 4,
|
||||
Order = 12,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
return metaList;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<ReceivedPenaltyResponse>> GetReceivedPenaltiesMeta(ClientPaginationRequest request)
|
||||
private async Task<IEnumerable<ReceivedPenaltyResponse>> GetReceivedPenaltiesMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var penalties = await _receivedPenaltyHelper.QueryResource(request);
|
||||
return penalties.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<AdministeredPenaltyResponse>> GetAdministeredPenaltiesMeta(ClientPaginationRequest request)
|
||||
private async Task<IEnumerable<AdministeredPenaltyResponse>> GetAdministeredPenaltiesMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var penalties = await _administeredPenaltyHelper.QueryResource(request);
|
||||
return penalties.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<UpdatedAliasResponse>> GetUpdatedAliasMeta(ClientPaginationRequest request)
|
||||
private async Task<IEnumerable<UpdatedAliasResponse>> GetUpdatedAliasMeta(ClientPaginationRequest request,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
var aliases = await _updatedAliasHelper.QueryResource(request);
|
||||
return aliases.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<ConnectionHistoryResponse>> GetConnectionHistoryMeta(ClientPaginationRequest request)
|
||||
|
||||
private async Task<IEnumerable<ConnectionHistoryResponse>> GetConnectionHistoryMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var connections = await _connectionHistoryHelper.QueryResource(request);
|
||||
return connections.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<PermissionLevelChangedResponse>> GetPermissionLevelMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var permissionChanges = await _permissionLevelHelper.QueryResource(request);
|
||||
return permissionChanges.Results;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -0,0 +1,52 @@
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta;
|
||||
|
||||
public class
|
||||
PermissionLevelChangedResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest,
|
||||
PermissionLevelChangedResponse>
|
||||
{
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
|
||||
public PermissionLevelChangedResourceQueryHelper(IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<PermissionLevelChangedResponse>> QueryResource(
|
||||
ClientPaginationRequest query)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var auditEntries = context.EFChangeHistory.Where(change => change.TargetEntityId == query.ClientId)
|
||||
.Where(change => change.TypeOfChange == EFChangeHistory.ChangeType.Permission)
|
||||
.OrderByDescending(change => change.TimeChanged);
|
||||
|
||||
var audits = from change in auditEntries
|
||||
join client in context.Clients
|
||||
on change.OriginEntityId equals client.ClientId
|
||||
select new PermissionLevelChangedResponse
|
||||
{
|
||||
ChangedById = change.OriginEntityId,
|
||||
ChangedByName = client.CurrentAlias.Name,
|
||||
PreviousPermissionLevelValue = change.PreviousValue,
|
||||
CurrentPermissionLevelValue = change.CurrentValue,
|
||||
When = change.TimeChanged,
|
||||
ClientId = change.TargetEntityId,
|
||||
IsSensitive = true
|
||||
};
|
||||
|
||||
return new ResourceQueryHelperResult<PermissionLevelChangedResponse>
|
||||
{
|
||||
Results = await audits.Skip(query.Offset).Take(query.Count).ToListAsync()
|
||||
};
|
||||
}
|
||||
}
|
@ -11,6 +11,7 @@ using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using SharedLibraryCore.Services;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta
|
||||
@ -19,13 +20,14 @@ namespace IW4MAdmin.Application.Meta
|
||||
/// implementation of IResourceQueryHelper
|
||||
/// used to pull in penalties applied to a given client id
|
||||
/// </summary>
|
||||
public class ReceivedPenaltyResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse>
|
||||
public class
|
||||
ReceivedPenaltyResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse>
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
public ReceivedPenaltyResourceQueryHelper(ILogger<ReceivedPenaltyResourceQueryHelper> logger,
|
||||
public ReceivedPenaltyResourceQueryHelper(ILogger<ReceivedPenaltyResourceQueryHelper> logger,
|
||||
IDatabaseContextFactory contextFactory, ApplicationConfiguration appConfig)
|
||||
{
|
||||
_contextFactory = contextFactory;
|
||||
@ -33,45 +35,58 @@ namespace IW4MAdmin.Application.Meta
|
||||
_appConfig = appConfig;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<ReceivedPenaltyResponse>> QueryResource(ClientPaginationRequest query)
|
||||
public async Task<ResourceQueryHelperResult<ReceivedPenaltyResponse>> QueryResource(
|
||||
ClientPaginationRequest query)
|
||||
{
|
||||
var linkedPenaltyType = Utilities.LinkedPenaltyTypes();
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
var linkId = await ctx.Clients.AsNoTracking()
|
||||
.Where(_client => _client.ClientId == query.ClientId)
|
||||
.Select(_client => new {_client.AliasLinkId, _client.CurrentAliasId })
|
||||
.FirstOrDefaultAsync();
|
||||
.Where(_client => _client.ClientId == query.ClientId)
|
||||
.Select(_client => new { _client.AliasLinkId, _client.CurrentAliasId })
|
||||
.FirstOrDefaultAsync();
|
||||
|
||||
var iqPenalties = ctx.Penalties.AsNoTracking()
|
||||
.Where(_penalty => _penalty.OffenderId == query.ClientId ||
|
||||
linkedPenaltyType.Contains(_penalty.Type) && _penalty.LinkId == linkId.AliasLinkId);
|
||||
|
||||
IQueryable<EFPenalty> iqIpLinkedPenalties = null;
|
||||
|
||||
IQueryable<EFPenalty> identifierPenalties = null;
|
||||
|
||||
if (!_appConfig.EnableImplicitAccountLinking)
|
||||
{
|
||||
var usedIps = await ctx.Aliases.AsNoTracking()
|
||||
.Where(alias => (alias.LinkId == linkId.AliasLinkId || alias.AliasId == linkId.CurrentAliasId) && alias.IPAddress != null)
|
||||
.Where(alias =>
|
||||
(alias.LinkId == linkId.AliasLinkId || alias.AliasId == linkId.CurrentAliasId) &&
|
||||
alias.IPAddress != null)
|
||||
.Select(alias => alias.IPAddress).ToListAsync();
|
||||
|
||||
identifierPenalties = ctx.PenaltyIdentifiers.AsNoTracking().Where(identifier =>
|
||||
identifier.IPv4Address != null && usedIps.Contains(identifier.IPv4Address))
|
||||
.Select(id => id.Penalty);
|
||||
|
||||
var aliasedIds = await ctx.Aliases.AsNoTracking().Where(alias => usedIps.Contains(alias.IPAddress))
|
||||
.Select(alias => alias.LinkId)
|
||||
.ToListAsync();
|
||||
|
||||
iqIpLinkedPenalties = ctx.Penalties.AsNoTracking()
|
||||
.Where(penalty =>
|
||||
linkedPenaltyType.Contains(penalty.Type) && aliasedIds.Contains(penalty.LinkId));
|
||||
linkedPenaltyType.Contains(penalty.Type) && aliasedIds.Contains(penalty.LinkId ?? -1));
|
||||
}
|
||||
|
||||
var iqAllPenalties = iqPenalties;
|
||||
|
||||
|
||||
if (iqIpLinkedPenalties != null)
|
||||
{
|
||||
iqAllPenalties = iqPenalties.Union(iqIpLinkedPenalties);
|
||||
}
|
||||
|
||||
var penalties = await iqAllPenalties
|
||||
if (identifierPenalties != null)
|
||||
{
|
||||
iqAllPenalties = iqPenalties.Union(identifierPenalties);
|
||||
}
|
||||
|
||||
var penalties = await iqAllPenalties
|
||||
.Where(_penalty => _penalty.When < query.Before)
|
||||
.OrderByDescending(_penalty => _penalty.When)
|
||||
.Take(query.Count)
|
||||
@ -97,7 +112,7 @@ namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
// todo: maybe actually count
|
||||
RetrievedResultCount = penalties.Count,
|
||||
Results = penalties
|
||||
Results = penalties.Distinct()
|
||||
};
|
||||
}
|
||||
}
|
||||
|
@ -88,7 +88,7 @@ namespace IW4MAdmin.Application.Migration
|
||||
|
||||
public static void RemoveObsoletePlugins20210322()
|
||||
{
|
||||
var files = new[] {"StatsWeb.dll", "StatsWeb.Views.dll"};
|
||||
var files = new[] {"StatsWeb.dll", "StatsWeb.Views.dll", "IW4ScriptCommands.dll"};
|
||||
|
||||
foreach (var file in files)
|
||||
{
|
||||
|
12
Application/Misc/AsyncResult.cs
Normal file
12
Application/Misc/AsyncResult.cs
Normal file
@ -0,0 +1,12 @@
|
||||
using System;
|
||||
using System.Threading;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class AsyncResult : IAsyncResult
|
||||
{
|
||||
public object AsyncState { get; set; }
|
||||
public WaitHandle AsyncWaitHandle { get; set; }
|
||||
public bool CompletedSynchronously { get; set; }
|
||||
public bool IsCompleted { get; set; }
|
||||
}
|
@ -1,11 +1,13 @@
|
||||
using Newtonsoft.Json;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using JsonSerializer = System.Text.Json.JsonSerializer;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
@ -15,19 +17,25 @@ namespace IW4MAdmin.Application.Misc
|
||||
/// <typeparam name="T">base configuration type</typeparam>
|
||||
public class BaseConfigurationHandler<T> : IConfigurationHandler<T> where T : IBaseConfiguration
|
||||
{
|
||||
T _configuration;
|
||||
private T _configuration;
|
||||
private readonly SemaphoreSlim _onSaving;
|
||||
private readonly JsonSerializerOptions _serializerOptions;
|
||||
|
||||
public BaseConfigurationHandler(string fn)
|
||||
|
||||
public BaseConfigurationHandler(string fileName)
|
||||
{
|
||||
_serializerOptions = new JsonSerializerOptions
|
||||
{
|
||||
WriteIndented = true,
|
||||
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
|
||||
};
|
||||
_serializerOptions.Converters.Add(new JsonStringEnumConverter());
|
||||
_onSaving = new SemaphoreSlim(1, 1);
|
||||
FileName = Path.Join(Utilities.OperatingDirectory, "Configuration", $"{fn}.json");
|
||||
Build();
|
||||
FileName = Path.Join(Utilities.OperatingDirectory, "Configuration", $"{fileName}.json");
|
||||
}
|
||||
|
||||
public BaseConfigurationHandler() : this(typeof(T).Name)
|
||||
{
|
||||
_onSaving = new SemaphoreSlim(1, 1);
|
||||
}
|
||||
|
||||
~BaseConfigurationHandler()
|
||||
@ -37,12 +45,14 @@ namespace IW4MAdmin.Application.Misc
|
||||
|
||||
public string FileName { get; }
|
||||
|
||||
public void Build()
|
||||
public async Task BuildAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
var configContent = File.ReadAllText(FileName);
|
||||
_configuration = JsonConvert.DeserializeObject<T>(configContent);
|
||||
await _onSaving.WaitAsync();
|
||||
await using var fileStream = File.OpenRead(FileName);
|
||||
_configuration = await JsonSerializer.DeserializeAsync<T>(fileStream, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
}
|
||||
|
||||
catch (FileNotFoundException)
|
||||
@ -52,12 +62,19 @@ namespace IW4MAdmin.Application.Misc
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new ConfigurationException("MANAGER_CONFIGURATION_ERROR")
|
||||
throw new ConfigurationException("Could not load configuration")
|
||||
{
|
||||
Errors = new[] { e.Message },
|
||||
ConfigurationFileName = FileName
|
||||
};
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onSaving.CurrentCount == 0)
|
||||
{
|
||||
_onSaving.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task Save()
|
||||
@ -65,14 +82,10 @@ namespace IW4MAdmin.Application.Misc
|
||||
try
|
||||
{
|
||||
await _onSaving.WaitAsync();
|
||||
var settings = new JsonSerializerSettings()
|
||||
{
|
||||
Formatting = Formatting.Indented
|
||||
};
|
||||
settings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
|
||||
|
||||
var appConfigJson = JsonConvert.SerializeObject(_configuration, settings);
|
||||
await File.WriteAllTextAsync(FileName, appConfigJson);
|
||||
await using var fileStream = File.Create(FileName);
|
||||
await JsonSerializer.SerializeAsync(fileStream, _configuration, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
}
|
||||
|
||||
finally
|
||||
|
@ -33,7 +33,7 @@ namespace IW4MAdmin.Application.Misc
|
||||
builder.Append(header);
|
||||
builder.Append(config.NoticeLineSeparator);
|
||||
// build the reason
|
||||
var reason = _transLookup["GAME_MESSAGE_PENALTY_REASON"].FormatExt(penalty.Offense);
|
||||
var reason = _transLookup["GAME_MESSAGE_PENALTY_REASON"].FormatExt(penalty.Offense.FormatMessageForEngine(config));
|
||||
|
||||
if (isNewLineSeparator)
|
||||
{
|
||||
@ -117,4 +117,4 @@ namespace IW4MAdmin.Application.Misc
|
||||
return segments;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,27 +0,0 @@
|
||||
using Newtonsoft.Json;
|
||||
using SharedLibraryCore;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
public class EventLog : Dictionary<long, IList<GameEvent>>
|
||||
{
|
||||
private static JsonSerializerSettings serializationSettings;
|
||||
|
||||
public static JsonSerializerSettings BuildVcrSerializationSettings()
|
||||
{
|
||||
if (serializationSettings == null)
|
||||
{
|
||||
serializationSettings = new JsonSerializerSettings() { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore };
|
||||
serializationSettings.Converters.Add(new IPAddressConverter());
|
||||
serializationSettings.Converters.Add(new IPEndPointConverter());
|
||||
serializationSettings.Converters.Add(new GameEventConverter());
|
||||
serializationSettings.Converters.Add(new ClientEntityConverter());
|
||||
}
|
||||
|
||||
return serializationSettings;
|
||||
}
|
||||
}
|
||||
}
|
@ -1,44 +0,0 @@
|
||||
using System;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
public class EventPublisher : IEventPublisher
|
||||
{
|
||||
public event EventHandler<GameEvent> OnClientDisconnect;
|
||||
public event EventHandler<GameEvent> OnClientConnect;
|
||||
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public EventPublisher(ILogger<EventPublisher> logger)
|
||||
{
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public void Publish(GameEvent gameEvent)
|
||||
{
|
||||
_logger.LogDebug("Handling publishing event of type {EventType}", gameEvent.Type);
|
||||
|
||||
try
|
||||
{
|
||||
if (gameEvent.Type == GameEvent.EventType.Connect)
|
||||
{
|
||||
OnClientConnect?.Invoke(this, gameEvent);
|
||||
}
|
||||
|
||||
if (gameEvent.Type == GameEvent.EventType.Disconnect)
|
||||
{
|
||||
OnClientDisconnect?.Invoke(this, gameEvent);
|
||||
}
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not publish event of type {EventType}", gameEvent.Type);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
13
Application/Misc/GeoLocationResult.cs
Normal file
13
Application/Misc/GeoLocationResult.cs
Normal file
@ -0,0 +1,13 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class GeoLocationResult : IGeoLocationResult
|
||||
{
|
||||
public string Country { get; set; }
|
||||
public string CountryCode { get; set; }
|
||||
public string Region { get; set; }
|
||||
public string ASN { get; set; }
|
||||
public string Timezone { get; set; }
|
||||
public string Organization { get; set; }
|
||||
}
|
40
Application/Misc/GeoLocationService.cs
Normal file
40
Application/Misc/GeoLocationService.cs
Normal file
@ -0,0 +1,40 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using MaxMind.GeoIP2;
|
||||
using MaxMind.GeoIP2.Responses;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class GeoLocationService : IGeoLocationService
|
||||
{
|
||||
private readonly string _sourceAddress;
|
||||
|
||||
public GeoLocationService(string sourceAddress)
|
||||
{
|
||||
_sourceAddress = sourceAddress;
|
||||
}
|
||||
|
||||
public Task<IGeoLocationResult> Locate(string address)
|
||||
{
|
||||
CountryResponse country = null;
|
||||
|
||||
try
|
||||
{
|
||||
using var reader = new DatabaseReader(_sourceAddress);
|
||||
country = reader.Country(address);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
|
||||
var response = new GeoLocationResult
|
||||
{
|
||||
Country = country?.Country.Name ?? "Unknown",
|
||||
CountryCode = country?.Country.IsoCode ?? ""
|
||||
};
|
||||
|
||||
return Task.FromResult((IGeoLocationResult)response);
|
||||
}
|
||||
}
|
171
Application/Misc/InteractionRegistration.cs
Normal file
171
Application/Misc/InteractionRegistration.cs
Normal file
@ -0,0 +1,171 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using InteractionRegistrationCallback =
|
||||
System.Func<int?, Data.Models.Reference.Game?, System.Threading.CancellationToken,
|
||||
System.Threading.Tasks.Task<SharedLibraryCore.Interfaces.IInteractionData>>;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class InteractionRegistration : IInteractionRegistration
|
||||
{
|
||||
private readonly ILogger<InteractionRegistration> _logger;
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
private readonly ConcurrentDictionary<string, InteractionRegistrationCallback> _interactions = new();
|
||||
|
||||
public InteractionRegistration(ILogger<InteractionRegistration> logger, IServiceProvider serviceProvider)
|
||||
{
|
||||
_logger = logger;
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
public void RegisterScriptInteraction(string interactionName, string source, Delegate interactionRegistration)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(source))
|
||||
{
|
||||
throw new ArgumentException("Script interaction source cannot be null");
|
||||
}
|
||||
|
||||
_logger.LogDebug("Registering script interaction {InteractionName} from {Source}", interactionName, source);
|
||||
|
||||
var plugin = _serviceProvider.GetRequiredService<IEnumerable<IPlugin>>()
|
||||
.FirstOrDefault(plugin => plugin.Name == source);
|
||||
|
||||
if (plugin is not ScriptPlugin scriptPlugin)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Task<IInteractionData> WrappedDelegate(int? clientId, Reference.Game? game, CancellationToken token) =>
|
||||
Task.FromResult(
|
||||
scriptPlugin.WrapDelegate<IInteractionData>(interactionRegistration, token, clientId, game, token));
|
||||
|
||||
if (!_interactions.ContainsKey(interactionName))
|
||||
{
|
||||
_interactions.TryAdd(interactionName, WrappedDelegate);
|
||||
}
|
||||
else
|
||||
{
|
||||
_interactions[interactionName] = WrappedDelegate;
|
||||
}
|
||||
}
|
||||
|
||||
public void RegisterInteraction(string interactionName, InteractionRegistrationCallback interactionRegistration)
|
||||
{
|
||||
if (!_interactions.ContainsKey(interactionName))
|
||||
{
|
||||
_logger.LogDebug("Registering interaction {InteractionName}", interactionName);
|
||||
_interactions.TryAdd(interactionName, interactionRegistration);
|
||||
}
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Updating interaction {InteractionName}", interactionName);
|
||||
_interactions[interactionName] = interactionRegistration;
|
||||
}
|
||||
}
|
||||
|
||||
public void UnregisterInteraction(string interactionName)
|
||||
{
|
||||
if (!_interactions.ContainsKey(interactionName))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Unregistering interaction {InteractionName}", interactionName);
|
||||
_interactions.TryRemove(interactionName, out _);
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<IInteractionData>> GetInteractions(string interactionPrefix = null,
|
||||
int? clientId = null,
|
||||
Reference.Game? game = null, CancellationToken token = default)
|
||||
{
|
||||
return await GetInteractionsInternal(interactionPrefix, clientId, game, token);
|
||||
}
|
||||
|
||||
public async Task<string> ProcessInteraction(string interactionId, int originId, int? targetId = null,
|
||||
Reference.Game? game = null, IDictionary<string, string> meta = null, CancellationToken token = default)
|
||||
{
|
||||
if (!_interactions.ContainsKey(interactionId))
|
||||
{
|
||||
throw new ArgumentException($"Interaction with ID {interactionId} has not been registered");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var interaction = await _interactions[interactionId](targetId, game, token);
|
||||
|
||||
if (interaction.Action is not null)
|
||||
{
|
||||
return await interaction.Action(originId, targetId, game, meta, token);
|
||||
}
|
||||
|
||||
if (interaction.ScriptAction is not null)
|
||||
{
|
||||
foreach (var plugin in _serviceProvider.GetRequiredService<IEnumerable<IPlugin>>())
|
||||
{
|
||||
if (plugin is not ScriptPlugin scriptPlugin || scriptPlugin.Name != interaction.Source)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
return scriptPlugin.ExecuteAction<string>(interaction.ScriptAction, token, originId, targetId, game, meta,
|
||||
token);
|
||||
}
|
||||
|
||||
foreach (var plugin in _serviceProvider.GetRequiredService<IEnumerable<IPluginV2>>())
|
||||
{
|
||||
if (plugin is not ScriptPluginV2 scriptPlugin || scriptPlugin.Name != interaction.Source)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
return scriptPlugin
|
||||
.QueryWithErrorHandling(interaction.ScriptAction, originId, targetId, game, meta, token)
|
||||
?.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,
|
||||
"Could not process interaction for {InteractionName} and OriginId {ClientId}",
|
||||
interactionId, originId);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<IInteractionData>> GetInteractionsInternal(string prefix = null,
|
||||
int? clientId = null, Reference.Game? game = null, CancellationToken token = default)
|
||||
{
|
||||
var interactions = _interactions
|
||||
.Where(interaction => string.IsNullOrWhiteSpace(prefix) || interaction.Key.StartsWith(prefix)).Select(
|
||||
async kvp =>
|
||||
{
|
||||
try
|
||||
{
|
||||
return await kvp.Value(clientId, game, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,
|
||||
"Could not get interaction for {InteractionName} and ClientId {ClientId}",
|
||||
kvp.Key,
|
||||
clientId);
|
||||
return null;
|
||||
}
|
||||
});
|
||||
|
||||
return (await Task.WhenAll(interactions))
|
||||
.Where(interaction => interaction is not null)
|
||||
.ToList();
|
||||
}
|
||||
}
|
@ -26,7 +26,8 @@ namespace IW4MAdmin.Application.Misc
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly BuildNumber _fallbackVersion = BuildNumber.Parse("99.99.99.99");
|
||||
private readonly int _apiVersion = 1;
|
||||
private bool firstHeartBeat = true;
|
||||
private bool _firstHeartBeat = true;
|
||||
private static readonly TimeSpan Interval = TimeSpan.FromSeconds(30);
|
||||
|
||||
public MasterCommunication(ILogger<MasterCommunication> logger, ApplicationConfiguration appConfig, ITranslationLookup translationLookup, IMasterApi apiInstance, IManager manager)
|
||||
{
|
||||
@ -97,19 +98,20 @@ namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
try
|
||||
{
|
||||
await UploadStatus();
|
||||
if (_manager.IsRunning)
|
||||
{
|
||||
await UploadStatus();
|
||||
}
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Could not send heartbeat");
|
||||
_logger.LogWarning("Could not send heartbeat - {Message}", ex.Message);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await Task.Delay(30000, token);
|
||||
await Task.Delay(Interval, token);
|
||||
}
|
||||
|
||||
catch
|
||||
{
|
||||
break;
|
||||
@ -119,7 +121,7 @@ namespace IW4MAdmin.Application.Misc
|
||||
|
||||
private async Task UploadStatus()
|
||||
{
|
||||
if (firstHeartBeat)
|
||||
if (_firstHeartBeat)
|
||||
{
|
||||
var token = await _apiInstance.Authenticate(new AuthenticationId
|
||||
{
|
||||
@ -145,15 +147,15 @@ namespace IW4MAdmin.Application.Misc
|
||||
Map = s.CurrentMap.Name,
|
||||
MaxClientNum = s.MaxClients,
|
||||
Id = s.EndPoint,
|
||||
Port = (short)s.Port,
|
||||
IPAddress = s.IP
|
||||
Port = (short)s.ListenPort,
|
||||
IPAddress = s.ListenAddress
|
||||
}).ToList(),
|
||||
WebfrontUrl = _appConfig.WebfrontUrl
|
||||
};
|
||||
|
||||
Response<ResultMessage> response = null;
|
||||
Response<ResultMessage> response;
|
||||
|
||||
if (firstHeartBeat)
|
||||
if (_firstHeartBeat)
|
||||
{
|
||||
response = await _apiInstance.AddInstance(instance);
|
||||
}
|
||||
@ -161,12 +163,12 @@ namespace IW4MAdmin.Application.Misc
|
||||
else
|
||||
{
|
||||
response = await _apiInstance.UpdateInstance(instance.Id, instance);
|
||||
firstHeartBeat = false;
|
||||
_firstHeartBeat = false;
|
||||
}
|
||||
|
||||
if (response.ResponseMessage.StatusCode != System.Net.HttpStatusCode.OK)
|
||||
{
|
||||
_logger.LogWarning("Non success response code from master is {statusCode}, message is {message}", response.ResponseMessage.StatusCode, response.StringContent);
|
||||
_logger.LogWarning("Non success response code from master is {StatusCode}, message is {Message}", response.ResponseMessage.StatusCode, response.StringContent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -18,6 +18,7 @@ namespace IW4MAdmin.Application.Misc
|
||||
/// implementation of IMetaService
|
||||
/// used to add and retrieve runtime and persistent meta
|
||||
/// </summary>
|
||||
[Obsolete("Use MetaServiceV2")]
|
||||
public class MetaService : IMetaService
|
||||
{
|
||||
private readonly IDictionary<MetaType, List<dynamic>> _metaActions;
|
||||
@ -68,6 +69,29 @@ namespace IW4MAdmin.Application.Misc
|
||||
await ctx.SaveChangesAsync();
|
||||
}
|
||||
|
||||
public async Task SetPersistentMeta(string metaKey, string metaValue, int clientId)
|
||||
{
|
||||
await AddPersistentMeta(metaKey, metaValue, new EFClient { ClientId = clientId });
|
||||
}
|
||||
|
||||
public async Task IncrementPersistentMeta(string metaKey, int incrementAmount, int clientId)
|
||||
{
|
||||
var existingMeta = await GetPersistentMeta(metaKey, new EFClient { ClientId = clientId });
|
||||
|
||||
if (!long.TryParse(existingMeta?.Value ?? "0", out var existingValue))
|
||||
{
|
||||
existingValue = 0;
|
||||
}
|
||||
|
||||
var newValue = existingValue + incrementAmount;
|
||||
await SetPersistentMeta(metaKey, newValue.ToString(), clientId);
|
||||
}
|
||||
|
||||
public async Task DecrementPersistentMeta(string metaKey, int decrementAmount, int clientId)
|
||||
{
|
||||
await IncrementPersistentMeta(metaKey, -decrementAmount, clientId);
|
||||
}
|
||||
|
||||
public async Task AddPersistentMeta(string metaKey, string metaValue)
|
||||
{
|
||||
await using var ctx = _contextFactory.CreateContext();
|
||||
@ -207,42 +231,30 @@ namespace IW4MAdmin.Application.Misc
|
||||
|
||||
public async Task<IEnumerable<IClientMeta>> GetRuntimeMeta(ClientPaginationRequest request)
|
||||
{
|
||||
var meta = new List<IClientMeta>();
|
||||
var metas = await Task.WhenAll(_metaActions.Where(kvp => kvp.Key != MetaType.Information)
|
||||
.Select(async kvp => await kvp.Value[0](request)));
|
||||
|
||||
foreach (var (type, actions) in _metaActions)
|
||||
{
|
||||
// information is not listed chronologically
|
||||
if (type != MetaType.Information)
|
||||
{
|
||||
var metaItems = await actions[0](request);
|
||||
meta.AddRange(metaItems);
|
||||
}
|
||||
}
|
||||
|
||||
return meta.OrderByDescending(_meta => _meta.When)
|
||||
return metas.SelectMany(m => (IEnumerable<IClientMeta>)m)
|
||||
.OrderByDescending(m => m.When)
|
||||
.Take(request.Count)
|
||||
.ToList();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<T>> GetRuntimeMeta<T>(ClientPaginationRequest request, MetaType metaType) where T : IClientMeta
|
||||
{
|
||||
IEnumerable<T> meta;
|
||||
if (metaType == MetaType.Information)
|
||||
{
|
||||
var allMeta = new List<T>();
|
||||
|
||||
foreach (var individualMetaRegistration in _metaActions[metaType])
|
||||
{
|
||||
allMeta.AddRange(await individualMetaRegistration(request));
|
||||
}
|
||||
|
||||
var completedMeta = await Task.WhenAll(_metaActions[metaType].Select(async individualMetaRegistration =>
|
||||
(IEnumerable<T>)await individualMetaRegistration(request)));
|
||||
|
||||
allMeta.AddRange(completedMeta.SelectMany(meta => meta));
|
||||
|
||||
return ProcessInformationMeta(allMeta);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
meta = await _metaActions[metaType][0](request) as IEnumerable<T>;
|
||||
}
|
||||
var meta = await _metaActions[metaType][0](request) as IEnumerable<T>;
|
||||
|
||||
return meta;
|
||||
}
|
||||
|
453
Application/Misc/MetaServiceV2.cs
Normal file
453
Application/Misc/MetaServiceV2.cs
Normal file
@ -0,0 +1,453 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class MetaServiceV2 : IMetaServiceV2
|
||||
{
|
||||
private readonly IDictionary<MetaType, List<dynamic>> _metaActions;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public MetaServiceV2(ILogger<MetaServiceV2> logger, IDatabaseContextFactory contextFactory, IServiceProvider serviceProvider)
|
||||
{
|
||||
_logger = logger;
|
||||
_metaActions = new Dictionary<MetaType, List<dynamic>>();
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public async Task SetPersistentMeta(string metaKey, string metaValue, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == clientId)
|
||||
.FirstOrDefaultAsync(token);
|
||||
|
||||
if (existingMeta != null)
|
||||
{
|
||||
_logger.LogDebug("Updating existing meta with key {Key} and id {Id}", existingMeta.Key,
|
||||
existingMeta.MetaId);
|
||||
existingMeta.Value = metaValue;
|
||||
existingMeta.Updated = DateTime.UtcNow;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Adding new meta with key {Key}", metaKey);
|
||||
context.EFMeta.Add(new EFMeta
|
||||
{
|
||||
ClientId = clientId,
|
||||
Created = DateTime.UtcNow,
|
||||
Key = metaKey,
|
||||
Value = metaValue,
|
||||
});
|
||||
}
|
||||
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
public async Task SetPersistentMetaValue<T>(string metaKey, T metaValue, int clientId,
|
||||
CancellationToken token = default) where T : class
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
string serializedValue;
|
||||
|
||||
try
|
||||
{
|
||||
serializedValue = JsonSerializer.Serialize(metaValue);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not serialize meta with key {Key}", metaKey);
|
||||
return;
|
||||
}
|
||||
|
||||
await SetPersistentMeta(metaKey, serializedValue, clientId, token);
|
||||
}
|
||||
|
||||
public async Task SetPersistentMetaForLookupKey(string metaKey, string lookupKey, int lookupId, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var lookupMeta = await context.EFMeta.FirstOrDefaultAsync(meta => meta.Key == lookupKey, token);
|
||||
|
||||
if (lookupMeta is null)
|
||||
{
|
||||
_logger.LogWarning("No lookup meta exists for metaKey {MetaKey} and lookupKey {LookupKey}", metaKey,
|
||||
lookupKey);
|
||||
return;
|
||||
}
|
||||
|
||||
var lookupValues = JsonSerializer.Deserialize<List<LookupValue<string>>>(lookupMeta.Value);
|
||||
|
||||
if (lookupValues is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var foundLookup = lookupValues.FirstOrDefault(value => value.Id == lookupId);
|
||||
|
||||
if (foundLookup is null)
|
||||
{
|
||||
_logger.LogWarning("No lookup meta found for provided lookup id {MetaKey}, {LookupKey}, {LookupId}",
|
||||
metaKey, lookupKey, lookupId);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Setting meta for lookup {MetaKey}, {LookupKey}, {LookupId}",
|
||||
metaKey, lookupKey, lookupId);
|
||||
|
||||
await SetPersistentMeta(metaKey, lookupId.ToString(), clientId, token);
|
||||
}
|
||||
|
||||
public async Task IncrementPersistentMeta(string metaKey, int incrementAmount, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var existingMeta = await GetPersistentMeta(metaKey, clientId, token);
|
||||
|
||||
if (!long.TryParse(existingMeta?.Value ?? "0", out var existingValue))
|
||||
{
|
||||
existingValue = 0;
|
||||
}
|
||||
|
||||
var newValue = existingValue + incrementAmount;
|
||||
await SetPersistentMeta(metaKey, newValue.ToString(), clientId, token);
|
||||
}
|
||||
|
||||
public async Task DecrementPersistentMeta(string metaKey, int decrementAmount, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
await IncrementPersistentMeta(metaKey, -decrementAmount, clientId, token);
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMeta(string metaKey, int clientId, CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
return await ctx.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == clientId)
|
||||
.Select(meta => new EFMeta
|
||||
{
|
||||
MetaId = meta.MetaId,
|
||||
Key = meta.Key,
|
||||
ClientId = meta.ClientId,
|
||||
Value = meta.Value,
|
||||
})
|
||||
.FirstOrDefaultAsync(token);
|
||||
}
|
||||
|
||||
public async Task<T> GetPersistentMetaValue<T>(string metaKey, int clientId, CancellationToken token = default)
|
||||
where T : class
|
||||
{
|
||||
var meta = await GetPersistentMeta(metaKey, clientId, token);
|
||||
|
||||
if (meta is null)
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return JsonSerializer.Deserialize<T>(meta.Value);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not deserialize meta with key {Key} and value {Value}", metaKey, meta.Value);
|
||||
return default;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMetaByLookup(string metaKey, string lookupKey, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var metaValue = await GetPersistentMeta(metaKey, clientId, token);
|
||||
|
||||
if (metaValue is null)
|
||||
{
|
||||
_logger.LogDebug("No meta exists for key {Key}, clientId {ClientId}", metaKey, clientId);
|
||||
return default;
|
||||
}
|
||||
|
||||
var lookupMeta = await context.EFMeta.FirstOrDefaultAsync(meta => meta.Key == lookupKey, token);
|
||||
|
||||
if (lookupMeta is null)
|
||||
{
|
||||
_logger.LogWarning("No lookup meta exists for metaKey {MetaKey} and lookupKey {LookupKey}", metaKey,
|
||||
lookupKey);
|
||||
return default;
|
||||
}
|
||||
|
||||
var lookupId = int.Parse(metaValue.Value);
|
||||
var lookupValues = JsonSerializer.Deserialize<List<LookupValue<string>>>(lookupMeta.Value);
|
||||
|
||||
if (lookupValues is null)
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
var foundLookup = lookupValues.FirstOrDefault(value => value.Id == lookupId);
|
||||
|
||||
if (foundLookup is not null)
|
||||
{
|
||||
return new EFMeta
|
||||
{
|
||||
Created = metaValue.Created,
|
||||
Updated = metaValue.Updated,
|
||||
Extra = metaValue.Extra,
|
||||
MetaId = metaValue.MetaId,
|
||||
Value = foundLookup.Value
|
||||
};
|
||||
}
|
||||
|
||||
_logger.LogWarning("No lookup meta found for provided lookup id {MetaKey}, {LookupKey}, {LookupId}",
|
||||
metaKey, lookupKey, lookupId);
|
||||
return default;
|
||||
}
|
||||
|
||||
public async Task RemovePersistentMeta(string metaKey, int clientId, CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.FirstOrDefaultAsync(meta => meta.Key == metaKey && meta.ClientId == clientId, token);
|
||||
|
||||
if (existingMeta == null)
|
||||
{
|
||||
_logger.LogDebug("No meta with key {Key} found for client id {Id}", metaKey, clientId);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Removing meta for key {Key} with id {Id}", metaKey, existingMeta.MetaId);
|
||||
context.EFMeta.Remove(existingMeta);
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
public async Task SetPersistentMeta(string metaKey, string metaValue, CancellationToken token = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
_logger.LogWarning("Cannot save meta with no key");
|
||||
return;
|
||||
}
|
||||
|
||||
await using var ctx = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await ctx.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.FirstOrDefaultAsync(token);
|
||||
|
||||
if (existingMeta is not null)
|
||||
{
|
||||
_logger.LogDebug("Updating existing meta with key {Key} and id {Id}", existingMeta.Key,
|
||||
existingMeta.MetaId);
|
||||
|
||||
existingMeta.Value = metaValue;
|
||||
existingMeta.Updated = DateTime.UtcNow;
|
||||
|
||||
await ctx.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Adding new meta with key {Key}", metaKey);
|
||||
|
||||
ctx.EFMeta.Add(new EFMeta
|
||||
{
|
||||
Created = DateTime.UtcNow,
|
||||
Key = metaKey,
|
||||
Value = metaValue
|
||||
});
|
||||
|
||||
await ctx.SaveChangesAsync(token);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task SetPersistentMetaValue<T>(string metaKey, T metaValue, CancellationToken token = default)
|
||||
where T : class
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
_logger.LogWarning("Meta key is null, not setting");
|
||||
return;
|
||||
}
|
||||
|
||||
if (metaValue is null)
|
||||
{
|
||||
_logger.LogWarning("Meta value is null, not setting");
|
||||
return;
|
||||
}
|
||||
|
||||
string serializedMeta;
|
||||
try
|
||||
{
|
||||
serializedMeta = JsonSerializer.Serialize(metaValue);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not serialize meta with {Key} and value {Value}", metaKey, metaValue);
|
||||
return;
|
||||
}
|
||||
|
||||
await SetPersistentMeta(metaKey, serializedMeta, token);
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMeta(string metaKey, CancellationToken token = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext(false);
|
||||
return await context.EFMeta.FirstOrDefaultAsync(meta => meta.Key == metaKey, token);
|
||||
}
|
||||
|
||||
public async Task<T> GetPersistentMetaValue<T>(string metaKey, CancellationToken token = default) where T : class
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
var meta = await GetPersistentMeta(metaKey, token);
|
||||
|
||||
if (meta is null)
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return JsonSerializer.Deserialize<T>(meta.Value);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not serialize meta with key {Key} and value {Value}", metaKey, meta.Value);
|
||||
return default;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task RemovePersistentMeta(string metaKey, CancellationToken token = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.FirstOrDefaultAsync(token);
|
||||
|
||||
if (existingMeta != null)
|
||||
{
|
||||
_logger.LogDebug("Removing meta for key {Key} with id {Id}", metaKey, existingMeta.MetaId);
|
||||
context.Remove(existingMeta);
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
}
|
||||
|
||||
public void AddRuntimeMeta<T, TReturnType>(MetaType metaKey,
|
||||
Func<T, CancellationToken, Task<IEnumerable<TReturnType>>> metaAction)
|
||||
where T : PaginationRequest where TReturnType : IClientMeta
|
||||
{
|
||||
if (!_metaActions.ContainsKey(metaKey))
|
||||
{
|
||||
_metaActions.Add(metaKey, new List<dynamic> { metaAction });
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_metaActions[metaKey].Add(metaAction);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<IClientMeta>> GetRuntimeMeta(ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var metas = await Task.WhenAll(_metaActions.Where(kvp => kvp.Key != MetaType.Information)
|
||||
.Select(async kvp => await kvp.Value[0](request, token)));
|
||||
|
||||
return metas.SelectMany(m => (IEnumerable<IClientMeta>)m)
|
||||
.OrderByDescending(m => m.When)
|
||||
.Take(request.Count)
|
||||
.ToList();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<T>> GetRuntimeMeta<T>(ClientPaginationRequest request, MetaType metaType, CancellationToken token = default)
|
||||
where T : IClientMeta
|
||||
{
|
||||
if (metaType == MetaType.Information)
|
||||
{
|
||||
var allMeta = new List<T>();
|
||||
|
||||
var completedMeta = await Task.WhenAll(_metaActions[metaType].Select(async individualMetaRegistration =>
|
||||
(IEnumerable<T>)await individualMetaRegistration(request, token)));
|
||||
|
||||
allMeta.AddRange(completedMeta.SelectMany(meta => meta));
|
||||
|
||||
return ProcessInformationMeta(allMeta);
|
||||
}
|
||||
|
||||
var meta = await _metaActions[metaType][0](request, token) as IEnumerable<T>;
|
||||
|
||||
return meta;
|
||||
}
|
||||
|
||||
private static IEnumerable<T> ProcessInformationMeta<T>(IEnumerable<T> meta) where T : IClientMeta
|
||||
{
|
||||
return meta;
|
||||
}
|
||||
|
||||
private static bool ValidArgs(string key, int clientId) => !string.IsNullOrWhiteSpace(key) && clientId > 0;
|
||||
}
|
@ -1,177 +0,0 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Linq;
|
||||
using SharedLibraryCore;
|
||||
using IW4MAdmin.Application.API.Master;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IPluginImporter
|
||||
/// discovers plugins and script plugins
|
||||
/// </summary>
|
||||
public class PluginImporter : IPluginImporter
|
||||
{
|
||||
private IEnumerable<PluginSubscriptionContent> _pluginSubscription;
|
||||
private static readonly string PLUGIN_DIR = "Plugins";
|
||||
private readonly ILogger _logger;
|
||||
private readonly IRemoteAssemblyHandler _remoteAssemblyHandler;
|
||||
private readonly IMasterApi _masterApi;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
public PluginImporter(ILogger<PluginImporter> logger, ApplicationConfiguration appConfig, IMasterApi masterApi, IRemoteAssemblyHandler remoteAssemblyHandler)
|
||||
{
|
||||
_logger = logger;
|
||||
_masterApi = masterApi;
|
||||
_remoteAssemblyHandler = remoteAssemblyHandler;
|
||||
_appConfig = appConfig;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// discovers all the script plugins in the plugins dir
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public IEnumerable<IPlugin> DiscoverScriptPlugins()
|
||||
{
|
||||
string pluginDir = $"{Utilities.OperatingDirectory}{PLUGIN_DIR}{Path.DirectorySeparatorChar}";
|
||||
|
||||
if (Directory.Exists(pluginDir))
|
||||
{
|
||||
var scriptPluginFiles = Directory.GetFiles(pluginDir, "*.js").AsEnumerable().Union(GetRemoteScripts());
|
||||
|
||||
_logger.LogDebug("Discovered {count} potential script plugins", scriptPluginFiles.Count());
|
||||
|
||||
if (scriptPluginFiles.Count() > 0)
|
||||
{
|
||||
foreach (string fileName in scriptPluginFiles)
|
||||
{
|
||||
_logger.LogDebug("Discovered script plugin {fileName}", fileName);
|
||||
var plugin = new ScriptPlugin(_logger, fileName);
|
||||
yield return plugin;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// discovers all the C# assembly plugins and commands
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public (IEnumerable<Type>, IEnumerable<Type>, IEnumerable<Type>) DiscoverAssemblyPluginImplementations()
|
||||
{
|
||||
var pluginDir = $"{Utilities.OperatingDirectory}{PLUGIN_DIR}{Path.DirectorySeparatorChar}";
|
||||
var pluginTypes = Enumerable.Empty<Type>();
|
||||
var commandTypes = Enumerable.Empty<Type>();
|
||||
var configurationTypes = Enumerable.Empty<Type>();
|
||||
|
||||
if (Directory.Exists(pluginDir))
|
||||
{
|
||||
var dllFileNames = Directory.GetFiles(pluginDir, "*.dll");
|
||||
_logger.LogDebug("Discovered {count} potential plugin assemblies", dllFileNames.Length);
|
||||
|
||||
if (dllFileNames.Length > 0)
|
||||
{
|
||||
// we only want to load the most recent assembly in case of duplicates
|
||||
var assemblies = dllFileNames.Select(_name => Assembly.LoadFrom(_name))
|
||||
.Union(GetRemoteAssemblies())
|
||||
.GroupBy(_assembly => _assembly.FullName).Select(_assembly => _assembly.OrderByDescending(_assembly => _assembly.GetName().Version).First());
|
||||
|
||||
pluginTypes = assemblies
|
||||
.SelectMany(_asm =>
|
||||
{
|
||||
try
|
||||
{
|
||||
return _asm.GetTypes();
|
||||
}
|
||||
catch
|
||||
{
|
||||
return Enumerable.Empty<Type>();
|
||||
}
|
||||
})
|
||||
.Where(_assemblyType => _assemblyType.GetInterface(nameof(IPlugin), false) != null);
|
||||
|
||||
_logger.LogDebug("Discovered {count} plugin implementations", pluginTypes.Count());
|
||||
|
||||
commandTypes = assemblies
|
||||
.SelectMany(_asm =>{
|
||||
try
|
||||
{
|
||||
return _asm.GetTypes();
|
||||
}
|
||||
catch
|
||||
{
|
||||
return Enumerable.Empty<Type>();
|
||||
}
|
||||
})
|
||||
.Where(_assemblyType => _assemblyType.IsClass && _assemblyType.BaseType == typeof(Command));
|
||||
|
||||
_logger.LogDebug("Discovered {count} plugin commands", commandTypes.Count());
|
||||
|
||||
configurationTypes = assemblies
|
||||
.SelectMany(asm => {
|
||||
try
|
||||
{
|
||||
return asm.GetTypes();
|
||||
}
|
||||
catch
|
||||
{
|
||||
return Enumerable.Empty<Type>();
|
||||
}
|
||||
})
|
||||
.Where(asmType =>
|
||||
asmType.IsClass && asmType.GetInterface(nameof(IBaseConfiguration), false) != null);
|
||||
|
||||
_logger.LogDebug("Discovered {count} configuration implementations", configurationTypes.Count());
|
||||
}
|
||||
}
|
||||
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
private IEnumerable<Assembly> GetRemoteAssemblies()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_pluginSubscription == null)
|
||||
_pluginSubscription = _masterApi.GetPluginSubscription(Guid.Parse(_appConfig.Id), _appConfig.SubscriptionId).Result;
|
||||
|
||||
return _remoteAssemblyHandler.DecryptAssemblies(_pluginSubscription.Where(sub => sub.Type == PluginType.Binary).Select(sub => sub.Content).ToArray());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Could not load remote assemblies");
|
||||
return Enumerable.Empty<Assembly>();
|
||||
}
|
||||
}
|
||||
|
||||
private IEnumerable<string> GetRemoteScripts()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_pluginSubscription == null)
|
||||
_pluginSubscription = _masterApi.GetPluginSubscription(Guid.Parse(_appConfig.Id), _appConfig.SubscriptionId).Result;
|
||||
|
||||
return _remoteAssemblyHandler.DecryptScripts(_pluginSubscription.Where(sub => sub.Type == PluginType.Script).Select(sub => sub.Content).ToArray());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,"Could not load remote scripts");
|
||||
return Enumerable.Empty<string>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public enum PluginType
|
||||
{
|
||||
Binary,
|
||||
Script
|
||||
}
|
||||
}
|
@ -13,10 +13,10 @@ namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
public class RemoteAssemblyHandler : IRemoteAssemblyHandler
|
||||
{
|
||||
private const int keyLength = 32;
|
||||
private const int tagLength = 16;
|
||||
private const int nonceLength = 12;
|
||||
private const int iterationCount = 10000;
|
||||
private const int KeyLength = 32;
|
||||
private const int TagLength = 16;
|
||||
private const int NonceLength = 12;
|
||||
private const int IterationCount = 10000;
|
||||
|
||||
private readonly ApplicationConfiguration _appconfig;
|
||||
private readonly ILogger _logger;
|
||||
@ -30,7 +30,7 @@ namespace IW4MAdmin.Application.Misc
|
||||
public IEnumerable<Assembly> DecryptAssemblies(string[] encryptedAssemblies)
|
||||
{
|
||||
return DecryptContent(encryptedAssemblies)
|
||||
.Select(decryptedAssembly => Assembly.Load(decryptedAssembly));
|
||||
.Select(Assembly.Load);
|
||||
}
|
||||
|
||||
public IEnumerable<string> DecryptScripts(string[] encryptedScripts)
|
||||
@ -38,24 +38,24 @@ namespace IW4MAdmin.Application.Misc
|
||||
return DecryptContent(encryptedScripts).Select(decryptedScript => Encoding.UTF8.GetString(decryptedScript));
|
||||
}
|
||||
|
||||
private byte[][] DecryptContent(string[] content)
|
||||
private IEnumerable<byte[]> DecryptContent(string[] content)
|
||||
{
|
||||
if (string.IsNullOrEmpty(_appconfig.Id) || string.IsNullOrWhiteSpace(_appconfig.SubscriptionId))
|
||||
{
|
||||
_logger.LogWarning($"{nameof(_appconfig.Id)} and {nameof(_appconfig.SubscriptionId)} must be provided to attempt loading remote assemblies/scripts");
|
||||
return new byte[0][];
|
||||
return Array.Empty<byte[]>();
|
||||
}
|
||||
|
||||
var assemblies = content.Select(piece =>
|
||||
{
|
||||
byte[] byteContent = Convert.FromBase64String(piece);
|
||||
byte[] encryptedContent = byteContent.Take(byteContent.Length - (tagLength + nonceLength)).ToArray();
|
||||
byte[] tag = byteContent.Skip(byteContent.Length - (tagLength + nonceLength)).Take(tagLength).ToArray();
|
||||
byte[] nonce = byteContent.Skip(byteContent.Length - nonceLength).Take(nonceLength).ToArray();
|
||||
byte[] decryptedContent = new byte[encryptedContent.Length];
|
||||
var byteContent = Convert.FromBase64String(piece);
|
||||
var encryptedContent = byteContent.Take(byteContent.Length - (TagLength + NonceLength)).ToArray();
|
||||
var tag = byteContent.Skip(byteContent.Length - (TagLength + NonceLength)).Take(TagLength).ToArray();
|
||||
var nonce = byteContent.Skip(byteContent.Length - NonceLength).Take(NonceLength).ToArray();
|
||||
var decryptedContent = new byte[encryptedContent.Length];
|
||||
|
||||
var keyGen = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(_appconfig.SubscriptionId), Encoding.UTF8.GetBytes(_appconfig.Id.ToString()), iterationCount, HashAlgorithmName.SHA512);
|
||||
var encryption = new AesGcm(keyGen.GetBytes(keyLength));
|
||||
var keyGen = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(_appconfig.SubscriptionId), Encoding.UTF8.GetBytes(_appconfig.Id), IterationCount, HashAlgorithmName.SHA512);
|
||||
var encryption = new AesGcm(keyGen.GetBytes(KeyLength));
|
||||
|
||||
try
|
||||
{
|
||||
|
109
Application/Misc/RemoteCommandService.cs
Normal file
109
Application/Misc/RemoteCommandService.cs
Normal file
@ -0,0 +1,109 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.Services;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class RemoteCommandService : IRemoteCommandService
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly ClientService _clientService;
|
||||
|
||||
public RemoteCommandService(ILogger<RemoteCommandService> logger, ApplicationConfiguration appConfig, ClientService clientService)
|
||||
{
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
_clientService = clientService;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<CommandResponseInfo>> Execute(int originId, int? targetId, string command,
|
||||
IEnumerable<string> arguments, Server server)
|
||||
{
|
||||
var (_, result) = await ExecuteWithResult(originId, targetId, command, arguments, server);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public async Task<(bool, IEnumerable<CommandResponseInfo>)> ExecuteWithResult(int originId, int? targetId, string command,
|
||||
IEnumerable<string> arguments, Server server)
|
||||
{
|
||||
if (originId < 1)
|
||||
{
|
||||
_logger.LogWarning("Not executing command {Command} for {Originid} because origin id is invalid", command,
|
||||
originId);
|
||||
return (false, Enumerable.Empty<CommandResponseInfo>());
|
||||
}
|
||||
|
||||
var client = await _clientService.Get(originId);
|
||||
client.CurrentServer = server;
|
||||
|
||||
command += $" {(targetId.HasValue ? $"@{targetId} " : "")}{string.Join(" ", arguments ?? Enumerable.Empty<string>())}";
|
||||
|
||||
var remoteEvent = new GameEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = command.StartsWith(_appConfig.CommandPrefix) ||
|
||||
command.StartsWith(_appConfig.BroadcastCommandPrefix)
|
||||
? command
|
||||
: $"{_appConfig.CommandPrefix}{command}",
|
||||
Origin = client,
|
||||
Owner = server,
|
||||
IsRemote = true,
|
||||
CorrelationId = Guid.NewGuid()
|
||||
};
|
||||
|
||||
server.Manager.AddEvent(remoteEvent);
|
||||
CommandResponseInfo[] response;
|
||||
|
||||
try
|
||||
{
|
||||
// wait for the event to process
|
||||
var completedEvent =
|
||||
await remoteEvent.WaitAsync(Utilities.DefaultCommandTimeout, server.Manager.CancellationToken);
|
||||
|
||||
if (completedEvent.FailReason == GameEvent.EventFailReason.Timeout)
|
||||
{
|
||||
response = new[]
|
||||
{
|
||||
new CommandResponseInfo
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Response = Utilities.CurrentLocalization.LocalizationIndex["SERVER_ERROR_COMMAND_TIMEOUT"]
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
response = completedEvent.Output.Select(output => new CommandResponseInfo()
|
||||
{
|
||||
Response = output,
|
||||
ClientId = client.ClientId
|
||||
}).ToArray();
|
||||
}
|
||||
}
|
||||
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
response = new[]
|
||||
{
|
||||
new CommandResponseInfo
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Response = Utilities.CurrentLocalization.LocalizationIndex["COMMANDS_RESTART_SUCCESS"]
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return (!remoteEvent.Failed, response);
|
||||
}
|
||||
}
|
@ -1,365 +0,0 @@
|
||||
using System;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Jint.Runtime;
|
||||
using Microsoft.CSharp.RuntimeBinder;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IPlugin
|
||||
/// used to proxy script plugin requests
|
||||
/// </summary>
|
||||
public class ScriptPlugin : IPlugin
|
||||
{
|
||||
public string Name { get; set; }
|
||||
|
||||
public float Version { get; set; }
|
||||
|
||||
public string Author { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// indicates if the plugin is a parser
|
||||
/// </summary>
|
||||
public bool IsParser { get; private set; }
|
||||
|
||||
public FileSystemWatcher Watcher { get; private set; }
|
||||
|
||||
private Engine _scriptEngine;
|
||||
private readonly string _fileName;
|
||||
private readonly SemaphoreSlim _onProcessing;
|
||||
private bool successfullyLoaded;
|
||||
private readonly List<string> _registeredCommandNames;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public ScriptPlugin(ILogger logger, string filename, string workingDirectory = null)
|
||||
{
|
||||
_logger = logger;
|
||||
_fileName = filename;
|
||||
Watcher = new FileSystemWatcher()
|
||||
{
|
||||
Path = workingDirectory == null ? $"{Utilities.OperatingDirectory}Plugins{Path.DirectorySeparatorChar}" : workingDirectory,
|
||||
NotifyFilter = NotifyFilters.Size,
|
||||
Filter = _fileName.Split(Path.DirectorySeparatorChar).Last()
|
||||
};
|
||||
|
||||
Watcher.EnableRaisingEvents = true;
|
||||
_onProcessing = new SemaphoreSlim(1, 1);
|
||||
_registeredCommandNames = new List<string>();
|
||||
}
|
||||
|
||||
~ScriptPlugin()
|
||||
{
|
||||
Watcher.Dispose();
|
||||
_onProcessing.Dispose();
|
||||
}
|
||||
|
||||
public async Task Initialize(IManager manager, IScriptCommandFactory scriptCommandFactory, IScriptPluginServiceResolver serviceResolver)
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
try
|
||||
{
|
||||
// for some reason we get an event trigger when the file is not finished being modified.
|
||||
// this must have been a change in .NET CORE 3.x
|
||||
// so if the new file is empty we can't process it yet
|
||||
if (new FileInfo(_fileName).Length == 0L)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
bool firstRun = _scriptEngine == null;
|
||||
|
||||
// it's been loaded before so we need to call the unload event
|
||||
if (!firstRun)
|
||||
{
|
||||
await OnUnloadAsync();
|
||||
|
||||
foreach (string commandName in _registeredCommandNames)
|
||||
{
|
||||
_logger.LogDebug("Removing plugin registered command {command}", commandName);
|
||||
manager.RemoveCommandByName(commandName);
|
||||
}
|
||||
|
||||
_registeredCommandNames.Clear();
|
||||
}
|
||||
|
||||
successfullyLoaded = false;
|
||||
string script;
|
||||
|
||||
using (var stream = new FileStream(_fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
||||
{
|
||||
using (var reader = new StreamReader(stream, Encoding.Default))
|
||||
{
|
||||
script = await reader.ReadToEndAsync();
|
||||
}
|
||||
}
|
||||
|
||||
_scriptEngine = new Engine(cfg =>
|
||||
cfg.AllowClr(new[]
|
||||
{
|
||||
typeof(System.Net.Http.HttpClient).Assembly,
|
||||
typeof(EFClient).Assembly,
|
||||
typeof(Utilities).Assembly,
|
||||
typeof(Encoding).Assembly
|
||||
})
|
||||
.CatchClrExceptions());
|
||||
|
||||
try
|
||||
{
|
||||
_scriptEngine.Execute(script);
|
||||
}
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {methodName} for script plugin {plugin} at {@locationInfo}",
|
||||
nameof(Initialize), _fileName, ex.Location);
|
||||
throw new PluginException($"A JavaScript parsing error occured while initializing script plugin");
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
|
||||
_logger.LogError(e,
|
||||
"Encountered unexpected error while running {methodName} for script plugin {plugin}",
|
||||
nameof(Initialize), _fileName);
|
||||
throw new PluginException($"An unexpected error occured while initialization script plugin");
|
||||
}
|
||||
|
||||
_scriptEngine.SetValue("_localization", Utilities.CurrentLocalization);
|
||||
_scriptEngine.SetValue("_serviceResolver", serviceResolver);
|
||||
dynamic pluginObject = _scriptEngine.GetValue("plugin").ToObject();
|
||||
|
||||
Author = pluginObject.author;
|
||||
Name = pluginObject.name;
|
||||
Version = (float)pluginObject.version;
|
||||
|
||||
var commands = _scriptEngine.GetValue("commands");
|
||||
|
||||
if (commands != JsValue.Undefined)
|
||||
{
|
||||
try
|
||||
{
|
||||
foreach (var command in GenerateScriptCommands(commands, scriptCommandFactory))
|
||||
{
|
||||
_logger.LogDebug("Adding plugin registered command {commandName}", command.Name);
|
||||
manager.AddAdditionalCommand(command);
|
||||
_registeredCommandNames.Add(command.Name);
|
||||
}
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException e)
|
||||
{
|
||||
throw new PluginException($"Not all required fields were found: {e.Message}") { PluginFile = _fileName };
|
||||
}
|
||||
}
|
||||
|
||||
_scriptEngine.SetValue("_configHandler", new ScriptPluginConfigurationWrapper(Name, _scriptEngine));
|
||||
await OnLoadAsync(manager);
|
||||
|
||||
try
|
||||
{
|
||||
if (pluginObject.isParser)
|
||||
{
|
||||
IsParser = true;
|
||||
IEventParser eventParser = (IEventParser)_scriptEngine.GetValue("eventParser").ToObject();
|
||||
IRConParser rconParser = (IRConParser)_scriptEngine.GetValue("rconParser").ToObject();
|
||||
manager.AdditionalEventParsers.Add(eventParser);
|
||||
manager.AdditionalRConParsers.Add(rconParser);
|
||||
}
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException) { }
|
||||
|
||||
if (!firstRun)
|
||||
{
|
||||
await OnLoadAsync(manager);
|
||||
}
|
||||
|
||||
successfullyLoaded = true;
|
||||
}
|
||||
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {methodName} for script plugin {plugin} initialization {@locationInfo}",
|
||||
nameof(OnLoadAsync), _fileName, ex.Location);
|
||||
|
||||
throw new PluginException("An error occured while initializing script plugin");
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered unexpected error while running {methodName} for script plugin {plugin}",
|
||||
nameof(OnLoadAsync), _fileName);
|
||||
|
||||
throw new PluginException("An unexpected error occured while initializing script plugin");
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task OnEventAsync(GameEvent E, Server S)
|
||||
{
|
||||
if (successfullyLoaded)
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
try
|
||||
{
|
||||
_scriptEngine.SetValue("_gameEvent", E);
|
||||
_scriptEngine.SetValue("_server", S);
|
||||
_scriptEngine.SetValue("_IW4MAdminClient", Utilities.IW4MAdminClient(S));
|
||||
_scriptEngine.Execute("plugin.onEventAsync(_gameEvent, _server)").GetCompletionValue();
|
||||
}
|
||||
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", S.ToString()))
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {methodName} for script plugin {plugin} with event type {eventType} {@locationInfo}",
|
||||
nameof(OnEventAsync), _fileName, E.Type, ex.Location);
|
||||
}
|
||||
|
||||
throw new PluginException($"An error occured while executing action for script plugin");
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", S.ToString()))
|
||||
{
|
||||
_logger.LogError(e,
|
||||
"Encountered unexpected error while running {methodName} for script plugin {plugin} with event type {eventType}",
|
||||
nameof(OnEventAsync), _fileName, E.Type);
|
||||
}
|
||||
|
||||
throw new PluginException($"An error occured while executing action for script plugin");
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task OnLoadAsync(IManager manager)
|
||||
{
|
||||
_logger.LogDebug("OnLoad executing for {name}", Name);
|
||||
_scriptEngine.SetValue("_manager", manager);
|
||||
await Task.FromResult(_scriptEngine.Execute("plugin.onLoadAsync(_manager)").GetCompletionValue());
|
||||
}
|
||||
|
||||
public async Task OnTickAsync(Server S)
|
||||
{
|
||||
_scriptEngine.SetValue("_server", S);
|
||||
await Task.FromResult(_scriptEngine.Execute("plugin.onTickAsync(_server)").GetCompletionValue());
|
||||
}
|
||||
|
||||
public async Task OnUnloadAsync()
|
||||
{
|
||||
if (successfullyLoaded)
|
||||
{
|
||||
await Task.FromResult(_scriptEngine.Execute("plugin.onUnloadAsync()").GetCompletionValue());
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// finds declared script commands in the script plugin
|
||||
/// </summary>
|
||||
/// <param name="commands">commands value from jint parser</param>
|
||||
/// <param name="scriptCommandFactory">factory to create the command from</param>
|
||||
/// <returns></returns>
|
||||
public IEnumerable<IManagerCommand> GenerateScriptCommands(JsValue commands, IScriptCommandFactory scriptCommandFactory)
|
||||
{
|
||||
List<IManagerCommand> commandList = new List<IManagerCommand>();
|
||||
|
||||
// go through each defined command
|
||||
foreach (var command in commands.AsArray())
|
||||
{
|
||||
dynamic dynamicCommand = command.ToObject();
|
||||
string name = dynamicCommand.name;
|
||||
string alias = dynamicCommand.alias;
|
||||
string description = dynamicCommand.description;
|
||||
string permission = dynamicCommand.permission;
|
||||
bool targetRequired = false;
|
||||
|
||||
List<(string, bool)> args = new List<(string, bool)>();
|
||||
dynamic arguments = null;
|
||||
|
||||
try
|
||||
{
|
||||
arguments = dynamicCommand.arguments;
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// arguments are optional
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
targetRequired = dynamicCommand.targetRequired;
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// arguments are optional
|
||||
}
|
||||
|
||||
if (arguments != null)
|
||||
{
|
||||
foreach (var arg in dynamicCommand.arguments)
|
||||
{
|
||||
args.Add((arg.name, (bool)arg.required));
|
||||
}
|
||||
}
|
||||
|
||||
void execute(GameEvent e)
|
||||
{
|
||||
_scriptEngine.SetValue("_event", e);
|
||||
var jsEventObject = _scriptEngine.GetValue("_event");
|
||||
|
||||
try
|
||||
{
|
||||
dynamicCommand.execute.Target.Invoke(jsEventObject);
|
||||
}
|
||||
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
throw new PluginException($"An error occured while executing action for script plugin: {ex.Error} (Line: {ex.Location.Start.Line}, Character: {ex.Location.Start.Column})") { PluginFile = _fileName };
|
||||
}
|
||||
}
|
||||
|
||||
commandList.Add(scriptCommandFactory.CreateScriptCommand(name, alias, description, permission, targetRequired, args, execute));
|
||||
}
|
||||
|
||||
return commandList;
|
||||
}
|
||||
}
|
||||
}
|
@ -1,90 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Newtonsoft.Json.Linq;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
public class ScriptPluginConfigurationWrapper
|
||||
{
|
||||
private readonly BaseConfigurationHandler<ScriptPluginConfiguration> _handler;
|
||||
private readonly ScriptPluginConfiguration _config;
|
||||
private readonly string _pluginName;
|
||||
private readonly Engine _scriptEngine;
|
||||
|
||||
public ScriptPluginConfigurationWrapper(string pluginName, Engine scriptEngine)
|
||||
{
|
||||
_handler = new BaseConfigurationHandler<ScriptPluginConfiguration>("ScriptPluginSettings");
|
||||
_config = _handler.Configuration() ??
|
||||
(ScriptPluginConfiguration) new ScriptPluginConfiguration().Generate();
|
||||
_pluginName = pluginName;
|
||||
_scriptEngine = scriptEngine;
|
||||
}
|
||||
|
||||
private static int? AsInteger(double d)
|
||||
{
|
||||
return int.TryParse(d.ToString(CultureInfo.InvariantCulture), out var parsed) ? parsed : (int?) null;
|
||||
}
|
||||
|
||||
public async Task SetValue(string key, object value)
|
||||
{
|
||||
var castValue = value;
|
||||
|
||||
if (value is double d)
|
||||
{
|
||||
castValue = AsInteger(d) ?? value;
|
||||
}
|
||||
|
||||
if (value is object[] array && array.All(item => item is double d && AsInteger(d) != null))
|
||||
{
|
||||
castValue = array.Select(item => AsInteger((double)item)).ToArray();
|
||||
}
|
||||
|
||||
if (!_config.ContainsKey(_pluginName))
|
||||
{
|
||||
_config.Add(_pluginName, new Dictionary<string, object>());
|
||||
}
|
||||
|
||||
var plugin = _config[_pluginName];
|
||||
|
||||
if (plugin.ContainsKey(key))
|
||||
{
|
||||
plugin[key] = castValue;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
plugin.Add(key, castValue);
|
||||
}
|
||||
|
||||
_handler.Set(_config);
|
||||
await _handler.Save();
|
||||
}
|
||||
|
||||
public JsValue GetValue(string key)
|
||||
{
|
||||
if (!_config.ContainsKey(_pluginName))
|
||||
{
|
||||
return JsValue.Undefined;
|
||||
}
|
||||
|
||||
if (!_config[_pluginName].ContainsKey(key))
|
||||
{
|
||||
return JsValue.Undefined;
|
||||
}
|
||||
|
||||
var item = _config[_pluginName][key];
|
||||
|
||||
if (item is JArray array)
|
||||
{
|
||||
item = array.ToObject<List<dynamic>>();
|
||||
}
|
||||
|
||||
return JsValue.FromObject(_scriptEngine, item);
|
||||
}
|
||||
}
|
||||
}
|
@ -12,8 +12,10 @@ using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Events.Management;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.Interfaces.Events;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
@ -24,28 +26,20 @@ namespace IW4MAdmin.Application.Misc
|
||||
private readonly IManager _manager;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly IEventPublisher _eventPublisher;
|
||||
|
||||
private bool _inProgress;
|
||||
private TimeSpan _period;
|
||||
|
||||
public ServerDataCollector(ILogger<ServerDataCollector> logger, ApplicationConfiguration appConfig,
|
||||
IManager manager, IDatabaseContextFactory contextFactory, IEventPublisher eventPublisher)
|
||||
IManager manager, IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
_manager = manager;
|
||||
_contextFactory = contextFactory;
|
||||
_eventPublisher = eventPublisher;
|
||||
|
||||
_eventPublisher.OnClientConnect += SaveConnectionInfo;
|
||||
_eventPublisher.OnClientDisconnect += SaveConnectionInfo;
|
||||
}
|
||||
|
||||
~ServerDataCollector()
|
||||
{
|
||||
_eventPublisher.OnClientConnect -= SaveConnectionInfo;
|
||||
_eventPublisher.OnClientDisconnect -= SaveConnectionInfo;
|
||||
IManagementEventSubscriptions.ClientStateAuthorized += SaveConnectionInfo;
|
||||
IManagementEventSubscriptions.ClientStateDisposed += SaveConnectionInfo;
|
||||
}
|
||||
|
||||
public async Task BeginCollectionAsync(TimeSpan? period = null, CancellationToken cancellationToken = default)
|
||||
@ -94,7 +88,8 @@ namespace IW4MAdmin.Application.Misc
|
||||
PeriodBlock = (int) (DateTimeOffset.UtcNow - DateTimeOffset.UnixEpoch).TotalMinutes,
|
||||
ServerId = await server.GetIdForServer(),
|
||||
MapId = await GetOrCreateMap(server.CurrentMap.Name, (Reference.Game) server.GameName, token),
|
||||
ClientCount = server.ClientNum
|
||||
ClientCount = server.ClientNum,
|
||||
ConnectionInterrupted = server.Throttled,
|
||||
}));
|
||||
|
||||
return data;
|
||||
@ -130,18 +125,19 @@ namespace IW4MAdmin.Application.Misc
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
private void SaveConnectionInfo(object sender, GameEvent gameEvent)
|
||||
private async Task SaveConnectionInfo(ClientStateEvent stateEvent, CancellationToken token)
|
||||
{
|
||||
using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
context.ConnectionHistory.Add(new EFClientConnectionHistory
|
||||
{
|
||||
ClientId = gameEvent.Origin.ClientId,
|
||||
ServerId = gameEvent.Owner.GetIdForServer().Result,
|
||||
ConnectionType = gameEvent.Type == GameEvent.EventType.Connect
|
||||
ClientId = stateEvent.Client.ClientId,
|
||||
ServerId = await stateEvent.Client.CurrentServer.GetIdForServer(),
|
||||
ConnectionType = stateEvent is ClientStateAuthorizeEvent
|
||||
? Reference.ConnectionType.Connect
|
||||
: Reference.ConnectionType.Disconnect
|
||||
});
|
||||
context.SaveChanges();
|
||||
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -4,7 +4,9 @@ using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Data.Models.Client.Stats;
|
||||
using Data.Models.Server;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
@ -22,36 +24,48 @@ namespace IW4MAdmin.Application.Misc
|
||||
private readonly IDataValueCache<EFServerSnapshot, (int?, DateTime?)> _snapshotCache;
|
||||
private readonly IDataValueCache<EFClient, (int, int)> _serverStatsCache;
|
||||
private readonly IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> _clientHistoryCache;
|
||||
private readonly IDataValueCache<EFClientRankingHistory, int> _rankedClientsCache;
|
||||
|
||||
private readonly TimeSpan? _cacheTimeSpan =
|
||||
Utilities.IsDevelopment ? TimeSpan.FromSeconds(30) : (TimeSpan?) TimeSpan.FromMinutes(10);
|
||||
|
||||
public ServerDataViewer(ILogger<ServerDataViewer> logger, IDataValueCache<EFServerSnapshot, (int?, DateTime?)> snapshotCache,
|
||||
IDataValueCache<EFClient, (int, int)> serverStatsCache,
|
||||
IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> clientHistoryCache)
|
||||
IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> clientHistoryCache, IDataValueCache<EFClientRankingHistory, int> rankedClientsCache)
|
||||
{
|
||||
_logger = logger;
|
||||
_snapshotCache = snapshotCache;
|
||||
_serverStatsCache = serverStatsCache;
|
||||
_clientHistoryCache = clientHistoryCache;
|
||||
_rankedClientsCache = rankedClientsCache;
|
||||
}
|
||||
|
||||
public async Task<(int?, DateTime?)>
|
||||
MaxConcurrentClientsAsync(long? serverId = null, TimeSpan? overPeriod = null,
|
||||
MaxConcurrentClientsAsync(long? serverId = null, Reference.Game? gameCode = null, TimeSpan? overPeriod = null,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
_snapshotCache.SetCacheItem(async (snapshots, cancellationToken) =>
|
||||
_snapshotCache.SetCacheItem(async (snapshots, ids, cancellationToken) =>
|
||||
{
|
||||
Reference.Game? game = null;
|
||||
long? id = null;
|
||||
|
||||
if (ids.Any())
|
||||
{
|
||||
game = (Reference.Game?)ids.First();
|
||||
id = (long?)ids.Last();
|
||||
}
|
||||
|
||||
var oldestEntry = overPeriod.HasValue
|
||||
? DateTime.UtcNow - overPeriod.Value
|
||||
: DateTime.UtcNow.AddDays(-1);
|
||||
|
||||
|
||||
int? maxClients;
|
||||
DateTime? maxClientsTime;
|
||||
|
||||
if (serverId != null)
|
||||
if (id != null)
|
||||
{
|
||||
var clients = await snapshots.Where(snapshot => snapshot.ServerId == serverId)
|
||||
var clients = await snapshots.Where(snapshot => snapshot.ServerId == id)
|
||||
.Where(snapshot => game == null || snapshot.Server.GameName == game)
|
||||
.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
|
||||
.OrderByDescending(snapshot => snapshot.ClientCount)
|
||||
.Select(snapshot => new
|
||||
@ -68,15 +82,16 @@ namespace IW4MAdmin.Application.Misc
|
||||
else
|
||||
{
|
||||
var clients = await snapshots.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
|
||||
.Where(snapshot => game == null || snapshot.Server.GameName == game)
|
||||
.GroupBy(snapshot => snapshot.PeriodBlock)
|
||||
.Select(grp => new
|
||||
{
|
||||
ClientCount = grp.Sum(snapshot => (int?) snapshot.ClientCount),
|
||||
Time = grp.Max(snapshot => (DateTime?) snapshot.CapturedAt)
|
||||
ClientCount = grp.Sum(snapshot => (int?)snapshot.ClientCount),
|
||||
Time = grp.Max(snapshot => (DateTime?)snapshot.CapturedAt)
|
||||
})
|
||||
.OrderByDescending(snapshot => snapshot.ClientCount)
|
||||
.FirstOrDefaultAsync(cancellationToken);
|
||||
|
||||
|
||||
maxClients = clients?.ClientCount;
|
||||
maxClientsTime = clients?.Time;
|
||||
}
|
||||
@ -84,11 +99,12 @@ namespace IW4MAdmin.Application.Misc
|
||||
_logger.LogDebug("Max concurrent clients since {Start} is {Clients}", oldestEntry, maxClients);
|
||||
|
||||
return (maxClients, maxClientsTime);
|
||||
}, nameof(MaxConcurrentClientsAsync), _cacheTimeSpan, true);
|
||||
}, nameof(MaxConcurrentClientsAsync), new object[] { gameCode, serverId }, _cacheTimeSpan, true);
|
||||
|
||||
try
|
||||
{
|
||||
return await _snapshotCache.GetCacheItem(nameof(MaxConcurrentClientsAsync), token);
|
||||
return await _snapshotCache.GetCacheItem(nameof(MaxConcurrentClientsAsync),
|
||||
new object[] { gameCode, serverId }, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
@ -97,22 +113,30 @@ namespace IW4MAdmin.Application.Misc
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<(int, int)> ClientCountsAsync(TimeSpan? overPeriod = null, CancellationToken token = default)
|
||||
public async Task<(int, int)> ClientCountsAsync(TimeSpan? overPeriod = null, Reference.Game? gameCode = null, CancellationToken token = default)
|
||||
{
|
||||
_serverStatsCache.SetCacheItem(async (set, cancellationToken) =>
|
||||
_serverStatsCache.SetCacheItem(async (set, ids, cancellationToken) =>
|
||||
{
|
||||
var count = await set.CountAsync(cancellationToken);
|
||||
Reference.Game? game = null;
|
||||
|
||||
if (ids.Any())
|
||||
{
|
||||
game = (Reference.Game?)ids.First();
|
||||
}
|
||||
|
||||
var count = await set.CountAsync(item => game == null || item.GameName == game,
|
||||
cancellationToken);
|
||||
var startOfPeriod =
|
||||
DateTime.UtcNow.AddHours(-overPeriod?.TotalHours ?? -24);
|
||||
var recentCount = await set.CountAsync(client => client.LastConnection >= startOfPeriod,
|
||||
var recentCount = await set.CountAsync(client => (game == null || client.GameName == game) && client.LastConnection >= startOfPeriod,
|
||||
cancellationToken);
|
||||
|
||||
return (count, recentCount);
|
||||
}, nameof(_serverStatsCache), _cacheTimeSpan, true);
|
||||
}, nameof(_serverStatsCache), new object[] { gameCode }, _cacheTimeSpan, true);
|
||||
|
||||
try
|
||||
{
|
||||
return await _serverStatsCache.GetCacheItem(nameof(_serverStatsCache), token);
|
||||
return await _serverStatsCache.GetCacheItem(nameof(_serverStatsCache), new object[] { gameCode }, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
@ -135,7 +159,9 @@ namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
snapshot.ServerId,
|
||||
snapshot.CapturedAt,
|
||||
snapshot.ClientCount
|
||||
snapshot.ClientCount,
|
||||
snapshot.ConnectionInterrupted,
|
||||
MapName = snapshot.Map.Name,
|
||||
})
|
||||
.OrderBy(snapshot => snapshot.CapturedAt)
|
||||
.ToListAsync(cancellationToken);
|
||||
@ -143,8 +169,8 @@ namespace IW4MAdmin.Application.Misc
|
||||
return history.GroupBy(snapshot => snapshot.ServerId).Select(byServer => new ClientHistoryInfo
|
||||
{
|
||||
ServerId = byServer.Key,
|
||||
ClientCounts = byServer.Select(snapshot => new ClientCountSnapshot()
|
||||
{Time = snapshot.CapturedAt, ClientCount = snapshot.ClientCount}).ToList()
|
||||
ClientCounts = byServer.Select(snapshot => new ClientCountSnapshot
|
||||
{ Time = snapshot.CapturedAt, ClientCount = snapshot.ClientCount, ConnectionInterrupted = snapshot.ConnectionInterrupted ?? false, Map = snapshot.MapName}).ToList()
|
||||
}).ToList();
|
||||
}, nameof(_clientHistoryCache), TimeSpan.MaxValue);
|
||||
|
||||
@ -158,5 +184,37 @@ namespace IW4MAdmin.Application.Misc
|
||||
return Enumerable.Empty<ClientHistoryInfo>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<int> RankedClientsCountAsync(long? serverId = null, CancellationToken token = default)
|
||||
{
|
||||
_rankedClientsCache.SetCacheItem((set, ids, cancellationToken) =>
|
||||
{
|
||||
long? id = null;
|
||||
|
||||
if (ids.Any())
|
||||
{
|
||||
id = (long?)ids.First();
|
||||
}
|
||||
|
||||
var fifteenDaysAgo = DateTime.UtcNow.AddDays(-15);
|
||||
return set
|
||||
.Where(rating => rating.Newest)
|
||||
.Where(rating => rating.ServerId == id)
|
||||
.Where(rating => rating.CreatedDateTime >= fifteenDaysAgo)
|
||||
.Where(rating => rating.Client.Level != EFClient.Permission.Banned)
|
||||
.Where(rating => rating.Ranking != null)
|
||||
.CountAsync(cancellationToken);
|
||||
}, nameof(_rankedClientsCache), new object[] { serverId }, _cacheTimeSpan);
|
||||
|
||||
try
|
||||
{
|
||||
return await _rankedClientsCache.GetCacheItem(nameof(_rankedClientsCache), new object[] { serverId }, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not retrieve data for {Name}", nameof(RankedClientsCountAsync));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -9,40 +9,41 @@ namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
internal class TokenAuthentication : ITokenAuthentication
|
||||
{
|
||||
private readonly ConcurrentDictionary<long, TokenState> _tokens;
|
||||
private readonly ConcurrentDictionary<int, TokenState> _tokens;
|
||||
private readonly RandomNumberGenerator _random;
|
||||
private static readonly TimeSpan TimeoutPeriod = new TimeSpan(0, 0, 120);
|
||||
private static readonly TimeSpan TimeoutPeriod = new(0, 0, 120);
|
||||
private const short TokenLength = 4;
|
||||
|
||||
public TokenAuthentication()
|
||||
{
|
||||
_tokens = new ConcurrentDictionary<long, TokenState>();
|
||||
_tokens = new ConcurrentDictionary<int, TokenState>();
|
||||
_random = RandomNumberGenerator.Create();
|
||||
}
|
||||
|
||||
public bool AuthorizeToken(long networkId, string token)
|
||||
public bool AuthorizeToken(ITokenIdentifier authInfo)
|
||||
{
|
||||
var authorizeSuccessful = _tokens.ContainsKey(networkId) && _tokens[networkId].Token == token;
|
||||
var authorizeSuccessful = _tokens.ContainsKey(authInfo.ClientId) &&
|
||||
_tokens[authInfo.ClientId].Token == authInfo.Token;
|
||||
|
||||
if (authorizeSuccessful)
|
||||
{
|
||||
_tokens.TryRemove(networkId, out _);
|
||||
_tokens.TryRemove(authInfo.ClientId, out _);
|
||||
}
|
||||
|
||||
return authorizeSuccessful;
|
||||
}
|
||||
|
||||
public TokenState GenerateNextToken(long networkId)
|
||||
public TokenState GenerateNextToken(ITokenIdentifier authInfo)
|
||||
{
|
||||
TokenState state;
|
||||
|
||||
if (_tokens.ContainsKey(networkId))
|
||||
if (_tokens.ContainsKey(authInfo.ClientId))
|
||||
{
|
||||
state = _tokens[networkId];
|
||||
state = _tokens[authInfo.ClientId];
|
||||
|
||||
if ((DateTime.Now - state.RequestTime) > TimeoutPeriod)
|
||||
if (DateTime.Now - state.RequestTime > TimeoutPeriod)
|
||||
{
|
||||
_tokens.TryRemove(networkId, out _);
|
||||
_tokens.TryRemove(authInfo.ClientId, out _);
|
||||
}
|
||||
|
||||
else
|
||||
@ -53,17 +54,16 @@ namespace IW4MAdmin.Application.Misc
|
||||
|
||||
state = new TokenState
|
||||
{
|
||||
NetworkId = networkId,
|
||||
Token = _generateToken(),
|
||||
TokenDuration = TimeoutPeriod
|
||||
};
|
||||
|
||||
_tokens.TryAdd(networkId, state);
|
||||
_tokens.TryAdd(authInfo.ClientId, state);
|
||||
|
||||
// perform some housekeeping so we don't have built up tokens if they're not ever used
|
||||
foreach (var (key, value) in _tokens)
|
||||
{
|
||||
if ((DateTime.Now - value.RequestTime) > TimeoutPeriod)
|
||||
if (DateTime.Now - value.RequestTime > TimeoutPeriod)
|
||||
{
|
||||
_tokens.TryRemove(key, out _);
|
||||
}
|
||||
|
207
Application/Plugin/PluginImporter.cs
Normal file
207
Application/Plugin/PluginImporter.cs
Normal file
@ -0,0 +1,207 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Text.RegularExpressions;
|
||||
using IW4MAdmin.Application.API.Master;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IPluginImporter
|
||||
/// discovers plugins and script plugins
|
||||
/// </summary>
|
||||
public class PluginImporter : IPluginImporter
|
||||
{
|
||||
private IEnumerable<PluginSubscriptionContent> _pluginSubscription;
|
||||
private const string PluginDir = "Plugins";
|
||||
private const string PluginV2Match = "^ *((?:var|const|let) +init)|function init";
|
||||
private readonly ILogger _logger;
|
||||
private readonly IRemoteAssemblyHandler _remoteAssemblyHandler;
|
||||
private readonly IMasterApi _masterApi;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
private static readonly Type[] FilterTypes =
|
||||
{
|
||||
typeof(IPlugin),
|
||||
typeof(IPluginV2),
|
||||
typeof(Command),
|
||||
typeof(IBaseConfiguration)
|
||||
};
|
||||
|
||||
public PluginImporter(ILogger<PluginImporter> logger, ApplicationConfiguration appConfig, IMasterApi masterApi,
|
||||
IRemoteAssemblyHandler remoteAssemblyHandler)
|
||||
{
|
||||
_logger = logger;
|
||||
_masterApi = masterApi;
|
||||
_remoteAssemblyHandler = remoteAssemblyHandler;
|
||||
_appConfig = appConfig;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// discovers all the script plugins in the plugins dir
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public IEnumerable<(Type, string)> DiscoverScriptPlugins()
|
||||
{
|
||||
var pluginDir = $"{Utilities.OperatingDirectory}{PluginDir}{Path.DirectorySeparatorChar}";
|
||||
|
||||
if (!Directory.Exists(pluginDir))
|
||||
{
|
||||
return Enumerable.Empty<(Type, string)>();
|
||||
}
|
||||
|
||||
var scriptPluginFiles =
|
||||
Directory.GetFiles(pluginDir, "*.js").AsEnumerable().Union(GetRemoteScripts()).ToList();
|
||||
|
||||
var bothVersionPlugins = scriptPluginFiles.Select(fileName =>
|
||||
{
|
||||
_logger.LogDebug("Discovered script plugin {FileName}", fileName);
|
||||
try
|
||||
{
|
||||
var fileContents = File.ReadAllLines(fileName);
|
||||
var isValidV2 = fileContents.Any(line => Regex.IsMatch(line, PluginV2Match));
|
||||
return isValidV2 ? (typeof(IPluginV2), fileName) : (typeof(IPlugin), fileName);
|
||||
}
|
||||
catch
|
||||
{
|
||||
return (typeof(IPlugin), fileName);
|
||||
}
|
||||
}).ToList();
|
||||
|
||||
return bothVersionPlugins;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// discovers all the C# assembly plugins and commands
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public (IEnumerable<Type>, IEnumerable<Type>, IEnumerable<Type>) DiscoverAssemblyPluginImplementations()
|
||||
{
|
||||
var pluginDir = $"{Utilities.OperatingDirectory}{PluginDir}{Path.DirectorySeparatorChar}";
|
||||
var pluginTypes = new List<Type>();
|
||||
var commandTypes = new List<Type>();
|
||||
var configurationTypes = new List<Type>();
|
||||
|
||||
if (!Directory.Exists(pluginDir))
|
||||
{
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
var dllFileNames = Directory.GetFiles(pluginDir, "*.dll");
|
||||
_logger.LogDebug("Discovered {Count} potential plugin assemblies", dllFileNames.Length);
|
||||
|
||||
if (!dllFileNames.Any())
|
||||
{
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
// we only want to load the most recent assembly in case of duplicates
|
||||
var assemblies = dllFileNames.Select(Assembly.LoadFrom)
|
||||
.Union(GetRemoteAssemblies())
|
||||
.GroupBy(assembly => assembly.FullName).Select(assembly =>
|
||||
assembly.OrderByDescending(asm => asm.GetName().Version).First());
|
||||
|
||||
var eligibleAssemblyTypes = assemblies
|
||||
.SelectMany(asm =>
|
||||
{
|
||||
try
|
||||
{
|
||||
return asm.GetTypes();
|
||||
}
|
||||
catch
|
||||
{
|
||||
return Enumerable.Empty<Type>();
|
||||
}
|
||||
}).Where(type =>
|
||||
FilterTypes.Any(filterType => type.GetInterface(filterType.Name, false) != null) ||
|
||||
(type.IsClass && FilterTypes.Contains(type.BaseType)));
|
||||
|
||||
foreach (var assemblyType in eligibleAssemblyTypes)
|
||||
{
|
||||
var isPlugin =
|
||||
(assemblyType.GetInterface(nameof(IPlugin), false) ??
|
||||
assemblyType.GetInterface(nameof(IPluginV2), false)) != null &&
|
||||
(!assemblyType.Namespace?.StartsWith(nameof(SharedLibraryCore)) ?? false);
|
||||
|
||||
if (isPlugin)
|
||||
{
|
||||
pluginTypes.Add(assemblyType);
|
||||
continue;
|
||||
}
|
||||
|
||||
var isCommand = assemblyType.IsClass && assemblyType.BaseType == typeof(Command) &&
|
||||
(!assemblyType.Namespace?.StartsWith(nameof(SharedLibraryCore)) ?? false);
|
||||
|
||||
if (isCommand)
|
||||
{
|
||||
commandTypes.Add(assemblyType);
|
||||
continue;
|
||||
}
|
||||
|
||||
var isConfiguration = assemblyType.IsClass &&
|
||||
assemblyType.GetInterface(nameof(IBaseConfiguration), false) != null &&
|
||||
(!assemblyType.Namespace?.StartsWith(nameof(SharedLibraryCore)) ?? false);
|
||||
|
||||
if (isConfiguration)
|
||||
{
|
||||
configurationTypes.Add(assemblyType);
|
||||
}
|
||||
}
|
||||
|
||||
_logger.LogDebug("Discovered {Count} plugin implementations", pluginTypes.Count);
|
||||
_logger.LogDebug("Discovered {Count} plugin command implementations", commandTypes.Count);
|
||||
_logger.LogDebug("Discovered {Count} plugin configuration implementations", configurationTypes.Count);
|
||||
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
private IEnumerable<Assembly> GetRemoteAssemblies()
|
||||
{
|
||||
try
|
||||
{
|
||||
_pluginSubscription ??= _masterApi
|
||||
.GetPluginSubscription(Guid.Parse(_appConfig.Id), _appConfig.SubscriptionId).Result;
|
||||
|
||||
return _remoteAssemblyHandler.DecryptAssemblies(_pluginSubscription
|
||||
.Where(sub => sub.Type == PluginType.Binary).Select(sub => sub.Content).ToArray());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Could not load remote assemblies");
|
||||
return Enumerable.Empty<Assembly>();
|
||||
}
|
||||
}
|
||||
|
||||
private IEnumerable<string> GetRemoteScripts()
|
||||
{
|
||||
try
|
||||
{
|
||||
_pluginSubscription ??= _masterApi
|
||||
.GetPluginSubscription(Guid.Parse(_appConfig.Id), _appConfig.SubscriptionId).Result;
|
||||
|
||||
return _remoteAssemblyHandler.DecryptScripts(_pluginSubscription
|
||||
.Where(sub => sub.Type == PluginType.Script).Select(sub => sub.Content).ToArray());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,"Could not load remote scripts");
|
||||
return Enumerable.Empty<string>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public enum PluginType
|
||||
{
|
||||
Binary,
|
||||
Script
|
||||
}
|
||||
}
|
@ -1,29 +1,32 @@
|
||||
using SharedLibraryCore;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using static SharedLibraryCore.Database.Models.EFClient;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
namespace IW4MAdmin.Application.Plugin.Script
|
||||
{
|
||||
/// <summary>
|
||||
/// generic script command implementation
|
||||
/// </summary>
|
||||
public class ScriptCommand : Command
|
||||
{
|
||||
private readonly Action<GameEvent> _executeAction;
|
||||
private readonly Func<GameEvent, Task> _executeAction;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public ScriptCommand(string name, string alias, string description, bool isTargetRequired, EFClient.Permission permission,
|
||||
CommandArgument[] args, Action<GameEvent> executeAction, CommandConfiguration config, ITranslationLookup layout, ILogger<ScriptCommand> logger)
|
||||
public ScriptCommand(string name, string alias, string description, bool isTargetRequired,
|
||||
EFClient.Permission permission,
|
||||
IEnumerable<CommandArgument> args, Func<GameEvent, Task> executeAction, CommandConfiguration config,
|
||||
ITranslationLookup layout, ILogger<ScriptCommand> logger, IEnumerable<Reference.Game> supportedGames)
|
||||
: base(config, layout)
|
||||
{
|
||||
|
||||
_executeAction = executeAction;
|
||||
_logger = logger;
|
||||
Name = name;
|
||||
@ -31,7 +34,8 @@ namespace IW4MAdmin.Application.Misc
|
||||
Description = description;
|
||||
RequiresTarget = isTargetRequired;
|
||||
Permission = permission;
|
||||
Arguments = args;
|
||||
Arguments = args.ToArray();
|
||||
SupportedGames = supportedGames?.Select(game => (Server.Game)game).ToArray();
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent e)
|
||||
@ -43,11 +47,11 @@ namespace IW4MAdmin.Application.Misc
|
||||
|
||||
try
|
||||
{
|
||||
await Task.Run(() => _executeAction(e));
|
||||
await _executeAction(e);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Failed to execute ScriptCommand action for command {command} {@event}", Name, e);
|
||||
_logger.LogError(ex, "Failed to execute ScriptCommand action for command {Command} {@Event}", Name, e);
|
||||
}
|
||||
}
|
||||
}
|
567
Application/Plugin/Script/ScriptPlugin.cs
Normal file
567
Application/Plugin/Script/ScriptPlugin.cs
Normal file
@ -0,0 +1,567 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using IW4MAdmin.Application.Extensions;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Jint.Runtime;
|
||||
using Jint.Runtime.Interop;
|
||||
using Microsoft.CSharp.RuntimeBinder;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IPlugin
|
||||
/// used to proxy script plugin requests
|
||||
/// </summary>
|
||||
public class ScriptPlugin : IPlugin
|
||||
{
|
||||
public string Name { get; set; }
|
||||
|
||||
public float Version { get; set; }
|
||||
|
||||
public string Author { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// indicates if the plugin is a parser
|
||||
/// </summary>
|
||||
public bool IsParser { get; private set; }
|
||||
|
||||
public FileSystemWatcher Watcher { get; }
|
||||
|
||||
private Engine _scriptEngine;
|
||||
private readonly string _fileName;
|
||||
private readonly SemaphoreSlim _onProcessing = new(1, 1);
|
||||
private bool _successfullyLoaded;
|
||||
private readonly List<string> _registeredCommandNames;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public ScriptPlugin(ILogger logger, string filename, string workingDirectory = null)
|
||||
{
|
||||
_logger = logger;
|
||||
_fileName = filename;
|
||||
Watcher = new FileSystemWatcher
|
||||
{
|
||||
Path = workingDirectory ?? $"{Utilities.OperatingDirectory}Plugins{Path.DirectorySeparatorChar}",
|
||||
NotifyFilter = NotifyFilters.LastWrite,
|
||||
Filter = _fileName.Split(Path.DirectorySeparatorChar).Last()
|
||||
};
|
||||
|
||||
Watcher.EnableRaisingEvents = true;
|
||||
_registeredCommandNames = new List<string>();
|
||||
}
|
||||
|
||||
~ScriptPlugin()
|
||||
{
|
||||
Watcher.Dispose();
|
||||
_onProcessing.Dispose();
|
||||
}
|
||||
|
||||
public async Task Initialize(IManager manager, IScriptCommandFactory scriptCommandFactory,
|
||||
IScriptPluginServiceResolver serviceResolver, IConfigurationHandlerV2<ScriptPluginConfiguration> configHandler)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
// for some reason we get an event trigger when the file is not finished being modified.
|
||||
// this must have been a change in .NET CORE 3.x
|
||||
// so if the new file is empty we can't process it yet
|
||||
if (new FileInfo(_fileName).Length == 0L)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var firstRun = _scriptEngine == null;
|
||||
|
||||
// it's been loaded before so we need to call the unload event
|
||||
if (!firstRun)
|
||||
{
|
||||
await OnUnloadAsync();
|
||||
|
||||
foreach (var commandName in _registeredCommandNames)
|
||||
{
|
||||
_logger.LogDebug("Removing plugin registered command {Command}", commandName);
|
||||
manager.RemoveCommandByName(commandName);
|
||||
}
|
||||
|
||||
_registeredCommandNames.Clear();
|
||||
}
|
||||
|
||||
_successfullyLoaded = false;
|
||||
string script;
|
||||
|
||||
await using (var stream =
|
||||
new FileStream(_fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
||||
{
|
||||
using (var reader = new StreamReader(stream, Encoding.Default))
|
||||
{
|
||||
script = await reader.ReadToEndAsync();
|
||||
}
|
||||
}
|
||||
|
||||
_scriptEngine?.Dispose();
|
||||
_scriptEngine = new Engine(cfg =>
|
||||
cfg.AddExtensionMethods(typeof(Utilities), typeof(Enumerable), typeof(Queryable),
|
||||
typeof(ScriptPluginExtensions))
|
||||
.AllowClr(new[]
|
||||
{
|
||||
typeof(System.Net.Http.HttpClient).Assembly,
|
||||
typeof(EFClient).Assembly,
|
||||
typeof(Utilities).Assembly,
|
||||
typeof(Encoding).Assembly,
|
||||
typeof(CancellationTokenSource).Assembly,
|
||||
typeof(Data.Models.Client.EFClient).Assembly,
|
||||
typeof(IW4MAdmin.Plugins.Stats.Plugin).Assembly
|
||||
})
|
||||
.CatchClrExceptions()
|
||||
.AddObjectConverter(new PermissionLevelToStringConverter()));
|
||||
|
||||
_scriptEngine.Execute(script);
|
||||
if (!_scriptEngine.GetValue("init").IsUndefined())
|
||||
{
|
||||
// this is a v2 plugin and we don't want to try to load it
|
||||
Watcher.EnableRaisingEvents = false;
|
||||
Watcher.Dispose();
|
||||
return;
|
||||
}
|
||||
_scriptEngine.SetValue("_localization", Utilities.CurrentLocalization);
|
||||
_scriptEngine.SetValue("_serviceResolver", serviceResolver);
|
||||
dynamic pluginObject = _scriptEngine.Evaluate("plugin").ToObject();
|
||||
|
||||
Author = pluginObject.author;
|
||||
Name = pluginObject.name;
|
||||
Version = (float)pluginObject.version;
|
||||
|
||||
var commands = JsValue.Undefined;
|
||||
try
|
||||
{
|
||||
commands = _scriptEngine.Evaluate("commands");
|
||||
}
|
||||
catch (JavaScriptException)
|
||||
{
|
||||
// ignore because commands aren't defined;
|
||||
}
|
||||
|
||||
if (commands != JsValue.Undefined)
|
||||
{
|
||||
try
|
||||
{
|
||||
foreach (var command in GenerateScriptCommands(commands, scriptCommandFactory))
|
||||
{
|
||||
_logger.LogDebug("Adding plugin registered command {CommandName}", command.Name);
|
||||
manager.AddAdditionalCommand(command);
|
||||
_registeredCommandNames.Add(command.Name);
|
||||
}
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException e)
|
||||
{
|
||||
throw new PluginException($"Not all required fields were found: {e.Message}")
|
||||
{ PluginFile = _fileName };
|
||||
}
|
||||
}
|
||||
|
||||
async Task<bool> OnLoadTask()
|
||||
{
|
||||
await OnLoadAsync(manager);
|
||||
return true;
|
||||
}
|
||||
|
||||
var loadComplete = false;
|
||||
|
||||
try
|
||||
{
|
||||
if (pluginObject.isParser)
|
||||
{
|
||||
loadComplete = await OnLoadTask();
|
||||
IsParser = true;
|
||||
var eventParser = (IEventParser)_scriptEngine.Evaluate("eventParser").ToObject();
|
||||
var rconParser = (IRConParser)_scriptEngine.Evaluate("rconParser").ToObject();
|
||||
manager.AdditionalEventParsers.Add(eventParser);
|
||||
manager.AdditionalRConParsers.Add(rconParser);
|
||||
}
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
var configWrapper = new ScriptPluginConfigurationWrapper(Name, _scriptEngine, configHandler);
|
||||
|
||||
if (!loadComplete)
|
||||
{
|
||||
_scriptEngine.SetValue("_configHandler", configWrapper);
|
||||
loadComplete = await OnLoadTask();
|
||||
}
|
||||
}
|
||||
|
||||
if (!firstRun && !loadComplete)
|
||||
{
|
||||
loadComplete = await OnLoadTask();
|
||||
}
|
||||
|
||||
_successfullyLoaded = loadComplete;
|
||||
}
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace}",
|
||||
nameof(Initialize), Path.GetFileName(_fileName), ex.Location, ex.JavaScriptStackTrace);
|
||||
|
||||
throw new PluginException("An error occured while initializing script plugin");
|
||||
}
|
||||
catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace}",
|
||||
nameof(Initialize), _fileName, jsEx.Location, jsEx.JavaScriptStackTrace);
|
||||
|
||||
throw new PluginException("An error occured while initializing script plugin");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
|
||||
nameof(OnLoadAsync), Path.GetFileName(_fileName));
|
||||
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task OnEventAsync(GameEvent gameEvent, Server server)
|
||||
{
|
||||
if (!_successfullyLoaded)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var shouldRelease = false;
|
||||
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync(Utilities.DefaultCommandTimeout / 2);
|
||||
shouldRelease = true;
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
_scriptEngine.SetValue("_gameEvent", gameEvent);
|
||||
_scriptEngine.SetValue("_server", server);
|
||||
_scriptEngine.SetValue("_IW4MAdminClient", Utilities.IW4MAdminClient(server));
|
||||
return _scriptEngine.Evaluate("plugin.onEventAsync(_gameEvent, _server)");
|
||||
}, new { EventType = gameEvent.Type }, server);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0 && shouldRelease)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Task OnLoadAsync(IManager manager)
|
||||
{
|
||||
_logger.LogDebug("OnLoad executing for {Name}", Name);
|
||||
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
_scriptEngine.SetValue("_manager", manager);
|
||||
return _scriptEngine.Evaluate("plugin.onLoadAsync(_manager)");
|
||||
});
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task OnTickAsync(Server server)
|
||||
{
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public async Task OnUnloadAsync()
|
||||
{
|
||||
if (!_successfullyLoaded)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
_logger.LogDebug("OnUnload executing for {Name}", Name);
|
||||
|
||||
WrapJavaScriptErrorHandling(() => _scriptEngine.Evaluate("plugin.onUnloadAsync()"));
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public T ExecuteAction<T>(Delegate action, CancellationToken token, params object[] param)
|
||||
{
|
||||
var shouldRelease = false;
|
||||
|
||||
try
|
||||
{
|
||||
using var forceTimeout = new CancellationTokenSource(5000);
|
||||
using var combined = CancellationTokenSource.CreateLinkedTokenSource(forceTimeout.Token, token);
|
||||
_onProcessing.Wait(combined.Token);
|
||||
shouldRelease = true;
|
||||
|
||||
_logger.LogDebug("Executing action for {Name}", Name);
|
||||
|
||||
return WrapJavaScriptErrorHandling(T() =>
|
||||
{
|
||||
var args = param.Select(p => JsValue.FromObject(_scriptEngine, p)).ToArray();
|
||||
var result = action.DynamicInvoke(JsValue.Undefined, args);
|
||||
return (T)(result as JsValue)?.ToObject();
|
||||
},
|
||||
new
|
||||
{
|
||||
Params = string.Join(", ",
|
||||
param?.Select(eachParam => $"Type={eachParam?.GetType().Name} Value={eachParam}") ??
|
||||
Enumerable.Empty<string>())
|
||||
});
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0 && shouldRelease)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public T WrapDelegate<T>(Delegate act, CancellationToken token, params object[] args)
|
||||
{
|
||||
var shouldRelease = false;
|
||||
|
||||
try
|
||||
{
|
||||
using var forceTimeout = new CancellationTokenSource(5000);
|
||||
using var combined = CancellationTokenSource.CreateLinkedTokenSource(forceTimeout.Token, token);
|
||||
_onProcessing.Wait(combined.Token);
|
||||
shouldRelease = true;
|
||||
|
||||
_logger.LogDebug("Wrapping delegate action for {Name}", Name);
|
||||
|
||||
return WrapJavaScriptErrorHandling(
|
||||
T() => (T)(act.DynamicInvoke(JsValue.Null,
|
||||
args.Select(arg => JsValue.FromObject(_scriptEngine, arg)).ToArray()) as ObjectWrapper)
|
||||
?.ToObject(),
|
||||
new
|
||||
{
|
||||
Params = string.Join(", ",
|
||||
args?.Select(eachParam => $"Type={eachParam?.GetType().Name} Value={eachParam}") ??
|
||||
Enumerable.Empty<string>())
|
||||
});
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0 && shouldRelease)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// finds declared script commands in the script plugin
|
||||
/// </summary>
|
||||
/// <param name="commands">commands value from jint parser</param>
|
||||
/// <param name="scriptCommandFactory">factory to create the command from</param>
|
||||
/// <returns></returns>
|
||||
private IEnumerable<IManagerCommand> GenerateScriptCommands(JsValue commands,
|
||||
IScriptCommandFactory scriptCommandFactory)
|
||||
{
|
||||
var commandList = new List<IManagerCommand>();
|
||||
|
||||
// go through each defined command
|
||||
foreach (var command in commands.AsArray())
|
||||
{
|
||||
dynamic dynamicCommand = command.ToObject();
|
||||
string name = dynamicCommand.name;
|
||||
string alias = dynamicCommand.alias;
|
||||
string description = dynamicCommand.description;
|
||||
|
||||
if (dynamicCommand.permission is Data.Models.Client.EFClient.Permission perm)
|
||||
{
|
||||
dynamicCommand.permission = perm.ToString();
|
||||
}
|
||||
|
||||
string permission = dynamicCommand.permission;
|
||||
List<Reference.Game> supportedGames = null;
|
||||
var targetRequired = false;
|
||||
|
||||
var args = new List<CommandArgument>();
|
||||
dynamic arguments = null;
|
||||
|
||||
try
|
||||
{
|
||||
arguments = dynamicCommand.arguments;
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// arguments are optional
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
targetRequired = dynamicCommand.targetRequired;
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// arguments are optional
|
||||
}
|
||||
|
||||
if (arguments != null)
|
||||
{
|
||||
foreach (var arg in dynamicCommand.arguments)
|
||||
{
|
||||
args.Add(new CommandArgument { Name = arg.name, Required = (bool)arg.required });
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
foreach (var game in dynamicCommand.supportedGames)
|
||||
{
|
||||
supportedGames ??= new List<Reference.Game>();
|
||||
supportedGames.Add(Enum.Parse(typeof(Reference.Game), game.ToString()));
|
||||
}
|
||||
}
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// supported games is optional
|
||||
}
|
||||
|
||||
async Task Execute(GameEvent gameEvent)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
_scriptEngine.SetValue("_event", gameEvent);
|
||||
var jsEventObject = _scriptEngine.Evaluate("_event");
|
||||
|
||||
dynamicCommand.execute.Target.Invoke(_scriptEngine, jsEventObject);
|
||||
}
|
||||
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", gameEvent.Owner?.ToString()))
|
||||
{
|
||||
_logger.LogError(ex, "Could not execute command action for {Filename} {@Location}",
|
||||
Path.GetFileName(_fileName), ex.Location);
|
||||
}
|
||||
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", gameEvent.Owner?.ToString()))
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Could not execute command action for script plugin {FileName}",
|
||||
Path.GetFileName(_fileName));
|
||||
}
|
||||
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
commandList.Add(scriptCommandFactory.CreateScriptCommand(name, alias, description, permission,
|
||||
targetRequired, args, Execute, supportedGames));
|
||||
}
|
||||
|
||||
return commandList;
|
||||
}
|
||||
|
||||
private T WrapJavaScriptErrorHandling<T>(Func<T> work, object additionalData = null, Server server = null,
|
||||
[CallerMemberName] string methodName = "")
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server?.ToString()))
|
||||
{
|
||||
try
|
||||
{
|
||||
return work();
|
||||
}
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
|
||||
methodName, Path.GetFileName(_fileName), ex.Location, ex.StackTrace, additionalData);
|
||||
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
|
||||
methodName, _fileName, jsEx.Location, jsEx.JavaScriptStackTrace, additionalData);
|
||||
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
|
||||
methodName, Path.GetFileName(_fileName));
|
||||
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class PermissionLevelToStringConverter : IObjectConverter
|
||||
{
|
||||
public bool TryConvert(Engine engine, object value, out JsValue result)
|
||||
{
|
||||
if (value is Data.Models.Client.EFClient.Permission)
|
||||
{
|
||||
result = value.ToString();
|
||||
return true;
|
||||
}
|
||||
|
||||
result = JsValue.Null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
130
Application/Plugin/Script/ScriptPluginConfigurationWrapper.cs
Normal file
130
Application/Plugin/Script/ScriptPluginConfigurationWrapper.cs
Normal file
@ -0,0 +1,130 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Jint.Native.Json;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginConfigurationWrapper
|
||||
{
|
||||
public event Action<JsValue, Delegate> ConfigurationUpdated;
|
||||
|
||||
private readonly ScriptPluginConfiguration _config;
|
||||
private readonly IConfigurationHandlerV2<ScriptPluginConfiguration> _configHandler;
|
||||
private readonly Engine _scriptEngine;
|
||||
private readonly JsonParser _engineParser;
|
||||
private readonly List<(string, Delegate)> _updateCallbackActions = new();
|
||||
private string _pluginName;
|
||||
|
||||
public ScriptPluginConfigurationWrapper(string pluginName, Engine scriptEngine, IConfigurationHandlerV2<ScriptPluginConfiguration> configHandler)
|
||||
{
|
||||
_pluginName = pluginName;
|
||||
_scriptEngine = scriptEngine;
|
||||
_configHandler = configHandler;
|
||||
_configHandler.Updated += OnConfigurationUpdated;
|
||||
_config = configHandler.Get("ScriptPluginSettings", new ScriptPluginConfiguration()).GetAwaiter().GetResult();
|
||||
_engineParser = new JsonParser(_scriptEngine);
|
||||
}
|
||||
|
||||
~ScriptPluginConfigurationWrapper()
|
||||
{
|
||||
_configHandler.Updated -= OnConfigurationUpdated;
|
||||
}
|
||||
|
||||
public void SetName(string name)
|
||||
{
|
||||
_pluginName = name;
|
||||
}
|
||||
|
||||
public async Task SetValue(string key, object value)
|
||||
{
|
||||
var castValue = value;
|
||||
|
||||
if (value is double doubleValue)
|
||||
{
|
||||
castValue = AsInteger(doubleValue) ?? value;
|
||||
}
|
||||
|
||||
if (value is object[] array && array.All(item => item is double d && AsInteger(d) != null))
|
||||
{
|
||||
castValue = array.Select(item => AsInteger((double)item)).ToArray();
|
||||
}
|
||||
|
||||
if (!_config.ContainsKey(_pluginName))
|
||||
{
|
||||
_config.Add(_pluginName, new Dictionary<string, object>());
|
||||
}
|
||||
|
||||
var plugin = _config[_pluginName];
|
||||
|
||||
if (plugin.ContainsKey(key))
|
||||
{
|
||||
plugin[key] = castValue;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
plugin.Add(key, castValue);
|
||||
}
|
||||
|
||||
await _configHandler.Set(_config);
|
||||
}
|
||||
|
||||
public JsValue GetValue(string key) => GetValue(key, null);
|
||||
|
||||
public JsValue GetValue(string key, Delegate updateCallback)
|
||||
{
|
||||
if (!_config.ContainsKey(_pluginName))
|
||||
{
|
||||
return JsValue.Undefined;
|
||||
}
|
||||
|
||||
if (!_config[_pluginName].ContainsKey(key))
|
||||
{
|
||||
return JsValue.Undefined;
|
||||
}
|
||||
|
||||
var item = _config[_pluginName][key];
|
||||
|
||||
if (item is JsonElement { ValueKind: JsonValueKind.Array } jElem)
|
||||
{
|
||||
item = jElem.Deserialize<List<dynamic>>();
|
||||
}
|
||||
|
||||
if (updateCallback is not null)
|
||||
{
|
||||
_updateCallbackActions.Add((key, updateCallback));
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return _engineParser.Parse(item!.ToString()!);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
|
||||
return JsValue.FromObject(_scriptEngine, item);
|
||||
}
|
||||
|
||||
private static int? AsInteger(double value)
|
||||
{
|
||||
return int.TryParse(value.ToString(CultureInfo.InvariantCulture), out var parsed) ? parsed : null;
|
||||
}
|
||||
|
||||
private void OnConfigurationUpdated(ScriptPluginConfiguration config)
|
||||
{
|
||||
foreach (var callback in _updateCallbackActions)
|
||||
{
|
||||
ConfigurationUpdated?.Invoke(GetValue(callback.Item1), callback.Item2);
|
||||
}
|
||||
}
|
||||
}
|
32
Application/Plugin/Script/ScriptPluginFactory.cs
Normal file
32
Application/Plugin/Script/ScriptPluginFactory.cs
Normal file
@ -0,0 +1,32 @@
|
||||
using System;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginFactory : IScriptPluginFactory
|
||||
{
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
public ScriptPluginFactory(IServiceProvider serviceProvider)
|
||||
{
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
public object CreateScriptPlugin(Type type, string fileName)
|
||||
{
|
||||
if (type == typeof(IPlugin))
|
||||
{
|
||||
return new ScriptPlugin(_serviceProvider.GetRequiredService<ILogger<ScriptPlugin>>(),
|
||||
fileName);
|
||||
}
|
||||
|
||||
return new ScriptPluginV2(fileName, _serviceProvider.GetRequiredService<ILogger<ScriptPluginV2>>(),
|
||||
_serviceProvider.GetRequiredService<IScriptPluginServiceResolver>(),
|
||||
_serviceProvider.GetRequiredService<IScriptCommandFactory>(),
|
||||
_serviceProvider.GetRequiredService<IConfigurationHandlerV2<ScriptPluginConfiguration>>(),
|
||||
_serviceProvider.GetRequiredService<IInteractionRegistration>());
|
||||
}
|
||||
}
|
143
Application/Plugin/Script/ScriptPluginHelper.cs
Normal file
143
Application/Plugin/Script/ScriptPluginHelper.cs
Normal file
@ -0,0 +1,143 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Net.Http;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Jint.Native;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginHelper
|
||||
{
|
||||
private readonly IManager _manager;
|
||||
private readonly ScriptPluginV2 _scriptPlugin;
|
||||
private readonly SemaphoreSlim _onRequestRunning = new(1, 1);
|
||||
private const int RequestTimeout = 5000;
|
||||
|
||||
public ScriptPluginHelper(IManager manager, ScriptPluginV2 scriptPlugin)
|
||||
{
|
||||
_manager = manager;
|
||||
_scriptPlugin = scriptPlugin;
|
||||
}
|
||||
|
||||
public void GetUrl(string url, Delegate callback)
|
||||
{
|
||||
RequestUrl(new ScriptPluginWebRequest(url), callback);
|
||||
}
|
||||
|
||||
public void GetUrl(string url, string bearerToken, Delegate callback)
|
||||
{
|
||||
var headers = new Dictionary<string, string> { { "Authorization", $"Bearer {bearerToken}" } };
|
||||
RequestUrl(new ScriptPluginWebRequest(url, Headers: headers), callback);
|
||||
}
|
||||
|
||||
public void PostUrl(string url, string body, string bearerToken, Delegate callback)
|
||||
{
|
||||
var headers = new Dictionary<string, string> { { "Authorization", $"Bearer {bearerToken}" } };
|
||||
RequestUrl(
|
||||
new ScriptPluginWebRequest(url, body, "POST", Headers: headers), callback);
|
||||
}
|
||||
|
||||
public void RequestUrl(ScriptPluginWebRequest request, Delegate callback)
|
||||
{
|
||||
Task.Run(() =>
|
||||
{
|
||||
try
|
||||
{
|
||||
var response = RequestInternal(request);
|
||||
_scriptPlugin.ExecuteWithErrorHandling(scriptEngine =>
|
||||
{
|
||||
callback.DynamicInvoke(JsValue.Undefined, new[] { JsValue.FromObject(scriptEngine, response) });
|
||||
});
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void RequestNotifyAfterDelay(int delayMs, Delegate callback)
|
||||
{
|
||||
Task.Run(async () =>
|
||||
{
|
||||
try
|
||||
{
|
||||
await Task.Delay(delayMs, _manager.CancellationToken);
|
||||
_scriptPlugin.ExecuteWithErrorHandling(_ => callback.DynamicInvoke(JsValue.Undefined, new[] { JsValue.Undefined }));
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void RegisterDynamicCommand(JsValue command)
|
||||
{
|
||||
_scriptPlugin.RegisterDynamicCommand(command.ToObject());
|
||||
}
|
||||
|
||||
private object RequestInternal(ScriptPluginWebRequest request)
|
||||
{
|
||||
var entered = false;
|
||||
using var tokenSource = new CancellationTokenSource(RequestTimeout);
|
||||
using var client = new HttpClient();
|
||||
|
||||
try
|
||||
{
|
||||
_onRequestRunning.Wait(tokenSource.Token);
|
||||
|
||||
entered = true;
|
||||
var requestMessage = new HttpRequestMessage(new HttpMethod(request.Method), request.Url);
|
||||
|
||||
if (request.Body is not null)
|
||||
{
|
||||
requestMessage.Content = new StringContent(request.Body.ToString() ?? string.Empty, Encoding.Default,
|
||||
request.ContentType ?? "text/plain");
|
||||
}
|
||||
|
||||
if (request.Headers is not null)
|
||||
{
|
||||
foreach (var (key, value) in request.Headers)
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(key))
|
||||
{
|
||||
requestMessage.Headers.Add(key, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var response = client.Send(requestMessage, tokenSource.Token);
|
||||
using var reader = new StreamReader(response.Content.ReadAsStream());
|
||||
return reader.ReadToEnd();
|
||||
}
|
||||
catch (HttpRequestException ex)
|
||||
{
|
||||
return new
|
||||
{
|
||||
ex.StatusCode,
|
||||
ex.Message,
|
||||
IsError = true
|
||||
};
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
return new
|
||||
{
|
||||
ex.Message,
|
||||
IsError = true
|
||||
};
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (entered)
|
||||
{
|
||||
_onRequestRunning.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,8 +1,8 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System;
|
||||
using System.Linq;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
namespace IW4MAdmin.Application.Plugin.Script
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IScriptPluginServiceResolver
|
||||
@ -25,7 +25,7 @@ namespace IW4MAdmin.Application.Misc
|
||||
public object ResolveService(string serviceName, string[] genericParameters)
|
||||
{
|
||||
var serviceType = DetermineRootType(serviceName, genericParameters.Length);
|
||||
var genericTypes = genericParameters.Select(_genericTypeParam => DetermineRootType(_genericTypeParam));
|
||||
var genericTypes = genericParameters.Select(genericTypeParam => DetermineRootType(genericTypeParam));
|
||||
var resolvedServiceType = serviceType.MakeGenericType(genericTypes.ToArray());
|
||||
return _serviceProvider.GetService(resolvedServiceType);
|
||||
}
|
||||
@ -34,8 +34,8 @@ namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
var typeCollection = AppDomain.CurrentDomain.GetAssemblies()
|
||||
.SelectMany(t => t.GetTypes());
|
||||
string generatedName = $"{serviceName}{(genericParamCount == 0 ? "" : $"`{genericParamCount}")}".ToLower();
|
||||
var serviceType = typeCollection.FirstOrDefault(_type => _type.Name.ToLower() == generatedName);
|
||||
var generatedName = $"{serviceName}{(genericParamCount == 0 ? "" : $"`{genericParamCount}")}".ToLower();
|
||||
var serviceType = typeCollection.FirstOrDefault(type => type.Name.ToLower() == generatedName);
|
||||
|
||||
if (serviceType == null)
|
||||
{
|
201
Application/Plugin/Script/ScriptPluginTimerHelper.cs
Normal file
201
Application/Plugin/Script/ScriptPluginTimerHelper.cs
Normal file
@ -0,0 +1,201 @@
|
||||
using System;
|
||||
using System.Threading;
|
||||
using Jint.Native;
|
||||
using Jint.Runtime;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
[Obsolete("This architecture is superseded by the request notify delay architecture")]
|
||||
public class ScriptPluginTimerHelper : IScriptPluginTimerHelper
|
||||
{
|
||||
private Timer _timer;
|
||||
private Action _actions;
|
||||
private Delegate _jsAction;
|
||||
private string _actionName;
|
||||
private int _interval = DefaultInterval;
|
||||
private long _waitingCount;
|
||||
private const int DefaultDelay = 0;
|
||||
private const int DefaultInterval = 1000;
|
||||
private const int MaxWaiting = 10;
|
||||
private readonly ILogger _logger;
|
||||
private readonly SemaphoreSlim _onRunningTick = new(1, 1);
|
||||
private SemaphoreSlim _onDependentAction;
|
||||
|
||||
public ScriptPluginTimerHelper(ILogger<ScriptPluginTimerHelper> logger)
|
||||
{
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
~ScriptPluginTimerHelper()
|
||||
{
|
||||
if (_timer != null)
|
||||
{
|
||||
Stop();
|
||||
}
|
||||
|
||||
_onRunningTick.Dispose();
|
||||
}
|
||||
|
||||
public void Start(int delay, int interval)
|
||||
{
|
||||
if (_actions is null)
|
||||
{
|
||||
throw new InvalidOperationException("Timer action must be defined before starting");
|
||||
}
|
||||
|
||||
if (delay < 0)
|
||||
{
|
||||
throw new ArgumentException("Timer delay must be >= 0");
|
||||
}
|
||||
|
||||
if (interval < 20)
|
||||
{
|
||||
throw new ArgumentException("Timer interval must be at least 20ms");
|
||||
}
|
||||
|
||||
Stop();
|
||||
|
||||
_logger.LogDebug("Starting script timer...");
|
||||
|
||||
_timer ??= new Timer(callback => _actions(), null, delay, interval);
|
||||
_interval = interval;
|
||||
IsRunning = true;
|
||||
}
|
||||
|
||||
public void Start(int interval)
|
||||
{
|
||||
Start(DefaultDelay, interval);
|
||||
}
|
||||
|
||||
public void Start()
|
||||
{
|
||||
Start(DefaultDelay, DefaultInterval);
|
||||
}
|
||||
|
||||
public void Stop()
|
||||
{
|
||||
if (_timer == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Stopping script timer...");
|
||||
_timer.Change(Timeout.Infinite, Timeout.Infinite);
|
||||
_timer.Dispose();
|
||||
_timer = null;
|
||||
IsRunning = false;
|
||||
}
|
||||
|
||||
public void OnTick(Delegate action, string actionName)
|
||||
{
|
||||
if (string.IsNullOrEmpty(actionName))
|
||||
{
|
||||
throw new ArgumentException("actionName must be provided", nameof(actionName));
|
||||
}
|
||||
|
||||
if (action is null)
|
||||
{
|
||||
throw new ArgumentException("action must be provided", nameof(action));
|
||||
}
|
||||
|
||||
_logger.LogDebug("Adding new action with name {ActionName}", actionName);
|
||||
|
||||
_jsAction = action;
|
||||
_actionName = actionName;
|
||||
_actions = OnTickInternal;
|
||||
}
|
||||
|
||||
private void ReleaseThreads(bool releaseOnRunning, bool releaseOnDependent)
|
||||
{
|
||||
if (releaseOnRunning && _onRunningTick.CurrentCount == 0)
|
||||
{
|
||||
_logger.LogDebug("-Releasing OnRunning for timer");
|
||||
_onRunningTick.Release(1);
|
||||
}
|
||||
|
||||
if (releaseOnDependent && _onDependentAction?.CurrentCount == 0)
|
||||
{
|
||||
_onDependentAction?.Release(1);
|
||||
}
|
||||
}
|
||||
|
||||
private async void OnTickInternal()
|
||||
{
|
||||
var releaseOnRunning = false;
|
||||
var releaseOnDependent = false;
|
||||
|
||||
try
|
||||
{
|
||||
try
|
||||
{
|
||||
if (Interlocked.Read(ref _waitingCount) > MaxWaiting)
|
||||
{
|
||||
_logger.LogWarning("Reached max number of waiting count ({WaitingCount}) for {OnTick}",
|
||||
_waitingCount, nameof(OnTickInternal));
|
||||
return;
|
||||
}
|
||||
|
||||
Interlocked.Increment(ref _waitingCount);
|
||||
using var tokenSource1 = new CancellationTokenSource();
|
||||
tokenSource1.CancelAfter(TimeSpan.FromMilliseconds(_interval));
|
||||
await _onRunningTick.WaitAsync(tokenSource1.Token);
|
||||
releaseOnRunning = true;
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogDebug("Previous {OnTick} is still running, so we are skipping this one",
|
||||
nameof(OnTickInternal));
|
||||
return;
|
||||
}
|
||||
|
||||
using var tokenSource = new CancellationTokenSource();
|
||||
tokenSource.CancelAfter(TimeSpan.FromSeconds(5));
|
||||
|
||||
try
|
||||
{
|
||||
// the js engine is not thread safe so we need to ensure we're not executing OnTick and OnEventAsync simultaneously
|
||||
if (_onDependentAction is not null)
|
||||
{
|
||||
await _onDependentAction.WaitAsync(tokenSource.Token);
|
||||
releaseOnDependent = true;
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogWarning("Dependent action did not release in allotted time so we are cancelling this tick");
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("+Running OnTick for timer");
|
||||
var start = DateTime.Now;
|
||||
_jsAction.DynamicInvoke(JsValue.Undefined, new[] { JsValue.Undefined });
|
||||
_logger.LogDebug("OnTick took {Time}ms", (DateTime.Now - start).TotalMilliseconds);
|
||||
}
|
||||
catch (Exception ex) when (ex.InnerException is JavaScriptException jsx)
|
||||
{
|
||||
_logger.LogError(jsx,
|
||||
"Could not execute timer tick for script action {ActionName} [{@LocationInfo}] [{@StackTrace}]",
|
||||
_actionName,
|
||||
jsx.Location, jsx.JavaScriptStackTrace);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not execute timer tick for script action {ActionName}", _actionName);
|
||||
}
|
||||
finally
|
||||
{
|
||||
ReleaseThreads(releaseOnRunning, releaseOnDependent);
|
||||
Interlocked.Decrement(ref _waitingCount);
|
||||
}
|
||||
}
|
||||
|
||||
public void SetDependency(SemaphoreSlim dependentSemaphore)
|
||||
{
|
||||
_onDependentAction = dependentSemaphore;
|
||||
}
|
||||
|
||||
public bool IsRunning { get; private set; }
|
||||
}
|
597
Application/Plugin/Script/ScriptPluginV2.cs
Normal file
597
Application/Plugin/Script/ScriptPluginV2.cs
Normal file
@ -0,0 +1,597 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Dynamic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using IW4MAdmin.Application.Extensions;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Jint.Runtime;
|
||||
using Jint.Runtime.Interop;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Events.Server;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.Interfaces.Events;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using JavascriptEngine = Jint.Engine;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginV2 : IPluginV2
|
||||
{
|
||||
public string Name { get; private set; } = string.Empty;
|
||||
public string Author { get; private set; } = string.Empty;
|
||||
public string Version { get; private set; }
|
||||
|
||||
private readonly string _fileName;
|
||||
private readonly ILogger<ScriptPluginV2> _logger;
|
||||
private readonly IScriptPluginServiceResolver _pluginServiceResolver;
|
||||
private readonly IScriptCommandFactory _scriptCommandFactory;
|
||||
private readonly IConfigurationHandlerV2<ScriptPluginConfiguration> _configHandler;
|
||||
private readonly IInteractionRegistration _interactionRegistration;
|
||||
private readonly SemaphoreSlim _onProcessingScript = new(1, 1);
|
||||
private readonly SemaphoreSlim _onLoadingFile = new(1, 1);
|
||||
private readonly FileSystemWatcher _scriptWatcher;
|
||||
private readonly List<string> _registeredCommandNames = new();
|
||||
private readonly List<string> _registeredInteractions = new();
|
||||
private readonly Dictionary<MethodInfo, List<object>> _registeredEvents = new();
|
||||
private IManager _manager;
|
||||
private bool _firstInitialization = true;
|
||||
|
||||
private record ScriptPluginDetails(string Name, string Author, string Version,
|
||||
ScriptPluginCommandDetails[] Commands, ScriptPluginInteractionDetails[] Interactions);
|
||||
|
||||
private record ScriptPluginCommandDetails(string Name, string Description, string Alias, string Permission,
|
||||
bool TargetRequired, CommandArgument[] Arguments, IEnumerable<Reference.Game> SupportedGames, Delegate Execute);
|
||||
|
||||
private JavascriptEngine ScriptEngine
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (ActiveEngines)
|
||||
{
|
||||
return ActiveEngines[$"{GetHashCode()}-{_nextEngineId}"];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private record ScriptPluginInteractionDetails(string Name, Delegate Action);
|
||||
|
||||
private ScriptPluginConfigurationWrapper _scriptPluginConfigurationWrapper;
|
||||
private int _nextEngineId;
|
||||
private static readonly Dictionary<string, JavascriptEngine> ActiveEngines = new();
|
||||
|
||||
public ScriptPluginV2(string fileName, ILogger<ScriptPluginV2> logger,
|
||||
IScriptPluginServiceResolver pluginServiceResolver, IScriptCommandFactory scriptCommandFactory,
|
||||
IConfigurationHandlerV2<ScriptPluginConfiguration> configHandler,
|
||||
IInteractionRegistration interactionRegistration)
|
||||
{
|
||||
_fileName = fileName;
|
||||
_logger = logger;
|
||||
_pluginServiceResolver = pluginServiceResolver;
|
||||
_scriptCommandFactory = scriptCommandFactory;
|
||||
_configHandler = configHandler;
|
||||
_interactionRegistration = interactionRegistration;
|
||||
_scriptWatcher = new FileSystemWatcher
|
||||
{
|
||||
Path = Path.Join(Utilities.OperatingDirectory, "Plugins"),
|
||||
NotifyFilter = NotifyFilters.LastWrite,
|
||||
Filter = _fileName.Split(Path.DirectorySeparatorChar).Last()
|
||||
};
|
||||
|
||||
IManagementEventSubscriptions.Load += OnLoad;
|
||||
}
|
||||
|
||||
public void ExecuteWithErrorHandling(Action<Engine> work)
|
||||
{
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
work(ScriptEngine);
|
||||
return true;
|
||||
}, _logger, _fileName, _onProcessingScript);
|
||||
}
|
||||
|
||||
public object QueryWithErrorHandling(Delegate action, params object[] args)
|
||||
{
|
||||
return WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
var jsArgs = args?.Select(param => JsValue.FromObject(ScriptEngine, param)).ToArray();
|
||||
var result = action.DynamicInvoke(JsValue.Undefined, jsArgs);
|
||||
return result;
|
||||
}, _logger, _fileName, _onProcessingScript);
|
||||
}
|
||||
|
||||
public void RegisterDynamicCommand(object command)
|
||||
{
|
||||
var parsedCommand = ParseScriptCommandDetails(command);
|
||||
RegisterCommand(_manager, parsedCommand.First());
|
||||
}
|
||||
|
||||
private async Task OnLoad(IManager manager, CancellationToken token)
|
||||
{
|
||||
_manager = manager;
|
||||
var entered = false;
|
||||
try
|
||||
{
|
||||
await _onLoadingFile.WaitAsync(token);
|
||||
entered = true;
|
||||
|
||||
_logger.LogDebug("{Method} executing for {Plugin}", nameof(OnLoad), _fileName);
|
||||
|
||||
if (new FileInfo(_fileName).Length == 0L)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_scriptWatcher.EnableRaisingEvents = false;
|
||||
|
||||
UnregisterScriptEntities(manager);
|
||||
ResetEngineState();
|
||||
|
||||
if (_firstInitialization)
|
||||
{
|
||||
_scriptWatcher.Changed += async (_, _) => await OnLoad(manager, token);
|
||||
_firstInitialization = false;
|
||||
}
|
||||
|
||||
await using var stream =
|
||||
new FileStream(_fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
|
||||
using var reader = new StreamReader(stream, Encoding.Default);
|
||||
var pluginScript = await reader.ReadToEndAsync();
|
||||
|
||||
var pluginDetails = WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
if (IsEngineDisposed(GetHashCode(), _nextEngineId))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
ScriptEngine.Execute(pluginScript);
|
||||
#pragma warning disable CS8974
|
||||
var initResult = ScriptEngine.Call("init", JsValue.FromObject(ScriptEngine, EventCallbackWrapper),
|
||||
JsValue.FromObject(ScriptEngine, _pluginServiceResolver),
|
||||
JsValue.FromObject(ScriptEngine, _scriptPluginConfigurationWrapper),
|
||||
JsValue.FromObject(ScriptEngine, new ScriptPluginHelper(manager, this)));
|
||||
#pragma warning restore CS8974
|
||||
|
||||
if (initResult.IsNull() || initResult.IsUndefined())
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
return AsScriptPluginInstance(initResult.ToObject());
|
||||
}, _logger, _fileName, _onProcessingScript);
|
||||
|
||||
if (pluginDetails is null)
|
||||
{
|
||||
_logger.LogInformation("No valid script plugin signature found for {FilePath}", _fileName);
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (var command in pluginDetails.Commands)
|
||||
{
|
||||
RegisterCommand(manager, command);
|
||||
|
||||
_logger.LogDebug("Registered script plugin command {Command} for {Plugin}", command.Name,
|
||||
pluginDetails.Name);
|
||||
}
|
||||
|
||||
foreach (var interaction in pluginDetails.Interactions)
|
||||
{
|
||||
RegisterInteraction(interaction);
|
||||
|
||||
_logger.LogDebug("Registered script plugin interaction {Interaction} for {Plugin}", interaction.Name,
|
||||
pluginDetails.Name);
|
||||
}
|
||||
|
||||
Name = pluginDetails.Name;
|
||||
Author = pluginDetails.Author;
|
||||
Version = pluginDetails.Version;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Unexpected error encountered loading script plugin {Name}", _fileName);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (entered)
|
||||
{
|
||||
_onLoadingFile.Release(1);
|
||||
_scriptWatcher.EnableRaisingEvents = true;
|
||||
}
|
||||
|
||||
_logger.LogDebug("{Method} completed for {Plugin}", nameof(OnLoad), _fileName);
|
||||
}
|
||||
}
|
||||
|
||||
private void RegisterInteraction(ScriptPluginInteractionDetails interaction)
|
||||
{
|
||||
Task<IInteractionData> Action(int? targetId, Reference.Game? game, CancellationToken token) =>
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
if (IsEngineDisposed(GetHashCode(), _nextEngineId))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var args = new object[] { targetId, game, token }.Select(arg => JsValue.FromObject(ScriptEngine, arg))
|
||||
.ToArray();
|
||||
|
||||
if (interaction.Action.DynamicInvoke(JsValue.Undefined, args) is not ObjectWrapper result)
|
||||
{
|
||||
throw new PluginException("Invalid interaction object returned");
|
||||
}
|
||||
|
||||
return Task.FromResult((IInteractionData)result.ToObject());
|
||||
}, _logger, _fileName, _onProcessingScript);
|
||||
|
||||
_interactionRegistration.RegisterInteraction(interaction.Name, Action);
|
||||
_registeredInteractions.Add(interaction.Name);
|
||||
}
|
||||
|
||||
private void RegisterCommand(IManager manager, ScriptPluginCommandDetails command)
|
||||
{
|
||||
Task Execute(GameEvent gameEvent) =>
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
if (IsEngineDisposed(GetHashCode(), _nextEngineId))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
command.Execute.DynamicInvoke(JsValue.Undefined,
|
||||
new[] { JsValue.FromObject(ScriptEngine, gameEvent) });
|
||||
return Task.CompletedTask;
|
||||
}, _logger, _fileName, _onProcessingScript);
|
||||
|
||||
var scriptCommand = _scriptCommandFactory.CreateScriptCommand(command.Name, command.Alias,
|
||||
command.Description,
|
||||
command.Permission, command.TargetRequired,
|
||||
command.Arguments, Execute, command.SupportedGames);
|
||||
|
||||
manager.RemoveCommandByName(scriptCommand.Name);
|
||||
manager.AddAdditionalCommand(scriptCommand);
|
||||
if (!_registeredCommandNames.Contains(scriptCommand.Name))
|
||||
{
|
||||
_registeredCommandNames.Add(scriptCommand.Name);
|
||||
}
|
||||
}
|
||||
|
||||
private void ResetEngineState()
|
||||
{
|
||||
JavascriptEngine oldEngine = null;
|
||||
|
||||
lock (ActiveEngines)
|
||||
{
|
||||
if (ActiveEngines.ContainsKey($"{GetHashCode()}-{_nextEngineId}"))
|
||||
{
|
||||
oldEngine = ActiveEngines[$"{GetHashCode()}-{_nextEngineId}"];
|
||||
_logger.LogDebug("Removing script engine from active list {HashCode}", _nextEngineId);
|
||||
ActiveEngines.Remove($"{GetHashCode()}-{_nextEngineId}");
|
||||
}
|
||||
}
|
||||
|
||||
Interlocked.Increment(ref _nextEngineId);
|
||||
oldEngine?.Dispose();
|
||||
var newEngine = new JavascriptEngine(cfg =>
|
||||
cfg.AddExtensionMethods(typeof(Utilities), typeof(Enumerable), typeof(Queryable),
|
||||
typeof(ScriptPluginExtensions), typeof(LoggerExtensions))
|
||||
.AllowClr(typeof(System.Net.Http.HttpClient).Assembly, typeof(EFClient).Assembly,
|
||||
typeof(Utilities).Assembly, typeof(Encoding).Assembly, typeof(CancellationTokenSource).Assembly,
|
||||
typeof(Data.Models.Client.EFClient).Assembly, typeof(IW4MAdmin.Plugins.Stats.Plugin).Assembly, typeof(ScriptPluginWebRequest).Assembly)
|
||||
.CatchClrExceptions()
|
||||
.AddObjectConverter(new EnumsToStringConverter()));
|
||||
|
||||
lock (ActiveEngines)
|
||||
{
|
||||
_logger.LogDebug("Adding script engine to active list {HashCode}", _nextEngineId);
|
||||
ActiveEngines.Add($"{GetHashCode()}-{_nextEngineId}", newEngine);
|
||||
}
|
||||
|
||||
_scriptPluginConfigurationWrapper =
|
||||
new ScriptPluginConfigurationWrapper(_fileName.Split(Path.DirectorySeparatorChar).Last(), ScriptEngine,
|
||||
_configHandler);
|
||||
|
||||
_scriptPluginConfigurationWrapper.ConfigurationUpdated += (configValue, callbackAction) =>
|
||||
{
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
callbackAction.DynamicInvoke(JsValue.Undefined, new[] { configValue });
|
||||
return Task.CompletedTask;
|
||||
}, _logger, _fileName, _onProcessingScript);
|
||||
};
|
||||
}
|
||||
|
||||
private void UnregisterScriptEntities(IManager manager)
|
||||
{
|
||||
foreach (var commandName in _registeredCommandNames)
|
||||
{
|
||||
manager.RemoveCommandByName(commandName);
|
||||
_logger.LogDebug("Unregistered script plugin command {Command} for {Plugin}", commandName, Name);
|
||||
}
|
||||
|
||||
_registeredCommandNames.Clear();
|
||||
|
||||
foreach (var interactionName in _registeredInteractions)
|
||||
{
|
||||
_interactionRegistration.UnregisterInteraction(interactionName);
|
||||
}
|
||||
|
||||
_registeredInteractions.Clear();
|
||||
|
||||
foreach (var (removeMethod, subscriptions) in _registeredEvents)
|
||||
{
|
||||
foreach (var subscription in subscriptions)
|
||||
{
|
||||
removeMethod.Invoke(null, new[] { subscription });
|
||||
}
|
||||
|
||||
subscriptions.Clear();
|
||||
}
|
||||
|
||||
_registeredEvents.Clear();
|
||||
}
|
||||
|
||||
private void EventCallbackWrapper(string eventCallbackName, Delegate javascriptAction)
|
||||
{
|
||||
var eventCategory = eventCallbackName.Split(".")[0];
|
||||
|
||||
var eventCategoryType = eventCategory switch
|
||||
{
|
||||
nameof(IManagementEventSubscriptions) => typeof(IManagementEventSubscriptions),
|
||||
nameof(IGameEventSubscriptions) => typeof(IGameEventSubscriptions),
|
||||
nameof(IGameServerEventSubscriptions) => typeof(IGameServerEventSubscriptions),
|
||||
_ => null
|
||||
};
|
||||
|
||||
if (eventCategoryType is null)
|
||||
{
|
||||
_logger.LogWarning("{EventCategory} is not a valid subscription category", eventCategory);
|
||||
return;
|
||||
}
|
||||
|
||||
var eventName = eventCallbackName.Split(".")[1];
|
||||
var eventAddMethod = eventCategoryType.GetMethods()
|
||||
.FirstOrDefault(method => method.Name.StartsWith($"add_{eventName}"));
|
||||
var eventRemoveMethod = eventCategoryType.GetMethods()
|
||||
.FirstOrDefault(method => method.Name.StartsWith($"remove_{eventName}"));
|
||||
|
||||
if (eventAddMethod is null || eventRemoveMethod is null)
|
||||
{
|
||||
_logger.LogWarning("{EventName} is not a valid subscription event", eventName);
|
||||
return;
|
||||
}
|
||||
|
||||
var genericType = eventAddMethod.GetParameters()[0].ParameterType.GetGenericArguments()[0];
|
||||
|
||||
var eventWrapper =
|
||||
typeof(ScriptPluginV2).GetMethod(nameof(BuildEventWrapper), BindingFlags.Static | BindingFlags.NonPublic)!
|
||||
.MakeGenericMethod(genericType)
|
||||
.Invoke(null,
|
||||
new object[]
|
||||
{ _logger, _fileName, javascriptAction, GetHashCode(), _nextEngineId, _onProcessingScript });
|
||||
|
||||
eventAddMethod.Invoke(null, new[] { eventWrapper });
|
||||
|
||||
if (!_registeredEvents.ContainsKey(eventRemoveMethod))
|
||||
{
|
||||
_registeredEvents.Add(eventRemoveMethod, new List<object> { eventWrapper });
|
||||
}
|
||||
else
|
||||
{
|
||||
_registeredEvents[eventRemoveMethod].Add(eventWrapper);
|
||||
}
|
||||
}
|
||||
|
||||
private static Func<TEventType, CancellationToken, Task> BuildEventWrapper<TEventType>(ILogger logger,
|
||||
string fileName, Delegate javascriptAction, int hashCode, int engineId, SemaphoreSlim onProcessingScript)
|
||||
{
|
||||
return (coreEvent, token) =>
|
||||
{
|
||||
return WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
if (IsEngineDisposed(hashCode, engineId))
|
||||
{
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
JavascriptEngine engine;
|
||||
|
||||
lock (ActiveEngines)
|
||||
{
|
||||
engine = ActiveEngines[$"{hashCode}-{engineId}"];
|
||||
}
|
||||
|
||||
var args = new object[] { coreEvent, token }
|
||||
.Select(param => JsValue.FromObject(engine, param))
|
||||
.ToArray();
|
||||
javascriptAction.DynamicInvoke(JsValue.Undefined, args);
|
||||
return Task.CompletedTask;
|
||||
}, logger, fileName, onProcessingScript, (coreEvent as GameServerEvent)?.Server,
|
||||
additionalData: coreEvent.GetType().Name);
|
||||
};
|
||||
}
|
||||
|
||||
private static bool IsEngineDisposed(int hashCode, int engineId)
|
||||
{
|
||||
lock (ActiveEngines)
|
||||
{
|
||||
return !ActiveEngines.ContainsKey($"{hashCode}-{engineId}");
|
||||
}
|
||||
}
|
||||
|
||||
private static TResultType WrapJavaScriptErrorHandling<TResultType>(Func<TResultType> work, ILogger logger,
|
||||
string fileName, SemaphoreSlim onProcessingScript, IGameServer server = null, object additionalData = null,
|
||||
bool throwException = false,
|
||||
[CallerMemberName] string methodName = "")
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server?.Id))
|
||||
{
|
||||
var waitCompleted = false;
|
||||
try
|
||||
{
|
||||
onProcessingScript.Wait();
|
||||
waitCompleted = true;
|
||||
return work();
|
||||
}
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
|
||||
methodName, Path.GetFileName(fileName), ex.Location, ex.StackTrace, additionalData);
|
||||
|
||||
if (throwException)
|
||||
{
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
|
||||
{
|
||||
logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
|
||||
methodName, fileName, jsEx.Location, jsEx.JavaScriptStackTrace, additionalData);
|
||||
|
||||
if (throwException)
|
||||
{
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
|
||||
methodName, Path.GetFileName(fileName));
|
||||
|
||||
if (throwException)
|
||||
{
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (waitCompleted)
|
||||
{
|
||||
onProcessingScript.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return default;
|
||||
}
|
||||
|
||||
private static ScriptPluginDetails AsScriptPluginInstance(dynamic source)
|
||||
{
|
||||
var commandDetails = ParseScriptCommandDetails(source);
|
||||
|
||||
var interactionDetails = Array.Empty<ScriptPluginInteractionDetails>();
|
||||
if (HasProperty(source, "interactions") && source.interactions is dynamic[])
|
||||
{
|
||||
interactionDetails = ((dynamic[])source.interactions).Select(interaction =>
|
||||
{
|
||||
var name = HasProperty(interaction, "name") && interaction.name is string
|
||||
? (string)interaction.name
|
||||
: string.Empty;
|
||||
var action = HasProperty(interaction, "action") && interaction.action is Delegate
|
||||
? (Delegate)interaction.action
|
||||
: null;
|
||||
|
||||
return new ScriptPluginInteractionDetails(name, action);
|
||||
}).ToArray();
|
||||
}
|
||||
|
||||
var name = HasProperty(source, "name") && source.name is string ? (string)source.name : string.Empty;
|
||||
var author = HasProperty(source, "author") && source.author is string ? (string)source.author : string.Empty;
|
||||
var version = HasProperty(source, "version") && source.version is string ? (string)source.author : string.Empty;
|
||||
|
||||
return new ScriptPluginDetails(name, author, version, commandDetails, interactionDetails);
|
||||
}
|
||||
|
||||
private static ScriptPluginCommandDetails[] ParseScriptCommandDetails(dynamic source)
|
||||
{
|
||||
var commandDetails = Array.Empty<ScriptPluginCommandDetails>();
|
||||
if (HasProperty(source, "commands") && source.commands is dynamic[])
|
||||
{
|
||||
commandDetails = ((dynamic[])source.commands).Select(command =>
|
||||
{
|
||||
var commandArgs = Array.Empty<CommandArgument>();
|
||||
if (HasProperty(command, "arguments") && command.arguments is dynamic[])
|
||||
{
|
||||
commandArgs = ((dynamic[])command.arguments).Select(argument => new CommandArgument
|
||||
{
|
||||
Name = HasProperty(argument, "name") ? argument.name : string.Empty,
|
||||
Required = HasProperty(argument, "required") && argument.required is bool &&
|
||||
(bool)argument.required
|
||||
}).ToArray();
|
||||
}
|
||||
|
||||
var name = HasProperty(command, "name") && command.name is string
|
||||
? (string)command.name
|
||||
: string.Empty;
|
||||
var description = HasProperty(command, "description") && command.description is string
|
||||
? (string)command.description
|
||||
: string.Empty;
|
||||
var alias = HasProperty(command, "alias") && command.alias is string
|
||||
? (string)command.alias
|
||||
: string.Empty;
|
||||
var permission = HasProperty(command, "permission") && command.permission is string
|
||||
? (string)command.permission
|
||||
: string.Empty;
|
||||
var isTargetRequired = HasProperty(command, "targetRequired") && command.targetRequired is bool &&
|
||||
(bool)command.targetRequired;
|
||||
var supportedGames =
|
||||
HasProperty(command, "supportedGames") && command.supportedGames is IEnumerable<object>
|
||||
? ((IEnumerable<object>)command.supportedGames).Where(game => !string.IsNullOrEmpty(game?.ToString()))
|
||||
.Select(game =>
|
||||
Enum.Parse<Reference.Game>(game.ToString()!))
|
||||
: Array.Empty<Reference.Game>();
|
||||
var execute = HasProperty(command, "execute") && command.execute is Delegate
|
||||
? (Delegate)command.execute
|
||||
: (GameEvent _) => Task.CompletedTask;
|
||||
|
||||
return new ScriptPluginCommandDetails(name, description, alias, permission, isTargetRequired,
|
||||
commandArgs, supportedGames, execute);
|
||||
}).ToArray();
|
||||
}
|
||||
|
||||
return commandDetails;
|
||||
}
|
||||
|
||||
private static bool HasProperty(dynamic source, string name)
|
||||
{
|
||||
Type objType = source.GetType();
|
||||
|
||||
if (objType == typeof(ExpandoObject))
|
||||
{
|
||||
return ((IDictionary<string, object>)source).ContainsKey(name);
|
||||
}
|
||||
|
||||
return objType.GetProperty(name) != null;
|
||||
}
|
||||
|
||||
public class EnumsToStringConverter : IObjectConverter
|
||||
{
|
||||
public bool TryConvert(Engine engine, object value, out JsValue result)
|
||||
{
|
||||
if (value is Enum)
|
||||
{
|
||||
result = value.ToString();
|
||||
return true;
|
||||
}
|
||||
|
||||
result = JsValue.Null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
6
Application/Plugin/Script/ScriptPluginWebRequest.cs
Normal file
6
Application/Plugin/Script/ScriptPluginWebRequest.cs
Normal file
@ -0,0 +1,6 @@
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public record ScriptPluginWebRequest(string Url, object Body = null, string Method = "GET", string ContentType = "text/plain",
|
||||
Dictionary<string, string> Headers = null);
|
297
Application/QueryHelpers/ClientResourceQueryHelper.cs
Normal file
297
Application/QueryHelpers/ClientResourceQueryHelper.cs
Normal file
@ -0,0 +1,297 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using WebfrontCore.Permissions;
|
||||
using WebfrontCore.QueryHelpers.Models;
|
||||
using EFClient = Data.Models.Client.EFClient;
|
||||
|
||||
namespace IW4MAdmin.Application.QueryHelpers;
|
||||
|
||||
public class ClientResourceQueryHelper : IResourceQueryHelper<ClientResourceRequest, ClientResourceResponse>
|
||||
{
|
||||
public ApplicationConfiguration _appConfig { get; }
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly IGeoLocationService _geoLocationService;
|
||||
|
||||
private class ClientAlias
|
||||
{
|
||||
public EFClient Client { get; set; }
|
||||
public EFAlias Alias { get; set; }
|
||||
}
|
||||
|
||||
public ClientResourceQueryHelper(IDatabaseContextFactory contextFactory, IGeoLocationService geoLocationService,
|
||||
ApplicationConfiguration appConfig)
|
||||
{
|
||||
_appConfig = appConfig;
|
||||
_contextFactory = contextFactory;
|
||||
_geoLocationService = geoLocationService;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<ClientResourceResponse>> QueryResource(ClientResourceRequest query)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext(false);
|
||||
var iqAliases = context.Aliases.AsQueryable();
|
||||
var iqClients = context.Clients.AsQueryable();
|
||||
|
||||
var iqClientAliases = iqClients.Join(iqAliases, client => client.AliasLinkId, alias => alias.LinkId,
|
||||
(client, alias) => new ClientAlias { Client = client, Alias = alias });
|
||||
|
||||
return await StartFromClient(query, iqClientAliases, iqClients);
|
||||
}
|
||||
|
||||
private async Task<ResourceQueryHelperResult<ClientResourceResponse>> StartFromClient(ClientResourceRequest query,
|
||||
IQueryable<ClientAlias> clientAliases, IQueryable<EFClient> iqClients)
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(query.ClientGuid))
|
||||
{
|
||||
clientAliases = SearchByGuid(query, clientAliases);
|
||||
}
|
||||
|
||||
if (query.ClientLevel is not null)
|
||||
{
|
||||
clientAliases = SearchByLevel(query, clientAliases);
|
||||
}
|
||||
|
||||
if (query.ClientConnected is not null)
|
||||
{
|
||||
clientAliases = SearchByLastConnection(query, clientAliases);
|
||||
}
|
||||
|
||||
if (query.GameName is not null)
|
||||
{
|
||||
clientAliases = SearchByGame(query, clientAliases);
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(query.ClientName))
|
||||
{
|
||||
clientAliases = SearchByName(query, clientAliases);
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(query.ClientIp))
|
||||
{
|
||||
clientAliases = SearchByIp(query, clientAliases,
|
||||
_appConfig.HasPermission(query.RequesterPermission, WebfrontEntity.ClientIPAddress,
|
||||
WebfrontPermission.Read));
|
||||
}
|
||||
|
||||
var iqGroupedClientAliases = clientAliases.GroupBy(a => new { a.Client.ClientId, a.Client.LastConnection });
|
||||
|
||||
iqGroupedClientAliases = query.Direction == SortDirection.Descending
|
||||
? iqGroupedClientAliases.OrderByDescending(clientAlias => clientAlias.Key.LastConnection)
|
||||
: iqGroupedClientAliases.OrderBy(clientAlias => clientAlias.Key.LastConnection);
|
||||
|
||||
var clientIds = iqGroupedClientAliases.Select(g => g.Key.ClientId)
|
||||
.Skip(query.Offset)
|
||||
.Take(query.Count);
|
||||
|
||||
// this pulls in more records than we need, but it's more efficient than ordering grouped entities
|
||||
var clientLookups = await clientAliases
|
||||
.Where(clientAlias => clientIds.Contains(clientAlias.Client.ClientId))
|
||||
.Select(clientAlias => new ClientResourceResponse
|
||||
{
|
||||
ClientId = clientAlias.Client.ClientId,
|
||||
AliasId = clientAlias.Alias.AliasId,
|
||||
LinkId = clientAlias.Client.AliasLinkId,
|
||||
CurrentClientName = clientAlias.Client.CurrentAlias.Name,
|
||||
MatchedClientName = clientAlias.Alias.Name,
|
||||
CurrentClientIp = clientAlias.Client.CurrentAlias.IPAddress,
|
||||
MatchedClientIp = clientAlias.Alias.IPAddress,
|
||||
ClientLevel = clientAlias.Client.Level.ToLocalizedLevelName(),
|
||||
ClientLevelValue = clientAlias.Client.Level,
|
||||
LastConnection = clientAlias.Client.LastConnection,
|
||||
Game = clientAlias.Client.GameName
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
var groupClients = clientLookups.GroupBy(x => x.ClientId);
|
||||
|
||||
var orderedClients = query.Direction == SortDirection.Descending
|
||||
? groupClients.OrderByDescending(SearchByAliasLocal(query.ClientName, query.ClientIp))
|
||||
: groupClients.OrderBy(SearchByAliasLocal(query.ClientName, query.ClientIp));
|
||||
|
||||
var clients = orderedClients.Select(client => client.First()).ToList();
|
||||
await ProcessAliases(query, clients);
|
||||
|
||||
return new ResourceQueryHelperResult<ClientResourceResponse>
|
||||
{
|
||||
Results = clients
|
||||
};
|
||||
}
|
||||
|
||||
private async Task ProcessAliases(ClientResourceRequest query, IEnumerable<ClientResourceResponse> clients)
|
||||
{
|
||||
await Parallel.ForEachAsync(clients, new ParallelOptions { MaxDegreeOfParallelism = 15 },
|
||||
async (client, token) =>
|
||||
{
|
||||
if (!query.IncludeGeolocationData || client.CurrentClientIp is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var geolocationData = await _geoLocationService.Locate(client.CurrentClientIp.ConvertIPtoString());
|
||||
client.ClientCountryCode = geolocationData.CountryCode;
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(client.ClientCountryCode))
|
||||
{
|
||||
client.ClientCountryDisplayName = geolocationData.Country;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private static Func<IGrouping<int, ClientResourceResponse>, DateTime> SearchByAliasLocal(string clientName,
|
||||
string ipAddress)
|
||||
{
|
||||
return group =>
|
||||
{
|
||||
ClientResourceResponse match = null;
|
||||
var lowercaseClientName = clientName?.ToLower();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(lowercaseClientName))
|
||||
{
|
||||
match = group.ToList().FirstOrDefault(SearchByNameLocal(lowercaseClientName));
|
||||
}
|
||||
|
||||
if (match is null && !string.IsNullOrWhiteSpace(ipAddress))
|
||||
{
|
||||
match = group.ToList().FirstOrDefault(SearchByIpLocal(ipAddress));
|
||||
}
|
||||
|
||||
return (match ?? group.First()).LastConnection;
|
||||
};
|
||||
}
|
||||
|
||||
private static Func<ClientResourceResponse, bool> SearchByNameLocal(string clientName)
|
||||
{
|
||||
return clientResourceResponse =>
|
||||
clientResourceResponse.MatchedClientName.Contains(clientName);
|
||||
}
|
||||
|
||||
private static Func<ClientResourceResponse, bool> SearchByIpLocal(string clientIp)
|
||||
{
|
||||
return clientResourceResponse => clientResourceResponse.MatchedClientIp.ConvertIPtoString().Contains(clientIp);
|
||||
}
|
||||
|
||||
private static IQueryable<ClientAlias> SearchByName(ClientResourceRequest query,
|
||||
IQueryable<ClientAlias> clientAliases)
|
||||
{
|
||||
var lowerCaseQueryName = query.ClientName.ToLower();
|
||||
|
||||
clientAliases = clientAliases.Where(query.IsExactClientName
|
||||
? ExactNameMatch(lowerCaseQueryName)
|
||||
: LikeNameMatch(lowerCaseQueryName));
|
||||
|
||||
return clientAliases;
|
||||
}
|
||||
|
||||
private static Expression<Func<ClientAlias, bool>> LikeNameMatch(string lowerCaseQueryName)
|
||||
{
|
||||
return clientAlias => EF.Functions.Like(
|
||||
clientAlias.Alias.SearchableName,
|
||||
$"%{lowerCaseQueryName}%") || EF.Functions.Like(
|
||||
clientAlias.Alias.Name.ToLower(),
|
||||
$"%{lowerCaseQueryName}%");
|
||||
}
|
||||
|
||||
private static Expression<Func<ClientAlias, bool>> ExactNameMatch(string lowerCaseQueryName)
|
||||
{
|
||||
return clientAlias =>
|
||||
lowerCaseQueryName == clientAlias.Alias.Name || lowerCaseQueryName == clientAlias.Alias.SearchableName;
|
||||
}
|
||||
|
||||
private static IQueryable<ClientAlias> SearchByIp(ClientResourceRequest query,
|
||||
IQueryable<ClientAlias> clientAliases, bool canSearchIP)
|
||||
{
|
||||
var ipString = query.ClientIp.Trim();
|
||||
var ipAddress = ipString.ConvertToIP();
|
||||
|
||||
if (ipAddress != null && ipString.Split('.').Length == 4 && query.IsExactClientIp)
|
||||
{
|
||||
clientAliases = clientAliases.Where(clientAlias =>
|
||||
clientAlias.Alias.IPAddress != null && clientAlias.Alias.IPAddress == ipAddress);
|
||||
}
|
||||
else if(canSearchIP)
|
||||
{
|
||||
clientAliases = clientAliases.Where(clientAlias =>
|
||||
EF.Functions.Like(clientAlias.Alias.SearchableIPAddress, $"{ipString}%"));
|
||||
}
|
||||
|
||||
return clientAliases;
|
||||
}
|
||||
|
||||
private static IQueryable<ClientAlias> SearchByGuid(ClientResourceRequest query,
|
||||
IQueryable<ClientAlias> clients)
|
||||
{
|
||||
var guidString = query.ClientGuid.Trim();
|
||||
var parsedGuids = new List<long>();
|
||||
long guid = 0;
|
||||
|
||||
try
|
||||
{
|
||||
guid = guidString.ConvertGuidToLong(NumberStyles.HexNumber, false, 0);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
|
||||
if (guid != 0)
|
||||
{
|
||||
parsedGuids.Add(guid);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
guid = guidString.ConvertGuidToLong(NumberStyles.Integer, false, 0);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
|
||||
if (guid != 0)
|
||||
{
|
||||
parsedGuids.Add(guid);
|
||||
}
|
||||
|
||||
if (!parsedGuids.Any())
|
||||
{
|
||||
return clients;
|
||||
}
|
||||
|
||||
clients = clients.Where(client => parsedGuids.Contains(client.Client.NetworkId));
|
||||
return clients;
|
||||
}
|
||||
|
||||
private static IQueryable<ClientAlias> SearchByLevel(ClientResourceRequest query, IQueryable<ClientAlias> clients)
|
||||
{
|
||||
clients = clients.Where(clientAlias => clientAlias.Client.Level == query.ClientLevel);
|
||||
|
||||
return clients;
|
||||
}
|
||||
|
||||
private static IQueryable<ClientAlias> SearchByLastConnection(ClientResourceRequest query,
|
||||
IQueryable<ClientAlias> clients)
|
||||
{
|
||||
clients = clients.Where(clientAlias => clientAlias.Client.LastConnection >= query.ClientConnected);
|
||||
|
||||
return clients;
|
||||
}
|
||||
|
||||
private static IQueryable<ClientAlias> SearchByGame(ClientResourceRequest query, IQueryable<ClientAlias> clients)
|
||||
{
|
||||
clients = clients.Where(clientAlias => clientAlias.Client.GameName == query.GameName);
|
||||
|
||||
return clients;
|
||||
}
|
||||
}
|
@ -7,8 +7,10 @@ using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text.RegularExpressions;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using static SharedLibraryCore.Server;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
@ -18,6 +20,7 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
public class BaseRConParser : IRConParser
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private static string _botIpIndicator = "00000000.";
|
||||
|
||||
public BaseRConParser(ILogger<BaseRConParser> logger, IParserRegexFactory parserRegexFactory)
|
||||
{
|
||||
@ -50,7 +53,7 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
Configuration.Status.AddMapping(ParserRegex.GroupType.RConName, 5);
|
||||
Configuration.Status.AddMapping(ParserRegex.GroupType.RConIpAddress, 7);
|
||||
|
||||
Configuration.Dvar.Pattern = "^\"(.+)\" is: \"(.+)?\" default: \"(.+)?\"\n(?:latched: \"(.+)?\"\n)? *(.+)$";
|
||||
Configuration.Dvar.Pattern = "^\"(.+)\" is: \"(.+)?\" default: \"(.+)?\"\n?(?:latched: \"(.+)?\"\n?)? *(.+)?$";
|
||||
Configuration.Dvar.AddMapping(ParserRegex.GroupType.RConDvarName, 1);
|
||||
Configuration.Dvar.AddMapping(ParserRegex.GroupType.RConDvarValue, 2);
|
||||
Configuration.Dvar.AddMapping(ParserRegex.GroupType.RConDvarDefaultValue, 3);
|
||||
@ -77,19 +80,20 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
public string RConEngine { get; set; } = "COD";
|
||||
public bool IsOneLog { get; set; }
|
||||
|
||||
public async Task<string[]> ExecuteCommandAsync(IRConConnection connection, string command)
|
||||
public async Task<string[]> ExecuteCommandAsync(IRConConnection connection, string command, CancellationToken token = default)
|
||||
{
|
||||
var response = await connection.SendQueryAsync(StaticHelpers.QueryType.COMMAND, command);
|
||||
command = command.FormatMessageForEngine(Configuration);
|
||||
var response = await connection.SendQueryAsync(StaticHelpers.QueryType.COMMAND, command, token);
|
||||
return response.Where(item => item != Configuration.CommandPrefixes.RConResponse).ToArray();
|
||||
}
|
||||
|
||||
public async Task<Dvar<T>> GetDvarAsync<T>(IRConConnection connection, string dvarName, T fallbackValue = default)
|
||||
public async Task<Dvar<T>> GetDvarAsync<T>(IRConConnection connection, string dvarName, T fallbackValue = default, CancellationToken token = default)
|
||||
{
|
||||
string[] lineSplit;
|
||||
|
||||
try
|
||||
{
|
||||
lineSplit = await connection.SendQueryAsync(StaticHelpers.QueryType.GET_DVAR, dvarName);
|
||||
lineSplit = await connection.SendQueryAsync(StaticHelpers.QueryType.GET_DVAR, dvarName, token);
|
||||
}
|
||||
catch
|
||||
{
|
||||
@ -98,10 +102,10 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
throw;
|
||||
}
|
||||
|
||||
lineSplit = new string[0];
|
||||
lineSplit = Array.Empty<string>();
|
||||
}
|
||||
|
||||
string response = string.Join('\n', lineSplit).TrimEnd('\0');
|
||||
var response = string.Join('\n', lineSplit).Replace("\n", "").TrimEnd('\0');
|
||||
var match = Regex.Match(response, Configuration.Dvar.Pattern);
|
||||
|
||||
if (response.Contains("Unknown command") ||
|
||||
@ -109,7 +113,7 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
{
|
||||
if (fallbackValue != null)
|
||||
{
|
||||
return new Dvar<T>()
|
||||
return new Dvar<T>
|
||||
{
|
||||
Name = dvarName,
|
||||
Value = fallbackValue
|
||||
@ -119,17 +123,17 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
throw new DvarException(Utilities.CurrentLocalization.LocalizationIndex["SERVER_ERROR_DVAR"].FormatExt(dvarName));
|
||||
}
|
||||
|
||||
string value = match.Groups[Configuration.Dvar.GroupMapping[ParserRegex.GroupType.RConDvarValue]].Value;
|
||||
string defaultValue = match.Groups[Configuration.Dvar.GroupMapping[ParserRegex.GroupType.RConDvarDefaultValue]].Value;
|
||||
string latchedValue = match.Groups[Configuration.Dvar.GroupMapping[ParserRegex.GroupType.RConDvarLatchedValue]].Value;
|
||||
var value = match.Groups[Configuration.Dvar.GroupMapping[ParserRegex.GroupType.RConDvarValue]].Value;
|
||||
var defaultValue = match.Groups[Configuration.Dvar.GroupMapping[ParserRegex.GroupType.RConDvarDefaultValue]].Value;
|
||||
var latchedValue = match.Groups[Configuration.Dvar.GroupMapping[ParserRegex.GroupType.RConDvarLatchedValue]].Value;
|
||||
|
||||
string removeTrailingColorCode(string input) => Regex.Replace(input, @"\^7$", "");
|
||||
string RemoveTrailingColorCode(string input) => Regex.Replace(input, @"\^7$", "");
|
||||
|
||||
value = removeTrailingColorCode(value);
|
||||
defaultValue = removeTrailingColorCode(defaultValue);
|
||||
latchedValue = removeTrailingColorCode(latchedValue);
|
||||
value = RemoveTrailingColorCode(value);
|
||||
defaultValue = RemoveTrailingColorCode(defaultValue);
|
||||
latchedValue = RemoveTrailingColorCode(latchedValue);
|
||||
|
||||
return new Dvar<T>()
|
||||
return new Dvar<T>
|
||||
{
|
||||
Name = dvarName,
|
||||
Value = string.IsNullOrEmpty(value) ? default : (T)Convert.ChangeType(value, typeof(T)),
|
||||
@ -139,23 +143,49 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
};
|
||||
}
|
||||
|
||||
public virtual async Task<IStatusResponse> GetStatusAsync(IRConConnection connection)
|
||||
public void BeginGetDvar(IRConConnection connection, string dvarName, AsyncCallback callback, CancellationToken token = default)
|
||||
{
|
||||
var response = await connection.SendQueryAsync(StaticHelpers.QueryType.COMMAND_STATUS);
|
||||
_logger.LogDebug("Status Response {response}", string.Join(Environment.NewLine, response));
|
||||
GetDvarAsync<string>(connection, dvarName, token: token).ContinueWith(action =>
|
||||
{
|
||||
if (action.IsCompletedSuccessfully)
|
||||
{
|
||||
callback?.Invoke(new AsyncResult
|
||||
{
|
||||
IsCompleted = true,
|
||||
AsyncState = (true, action.Result.Value)
|
||||
});
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
callback?.Invoke(new AsyncResult
|
||||
{
|
||||
IsCompleted = true,
|
||||
AsyncState = (false, (string)null)
|
||||
});
|
||||
}
|
||||
}, CancellationToken.None);
|
||||
}
|
||||
|
||||
public virtual async Task<IStatusResponse> GetStatusAsync(IRConConnection connection, CancellationToken token = default)
|
||||
{
|
||||
var response = await connection.SendQueryAsync(StaticHelpers.QueryType.COMMAND_STATUS, "status", token);
|
||||
|
||||
_logger.LogDebug("Status Response {Response}", string.Join(Environment.NewLine, response));
|
||||
|
||||
return new StatusResponse
|
||||
{
|
||||
Clients = ClientsFromStatus(response).ToArray(),
|
||||
Map = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusMap, Configuration.MapStatus.Pattern),
|
||||
GameType = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusGametype, Configuration.GametypeStatus.Pattern),
|
||||
Hostname = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusHostname, Configuration.HostnameStatus.Pattern),
|
||||
MaxClients = GetValueFromStatus<int?>(response, ParserRegex.GroupType.RConStatusMaxPlayers, Configuration.MaxPlayersStatus.Pattern)
|
||||
Map = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusMap, Configuration.MapStatus),
|
||||
GameType = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusGametype, Configuration.GametypeStatus),
|
||||
Hostname = GetValueFromStatus<string>(response, ParserRegex.GroupType.RConStatusHostname, Configuration.HostnameStatus),
|
||||
MaxClients = GetValueFromStatus<int?>(response, ParserRegex.GroupType.RConStatusMaxPlayers, Configuration.MaxPlayersStatus)
|
||||
};
|
||||
}
|
||||
|
||||
private T GetValueFromStatus<T>(IEnumerable<string> response, ParserRegex.GroupType groupType, string groupPattern)
|
||||
private T GetValueFromStatus<T>(IEnumerable<string> response, ParserRegex.GroupType groupType, ParserRegex parserRegex)
|
||||
{
|
||||
if (string.IsNullOrEmpty(groupPattern))
|
||||
if (string.IsNullOrEmpty(parserRegex.Pattern))
|
||||
{
|
||||
return default;
|
||||
}
|
||||
@ -163,11 +193,15 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
string value = null;
|
||||
foreach (var line in response)
|
||||
{
|
||||
var regex = Regex.Match(line, groupPattern);
|
||||
if (regex.Success)
|
||||
var regex = Regex.Match(line, parserRegex.Pattern);
|
||||
|
||||
if (!regex.Success || !parserRegex.GroupMapping.ContainsKey(groupType))
|
||||
{
|
||||
value = regex.Groups[Configuration.MapStatus.GroupMapping[groupType]].ToString();
|
||||
continue;
|
||||
}
|
||||
|
||||
value = regex.Groups[parserRegex.GroupMapping[groupType]].ToString();
|
||||
break;
|
||||
}
|
||||
|
||||
if (value == null)
|
||||
@ -183,13 +217,38 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
return (T)Convert.ChangeType(value, typeof(T));
|
||||
}
|
||||
|
||||
public async Task<bool> SetDvarAsync(IRConConnection connection, string dvarName, object dvarValue)
|
||||
public async Task<bool> SetDvarAsync(IRConConnection connection, string dvarName, object dvarValue, CancellationToken token = default)
|
||||
{
|
||||
string dvarString = (dvarValue is string str)
|
||||
var dvarString = (dvarValue is string str)
|
||||
? $"{dvarName} \"{str}\""
|
||||
: $"{dvarName} {dvarValue}";
|
||||
|
||||
return (await connection.SendQueryAsync(StaticHelpers.QueryType.SET_DVAR, dvarString)).Length > 0;
|
||||
return (await connection.SendQueryAsync(StaticHelpers.QueryType.SET_DVAR, dvarString, token)).Length > 0;
|
||||
}
|
||||
|
||||
public void BeginSetDvar(IRConConnection connection, string dvarName, object dvarValue, AsyncCallback callback,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
SetDvarAsync(connection, dvarName, dvarValue, token).ContinueWith(action =>
|
||||
{
|
||||
if (action.Exception is null && !action.IsCanceled)
|
||||
{
|
||||
callback?.Invoke(new AsyncResult
|
||||
{
|
||||
IsCompleted = true,
|
||||
AsyncState = true
|
||||
});
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
callback?.Invoke(new AsyncResult
|
||||
{
|
||||
IsCompleted = true,
|
||||
AsyncState = false
|
||||
});
|
||||
}
|
||||
}, CancellationToken.None);
|
||||
}
|
||||
|
||||
private List<EFClient> ClientsFromStatus(string[] Status)
|
||||
@ -236,13 +295,20 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
long networkId;
|
||||
var name = match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConName]].TrimNewLine();
|
||||
string networkIdString;
|
||||
|
||||
var ip = match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConIpAddress]].Split(':')[0].ConvertToIP();
|
||||
|
||||
if (match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConIpAddress]]
|
||||
.Contains(_botIpIndicator))
|
||||
{
|
||||
ip = System.Net.IPAddress.Broadcast.ToString().ConvertToIP();
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
networkIdString = match.Values[Configuration.Status.GroupMapping[ParserRegex.GroupType.RConNetworkId]];
|
||||
|
||||
networkId = networkIdString.IsBotGuid() || (ip == null && ping == 999) ?
|
||||
networkId = networkIdString.IsBotGuid() || (ip == null && ping is 999 or 0) ?
|
||||
name.GenerateGuidFromString() :
|
||||
networkIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
}
|
||||
@ -252,9 +318,9 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
continue;
|
||||
}
|
||||
|
||||
var client = new EFClient()
|
||||
var client = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias()
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = name,
|
||||
IPAddress = ip
|
||||
@ -306,15 +372,28 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
(T)Convert.ChangeType(Configuration.DefaultDvarValues[dvarName], typeof(T)) :
|
||||
default;
|
||||
|
||||
public TimeSpan OverrideTimeoutForCommand(string command)
|
||||
public TimeSpan? OverrideTimeoutForCommand(string command)
|
||||
{
|
||||
if (command.Contains("map_rotate", StringComparison.InvariantCultureIgnoreCase) ||
|
||||
command.StartsWith("map ", StringComparison.InvariantCultureIgnoreCase))
|
||||
if (string.IsNullOrEmpty(command))
|
||||
{
|
||||
return TimeSpan.FromSeconds(30);
|
||||
return TimeSpan.Zero;
|
||||
}
|
||||
|
||||
var commandToken = command.Split(' ', StringSplitOptions.RemoveEmptyEntries).First().ToLower();
|
||||
|
||||
if (!Configuration.OverrideCommandTimeouts.ContainsKey(commandToken))
|
||||
{
|
||||
return TimeSpan.Zero;
|
||||
}
|
||||
|
||||
return TimeSpan.Zero;
|
||||
var timeoutValue = Configuration.OverrideCommandTimeouts[commandToken];
|
||||
|
||||
if (timeoutValue.HasValue && timeoutValue.Value != 0) // JINT doesn't seem to be able to properly set nulls on dictionaries
|
||||
{
|
||||
return TimeSpan.FromSeconds(timeoutValue.Value);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -26,11 +26,14 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
public NumberStyles GuidNumberStyle { get; set; } = NumberStyles.HexNumber;
|
||||
public IDictionary<string, string> OverrideDvarNameMapping { get; set; } = new Dictionary<string, string>();
|
||||
public IDictionary<string, string> DefaultDvarValues { get; set; } = new Dictionary<string, string>();
|
||||
public IDictionary<string, int?> OverrideCommandTimeouts { get; set; } = new Dictionary<string, int?>();
|
||||
public int NoticeMaximumLines { get; set; } = 8;
|
||||
public int NoticeMaxCharactersPerLine { get; set; } = 50;
|
||||
public string NoticeLineSeparator { get; set; } = Environment.NewLine;
|
||||
public int? DefaultRConPort { get; set; }
|
||||
public string DefaultInstallationDirectoryHint { get; set; }
|
||||
public short FloodProtectInterval { get; set; } = 750;
|
||||
public bool ShouldRemoveDiacritics { get; set; }
|
||||
|
||||
public ColorCodeMapping ColorCodeMapping { get; set; } = new ColorCodeMapping
|
||||
{
|
||||
@ -45,7 +48,7 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
{ColorCodes.White.ToString(), "^7"},
|
||||
{ColorCodes.Map.ToString(), "^8"},
|
||||
{ColorCodes.Grey.ToString(), "^9"},
|
||||
{ColorCodes.Wildcard.ToString(), ":^"},
|
||||
{ColorCodes.Wildcard.ToString(), "^:"}
|
||||
};
|
||||
|
||||
public DynamicRConParserConfiguration(IParserRegexFactory parserRegexFactory)
|
||||
@ -57,6 +60,25 @@ namespace IW4MAdmin.Application.RConParsers
|
||||
StatusHeader = parserRegexFactory.CreateParserRegex();
|
||||
HostnameStatus = parserRegexFactory.CreateParserRegex();
|
||||
MaxPlayersStatus = parserRegexFactory.CreateParserRegex();
|
||||
|
||||
|
||||
const string mapRotateCommand = "map_rotate";
|
||||
const string mapCommand = "map";
|
||||
const string fastRestartCommand = "fast_restart";
|
||||
const string quitCommand = "quit";
|
||||
|
||||
foreach (var command in new[] { mapRotateCommand, mapCommand, fastRestartCommand})
|
||||
{
|
||||
if (!OverrideCommandTimeouts.ContainsKey(command))
|
||||
{
|
||||
OverrideCommandTimeouts.Add(command, 45);
|
||||
}
|
||||
}
|
||||
|
||||
if (!OverrideCommandTimeouts.ContainsKey(quitCommand))
|
||||
{
|
||||
OverrideCommandTimeouts.Add(quitCommand, 0); // we don't want to wait for a response when we quit the server
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
BIN
Application/Resources/GeoLite2-Country.mmdb
Normal file
BIN
Application/Resources/GeoLite2-Country.mmdb
Normal file
Binary file not shown.
@ -1,41 +0,0 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Events;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Linq;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
class SerialGameEventHandler : IEventHandler
|
||||
{
|
||||
private delegate void GameEventAddedEventHandler(object sender, GameEventArgs args);
|
||||
private event GameEventAddedEventHandler GameEventAdded;
|
||||
|
||||
private static readonly GameEvent.EventType[] overrideEvents = new[]
|
||||
{
|
||||
GameEvent.EventType.Connect,
|
||||
GameEvent.EventType.Disconnect,
|
||||
GameEvent.EventType.Quit,
|
||||
GameEvent.EventType.Stop
|
||||
};
|
||||
|
||||
public SerialGameEventHandler()
|
||||
{
|
||||
GameEventAdded += GameEventHandler_GameEventAdded;
|
||||
}
|
||||
|
||||
private async void GameEventHandler_GameEventAdded(object sender, GameEventArgs args)
|
||||
{
|
||||
await (sender as IManager).ExecuteEvent(args.Event);
|
||||
EventApi.OnGameEvent(args.Event);
|
||||
}
|
||||
|
||||
public void HandleEvent(IManager manager, GameEvent gameEvent)
|
||||
{
|
||||
if (manager.IsRunning || overrideEvents.Contains(gameEvent.Type))
|
||||
{
|
||||
GameEventAdded?.Invoke(manager, new GameEventArgs(null, false, gameEvent));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -1,4 +1,5 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
@ -9,6 +10,12 @@ namespace Data.Abstractions
|
||||
{
|
||||
void SetCacheItem(Func<DbSet<TEntityType>, CancellationToken, Task<TReturnType>> itemGetter, string keyName,
|
||||
TimeSpan? expirationTime = null, bool autoRefresh = false);
|
||||
|
||||
void SetCacheItem(Func<DbSet<TEntityType>, IEnumerable<object>, CancellationToken, Task<TReturnType>> itemGetter, string keyName,
|
||||
IEnumerable<object> ids = null, TimeSpan? expirationTime = null, bool autoRefresh = false);
|
||||
|
||||
Task<TReturnType> GetCacheItem(string keyName, CancellationToken token = default);
|
||||
|
||||
Task<TReturnType> GetCacheItem(string keyName, IEnumerable<object> ids = null, CancellationToken token = default);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -23,7 +23,7 @@ namespace Data.Context
|
||||
{
|
||||
var link = new EFAliasLink();
|
||||
|
||||
context.Clients.Add(new EFClient()
|
||||
context.Clients.Add(new EFClient
|
||||
{
|
||||
Active = false,
|
||||
Connections = 0,
|
||||
@ -33,7 +33,7 @@ namespace Data.Context
|
||||
Masked = true,
|
||||
NetworkId = 0,
|
||||
AliasLink = link,
|
||||
CurrentAlias = new EFAlias()
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Link = link,
|
||||
Active = true,
|
||||
@ -46,4 +46,4 @@ namespace Data.Context
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -18,6 +18,7 @@ namespace Data.Context
|
||||
public DbSet<EFAlias> Aliases { get; set; }
|
||||
public DbSet<EFAliasLink> AliasLinks { get; set; }
|
||||
public DbSet<EFPenalty> Penalties { get; set; }
|
||||
public DbSet<EFPenaltyIdentifier> PenaltyIdentifiers { get; set; }
|
||||
public DbSet<EFMeta> EFMeta { get; set; }
|
||||
public DbSet<EFChangeHistory> EFChangeHistory { get; set; }
|
||||
|
||||
@ -31,6 +32,7 @@ namespace Data.Context
|
||||
public DbSet<EFClientMessage> ClientMessages { get; set; }
|
||||
|
||||
public DbSet<EFServerStatistics> ServerStatistics { get; set; }
|
||||
public DbSet<EFClientStatistics> ClientStatistics { get; set; }
|
||||
public DbSet<EFHitLocation> HitLocations { get; set; }
|
||||
public DbSet<EFClientHitStatistic> HitStatistics { get; set; }
|
||||
public DbSet<EFWeapon> Weapons { get; set; }
|
||||
@ -84,7 +86,16 @@ namespace Data.Context
|
||||
protected override void OnModelCreating(ModelBuilder modelBuilder)
|
||||
{
|
||||
// make network id unique
|
||||
modelBuilder.Entity<EFClient>(entity => { entity.HasIndex(e => e.NetworkId).IsUnique(); });
|
||||
modelBuilder.Entity<EFClient>(entity =>
|
||||
{
|
||||
entity.HasIndex(client => client.NetworkId);
|
||||
entity.HasIndex(client => client.LastConnection);
|
||||
entity.HasAlternateKey(client => new
|
||||
{
|
||||
client.NetworkId,
|
||||
client.GameName
|
||||
});
|
||||
});
|
||||
|
||||
modelBuilder.Entity<EFPenalty>(entity =>
|
||||
{
|
||||
@ -119,6 +130,10 @@ namespace Data.Context
|
||||
ent.Property(_alias => _alias.SearchableName).HasMaxLength(24);
|
||||
ent.HasIndex(_alias => _alias.SearchableName);
|
||||
ent.HasIndex(_alias => new {_alias.Name, _alias.IPAddress});
|
||||
ent.Property(alias => alias.SearchableIPAddress)
|
||||
.HasMaxLength(255)
|
||||
.HasComputedColumnSql(@"((IPAddress & 255) || '.' || ((IPAddress >> 8) & 255)) || '.' || ((IPAddress >> 16) & 255) || '.' || ((IPAddress >> 24) & 255)", stored: true);
|
||||
ent.HasIndex(alias => alias.SearchableIPAddress);
|
||||
});
|
||||
|
||||
modelBuilder.Entity<EFMeta>(ent =>
|
||||
@ -130,13 +145,22 @@ namespace Data.Context
|
||||
.OnDelete(DeleteBehavior.SetNull);
|
||||
});
|
||||
|
||||
modelBuilder.Entity<EFPenaltyIdentifier>(ent =>
|
||||
{
|
||||
ent.HasIndex(identifiers => identifiers.NetworkId);
|
||||
ent.HasIndex(identifiers => identifiers.IPv4Address);
|
||||
});
|
||||
|
||||
modelBuilder.Entity<EFClientConnectionHistory>(ent => ent.HasIndex(history => history.CreatedDateTime));
|
||||
|
||||
modelBuilder.Entity<EFServerSnapshot>(ent => ent.HasIndex(snapshot => snapshot.CapturedAt));
|
||||
|
||||
// force full name for database conversion
|
||||
modelBuilder.Entity<EFClient>().ToTable("EFClients");
|
||||
modelBuilder.Entity<EFAlias>().ToTable("EFAlias");
|
||||
modelBuilder.Entity<EFAliasLink>().ToTable("EFAliasLinks");
|
||||
modelBuilder.Entity<EFPenalty>().ToTable("EFPenalties");
|
||||
modelBuilder.Entity<EFPenaltyIdentifier>().ToTable("EFPenaltyIdentifiers");
|
||||
modelBuilder.Entity<EFServerSnapshot>().ToTable(nameof(EFServerSnapshot));
|
||||
modelBuilder.Entity<EFClientConnectionHistory>().ToTable(nameof(EFClientConnectionHistory));
|
||||
|
||||
|
@ -1,5 +1,7 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
@ -15,8 +17,8 @@ namespace Data.Helpers
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
|
||||
private readonly ConcurrentDictionary<string, CacheState<TReturnType>> _cacheStates =
|
||||
new ConcurrentDictionary<string, CacheState<TReturnType>>();
|
||||
private readonly ConcurrentDictionary<string, Dictionary<object, CacheState<TReturnType>>> _cacheStates = new();
|
||||
private readonly string _defaultKey = null;
|
||||
|
||||
private bool _autoRefresh;
|
||||
private const int DefaultExpireMinutes = 15;
|
||||
@ -27,7 +29,7 @@ namespace Data.Helpers
|
||||
public string Key { get; set; }
|
||||
public DateTime LastRetrieval { get; set; }
|
||||
public TimeSpan ExpirationTime { get; set; }
|
||||
public Func<DbSet<TEntityType>, CancellationToken, Task<TCacheType>> Getter { get; set; }
|
||||
public Func<DbSet<TEntityType>, IEnumerable<object>, CancellationToken, Task<TCacheType>> Getter { get; set; }
|
||||
public TCacheType Value { get; set; }
|
||||
public bool IsSet { get; set; }
|
||||
|
||||
@ -51,10 +53,28 @@ namespace Data.Helpers
|
||||
public void SetCacheItem(Func<DbSet<TEntityType>, CancellationToken, Task<TReturnType>> getter, string key,
|
||||
TimeSpan? expirationTime = null, bool autoRefresh = false)
|
||||
{
|
||||
if (_cacheStates.ContainsKey(key))
|
||||
SetCacheItem((set, _, token) => getter(set, token), key, null, expirationTime, autoRefresh);
|
||||
}
|
||||
|
||||
public void SetCacheItem(Func<DbSet<TEntityType>, IEnumerable<object>, CancellationToken, Task<TReturnType>> getter, string key,
|
||||
IEnumerable<object> ids = null, TimeSpan? expirationTime = null, bool autoRefresh = false)
|
||||
{
|
||||
ids ??= new[] { _defaultKey };
|
||||
|
||||
if (!_cacheStates.ContainsKey(key))
|
||||
{
|
||||
_logger.LogDebug("Cache key {Key} is already added", key);
|
||||
return;
|
||||
_cacheStates.TryAdd(key, new Dictionary<object, CacheState<TReturnType>>());
|
||||
}
|
||||
|
||||
var cacheInstance = _cacheStates[key];
|
||||
var id = GenerateKeyFromIds(ids);
|
||||
|
||||
lock (_cacheStates)
|
||||
{
|
||||
if (cacheInstance.ContainsKey(id))
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
var state = new CacheState<TReturnType>
|
||||
@ -64,9 +84,12 @@ namespace Data.Helpers
|
||||
ExpirationTime = expirationTime ?? TimeSpan.FromMinutes(DefaultExpireMinutes)
|
||||
};
|
||||
|
||||
_autoRefresh = autoRefresh;
|
||||
lock (_cacheStates)
|
||||
{
|
||||
cacheInstance.Add(id, state);
|
||||
}
|
||||
|
||||
_cacheStates.TryAdd(key, state);
|
||||
_autoRefresh = autoRefresh;
|
||||
|
||||
if (!_autoRefresh || expirationTime == TimeSpan.MaxValue)
|
||||
{
|
||||
@ -74,37 +97,48 @@ namespace Data.Helpers
|
||||
}
|
||||
|
||||
_timer = new Timer(state.ExpirationTime.TotalMilliseconds);
|
||||
_timer.Elapsed += async (sender, args) => await RunCacheUpdate(state, CancellationToken.None);
|
||||
_timer.Elapsed += async (sender, args) => await RunCacheUpdate(state, ids, CancellationToken.None);
|
||||
_timer.Start();
|
||||
}
|
||||
|
||||
public async Task<TReturnType> GetCacheItem(string keyName, CancellationToken cancellationToken = default)
|
||||
public Task<TReturnType> GetCacheItem(string keyName, CancellationToken cancellationToken = default) =>
|
||||
GetCacheItem(keyName, null, cancellationToken);
|
||||
|
||||
public async Task<TReturnType> GetCacheItem(string keyName, IEnumerable<object> ids = null,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (!_cacheStates.ContainsKey(keyName))
|
||||
{
|
||||
throw new ArgumentException("No cache found for key {key}", keyName);
|
||||
}
|
||||
|
||||
var state = _cacheStates[keyName];
|
||||
var cacheInstance = _cacheStates[keyName];
|
||||
|
||||
CacheState<TReturnType> state;
|
||||
|
||||
lock (_cacheStates)
|
||||
{
|
||||
state = ids is null ? cacheInstance.Values.First() : _cacheStates[keyName][GenerateKeyFromIds(ids)];
|
||||
}
|
||||
|
||||
// when auto refresh is off we want to check the expiration and value
|
||||
// when auto refresh is on, we want to only check the value, because it'll be refreshed automatically
|
||||
if ((state.IsExpired || !state.IsSet) && !_autoRefresh || _autoRefresh && !state.IsSet)
|
||||
{
|
||||
await RunCacheUpdate(state, cancellationToken);
|
||||
await RunCacheUpdate(state, ids, cancellationToken);
|
||||
}
|
||||
|
||||
return state.Value;
|
||||
}
|
||||
|
||||
private async Task RunCacheUpdate(CacheState<TReturnType> state, CancellationToken token)
|
||||
|
||||
private async Task RunCacheUpdate(CacheState<TReturnType> state, IEnumerable<object> ids, CancellationToken token)
|
||||
{
|
||||
try
|
||||
{
|
||||
_logger.LogDebug("Running update for {ClassName} {@State}", GetType().Name, state);
|
||||
await using var context = _contextFactory.CreateContext(false);
|
||||
var set = context.Set<TEntityType>();
|
||||
var value = await state.Getter(set, token);
|
||||
var value = await state.Getter(set, ids, token);
|
||||
state.Value = value;
|
||||
state.IsSet = true;
|
||||
state.LastRetrieval = DateTime.Now;
|
||||
@ -114,5 +148,8 @@ namespace Data.Helpers
|
||||
_logger.LogError(ex, "Could not get cached value for {Key}", state.Key);
|
||||
}
|
||||
}
|
||||
|
||||
private static string GenerateKeyFromIds(IEnumerable<object> ids) =>
|
||||
string.Join("_", ids.Select(id => id?.ToString() ?? "null"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -8,107 +8,94 @@ using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace Data.Helpers
|
||||
namespace Data.Helpers;
|
||||
|
||||
public class LookupCache<T> : ILookupCache<T> where T : class, IUniqueId
|
||||
{
|
||||
public class LookupCache<T> : ILookupCache<T> where T : class, IUniqueId
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private Dictionary<long, T> _cachedItems;
|
||||
private readonly SemaphoreSlim _onOperation = new(1, 1);
|
||||
|
||||
public LookupCache(ILogger<LookupCache<T>> logger, IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private Dictionary<long, T> _cachedItems;
|
||||
private readonly SemaphoreSlim _onOperation = new SemaphoreSlim(1, 1);
|
||||
_logger = logger;
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public LookupCache(ILogger<LookupCache<T>> logger, IDatabaseContextFactory contextFactory)
|
||||
public async Task<T> AddAsync(T item)
|
||||
{
|
||||
await _onOperation.WaitAsync();
|
||||
T existingItem = null;
|
||||
|
||||
if (_cachedItems.ContainsKey(item.Id))
|
||||
{
|
||||
_logger = logger;
|
||||
_contextFactory = contextFactory;
|
||||
existingItem = _cachedItems[item.Id];
|
||||
}
|
||||
|
||||
public async Task<T> AddAsync(T item)
|
||||
if (existingItem != null)
|
||||
{
|
||||
await _onOperation.WaitAsync();
|
||||
T existingItem = null;
|
||||
_logger.LogDebug("Cached item already added for {Type} {Id} {Value}", typeof(T).Name, item.Id,
|
||||
item.Value);
|
||||
_onOperation.Release();
|
||||
return existingItem;
|
||||
}
|
||||
|
||||
if (_cachedItems.ContainsKey(item.Id))
|
||||
try
|
||||
{
|
||||
_logger.LogDebug("Adding new {Type} with {Id} {Value}", typeof(T).Name, item.Id, item.Value);
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
context.Set<T>().Add(item);
|
||||
await context.SaveChangesAsync();
|
||||
_cachedItems.Add(item.Id, item);
|
||||
return item;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not add item to cache for {Type}", typeof(T).Name);
|
||||
throw new Exception("Could not add item to cache");
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onOperation.CurrentCount == 0)
|
||||
{
|
||||
existingItem = _cachedItems[item.Id];
|
||||
}
|
||||
|
||||
if (existingItem != null)
|
||||
{
|
||||
_logger.LogDebug("Cached item already added for {type} {id} {value}", typeof(T).Name, item.Id,
|
||||
item.Value);
|
||||
_onOperation.Release();
|
||||
return existingItem;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
_logger.LogDebug("Adding new {type} with {id} {value}", typeof(T).Name, item.Id, item.Value);
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
context.Set<T>().Add(item);
|
||||
await context.SaveChangesAsync();
|
||||
_cachedItems.Add(item.Id, item);
|
||||
return item;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not add item to cache for {type}", typeof(T).Name);
|
||||
throw new Exception("Could not add item to cache");
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onOperation.CurrentCount == 0)
|
||||
{
|
||||
_onOperation.Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<T> FirstAsync(Func<T, bool> query)
|
||||
{
|
||||
await _onOperation.WaitAsync();
|
||||
|
||||
try
|
||||
{
|
||||
var cachedResult = _cachedItems.Values.Where(query);
|
||||
|
||||
if (cachedResult.Any())
|
||||
{
|
||||
return cachedResult.FirstOrDefault();
|
||||
}
|
||||
}
|
||||
|
||||
catch
|
||||
{
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
if (_onOperation.CurrentCount == 0)
|
||||
{
|
||||
_onOperation.Release(1);
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public IEnumerable<T> GetAll()
|
||||
{
|
||||
return _cachedItems.Values;
|
||||
}
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
_cachedItems = await context.Set<T>().ToDictionaryAsync(item => item.Id);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not initialize caching for {cacheType}", typeof(T).Name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<T> FirstAsync(Func<T, bool> query)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onOperation.WaitAsync();
|
||||
var cachedResult = _cachedItems.Values.Where(query);
|
||||
return cachedResult.FirstOrDefault();
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onOperation.CurrentCount == 0)
|
||||
{
|
||||
_onOperation.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public IEnumerable<T> GetAll()
|
||||
{
|
||||
return _cachedItems.Values;
|
||||
}
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext(false);
|
||||
_cachedItems = await context.Set<T>().ToDictionaryAsync(item => item.Id);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not initialize caching for {CacheType}", typeof(T).Name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -24,7 +24,8 @@ namespace Data.MigrationContext
|
||||
{
|
||||
if (MigrationExtensions.IsMigration)
|
||||
{
|
||||
optionsBuilder.UseMySql(ServerVersion.AutoDetect("Server=127.0.0.1;Database=IW4MAdmin_Migration;Uid=root;Pwd=password;"))
|
||||
var connectionString = "Server=127.0.0.1;Database=IW4MAdmin_Migration;Uid=root;Pwd=password;";
|
||||
optionsBuilder.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString))
|
||||
.EnableDetailedErrors()
|
||||
.EnableSensitiveDataLogging();
|
||||
}
|
||||
|
@ -23,12 +23,13 @@ namespace Data.MigrationContext
|
||||
{
|
||||
if (MigrationExtensions.IsMigration)
|
||||
{
|
||||
AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
|
||||
optionsBuilder.UseNpgsql(
|
||||
"Host=127.0.0.1;Database=IW4MAdmin_Migration;Username=postgres;Password=password;",
|
||||
options => options.SetPostgresVersion(new Version("9.4")))
|
||||
options => options.SetPostgresVersion(new Version("12.9")))
|
||||
.EnableDetailedErrors(true)
|
||||
.EnableSensitiveDataLogging(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
1622
Data/Migrations/MySql/20220222215149_AddEFPenaltyIdentifier.Designer.cs
generated
Normal file
1622
Data/Migrations/MySql/20220222215149_AddEFPenaltyIdentifier.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
250
Data/Migrations/MySql/20220222215149_AddEFPenaltyIdentifier.cs
Normal file
250
Data/Migrations/MySql/20220222215149_AddEFPenaltyIdentifier.cs
Normal file
@ -0,0 +1,250 @@
|
||||
using Microsoft.EntityFrameworkCore.Metadata;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Data.Migrations.MySql
|
||||
{
|
||||
public partial class AddEFPenaltyIdentifier : Migration
|
||||
{
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.CreateTable(
|
||||
name: "EFPenaltyIdentifiers",
|
||||
columns: table => new
|
||||
{
|
||||
PenaltyIdentifierId = table.Column<int>(type: "int", nullable: false)
|
||||
.Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
|
||||
IPv4Address = table.Column<int>(type: "int", nullable: true),
|
||||
NetworkId = table.Column<long>(type: "bigint", nullable: false),
|
||||
PenaltyId = table.Column<int>(type: "int", nullable: false),
|
||||
Active = table.Column<bool>(type: "tinyint(1)", nullable: false)
|
||||
},
|
||||
constraints: table =>
|
||||
{
|
||||
table.PrimaryKey("PK_EFPenaltyIdentifiers", x => x.PenaltyIdentifierId);
|
||||
table.ForeignKey(
|
||||
name: "FK_EFPenaltyIdentifiers_EFPenalties_PenaltyId",
|
||||
column: x => x.PenaltyId,
|
||||
principalTable: "EFPenalties",
|
||||
principalColumn: "PenaltyId",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
})
|
||||
.Annotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_EFPenaltyIdentifiers_IPv4Address",
|
||||
table: "EFPenaltyIdentifiers",
|
||||
column: "IPv4Address");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_EFPenaltyIdentifiers_NetworkId",
|
||||
table: "EFPenaltyIdentifiers",
|
||||
column: "NetworkId");
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_EFPenaltyIdentifiers_PenaltyId",
|
||||
table: "EFPenaltyIdentifiers",
|
||||
column: "PenaltyId");
|
||||
}
|
||||
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropTable(
|
||||
name: "EFPenaltyIdentifiers");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Message",
|
||||
table: "InboxMessages",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Name",
|
||||
table: "EFWeaponAttachments",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: false,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext")
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "HostName",
|
||||
table: "EFServers",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "EndPoint",
|
||||
table: "EFServers",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Offense",
|
||||
table: "EFPenalties",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: false,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext")
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "AutomatedOffense",
|
||||
table: "EFPenalties",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Value",
|
||||
table: "EFMeta",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: false,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext")
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Extra",
|
||||
table: "EFMeta",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Name",
|
||||
table: "EFMeansOfDeath",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: false,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext")
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Name",
|
||||
table: "EFMaps",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: false,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext")
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "PasswordSalt",
|
||||
table: "EFClients",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Password",
|
||||
table: "EFClients",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "Message",
|
||||
table: "EFClientMessages",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "WeaponReference",
|
||||
table: "EFClientKills",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "PreviousValue",
|
||||
table: "EFChangeHistory",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "CurrentValue",
|
||||
table: "EFChangeHistory",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "WeaponReference",
|
||||
table: "EFACSnapshot",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
|
||||
migrationBuilder.AlterColumn<string>(
|
||||
name: "HitLocationReference",
|
||||
table: "EFACSnapshot",
|
||||
type: "longtext CHARACTER SET utf8mb4",
|
||||
nullable: true,
|
||||
oldClrType: typeof(string),
|
||||
oldType: "longtext",
|
||||
oldNullable: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4")
|
||||
.OldAnnotation("MySql:CharSet", "utf8mb4");
|
||||
}
|
||||
}
|
||||
}
|
1620
Data/Migrations/MySql/20220222230049_MakeEFPenaltyLinkIdNullable.Designer.cs
generated
Normal file
1620
Data/Migrations/MySql/20220222230049_MakeEFPenaltyLinkIdNullable.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,56 @@
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Data.Migrations.MySql
|
||||
{
|
||||
public partial class MakeEFPenaltyLinkIdNullable : Migration
|
||||
{
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropForeignKey(
|
||||
name: "FK_EFPenalties_EFAliasLinks_LinkId",
|
||||
table: "EFPenalties");
|
||||
|
||||
migrationBuilder.AlterColumn<int>(
|
||||
name: "LinkId",
|
||||
table: "EFPenalties",
|
||||
type: "int",
|
||||
nullable: true,
|
||||
oldClrType: typeof(int),
|
||||
oldType: "int");
|
||||
|
||||
migrationBuilder.AddForeignKey(
|
||||
name: "FK_EFPenalties_EFAliasLinks_LinkId",
|
||||
table: "EFPenalties",
|
||||
column: "LinkId",
|
||||
principalTable: "EFAliasLinks",
|
||||
principalColumn: "AliasLinkId");
|
||||
}
|
||||
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropForeignKey(
|
||||
name: "FK_EFPenalties_EFAliasLinks_LinkId",
|
||||
table: "EFPenalties");
|
||||
|
||||
migrationBuilder.AlterColumn<int>(
|
||||
name: "LinkId",
|
||||
table: "EFPenalties",
|
||||
type: "int",
|
||||
nullable: false,
|
||||
defaultValue: 0,
|
||||
oldClrType: typeof(int),
|
||||
oldType: "int",
|
||||
oldNullable: true);
|
||||
|
||||
migrationBuilder.AddForeignKey(
|
||||
name: "FK_EFPenalties_EFAliasLinks_LinkId",
|
||||
table: "EFPenalties",
|
||||
column: "LinkId",
|
||||
principalTable: "EFAliasLinks",
|
||||
principalColumn: "AliasLinkId",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
}
|
||||
}
|
||||
}
|
1623
Data/Migrations/MySql/20220223150028_AddAuditFieldsToEFPenaltyIdentifier.Designer.cs
generated
Normal file
1623
Data/Migrations/MySql/20220223150028_AddAuditFieldsToEFPenaltyIdentifier.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,48 @@
|
||||
using System;
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Data.Migrations.MySql
|
||||
{
|
||||
public partial class AddAuditFieldsToEFPenaltyIdentifier : Migration
|
||||
{
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropColumn(
|
||||
name: "Active",
|
||||
table: "EFPenaltyIdentifiers");
|
||||
|
||||
migrationBuilder.AddColumn<DateTime>(
|
||||
name: "CreatedDateTime",
|
||||
table: "EFPenaltyIdentifiers",
|
||||
type: "datetime(6)",
|
||||
nullable: false,
|
||||
defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
|
||||
|
||||
migrationBuilder.AddColumn<DateTime>(
|
||||
name: "UpdatedDateTime",
|
||||
table: "EFPenaltyIdentifiers",
|
||||
type: "datetime(6)",
|
||||
nullable: true);
|
||||
}
|
||||
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropColumn(
|
||||
name: "CreatedDateTime",
|
||||
table: "EFPenaltyIdentifiers");
|
||||
|
||||
migrationBuilder.DropColumn(
|
||||
name: "UpdatedDateTime",
|
||||
table: "EFPenaltyIdentifiers");
|
||||
|
||||
migrationBuilder.AddColumn<bool>(
|
||||
name: "Active",
|
||||
table: "EFPenaltyIdentifiers",
|
||||
type: "tinyint(1)",
|
||||
nullable: false,
|
||||
defaultValue: false);
|
||||
}
|
||||
}
|
||||
}
|
1626
Data/Migrations/MySql/20220329213440_AddConnectionInterruptedToEFServerSnapshot.Designer.cs
generated
Normal file
1626
Data/Migrations/MySql/20220329213440_AddConnectionInterruptedToEFServerSnapshot.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,25 @@
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Data.Migrations.MySql
|
||||
{
|
||||
public partial class AddConnectionInterruptedToEFServerSnapshot : Migration
|
||||
{
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.AddColumn<bool>(
|
||||
name: "ConnectionInterrupted",
|
||||
table: "EFServerSnapshot",
|
||||
type: "tinyint(1)",
|
||||
nullable: true);
|
||||
}
|
||||
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropColumn(
|
||||
name: "ConnectionInterrupted",
|
||||
table: "EFServerSnapshot");
|
||||
}
|
||||
}
|
||||
}
|
1632
Data/Migrations/MySql/20220404151444_AddSearchableIPToEFAlias.Designer.cs
generated
Normal file
1632
Data/Migrations/MySql/20220404151444_AddSearchableIPToEFAlias.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,29 @@
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Data.Migrations.MySql
|
||||
{
|
||||
public partial class AddSearchableIPToEFAlias : Migration
|
||||
{
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.AddColumn<string>(
|
||||
name: "SearchableIPAddress",
|
||||
table: "EFAlias",
|
||||
type: "varchar(255)",
|
||||
maxLength: 255,
|
||||
nullable: true,
|
||||
computedColumnSql: "CONCAT((IPAddress & 255), \".\", ((IPAddress >> 8) & 255), \".\", ((IPAddress >> 16) & 255), \".\", ((IPAddress >> 24) & 255))",
|
||||
stored: true)
|
||||
.Annotation("MySql:CharSet", "utf8mb4");
|
||||
}
|
||||
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropColumn(
|
||||
name: "SearchableIPAddress",
|
||||
table: "EFAlias");
|
||||
}
|
||||
}
|
||||
}
|
1634
Data/Migrations/MySql/20220404192417_AddIndexToSearchableIPToEFAlias.Designer.cs
generated
Normal file
1634
Data/Migrations/MySql/20220404192417_AddIndexToSearchableIPToEFAlias.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,24 @@
|
||||
using Microsoft.EntityFrameworkCore.Migrations;
|
||||
|
||||
#nullable disable
|
||||
|
||||
namespace Data.Migrations.MySql
|
||||
{
|
||||
public partial class AddIndexToSearchableIPToEFAlias : Migration
|
||||
{
|
||||
protected override void Up(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_EFAlias_SearchableIPAddress",
|
||||
table: "EFAlias",
|
||||
column: "SearchableIPAddress");
|
||||
}
|
||||
|
||||
protected override void Down(MigrationBuilder migrationBuilder)
|
||||
{
|
||||
migrationBuilder.DropIndex(
|
||||
name: "IX_EFAlias_SearchableIPAddress",
|
||||
table: "EFAlias");
|
||||
}
|
||||
}
|
||||
}
|
1636
Data/Migrations/MySql/20220422202702_AddGameToEFClient.Designer.cs
generated
Normal file
1636
Data/Migrations/MySql/20220422202702_AddGameToEFClient.Designer.cs
generated
Normal file
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user