weiai/linker
1
0
Fork 0
mirror of https://github.com/snltty/linker.git synced 2025-12-18 09:26:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

重构中继

Browse Source
This commit is contained in:
snltty
2025-11-27 16:41:58 +08:00
parent fd532d3705
commit a90ed16721
24 changed files with 288 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shells/version.txt
View File

@@ -1,5 +1,5 @@
v1.9.6
2025-11-26 17:37:42
2025-11-27 16:41:58
1. 一些累计更新，一些BUG修复
2. 优化客户端数据同步，减少服务器流量
3. 去除cdkey，改为发电解锁中继速度

3
src/linker.libs/web/IWebApiServer.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace linker.libs.web
{
@@ -20,7 +21,7 @@ namespace linker.libs.web
public interface IWebApiController
{
public string Path { get; }
public Memory<byte> Handle(string query);
public Task<Memory<byte>> Handle(string query);
public void Free();
}

2
src/linker.libs/web/WebApiServer.cs
View File

@@ -88,7 +88,7 @@ namespace linker.libs.web
if (dic.TryGetValue(path, out IWebApiController controller))
{
Memory<byte> memory = controller.Handle(query);
Memory<byte> memory = await controller.Handle(query);
response.ContentLength64 = memory.Length;
response.ContentType = "application/json";
await response.OutputStream.WriteAsync(memory);

6
src/linker.messenger.action/SignInArgsAction.cs
View File

@@ -226,7 +226,7 @@ namespace linker.messenger.action
}
return string.Empty;
}
public async Task<List<RelayServerNodeReportInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayServerNodeReportInfo> nodes)
public async Task<List<RelayNodeStoreInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayNodeStoreInfo> nodes)
{
if (string.IsNullOrWhiteSpace(actionServerStore.RelayNodeUrl) == false)
{
@@ -242,7 +242,7 @@ namespace linker.messenger.action
FromMachineName = fromMachine.MachineName,
Nodes = nodes.Select(c => new JsonArgRelayNodeItemInfo
{
Id = c.Id,
Id = c.NodeId,
Name = c.Name,
Public = c.Public
}).ToList() ?? []
@@ -261,7 +261,7 @@ namespace linker.messenger.action
string ids = await actionTransfer.ExcuteActions(Replace(replace, str), actionServerStore.RelayNodeUrl).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(ids)) return [];
return nodes.Where(c => ids.Split(',').Contains(c.Id)).ToList();
return nodes.Where(c => ids.Split(',').Contains(c.NodeId)).ToList();
}
return nodes;
}

4
src/linker.messenger.flow/FlowRelayReport.cs
View File

@@ -32,8 +32,8 @@ namespace linker.messenger.flow
public sealed class RelayReportResolverFlow : RelayServerReportResolver
{
private readonly RelayReportFlow relayReportFlow;
public RelayReportResolverFlow(RelayReportFlow relayReportFlow, RelayServerMasterTransfer relayServerTransfer, IMessengerResolver messengerResolver)
: base(relayServerTransfer, messengerResolver)
public RelayReportResolverFlow(RelayReportFlow relayReportFlow, IMessengerResolver messengerResolver)
: base( messengerResolver)
{
this.relayReportFlow = relayReportFlow;
}

5
src/linker.messenger.flow/webapi/WebApiCitysController.cs
View File

@@ -1,5 +1,6 @@
using linker.libs.extends;
using linker.libs.web;
using System.Threading.Tasks;
namespace linker.messenger.flow.webapi
{
public sealed class WebApiCitysController : IWebApiController
@@ -11,9 +12,9 @@ namespace linker.messenger.flow.webapi
{
this.flowResolver = flowResolver;
}
public Memory<byte> Handle(string query)
public async Task<Memory<byte>> Handle(string query)
{
return flowResolver.GetCitys().ToJson().ToBytes();
return await Task.FromResult(flowResolver.GetCitys().ToJson().ToBytes()).ConfigureAwait(false);
}
public void Free()

7
src/linker.messenger.flow/webapi/WebApiOnlineController.cs
View File

@@ -1,6 +1,7 @@
using linker.libs.extends;
using linker.libs.web;
using linker.messenger.signin;
using System.Threading.Tasks;
namespace linker.messenger.flow.webapi
{
public sealed class WebApiOnlineController : IWebApiController
@@ -14,10 +15,10 @@ namespace linker.messenger.flow.webapi
this.signCaching = signCaching;
this.flowResolver = flowResolver;
}
public Memory<byte> Handle(string query)
public async Task<Memory<byte>> Handle(string query)
{
signCaching.GetOnline(out int all, out int online);
return new
return await Task.FromResult(new
{
CurrentServer = new
{
@@ -30,7 +31,7 @@ namespace linker.messenger.flow.webapi
Online = flowResolver.ReceiveBytes >> 32,
Server = flowResolver.SendtBytes,
}
}.ToJson().ToBytes();
}.ToJson().ToBytes()).ConfigureAwait(false);
}
public void Free()

5
src/linker.messenger.flow/webapi/WebApiSystemsController.cs
View File

@@ -1,5 +1,6 @@
using linker.libs.extends;
using linker.libs.web;
using System.Threading.Tasks;
namespace linker.messenger.flow.webapi
{
public sealed class WebApiSystemsController : IWebApiController
@@ -11,9 +12,9 @@ namespace linker.messenger.flow.webapi
{
this.flowResolver = flowResolver;
}
public Memory<byte> Handle(string query)
public async Task<Memory<byte>> Handle(string query)
{
return flowResolver.GetSystems().ToJson().ToBytes();
return await Task.FromResult(flowResolver.GetSystems().ToJson().ToBytes()).ConfigureAwait(false);
}
public void Free()

2
src/linker.messenger.relay/client/RelayApiController.cs
View File

@@ -33,7 +33,7 @@ namespace linker.messenger.relay.client
this.tunnelTransfer = tunnelTransfer;
}
public List<RelayServerNodeReportInfo> Subscribe(ApiControllerParamsInfo param)
public List<RelayNodeStoreInfo> Subscribe(ApiControllerParamsInfo param)
{
relayTestTransfer.Subscribe();
return relayTestTransfer.Nodes;

7
src/linker.messenger.relay/client/RelayClientTestTransfer.cs
View File

@@ -16,7 +16,7 @@ namespace linker.messenger.relay.client
private readonly TransportRelay transportRelay;
private readonly SignInClientState signInClientState;
public List<RelayServerNodeReportInfo> Nodes { get; private set; } = new List<RelayServerNodeReportInfo>();
public List<RelayNodeStoreInfo> Nodes { get; private set; } = new List<RelayNodeStoreInfo>();
public RelayClientTestTransfer(TransportRelay transportRelay, SignInClientState signInClientState)
{
@@ -39,10 +39,11 @@ namespace linker.messenger.relay.client
Nodes = await transportRelay.RelayTestAsync().ConfigureAwait(false);
var tasks = Nodes.Select(async (c) =>
{
c.EndPoint = c.EndPoint == null || c.EndPoint.Address.Equals(IPAddress.Any) ? signInClientState.Connection.Address : c.EndPoint;
IPEndPoint ep = NetworkHelper.GetEndPoint(c.Host, 1802);
IPAddress ip = ep.Address.Equals(IPAddress.Any) || ep.Address.Equals(IPAddress.Loopback) ? signInClientState.Connection.Address.Address : ep.Address;
using Ping ping = new Ping();
var resp = await ping.SendPingAsync(c.EndPoint.Address, 1000);
var resp = await ping.SendPingAsync(ip, 1000);
c.Delay = resp.Status == IPStatus.Success ? (int)resp.RoundtripTime : -1;
});
await Task.WhenAll(tasks).ConfigureAwait(false);

22
src/linker.messenger.relay/messenger/RelayMessenger.cs
View File

@@ -46,10 +46,10 @@ namespace linker.messenger.relay.messenger
{
if (signCaching.TryGet(connection.Id, out SignCacheInfo cache) == false)
{
connection.Write(serializer.Serialize(new List<RelayServerNodeReportInfo> { }));
connection.Write(serializer.Serialize(new List<RelayNodeStoreInfo> { }));
return;
}
List<RelayServerNodeReportInfo> nodes = await GetNodes(cache);
List<RelayNodeStoreInfo> nodes = await GetNodes(cache);
connection.Write(serializer.Serialize(nodes));
}
@@ -72,9 +72,9 @@ namespace linker.messenger.relay.messenger
return;
}
connection.Write(serializer.Serialize(new RelayAskResultInfo { Nodes = nodes, MasterId = relayServerNodeStore.Node.Id }));
connection.Write(serializer.Serialize(new RelayAskResultInfo { Nodes = nodes, MasterId = relayServerNodeStore.Node.NodeId }));
}
private async Task<List<RelayServerNodeReportInfo>> GetNodes(SignCacheInfo from)
private async Task<List<RelayNodeStoreInfo>> GetNodes(SignCacheInfo from)
{
return await relayServerTransfer.GetNodes(from.Super, from.UserId, from.MachineId);
}
@@ -97,5 +97,19 @@ namespace linker.messenger.relay.messenger
}
}
[MessengerId((ushort)RelayMessengerIds.NodeReport)]
public void NodeReport188(IConnection connection)
{
try
{
relayServerReportResolver.Add(connection.ReceiveRequestWrap.Payload.Length, 0);
RelayServerNodeReportInfoOld info = serializer.Deserialize<RelayServerNodeReportInfoOld>(connection.ReceiveRequestWrap.Payload.Span);
}
catch (Exception)
{
}
connection.Write(serializer.Serialize(VersionHelper.Version));
}
}
}

1
src/linker.messenger.relay/messenger/RelayMessengerIds.cs
View File

@@ -9,6 +9,7 @@
Nodes = 2105,
NodeGetCache = 2112,
NodeReport = 2128,
Hosts = 2133,

20
src/linker.messenger.relay/server/IRelayServerMasterStore.cs Normal file
View File

@@ -0,0 +1,20 @@
namespace linker.messenger.relay.server
{
public interface IRelayServerMasterStore
{
public Task<List<RelayNodeStoreInfo>> GetAll();
}
public sealed class RelayNodeStoreInfo : RelayServerNodeReportInfo
{
public int Id { get; set; }
public int BandwidthEachConnection { get; set; } = 50;
public bool Public { get; set; }
public int Delay { get; set; }
public long LastTicks { get; set; }
}
}

61
src/linker.messenger.relay/server/IRelayServerNodeStore.cs
View File

@@ -39,52 +39,33 @@ namespace linker.messenger.relay.server
public void Confirm();
}
public sealed class RelayServerNodeInfo
public class RelayServerNodeInfo
{
private string id = Guid.NewGuid().ToString().ToUpper();
public string Id
{
get => id; set
{
id = value.SubStr(0, 36);
}
}
private string nodeId = Guid.NewGuid().ToString().ToUpper();
public string NodeId { get => nodeId; set { nodeId = value.SubStr(0, 36); } }
private string name = Dns.GetHostName().SubStr(0, 32);
public string Name
{
get => name; set
{
name = value.SubStr(0, 32);
}
}
public string Name { get => name; set { name = value.SubStr(0, 32); } }
public string Host { get; set; } = string.Empty;
public int MaxConnection { get; set; }
public double MaxBandwidth { get; set; }
public double MaxBandwidthTotal { get; set; }
public double MaxGbTotal { get; set; }
public long MaxGbTotalLastBytes { get; set; }
public int MaxGbTotalMonth { get; set; }
public bool Public { get; set; }
public string MasterHost { get; set; } = string.Empty;
#if DEBUG
public string MasterSecretKey { get; set; } = Helper.GlobalString;
#else
public string MasterSecretKey { get; set; } = string.Empty;
#endif
public string Url { get; set; } = "https://linker-doc.snltty.com";
public bool AllowTcp { get; set; } = true;
public bool AllowUdp { get; set; }
public bool Sync2Server { get; set; }
public string[] MasterHosts { get; set; } = [];
public TunnelProtocolType Protocol { get; set; } = TunnelProtocolType.Tcp;
public int Connections { get; set; } = 1000;
public int Bandwidth { get; set; } = 50;
public int DataEachMonth { get; set; } = 100;
public long DataRemain { get; set; }
public int DataMonth { get; set; }
public string Url { get; set; } = "https://linker.snltty.com";
public string Logo { get; set; } = "https://linker.snltty.com/img/logo.png";
}
public partial class RelayServerNodeReportInfo
public class RelayServerNodeReportInfo : RelayServerNodeInfo
{
public string Version { get; set; } = string.Empty;
public int ConnectionsRatio { get; set; }
public int BandwidthRatio { get; set; }
}
public partial class RelayServerNodeReportInfoOld
{
public string Id { get; set; } = string.Empty;
public string Name { get; set; } = string.Empty;
@@ -101,9 +82,7 @@ namespace linker.messenger.relay.server
public bool Public { get; set; }
public int Delay { get; set; }
public IPEndPoint EndPoint { get; set; }
public long LastTicks { get; set; }
/// <summary>

48
src/linker.messenger.relay/server/RelayServerMasterTransfer.cs
View File

@@ -1,6 +1,5 @@

using linker.messenger.signin;
using System.Collections.Concurrent;
namespace linker.messenger.relay.server
{
@@ -9,16 +8,15 @@ namespace linker.messenger.relay.server
/// </summary>
public class RelayServerMasterTransfer
{
private readonly ConcurrentDictionary<string, RelayServerNodeReportInfo> reports = new ConcurrentDictionary<string, RelayServerNodeReportInfo>();
private readonly IRelayServerCaching relayCaching;
private readonly IRelayServerWhiteListStore relayServerWhiteListStore;
private readonly IRelayServerMasterStore relayServerMasterStore;
public RelayServerMasterTransfer(IRelayServerCaching relayCaching, IRelayServerWhiteListStore relayServerWhiteListStore)
public RelayServerMasterTransfer(IRelayServerCaching relayCaching, IRelayServerWhiteListStore relayServerWhiteListStore, IRelayServerMasterStore relayServerMasterStore)
{
this.relayCaching = relayCaching;
this.relayServerWhiteListStore = relayServerWhiteListStore;
this.relayServerMasterStore = relayServerMasterStore;
}
@@ -40,9 +38,9 @@ namespace linker.messenger.relay.server
public async Task<RelayCacheInfo> TryGetRelayCache(string key, string nodeid)
{
if (relayCaching.TryGetValue(key, out RelayCacheInfo cache) && reports.TryGetValue(nodeid, out var node))
if (relayCaching.TryGetValue(key, out RelayCacheInfo cache))
{
List<double> bandwidth = await relayServerWhiteListStore.GetBandwidth(cache.UserId, cache.FromId, cache.ToId, node.Id);
List<double> bandwidth = await relayServerWhiteListStore.GetBandwidth(cache.UserId, cache.FromId, cache.ToId, nodeid);
if (bandwidth.Any(c => c < 0))
{
return null;
@@ -61,42 +59,42 @@ namespace linker.messenger.relay.server
/// </summary>
/// <param name="validated">是否已认证</param>
/// <returns></returns>
public async Task<List<RelayServerNodeReportInfo>> GetNodes(bool validated, string userid, string machineId)
public async Task<List<RelayNodeStoreInfo>> GetNodes(bool validated, string userid, string machineId)
{
var nodes = (await relayServerWhiteListStore.GetNodes(userid, machineId)).Where(c => c.Bandwidth >= 0).SelectMany(c => c.Nodes);
var result = reports.Values
var result = (await relayServerMasterStore.GetAll())
.Where(c => Environment.TickCount64 - c.LastTicks < 15000)
.Where(c =>
{
return validated || nodes.Contains(c.Id) || nodes.Contains("*")
|| (c.Public && c.ConnectionRatio < c.MaxConnection && (c.MaxGbTotal == 0 || (c.MaxGbTotal > 0 && c.MaxGbTotalLastBytes > 0)));
return validated || nodes.Contains(c.NodeId) || nodes.Contains("*")
|| (c.Public && c.ConnectionsRatio < c.Connections && (c.DataEachMonth == 0 || (c.DataEachMonth > 0 && c.DataRemain > 0)));
})
.OrderByDescending(c => c.LastTicks);
return result.OrderByDescending(x => x.MaxConnection == 0 ? int.MaxValue : x.MaxConnection)
.ThenBy(x => x.ConnectionRatio)
return result.OrderByDescending(x => x.Connections == 0 ? int.MaxValue : x.Connections)
.ThenBy(x => x.ConnectionsRatio)
.ThenBy(x => x.BandwidthRatio)
.ThenByDescending(x => x.MaxBandwidth == 0 ? double.MaxValue : x.MaxBandwidth)
.ThenByDescending(x => x.MaxBandwidthTotal == 0 ? double.MaxValue : x.MaxBandwidthTotal)
.ThenByDescending(x => x.MaxGbTotal == 0 ? double.MaxValue : x.MaxGbTotal)
.ThenByDescending(x => x.MaxGbTotalLastBytes == 0 ? long.MaxValue : x.MaxGbTotalLastBytes)
.ThenByDescending(x => x.BandwidthEachConnection == 0 ? int.MaxValue : x.BandwidthEachConnection)
.ThenByDescending(x => x.Bandwidth == 0 ? int.MaxValue : x.Bandwidth)
.ThenByDescending(x => x.DataEachMonth == 0 ? int.MaxValue : x.DataEachMonth)
.ThenByDescending(x => x.DataRemain == 0 ? long.MaxValue : x.DataRemain)
.ToList();
}
public List<RelayServerNodeReportInfo> GetPublicNodes()
public async Task<List<RelayNodeStoreInfo>> GetPublicNodes()
{
var result = reports.Values
var result = (await relayServerMasterStore.GetAll())
.Where(c => Environment.TickCount64 - c.LastTicks < 15000)
.Where(c => c.Public)
.OrderByDescending(c => c.LastTicks);
return result.OrderByDescending(x => x.MaxConnection == 0 ? int.MaxValue : x.MaxConnection)
.ThenBy(x => x.ConnectionRatio)
return result.OrderByDescending(x => x.Connections == 0 ? int.MaxValue : x.Connections)
.ThenBy(x => x.ConnectionsRatio)
.ThenBy(x => x.BandwidthRatio)
.ThenByDescending(x => x.MaxBandwidth == 0 ? double.MaxValue : x.MaxBandwidth)
.ThenByDescending(x => x.MaxBandwidthTotal == 0 ? double.MaxValue : x.MaxBandwidthTotal)
.ThenByDescending(x => x.MaxGbTotal == 0 ? double.MaxValue : x.MaxGbTotal)
.ThenByDescending(x => x.MaxGbTotalLastBytes == 0 ? long.MaxValue : x.MaxGbTotalLastBytes)
.ThenByDescending(x => x.BandwidthEachConnection == 0 ? int.MaxValue : x.BandwidthEachConnection)
.ThenByDescending(x => x.Bandwidth == 0 ? int.MaxValue : x.Bandwidth)
.ThenByDescending(x => x.DataEachMonth == 0 ? int.MaxValue : x.DataEachMonth)
.ThenByDescending(x => x.DataRemain == 0 ? long.MaxValue : x.DataRemain)
.ToList();
}

40
src/linker.messenger.relay/server/RelayServerNodeTransfer.cs
View File

@@ -36,7 +36,7 @@ namespace linker.messenger.relay.server
this.messengerSender = messengerSender;
this.relayServerConnectionTransfer = relayServerConnectionTransfer;
limitTotal.SetLimit((uint)Math.Ceiling((Node.MaxBandwidthTotal * 1024 * 1024) / 8.0));
limitTotal.SetLimit((uint)Math.Ceiling((Node.Bandwidth * 1024 * 1024) / 8.0));
TrafficTask();
}
@@ -56,7 +56,7 @@ namespace linker.messenger.relay.server
{
Connection = connection,
MessengerId = (ushort)RelayMessengerIds.NodeGetCache,
Payload = serializer.Serialize(new ValueTuple<string, string>(key, Node.Id)),
Payload = serializer.Serialize(new ValueTuple<string, string>(key, Node.NodeId)),
Timeout = 1000
}).ConfigureAwait(false);
if (resp.Code == MessageResponeCodes.OK && resp.Data.Length > 0)
@@ -75,9 +75,6 @@ namespace linker.messenger.relay.server
public bool Validate(TunnelProtocolType tunnelProtocolType)
{
if (tunnelProtocolType == TunnelProtocolType.Udp && Node.AllowUdp == false) return false;
if (tunnelProtocolType == TunnelProtocolType.Tcp && Node.AllowTcp == false) return false;
return true;
}
/// <summary>
@@ -94,9 +91,9 @@ namespace linker.messenger.relay.server
/// <returns></returns>
private bool ValidateConnection(RelayCacheInfo relayCache)
{
bool res = Node.MaxConnection == 0 || Node.MaxConnection * 2 > connectionNum;
bool res = Node.Connections == 0 || Node.Connections * 2 > connectionNum;
if (res == false && LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Debug($"relay ValidateConnection false,{connectionNum}/{Node.MaxConnection * 2}");
LoggerHelper.Instance.Debug($"relay ValidateConnection false,{connectionNum}/{Node.Connections * 2}");
return res;
}
@@ -106,11 +103,11 @@ namespace linker.messenger.relay.server
/// <returns></returns>
private bool ValidateBytes(RelayCacheInfo relayCache)
{
bool res = Node.MaxGbTotal == 0
|| (Node.MaxGbTotal > 0 && Node.MaxGbTotalLastBytes > 0);
bool res = Node.DataEachMonth == 0
|| (Node.DataEachMonth > 0 && Node.DataRemain > 0);
if (res == false && LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)
LoggerHelper.Instance.Debug($"relay ValidateBytes false,{Node.MaxGbTotalLastBytes}bytes/{Node.MaxGbTotal}gb");
LoggerHelper.Instance.Debug($"relay ValidateBytes false,{Node.DataRemain}bytes/{Node.DataEachMonth}gb");
return res;
}
@@ -184,11 +181,11 @@ namespace linker.messenger.relay.server
{
Interlocked.Add(ref bytes, length);
if (Node.MaxGbTotal == 0) return true;
if (Node.DataEachMonth == 0) return true;
Interlocked.Add(ref cache.Sendt, length);
return Node.MaxGbTotalLastBytes > 0;
return Node.DataRemain > 0;
}
/// <summary>
@@ -204,32 +201,25 @@ namespace linker.messenger.relay.server
return;
}
//无限制
if (relayCache.Cache.Super || Node.MaxBandwidth == 0)
{
relayCache.Limit.SetLimit(0);
return;
}
relayCache.Limit.SetLimit((uint)Math.Ceiling(Node.MaxBandwidth * 1024 * 1024 / 8.0));
relayCache.Limit.SetLimit((uint)Math.Ceiling(Node.Bandwidth * 1024 * 1024 / 8.0));
}
private void ResetNodeBytes()
{
if (Node.MaxGbTotal == 0) return;
if (Node.DataEachMonth == 0) return;
foreach (var cache in trafficDict.Values)
{
long length = Interlocked.Exchange(ref cache.Sendt, 0);
if (Node.MaxGbTotalLastBytes >= length)
relayServerNodeStore.SetMaxGbTotalLastBytes(Node.MaxGbTotalLastBytes - length);
if (Node.DataRemain >= length)
relayServerNodeStore.SetMaxGbTotalLastBytes(Node.DataRemain - length);
else relayServerNodeStore.SetMaxGbTotalLastBytes(0);
}
if (Node.MaxGbTotalMonth != DateTime.Now.Month)
if (Node.DataMonth != DateTime.Now.Month)
{
relayServerNodeStore.SetMaxGbTotalMonth(DateTime.Now.Month);
relayServerNodeStore.SetMaxGbTotalLastBytes((long)(Node.MaxGbTotal * 1024 * 1024 * 1024));
relayServerNodeStore.SetMaxGbTotalLastBytes((long)(Node.DataEachMonth * 1024 * 1024 * 1024));
}
relayServerNodeStore.Confirm();
}

20
src/linker.messenger.relay/server/RelayServerReportResolver.cs
View File

@@ -13,12 +13,10 @@ namespace linker.messenger.relay.server
{
public byte Type => (byte)ResolverType.RelayReport;
private readonly RelayServerMasterTransfer relayServerTransfer;
private readonly IMessengerResolver messengerResolver;
public RelayServerReportResolver(RelayServerMasterTransfer relayServerTransfer, IMessengerResolver messengerResolver)
public RelayServerReportResolver(IMessengerResolver messengerResolver)
{
this.relayServerTransfer = relayServerTransfer;
this.messengerResolver = messengerResolver;
}
@@ -31,24 +29,10 @@ namespace linker.messenger.relay.server
byte[] buffer = ArrayPool<byte>.Shared.Rent(1024);
try
{
await socket.ReceiveAsync(buffer.AsMemory(), SocketFlags.None).ConfigureAwait(false);
await socket.ReceiveAsync(buffer.AsMemory(0, 1), SocketFlags.None).ConfigureAwait(false);
int length = buffer[0];
Add(memory.Length,length);
await socket.ReceiveAsync(buffer.AsMemory(0, length), SocketFlags.None).ConfigureAwait(false);
string key = buffer.AsMemory(0, length).GetString();
/*
if (relayServerMasterStore.Master.SecretKey.Sha256() == key)
{
await messengerResolver.BeginReceiveServer(socket, Helper.EmptyArray).ConfigureAwait(false);
}
else*/
{
socket.SafeClose();
}
}
catch (Exception ex)
{
if (LoggerHelper.Instance.LoggerLevel <= LoggerTypes.DEBUG)

2
src/linker.messenger.relay/server/validator/IRelayServerValidator.cs
View File

@@ -23,6 +23,6 @@ namespace linker.messenger.relay.server.validator
/// <param name="fromMachine"></param>
/// <param name="nodes"></param>
/// <returns></returns>
public Task<List<RelayServerNodeReportInfo>> Validate(string userid, SignCacheInfo from, List<RelayServerNodeReportInfo> nodes);
public Task<List<RelayNodeStoreInfo>> Validate(string userid, SignCacheInfo from, List<RelayNodeStoreInfo> nodes);
}
}

2
src/linker.messenger.relay/server/validator/RelayServerValidatorTransfer.cs
View File

@@ -59,7 +59,7 @@ namespace linker.messenger.relay.server.validator
}
return string.Empty;
}
public async Task<List<RelayServerNodeReportInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayServerNodeReportInfo> nodes)
public async Task<List<RelayNodeStoreInfo>> Validate(string userid, SignCacheInfo fromMachine, List<RelayNodeStoreInfo> nodes)
{
foreach (var item in validators)
{

22
src/linker.messenger.relay/transport/TransportRelay.cs
View File

@@ -62,7 +62,7 @@ namespace linker.tunnel.transport
{
//问一下能不能中继
RelayAskResultInfo ask = await RelayAsk(tunnelTransportInfo).ConfigureAwait(false);
List<RelayServerNodeReportInfo> nodes = ask.Nodes;
List<RelayNodeStoreInfo> nodes = ask.Nodes;
if (ask.Nodes.Count == 0)
{
return null;
@@ -149,7 +149,7 @@ namespace linker.tunnel.transport
}).ConfigureAwait(false);
if (resp.Code != MessageResponeCodes.OK)
{
return new RelayAskResultInfo { Info = relayInfo, Nodes = new List<RelayServerNodeReportInfo>() };
return new RelayAskResultInfo { Info = relayInfo, Nodes = new List<RelayNodeStoreInfo>() };
}
RelayAskResultInfo ask = serializer.Deserialize<RelayAskResultInfo>(resp.Data.Span);
ask.Info = relayInfo;
@@ -164,12 +164,12 @@ namespace linker.tunnel.transport
try
{
foreach (var node in ask.Nodes.Where(c => c.Id == ask.Info.NodeId).Concat(ask.Nodes.Where(c => c.Id != ask.Info.NodeId)))
foreach (var node in ask.Nodes.Where(c => c.NodeId == ask.Info.NodeId).Concat(ask.Nodes.Where(c => c.NodeId != ask.Info.NodeId)))
{
try
{
IPEndPoint ep = node.EndPoint;
if (ep == null || ep.Address.Equals(IPAddress.Any))
IPEndPoint ep = NetworkHelper.GetEndPoint(node.Host,1802);
if (ep == null || ep.Address.Equals(IPAddress.Any) || ep.Address.Equals(IPAddress.Loopback))
{
ep = signInClientState.Connection.Address;
}
@@ -198,8 +198,8 @@ namespace linker.tunnel.transport
};
if(await SendMessage(socket, relayMessage).ConfigureAwait(false))
{
ask.Info.Node = node.EndPoint;
ask.Info.NodeId = node.Id;
ask.Info.Node = ep;
ask.Info.NodeId = node.NodeId;
return socket;
}
socket.SafeClose();
@@ -355,7 +355,7 @@ namespace linker.tunnel.transport
{
}
public async Task<List<RelayServerNodeReportInfo>> RelayTestAsync()
public async Task<List<RelayNodeStoreInfo>> RelayTestAsync()
{
try
{
@@ -368,13 +368,13 @@ namespace linker.tunnel.transport
if (resp.Code == MessageResponeCodes.OK)
{
return serializer.Deserialize<List<RelayServerNodeReportInfo>>(resp.Data.Span);
return serializer.Deserialize<List<RelayNodeStoreInfo>>(resp.Data.Span);
}
}
catch (Exception)
{
}
return new List<RelayServerNodeReportInfo>();
return new List<RelayNodeStoreInfo>();
}
}
@@ -391,7 +391,7 @@ namespace linker.tunnel.transport
{
public RelayInfo Info { get; set; }
public string MasterId { get; set; }
public List<RelayServerNodeReportInfo> Nodes { get; set; } = new List<RelayServerNodeReportInfo>();
public List<RelayNodeStoreInfo> Nodes { get; set; } = new List<RelayNodeStoreInfo>();
}
public sealed partial class RelayMessageInfo
{

21
src/linker.messenger.relay/webapi/WebApiRelayNodesController.cs
View File

@@ -13,29 +13,28 @@ namespace linker.messenger.relay.webapi
{
this.relayServerMasterTransfer = relayServerMasterTransfer;
}
public Memory<byte> Handle(string query)
public async Task<Memory<byte>> Handle(string query)
{
return relayServerMasterTransfer.GetPublicNodes().Select(c =>
return (await relayServerMasterTransfer.GetPublicNodes().ConfigureAwait(false)).Select(c =>
{
return new
{
AllowProtocol = c.AllowProtocol,
AllowProtocol = c.Protocol,
Name = c.Name,
Version = c.Version,
BandwidthMaxMbps = c.MaxBandwidthTotal,
BandwidthConnMbps = c.MaxBandwidth,
BandwidthMaxMbps = c.Bandwidth,
BandwidthConnMbps = c.BandwidthEachConnection,
BandwidthCurrentMbps = c.BandwidthRatio,
BandwidthGbMonth = c.MaxGbTotal,
BandwidthByteAvailable = c.MaxGbTotalLastBytes,
BandwidthGbMonth = c.DataEachMonth,
BandwidthByteAvailable = c.DataRemain,
ConnectionMaxNum = c.MaxConnection,
ConnectionCurrentNum = c.ConnectionRatio,
ConnectionMaxNum = c.Connections,
ConnectionCurrentNum = c.ConnectionsRatio,
EndPoint = c.EndPoint,
Url = c.Url,
Logo = c.Logo,
};
}).ToJson().ToBytes();
}

1
src/linker.messenger.serializer.memorypack/Entry.cs
View File

@@ -64,6 +64,7 @@ namespace linker.messenger.serializer.memorypack
MemoryPackFormatterProvider.Register(new RelayAskResultInfoFormatter());
MemoryPackFormatterProvider.Register(new RelayCacheInfoFormatter());
MemoryPackFormatterProvider.Register(new RelayMessageInfoFormatter());
MemoryPackFormatterProvider.Register(new RelayServerNodeReportInfoFormatter());
MemoryPackFormatterProvider.Register(new AccessUpdateInfoFormatter());

138
src/linker.messenger.serializer.memorypack/RelaySerializer.cs
View File

@@ -1,6 +1,8 @@
using linker.messenger.relay.server;
using linker.tunnel.connection;
using linker.tunnel.transport;
using MemoryPack;
using System.Net;
namespace linker.messenger.serializer.memorypack
{
@@ -14,10 +16,10 @@ namespace linker.messenger.serializer.memorypack
[MemoryPackInclude]
string MasterId => info.MasterId;
[MemoryPackInclude]
List<RelayServerNodeReportInfo> Nodes => info.Nodes;
List<RelayNodeStoreInfo> Nodes => info.Nodes;
[MemoryPackConstructor]
SerializableRelayAskResultInfo(string masterId, List<RelayServerNodeReportInfo> nodes)
SerializableRelayAskResultInfo(string masterId, List<RelayNodeStoreInfo> nodes)
{
var info = new RelayAskResultInfo { MasterId = masterId, Nodes = nodes };
this.info = info;
@@ -53,7 +55,7 @@ namespace linker.messenger.serializer.memorypack
reader.TryReadObjectHeader(out byte count);
value.MasterId = reader.ReadValue<string>();
if (count > 1)
value.Nodes = reader.ReadValue<List<RelayServerNodeReportInfo>>();
value.Nodes = reader.ReadValue<List<RelayNodeStoreInfo>>();
}
}
@@ -214,4 +216,134 @@ namespace linker.messenger.serializer.memorypack
}
}
[MemoryPackable]
public readonly partial struct SerializableRelayServerNodeReportInfo
{
[MemoryPackIgnore]
public readonly RelayServerNodeReportInfoOld info;
[MemoryPackInclude]
string Id => info.Id;
[MemoryPackInclude]
string Name => info.Name;
[MemoryPackInclude]
int MaxConnection => info.MaxConnection;
[MemoryPackInclude]
double MaxBandwidth => info.MaxBandwidth;
[MemoryPackInclude]
double MaxBandwidthTotal => info.MaxBandwidthTotal;
[MemoryPackInclude]
double MaxGbTotal => info.MaxGbTotal;
[MemoryPackInclude]
long MaxGbTotalLastBytes => info.MaxGbTotalLastBytes;
[MemoryPackInclude]
double ConnectionRatio => info.ConnectionRatio;
[MemoryPackInclude]
double BandwidthRatio => info.BandwidthRatio;
[MemoryPackInclude]
bool Public => info.Public;
[MemoryPackInclude]
int Delay => info.Delay;
[MemoryPackInclude, MemoryPackAllowSerialize]
IPEndPoint EndPoint => info.EndPoint;
[MemoryPackInclude]
long LastTicks => info.LastTicks;
[MemoryPackInclude]
string Url => info.Url;
[MemoryPackInclude]
TunnelProtocolType AllowProtocol => info.AllowProtocol;
[MemoryPackInclude]
bool Sync2Server => info.Sync2Server;
[MemoryPackInclude]
string Version => info.Version;
[MemoryPackConstructor]
SerializableRelayServerNodeReportInfo(
string id, string name,
int maxConnection, double maxBandwidth, double maxBandwidthTotal,
double maxGbTotal, long maxGbTotalLastBytes,
double connectionRatio, double bandwidthRatio,
bool Public, int delay,
IPEndPoint endPoint, long lastTicks, string url, TunnelProtocolType allowProtocol, bool sync2Server, string version)
{
var info = new RelayServerNodeReportInfoOld
{
BandwidthRatio = bandwidthRatio,
ConnectionRatio = connectionRatio,
Delay = delay,
EndPoint = endPoint,
Id = id,
LastTicks = lastTicks,
MaxBandwidth = maxBandwidth,
MaxBandwidthTotal = maxBandwidthTotal,
MaxConnection = maxConnection,
MaxGbTotal = maxGbTotal,
MaxGbTotalLastBytes = maxGbTotalLastBytes,
Name = name,
Public = Public,
Url = url,
AllowProtocol = allowProtocol,
Sync2Server = sync2Server,
Version = version
};
this.info = info;
}
public SerializableRelayServerNodeReportInfo(RelayServerNodeReportInfoOld info)
{
this.info = info;
}
}
public class RelayServerNodeReportInfoFormatter : MemoryPackFormatter<RelayServerNodeReportInfoOld>
{
public override void Serialize<TBufferWriter>(ref MemoryPackWriter<TBufferWriter> writer, scoped ref RelayServerNodeReportInfoOld value)
{
if (value == null)
{
writer.WriteNullObjectHeader();
return;
}
writer.WritePackable(new SerializableRelayServerNodeReportInfo(value));
}
public override void Deserialize(ref MemoryPackReader reader, scoped ref RelayServerNodeReportInfoOld value)
{
if (reader.PeekIsNull())
{
reader.Advance(1); // skip null block
value = null;
return;
}
value = new RelayServerNodeReportInfoOld();
reader.TryReadObjectHeader(out byte count);
value.Id = reader.ReadValue<string>();
value.Name = reader.ReadValue<string>();
value.MaxConnection = reader.ReadValue<int>();
value.MaxBandwidth = reader.ReadValue<double>();
value.MaxBandwidthTotal = reader.ReadValue<double>();
value.MaxGbTotal = reader.ReadValue<double>();
value.MaxGbTotalLastBytes = reader.ReadValue<long>();
value.ConnectionRatio = reader.ReadValue<double>();
value.BandwidthRatio = reader.ReadValue<double>();
value.Public = reader.ReadValue<bool>();
value.Delay = reader.ReadValue<int>();
value.EndPoint = reader.ReadValue<IPEndPoint>();
value.LastTicks = reader.ReadValue<long>();
if (count > 13)
value.Url = reader.ReadValue<string>();
if (count > 14)
value.AllowProtocol = reader.ReadValue<TunnelProtocolType>();
if (count > 15)
value.Sync2Server = reader.ReadValue<bool>();
if (count > 16)
value.Version = reader.ReadValue<string>();
}
}
}

4
src/linker.messenger.store.file/relay/RelayServerNodeStore.cs
View File

@@ -24,12 +24,12 @@ namespace linker.messenger.store.file.relay
}
public void SetMaxGbTotalLastBytes(long value)
{
config.Data.Server.Relay.Distributed.Node.MaxGbTotalLastBytes = value;
config.Data.Server.Relay.Distributed.Node.DataRemain = value;
}
public void SetMaxGbTotalMonth(int month)
{
config.Data.Server.Relay.Distributed.Node.MaxGbTotalMonth = month;
config.Data.Server.Relay.Distributed.Node.DataMonth = month;
}