static void Net_Test2_Ssl_Client()
{
string hostname = "www.google.co.jp";
using (ConnSock sock = LocalNet.Connect(new TcpConnectParam(hostname, 443)))
{
using (SslSock ssl = new SslSock(sock))
{
//ssl.StartPCapRecorder(new PCapFileEmitter(new PCapFileEmitterOptions(new FilePath(@"c:\tmp\190610\test1.pcapng", flags: FileFlags.AutoCreateDirectory), false)));
var sslClientOptions = new PalSslClientAuthenticationOptions()
{
TargetHost = hostname,
ValidateRemoteCertificateProc = (cert) => { return(true); },
};
ssl.StartSslClient(sslClientOptions);
var st = ssl.GetStream();
var w = new StreamWriter(st);
var r = new StreamReader(st);
w.WriteLine("GET / HTTP/1.0");
w.WriteLine($"HOST: {hostname}");
w.WriteLine();
w.WriteLine();
w.Flush();
while (true)
{
string?s = r.ReadLine();
if (s == null)
{
break;
}
Con.WriteLine(s);
}
}
}
}
static void Net_Test3_PlainTcp_Server()
{
using (var listener = LocalNet.CreateListener(new TcpListenParam(
async(listener2, sock) =>
{
sock.StartPCapRecorder(new PCapFileEmitter(new PCapFileEmitterOptions(new FilePath(@"c:\tmp\190611\" + Str.DateTimeToStrShortWithMilliSecs(DateTime.Now) + ".pcapng", flags: FileFlags.AutoCreateDirectory))));
var stream = sock.GetStream();
StreamWriter w = new StreamWriter(stream);
while (true)
{
w.WriteLine(DateTimeOffset.Now._ToDtStr(true));
await w.FlushAsync();
await Task.Delay(100);
}
},
null,
9821)))
{
Con.ReadLine(">");
}
}
static void Net_Test4_SpeedTest_Client()
{
string hostname = "speed.coe.ad.jp";
CancellationTokenSource cts = new CancellationTokenSource();
var client = new SpeedTestClient(LocalNet, LocalNet.GetIp(hostname), 9821, 1, 30000, SpeedTestModeFlag.Download, cts.Token);
var task = client.RunClientAsync();
//Con.ReadLine("Enter to stop>");
////int wait = 2000 + Util.RandSInt32_Caution() % 1000;
////Con.WriteLine("Waiting for " + wait);
////ThreadObj.Sleep(wait);
//Con.WriteLine("Stopping...");
//cts._TryCancelNoBlock();
task._GetResult()._PrintAsJson();
Con.WriteLine("Stopped.");
}
static async Task Net_Test13_WebSocketClientAsync()
{
using (ConnSock sock = LocalNet.Connect(new TcpConnectParam("echo.websocket.org", 80)))
{
using (WebSocket ws = new WebSocket(sock))
{
await ws.StartWebSocketClientAsync("wss://echo.websocket.org");
using (var stream = ws.GetStream())
using (var r = new StreamReader(stream))
using (var w = new StreamWriter(stream))
{
w.AutoFlush = true;
for (int i = 1; i < 20; i++)
{
string src = Str.MakeCharArray((char)('a' + (i % 25)), i * 100);
Con.WriteLine(src.Length);
//await w.WriteLineAsync(src);
await stream.WriteAsync((src + "\r\n")._GetBytes_Ascii());
string?dst = await r.ReadLineAsync();
//Con.WriteLine(dst);
Con.WriteLine(i);
Debug.Assert(src == dst);
}
}
}
}
}
public async Task <HttpResult> PostHandlerAsync(WebMethods method, string path, QueryStringList queryString, HttpContext context, RouteData routeData, IPEndPoint local, IPEndPoint remote, CancellationToken cancel = default)
{
var request = context.Request;
string str = await request._RecvStringContentsAsync(CoresConfig.DataVaultServerApp.MaxHttpPostRecvData, cancel : cancel);
DataVaultData?recv = str._JsonToObject <DataVaultData>();
List <DataVaultData> list = new List <DataVaultData>();
if (recv != null)
{
recv.NormalizeReceivedData();
recv.StatGitCommitId = recv.StatGitCommitId._NonNullTrim();
recv.StatAppVer = recv.StatAppVer._NonNullTrim();
recv.TimeStamp = DtOffsetNow;
recv.StatGlobalIp = remote.Address.ToString();
recv.StatGlobalPort = remote.Port;
recv.StatGlobalFqdn = await LocalNet.GetHostNameSingleOrIpAsync(recv.StatGlobalIp, cancel);
recv.StatLocalIp = recv.StatLocalIp._NonNullTrim();
if (recv.StatLocalIp._IsEmpty())
{
recv.StatLocalIp = "127.0.0.1";
}
recv.StatLocalFqdn = recv.StatLocalFqdn._NonNullTrim();
if (recv.StatLocalFqdn._IsEmpty())
{
recv.StatLocalFqdn = "localhost";
}
recv.StatUid = recv.StatUid._NonNullTrim();
if (recv.SystemName._IsFilled() && recv.LogName._IsFilled())
{
// キー無し 1 つのディレクトリに全部書き込み
try
{
DataVaultData d = recv._CloneIfClonable();
d.KeyType = "all";
d.KeyShortValue = "all";
d.KeyFullValue = "all";
list.Add(d);
}
catch (Exception ex)
{
ex._Debug();
}
// UID からキーを生成
try
{
DataVaultData d = recv._CloneIfClonable();
d.KeyType = "by_uid";
d.KeyShortValue = recv.StatUid._TruncStr(2);
d.KeyFullValue = recv.StatUid._TruncStr(4);
list.Add(d);
}
catch (Exception ex)
{
ex._Debug();
}
// グローバル IP からキーを生成
try
{
DataVaultData d = recv._CloneIfClonable();
d.KeyType = "by_global_ip";
d.KeyShortValue = IPUtil.GetHead1BytesIPString(recv.StatGlobalIp);
d.KeyFullValue = IPUtil.GetHead2BytesIPString(recv.StatGlobalIp);
list.Add(d);
}
catch (Exception ex)
{
ex._Debug();
}
// グローバル FQDN からキーを生成
try
{
string shortKey, longKey;
if (IPUtil.IsStrIP(recv.StatGlobalFqdn) == false)
{
// FQDN
if (MasterData.DomainSuffixList.ParseDomainBySuffixList(recv.StatGlobalFqdn, out string tld, out string domain, out string hostname))
{
// 正しい TLD 配下のドメイン
// 例: 12345.abc.example.org の場合
// Short key は org.example.ab
// Long key は org.example.abc.1
string domainReverse = domain._Split(StringSplitOptions.RemoveEmptyEntries, '.').Reverse()._Combine(".");
string hostnameReverse = hostname._Split(StringSplitOptions.RemoveEmptyEntries, '.').Reverse()._Combine(".");
shortKey = new string[] { domainReverse, hostnameReverse._TruncStr(2) }._Combine(".");
longKey = new string[] { domainReverse, hostnameReverse._TruncStr(5) }._Combine(".");
}
else
{
// おかしなドメイン
shortKey = recv.StatGlobalFqdn._TruncStr(2);
longKey = recv.StatGlobalFqdn._TruncStr(4);
}
}
else
{
// IP アドレス
shortKey = IPUtil.GetHead1BytesIPString(recv.StatGlobalIp);
longKey = IPUtil.GetHead1BytesIPString(recv.StatGlobalIp);
}
DataVaultData d = recv._CloneIfClonable();
d.KeyType = "by_global_fqdn";
d.KeyShortValue = shortKey;
d.KeyFullValue = longKey;
list.Add(d);
}
async Task PostHttpMainAsync(CancellationToken cancel = default)
{
if (this.Config.PostUrl._IsEmpty())
{
return;
}
StatManDatabase copy;
lock (this.DataLock)
{
copy = this.Database._CloneWithJson();
}
KeyValueList <string, string> vers = new KeyValueList <string, string>();
vers.Add("APPNAME", CoresLib.AppNameFnSafe);
vers.Add("OS", Env.OsInfoString);
vers.Add("CPU", Env.CpuInfo.ToString());
vers.Add("NUMCPU", Env.NumCpus.ToString());
vers.Add("DOTNET", Env.FrameworkInfoString);
vers.Add("EXE", Env.AppExecutableExeOrDllFileName._GetFileName() ?? "");
List <string> versStrs = new List <string>();
vers.ForEach(x => versStrs.Add($"{x.Key}={x.Value}"));
var data = Json.NewJsonObject();
foreach (var item in copy.StrValues)
{
data.TryAdd(item.Key, new JValue(item.Value));
}
foreach (var item in copy.LongValues)
{
data.TryAdd(item.Key, new JValue(item.Value));
}
DataVaultData postData = new DataVaultData
{
TimeStamp = DtOffsetNow,
StatUid = copy.Uid,
StatAppVer = versStrs._Combine("|"),
StatGitCommitId = Dbg.GetCurrentGitCommitId(),
StatLocalIp = this.CurrentLocalIp.ToString(),
StatLocalFqdn = LocalNet.GetHostInfo(true).HostName,
SystemName = Config.SystemName,
LogName = Config.LogName,
Data = data,
};
string postStr = postData._ObjectToJson();
using var http = new WebApi(new WebApiOptions(new WebApiSettings { SslAcceptAnyCerts = true }));
var ret = await http.SimplePostJsonAsync(WebMethods.POST, Config.PostUrl, postStr, cancel);
if (ret.ToString()._InStr("ok") == false)
{
throw new CoresException($"Http error: {ret.ToString()._TruncStrEx(1000)}");
}
}
public TelnetStreamWatcherBase(TelnetStreamWatcherOptions options)
{
this.Options = options;
Listener = TcpIp.CreateListener(new TcpListenParam(async(listener, sock) =>
{
try
{
Con.WriteDebug($"TelnetStreamWatcher({this.ToString()}: Connected: {sock.EndPointInfo._GetObjectDump()}");
using (var destStream = sock.GetStream())
{
if (sock.Info.Ip.RemoteIPAddress == null || Options.IPAccessFilter(sock.Info.Ip.RemoteIPAddress) == false)
{
Con.WriteDebug($"TelnetStreamWatcher({this.ToString()}: Access denied: {sock.EndPointInfo._GetObjectDump()}");
await destStream.WriteAsync("You are not allowed to access to this service.\r\n\r\n"._GetBytes_Ascii());
await Task.Delay(100);
return;
}
using (var pipePoint = await SubscribeImplAsync())
{
// ソケットから Enter キー入力を待機する
Task keyInputTask = TaskUtil.StartAsyncTaskAsync(async() =>
{
using StreamReader lineReader = new StreamReader(destStream);
while (true)
{
string?line = await lineReader.ReadLineAsync();
if (line == null)
{
break;
}
line = line.Trim();
if (line._IsSamei("s"))
{
// Socket リストの表示
var list = LocalNet.GetSockList().OrderBy(x => x.Connected);
StringWriter w = new StringWriter();
w.WriteLine();
foreach (var sock in list)
{
string tmp = sock._GetObjectDump();
w.WriteLine(tmp);
}
w.WriteLine();
w.WriteLine($"Total sockets: {list.Count()}");
w.WriteLine();
byte[] data = w.ToString()._GetBytes_Ascii();
var pipe = pipePoint;
if (pipe.CounterPart != null)
{
lock (pipe.CounterPart.StreamWriter.LockObj)
{
if (pipe.CounterPart.StreamWriter.NonStopWriteWithLock(data, false, FastStreamNonStopWriteMode.DiscardExistingData) != 0)
{
// To avoid deadlock, CompleteWrite() must be called from other thread.
// (CompleteWrite() ==> Disconnect ==> Socket Log will recorded ==> ReceiveLog() ==> this function will be called!)
TaskUtil.StartSyncTaskAsync(() => pipe.CounterPart.StreamWriter.CompleteWrite(false), false, false)._LaissezFaire(true);
}
}
}
}
else
{
// GC
Dbg.WriteLine($"Manual GC is called by the administrator.");
long start = FastTick64.Now;
Dbg.GcCollect();
long end = FastTick64.Now;
long spentTime = end - start;
Dbg.WriteLine($"Manual GC Took Time: {spentTime} msecs.");
}
}
});
try
{
// ソケットに対して、pipePoint のストリームをそのまま非同期で流し込む
using (var pipeStub = pipePoint.GetNetAppProtocolStub())
using (var srcStream = pipeStub.GetStream())
{
await srcStream.CopyToAsync(destStream, sock.GrandCancel);
}
}
finally
{
await UnsubscribeImplAsync(pipePoint);
await pipePoint.CleanupAsync(new DisconnectedException());
await keyInputTask._TryAwait(noDebugMessage: true);
}
}
}
}
finally
{
Con.WriteDebug($"TelnetStreamWatcher({this.ToString()}: Disconnected: {sock.EndPointInfo._GetObjectDump()}");
}
},
"TelnetStreamWatcher",
this.Options.EndPoints.ToArray()));
this.AddIndirectDisposeLink(this.Listener);
}
// 1 回の処理
async Task <int> PerformOnceAsync(CancellationToken cancel = default)
{
CoresRuntimeStat runtimeStat = new CoresRuntimeStat();
runtimeStat.Refresh(forceGc: this.Report_ForceGc);
string[]? globalIpList = null;
try
{
globalIpList = (await LocalNet.GetLocalHostPossibleIpAddressListAsync(cancel)).Select(x => x.ToString()).ToArray();
}
catch { }
InstanceStat stat = new InstanceStat
{
DaemonName = this.Settings.DaemonName,
CommitId = this.Variables.CurrentCommitId,
CommitInfo = this.Variables.CurrentCommitInfo,
InstanceArguments = this.Variables.CurrentInstanceArguments,
RuntimeStat = runtimeStat,
EnvInfo = new EnvInfoSnapshot(),
StatFlag = this.Variables.StatFlag,
TcpIpHostData = LocalNet.GetTcpIpHostDataJsonSafe(true),
GlobalIpList = globalIpList,
PauseFlag = Variables.PauseFlag,
MetaStatusDictionary = GlobalDaemonStateManager.MetaStatusDictionary,
DaemonSecret = GlobalDaemonStateManager.DaemonSecret,
};
// リクエストメッセージの組立て
RequestMsg req = new RequestMsg
{
AppId = this.Settings.AppId,
HostName = this.Settings.HostName,
Guid = this.Settings.HostGuid,
Stat = stat,
};
// サーバーに送付し応答を受信
ResponseMsg res = await Rpc.KeepAliveAsync(req);
// 応答メッセージの分析
res.Normalize();
// ローカル IP アドレスを覚える
GlobalDaemonStateManager.SetDaemonClientLocalIpAddress(RpcClient.LastLocalIp);
// FileBrowser の URL が分かればこれを DaemonCenter に送付する
if (GlobalDaemonStateManager.FileBrowserHttpsPortNumber != 0)
{
IPAddress ip = GlobalDaemonStateManager.DaemonClientLocalIpAddress;
string hostname = ip.ToString();
if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
// ipv6
hostname = $"[{hostname}]";
}
try
{
// FQDN を DNS 解決する
string?fqdn = req.Stat.TcpIpHostData.FqdnHostName;
if (fqdn._IsFilled())
{
DnsResponse dnsReply = await LocalNet.QueryDnsAsync(new DnsGetIpQueryParam(fqdn, timeout : Consts.Timeouts.Rapid), cancel);
if (dnsReply.IPAddressList.Where(x => x == ip).Any())
{
// DNS 解決に成功し、同一の IP アドレスを指していることが分かったので URL には FQDN を埋め込む
hostname = fqdn;
}
}
}
catch { }
// url
string url = $"https://{hostname}:{GlobalDaemonStateManager.FileBrowserHttpsPortNumber}/{GlobalDaemonStateManager.DaemonSecret}/";
GlobalDaemonStateManager.MetaStatusDictionary[Consts.DaemonMetaStatKeys.CurrentLogFileBrowserUrl] = url;
}
else
{
GlobalDaemonStateManager.MetaStatusDictionary.TryRemove(Consts.DaemonMetaStatKeys.CurrentLogFileBrowserUrl, out _);
}
if (res.OsRebootRequested)
{
// OS そのものの再起動が要求されたので再起動を行なう
if (Env.IsAdmin)
{
try
{
Kernel.RebootOperatingSystemForcefullyDangerous();
}
catch { }
}
}
if (res.NextCommitId._IsFilled() || res.NextInstanceArguments._IsFilled() || res.NextPauseFlag != PauseFlag.None || res.RebootRequested)
{
// 再起動が要求された
this.RestartCb(res);
return(-1);
}
// 次回 KeepAlive 間隔の応答
return(res.NextKeepAliveMsec);
}
protected override async Task GetValueAsync(SortedDictionary <string, string> ret, RefInt nextPollingInterval, CancellationToken cancel = default)
{
SnmpWorkSettings settings = Host.Settings;
if (settings.PingTargets._IsSamei("none") || settings.PingTargets._IsSamei("null"))
{
return;
}
string hopsStr = "Hops";
if (settings.HopsToTTL)
{
hopsStr = "TTL";
}
string[] pingTargets = settings.PingTargets._Split(StringSplitOptions.RemoveEmptyEntries, ",");
numPerform++;
foreach (string pingTarget in pingTargets)
{
cancel.ThrowIfCancellationRequested();
ParseTargetString(pingTarget, out string hostname, out string alias);
bool ok = false;
try
{
IPAddress ipAddress = await LocalNet.GetIpAsync(hostname, cancel : cancel);
if (FirstPing.IsFirstCall())
{
// JIT 対策
try
{
await LocalNet.SendPingAsync(ipAddress, pingCancel : cancel);
}
catch { }
}
int numTry = 3;
if (numPerform >= 2)
{
// SpeedTest が動作中の場合は SpeedTest が完了するまで待機する
await TaskUtil.AwaitWithPollAsync(Timeout.Infinite, 10, () => !SpeedTestClient.IsInProgress, cancel);
// 試行回数を指定する
numTry = Math.Min(Math.Max(settings.PingNumTry, 1), 100);
}
SendPingReply reply = await LocalNet.SendPingAndGetBestResultAsync(ipAddress, pingCancel : cancel, numTry : numTry);
if (reply.Ok)
{
double rtt = reply.RttDouble;
rtt = Math.Min(rtt, 2.0);
int ttl = reply.Ttl;
bool ttl_ok = false;
if (ttl == 0)
{
// Use ping command to get TTL
try
{
var result = await EasyExec.ExecAsync(ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6?Consts.LinuxCommands.Ping6 : Consts.LinuxCommands.Ping,
$"-W 1 -c 1 {ipAddress.ToString()}",
cancel : cancel,
throwOnErrorExitCode : false);
string[] lines = result.OutputStr._GetLines(true);
foreach (string line in lines)
{
OneLineParams param = new OneLineParams(line, ' ', false);
string ttlStr = param._GetStrFirst("ttl");
if (ttlStr._IsFilled())
{
ttl = ttlStr._ToInt();
ttl_ok = true;
break;
}
}
}
catch (Exception ex)
{
ex._Debug();
}
}
else
{
ttl_ok = true;
}
ret.TryAdd($"Time - {alias}", (rtt * 1000.0).ToString("F3"));
if (ttl > 128)
{
ttl -= 128;
}
else if (ttl > 64)
{
ttl -= 64;
}
int hops = 64 - ttl;
if (ttl_ok == false)
{
hops = 0;
}
hops._SetMax(0);
hops._SetMin(64);
ret.TryAdd($"{hopsStr} - {alias}", hops.ToString());
ok = true;
}
}
catch (Exception ex)
{
ex._Debug();
}
if (ok == false)
{
ret.TryAdd($"Time - {alias}", "");
ret.TryAdd($"{hopsStr} - {alias}", "0");
}
}
}
protected override async Task GetValueAsync(SortedDictionary <string, string> ret, RefInt nextPollingInterval, CancellationToken cancel = default)
{
SnmpWorkSettings settings = Host.Settings;
if (settings.SpeedTargets._IsSamei("none") || settings.SpeedTargets._IsSamei("null"))
{
return;
}
string[] speedTargets = settings.SpeedTargets._Split(StringSplitOptions.RemoveEmptyEntries, ",");
count++;
foreach (string target in speedTargets)
{
ParseTargetString(target, out string hostnameAndPort, out string alias);
cancel.ThrowIfCancellationRequested();
string[] tokens = hostnameAndPort._Split(StringSplitOptions.RemoveEmptyEntries, '|');
string host;
int port = 9821;
host = tokens[0];
if (tokens.Length >= 2)
{
port = tokens[1]._ToInt();
}
//long downloadBps_1 = 0;
//long uploadBps_1 = 0;
long downloadBps_32 = 0;
long uploadBps_32 = 0;
int intervalBetween = settings.SpeedIntervalsSec * 1000;
if (count <= 1)
{
intervalBetween = 0;
}
int numTry = settings.SpeedTryCount;
if (count <= 1)
{
numTry = 1;
}
int span = settings.SpeedSpanSec * 1000;
if (count <= 1)
{
span = 2000;
}
try
{
IPAddress ipAddress = await LocalNet.GetIpAsync(host, cancel : cancel);
try
{
var downloadResult_32 = await SpeedTestClient.RunSpeedTestWithMultiTryAsync(LocalNet, ipAddress, port, 32, span, SpeedTestModeFlag.Download, numTry, intervalBetween, cancel);
downloadBps_32 = downloadResult_32.Select(x => x.BpsDownload).OrderByDescending(x => x).FirstOrDefault();
}
catch (Exception ex)
{
ex._Debug();
}
try
{
var uploadResult_32 = await SpeedTestClient.RunSpeedTestWithMultiTryAsync(LocalNet, ipAddress, port, 32, span, SpeedTestModeFlag.Upload, numTry, intervalBetween, cancel);
uploadBps_32 = uploadResult_32.Select(x => x.BpsUpload).OrderByDescending(x => x).FirstOrDefault();
}
catch (Exception ex)
{
ex._Debug();
}
//try
//{
// var downloadResult_1 = await SpeedTestClient.RunSpeedTestWithMultiTryAsync(LocalNet, ipAddress, port, 1, span, SpeedTestModeFlag.Download, numTry, intervalBetween, cancel);
// downloadBps_1 = downloadResult_1.Select(x => x.BpsDownload).OrderByDescending(x => x).FirstOrDefault();
//}
//catch (Exception ex)
//{
// ex._Debug();
//}
//try
//{
// var uploadResult_1 = await SpeedTestClient.RunSpeedTestWithMultiTryAsync(LocalNet, ipAddress, port, 1, span, SpeedTestModeFlag.Upload, numTry, intervalBetween, cancel);
// uploadBps_1 = uploadResult_1.Select(x => x.BpsUpload).OrderByDescending(x => x).FirstOrDefault();
//}
//catch (Exception ex)
//{
// ex._Debug();
//}
}
catch (Exception ex)
{
ex._Debug();
}
ret.TryAdd($"{alias} - RX (Mbps)", ((double)downloadBps_32 / 1000.0 / 1000.0).ToString("F3"));
ret.TryAdd($"{alias} - TX (Mbps)", ((double)uploadBps_32 / 1000.0 / 1000.0).ToString("F3"));
//ret.TryAdd($"{alias} - 01_RX (Mbps)", ((double)downloadBps_1 / 1000.0 / 1000.0).ToString("F3"));
//ret.TryAdd($"{alias} - 01_TX (Mbps)", ((double)uploadBps_1 / 1000.0 / 1000.0).ToString("F3"));
}
}
protected override async Task GetValueAsync(SortedDictionary <string, string> ret, RefInt nextPollingInterval, CancellationToken cancel = default)
{
SnmpWorkSettings settings = Host.Settings;
if (settings.PingTargets._IsSamei("none") || settings.PingTargets._IsSamei("null"))
{
return;
}
string[] pingTargets = settings.PingTargets._Split(StringSplitOptions.RemoveEmptyEntries, ",");
KeyValueList <string, IPAddress> kvList = new KeyValueList <string, IPAddress>();
// 名前解決
foreach (string pingTarget in pingTargets)
{
cancel.ThrowIfCancellationRequested();
try
{
ParseTargetString(pingTarget, out string hostname, out string alias);
IPAddress ip = await LocalNet.GetIpAsync(hostname, cancel : cancel);
kvList.Add(alias, ip);
}
catch (Exception ex)
{
ex._Debug();
}
}
List <Task <double> > taskList = new List <Task <double> >();
int interval = 0;
int count = 3;
// SpeedTest が動作中の場合は SpeedTest が完了するまで待機する
numPerform++;
if (numPerform >= 2)
{
interval = settings.PktLossIntervalMsec;
count = settings.PktLossTryCount;
await TaskUtil.AwaitWithPollAsync(Timeout.Infinite, 10, () => !SpeedTestClient.IsInProgress, cancel);
}
// 並列実行の開始
foreach (var kv in kvList)
{
taskList.Add(PerformOneAsync(kv.Value, count, settings.PktLossTimeoutMsecs, interval, cancel));
}
// すべて終了するまで待機し、結果を整理
for (int i = 0; i < kvList.Count; i++)
{
var kv = kvList[i];
var task = taskList[i];
double lossRate = await task._TryAwait();
double quality = 1.0 - lossRate;
quality = Math.Max(quality, 0.0);
quality = Math.Min(quality, 1.0);
ret.TryAdd($"{kv.Key}", ((double)quality * 100.0).ToString("F3"));
}
}
public static async Task <WebSocket> ConnectAsync(string uri, WebSocketConnectOptions?options = null, CancellationToken cancel = default)
{
if (options == null)
{
options = new WebSocketConnectOptions();
}
Uri u = new Uri(uri);
int port = 0;
bool useSsl = false;
if (u.Scheme._IsSamei("ws"))
{
port = Consts.Ports.Http;
}
else if (u.Scheme._IsSamei("wss"))
{
port = Consts.Ports.Https;
useSsl = true;
}
else
{
throw new ArgumentException($"uri \"{uri}\" is not a WebSocket address.");
}
if (u.IsDefaultPort == false)
{
port = u.Port;
}
ConnSock tcpSock = await LocalNet.ConnectIPv4v6DualAsync(new TcpConnectParam(u.Host, port, connectTimeout : options.WebSocketOptions.TimeoutOpen, dnsTimeout : options.WebSocketOptions.TimeoutOpen), cancel);
try
{
ConnSock targetSock = tcpSock;
try
{
if (useSsl)
{
SslSock sslSock = new SslSock(tcpSock);
try
{
options.SslOptions.TargetHost = u.Host;
await sslSock.StartSslClientAsync(options.SslOptions, cancel);
targetSock = sslSock;
}
catch
{
sslSock._DisposeSafe();
throw;
}
}
WebSocket webSock = new WebSocket(targetSock, options.WebSocketOptions);
await webSock.StartWebSocketClientAsync(uri, cancel);
return(webSock);
}
catch
{
targetSock.Dispose();
throw;
}
}
catch
{
tcpSock._DisposeSafe();
throw;
}
}
static void Net_Test11_AcceptLoop()
{
if (test11_flag == false)
{
test11_flag = true;
new ThreadObj(param =>
{
ThreadObj.Current.Thread.Priority = System.Threading.ThreadPriority.Highest;
int last = 0;
while (true)
{
int value = Environment.TickCount;
int span = value - last;
last = value;
Console.WriteLine("tick: " + span);
ThreadObj.Sleep(100);
}
});
}
using (var listener = LocalNet.CreateListener(new TcpListenParam(
async(listener2, sock) =>
{
while (true)
{
var stream = sock.GetStream();
StreamReader r = new StreamReader(stream);
while (true)
{
string?line = await r.ReadLineAsync();
if (line._IsEmpty())
{
break;
}
}
int segmentSize = 400;
int numSegments = 1000;
int totalSize = segmentSize * numSegments;
string ret =
$@"HTTP/1.1 200 OK
Content-Length: {totalSize}
";
await stream.WriteAsync(ret._GetBytes_Ascii());
byte[] buf = Util.Rand(numSegments);
for (int i = 0; i < numSegments; i++)
{
await stream.WriteAsync(buf);
}
}
},
null,
80)))
{
Con.ReadLine(" > ");
}
}
static void Net_Test12_AcceptLoop2(int port = 80)
{
new ThreadObj(param =>
{
ThreadObj.Current.Thread.Priority = System.Threading.ThreadPriority.Highest;
int last = 0;
while (true)
{
int value = Environment.TickCount;
int span = value - last;
last = value;
long mem = mem = GC.GetTotalMemory(false);
try
{
Console.WriteLine("tick: " + span + " mem = " + mem / 1024 / 1024 + " sock = " + LocalNet.GetOpenedSockCount());
}
catch { }
ThreadObj.Sleep(100);
}
});
if (true)
{
NetTcpListener listener = LocalNet.CreateListener(new TcpListenParam(
async(listener2, sock) =>
{
while (true)
{
var stream = sock.GetStream();
StreamReader r = new StreamReader(stream);
while (true)
{
string?line = await r.ReadLineAsync();
if (line._IsEmpty())
{
break;
}
}
int segmentSize = 400;
int numSegments = 1000;
int totalSize = segmentSize * numSegments;
string ret =
$@"HTTP/1.1 200 OK
Content-Length: {totalSize}
";
await stream.WriteAsync(ret._GetBytes_Ascii());
byte[] buf = Util.Rand(numSegments);
for (int i = 0; i < numSegments; i++)
{
await stream.WriteAsync(buf);
}
}
},
null,
port));
listener.HideAcceptProcError = true;
ThreadObj.Sleep(-1);
}
}
public void Show()
{
HiveData.SyncWithStorage(HiveSyncFlags.LoadFromFile, true);
long pid = HiveData.ManagedData.Pid;
int port = HiveData.ManagedData.LocalLogWatchPort;
if (pid != 0 && port != 0)
{
Con.WriteLine("Starting the real-time log session.");
Con.WriteLine("Pressing Ctrl + D or Ctrl + Q to disconnect the session.");
Con.WriteLine();
Con.WriteLine($"Connecting to localhost:{port} ...");
CancellationTokenSource cancelSource = new CancellationTokenSource();
CancellationToken cancel = cancelSource.Token;
Task task = TaskUtil.StartAsyncTaskAsync(async() =>
{
try
{
using (var sock = await LocalNet.ConnectAsync(new TcpConnectParam(IPAddress.Loopback, port), cancel))
using (var stream = sock.GetStream())
using (MemoryHelper.FastAllocMemoryWithUsing(65536, out Memory <byte> tmp))
{
Con.WriteLine("The real-time log session is connected.");
Con.WriteLine();
try
{
while (true)
{
int r = await stream.ReadAsync(tmp, cancel);
if (r <= 0)
{
break;
}
ReadOnlyMemory <byte> data = tmp.Slice(0, r);
string s = Str.Utf8Encoding.GetString(data.Span);
Console.Write(s);
}
}
catch { }
Con.WriteLine();
Con.WriteLine("The real-time log session is disconnected.");
}
}
catch (Exception ex)
{
Con.WriteError(ex.Message);
}
});
try
{
while (true)
{
var key = Console.ReadKey();
if ((key.Key == ConsoleKey.D || key.Key == ConsoleKey.Q) && key.Modifiers == ConsoleModifiers.Control)
{
break;
}
}
}
catch { }
cancelSource._TryCancelNoBlock();
task._TryWait(true);
}
else
{
Con.WriteLine($"The daemon \"{Name}\" is not running.");
}
}