static void Main()
{
Console.WriteLine("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
settings = client.GetSettings();
IEnumerable <Server> servers = SelectServers();
Server bestServer = SelectBestServer(servers);
Console.WriteLine("Testing speed...");
double downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
PrintSpeed("Download", downloadSpeed);
double uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
PrintSpeed("Upload", uploadSpeed);
//Opslaan van resultaten.
Console.WriteLine("");
Console.WriteLine("Opslaan van resultaat");
SaveSpeed("Download", downloadSpeed);
SaveSpeed("Upload", uploadSpeed);
Console.WriteLine("Press a key to exit.");
Console.ReadKey();
}
private async void ExecuteSpeedTest(SpeedTestSource source, Server server = null)
{
try
{
SpeedGrid.IsEnabled = false;
DownloadSpeed speed = null;
if (source == SpeedTestSource.Speedtest)
{
speed = await SpeedTestClient.GetDownloadSpeed(server, SpeedTestUnit.KiloBitsPerSecond);
}
else
{
speed = await FastClient.GetDownloadSpeed(SpeedTestUnit.KiloBitsPerSecond);
}
var message = $"Source: {speed.Source} Download Speed: {speed?.Speed} {speed.Unit}";
if (speed?.Server?.Id != null)
{
message += $" (Server Id = {speed?.Server?.Id})";
}
ShowMessage(message);
SpeedGrid.IsEnabled = true;
}
catch (System.Exception ex)
{
ShowMessage(ex.Message);
SpeedGrid.IsEnabled = true;
}
}
static public async Task <List <SpeedTestClient.Result> > RunSpeedTestWithMultiTryAsync(TcpIpSystem system, IPAddress ip, int port, int numConnection, int timespan, SpeedTestModeFlag mode, int numTry, int interval, CancellationToken cancel = default)
{
List <SpeedTestClient.Result> ret = new List <Result>();
numTry = Math.Max(numTry, 1);
for (int i = 0; i < numTry; i++)
{
if (cancel.IsCancellationRequested)
{
return(new List <Result>());
}
SpeedTestClient tc = new SpeedTestClient(system, ip, port, numConnection, timespan, mode, cancel);
var result = await tc.RunClientAsync();
if (result != null)
{
ret.Add(result);
}
await cancel._WaitUntilCanceledAsync(Util.GenRandInterval(interval));
}
return(ret);
}
static void Main()
{
Console.Title = "Jessica's Speed Tester";
Console.WriteLine("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
Console.WriteLine("Testing speed...");
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
PrintSpeed("Download", downloadSpeed);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
PrintSpeed("Upload", uploadSpeed);
DateTime dt = new DateTime(2018, 11, 12);
dt = DateTime.Now;
using (StreamWriter sw = new StreamWriter(logfile, true))
{
sw.WriteLine("[" + dt.ToString("ddMMyyy HH:mm") + "] Download speed: " + downloadSpeed);
sw.WriteLine("[" + dt.ToString("ddMMyyy HH:mm") + "] Upload speed: " + uploadSpeed);
}
Console.WriteLine("Press a key to exit.");
Console.ReadKey();
}
public SpeedTestRunner(SpeedTestClient client, RegionInfo location, bool useDummyData)
{
_client = client;
_settings = _client.GetSettings();
_location = location;
_useDummyData = useDummyData;
}
public static async Task StartSpeedTestAsync()
{
DateTime SpeedTestTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm"));
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
SpeedTest SpeetTestData = new SpeedTest();
try
{
SpeetTestData.ISP = settings.Client.Isp;
SpeetTestData.ClientLatitude = settings.Client.Latitude;
SpeetTestData.ClientLongitude = settings.Client.Longitude;
SpeetTestData.Server = bestServer.Host;
SpeetTestData.ServerLatitude = bestServer.Latitude;
SpeetTestData.ServerLongitude = bestServer.Longitude;
SpeetTestData.DelayTime = bestServer.Latency;
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
SpeetTestData.SpeedDownload = PrintSpeed(downloadSpeed);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
SpeetTestData.SpeetUpload = PrintSpeed(uploadSpeed);
}
catch
{
SpeetTestData.ClientLatitude = 0;
SpeetTestData.ClientLongitude = 0;
SpeetTestData.ISP = "Failed";
SpeetTestData.DelayTime = -1;
SpeetTestData.Server = "Failed";
SpeetTestData.ServerLatitude = 0;
SpeetTestData.ServerLongitude = 0;
SpeetTestData.SpeedDownload = "Failed";
SpeetTestData.SpeetUpload = "Failed";
}
SpeetTestData.Id = Guid.NewGuid();
SpeetTestData.TestTime = SpeedTestTime;
try
{
using (PingvalueModels db = new PingvalueModels())
{
db.SpeedTests.Add(SpeetTestData);
await db.SaveChangesAsync();
}
}
catch (Exception ex)
{
LogGenerator.Add("Start speed test db error: " + ex.Message);
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
SpeedTestClient speedTestClient = new SpeedTestClient();
Settings settings = speedTestClient.GetSettings();
Server bestServer = settings.Servers[0];
_logger.LogInformation("Server name: " + bestServer.Name);
double downloadSpeed = speedTestClient.TestDownloadSpeed(bestServer);
_logger.LogInformation("Download speed (kbps): " + downloadSpeed);
await Task.Delay(60000, stoppingToken);
}
}
static void Main()
{
Console.WriteLine("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
Console.WriteLine("Testing download speed...");
var downloadSpeed = client.TestDownloadSpeed(4);
PrintSpeed("Download", downloadSpeed);
Console.WriteLine("Testing upload speed...");
var uploadSpeed = client.TestUploadSpeed(2);
PrintSpeed("Upload", uploadSpeed);
}
private Server FindTestServer(SpeedTestClient client, Settings settings)
{
Console.WriteLine("Finding test servers...");
var tenLocalServers = settings.Servers.Where(server => server.Country.Equals(_location.EnglishName)).Take(10);
var serversByLatency = tenLocalServers
.Select(s =>
{
s.Latency = client.TestServerLatency(s);
return(s);
})
.OrderBy(s => s.Latency);
return(serversByLatency.First());
}
private async void FetchServer(object sender, RoutedEventArgs e)
{
try
{
SpeedGrid.IsEnabled = false;
Server = await SpeedTestClient.GetServer();
ShowMessage($"Server Fetched: {Server.Host} ({Server.Id})");
SpeedGrid.IsEnabled = true;
}
catch (System.Exception ex)
{
ShowMessage(ex.Message);
SpeedGrid.IsEnabled = true;
}
}
private async void ExecuteSpeedTest(Server server = null)
{
try
{
SpeedGrid.IsEnabled = false;
var speed = await SpeedTestClient.GetDownloadSpeed(server, Enums.SpeedTestUnit.KiloBitsPerSecond);
ShowMessage($"Download Speed: {speed?.Speed} {speed.Unit} (Server Id = {speed?.Server?.Id})");
SpeedGrid.IsEnabled = true;
}
catch (System.Exception ex)
{
ShowMessage(ex.Message);
SpeedGrid.IsEnabled = true;
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var client = new SpeedTestClient();
var settings = client.GetSettings();
var config = new LoggerConfiguration();
var runner = new SpeedTestRunner(config.LoggerLocation);
var testData = runner.RunSpeedTest();
var results = new TestResult {
SessionId = new Guid(),
User = config.UserId,
Device = config.LoggerId,
Timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds(),
Data = testData
};
}
/// <summary>
/// Gets download speed in megabits and sets song streaming quality.
/// </summary>
public static async void SetSongStreamingQualityAutomatically()
{
try {
var speedMb = await SpeedTestClient.GetDownloadSpeed(unit : SpeedTest.Net.Enums.SpeedTestUnit.MegaBitsPerSecond);
if (speedMb.Speed >= 20 && speedMb.Speed <= 40)
{
SongStreamingQualitySelected = "mediumquality";
}
else if (speedMb.Speed > 40)
{
SongStreamingQualitySelected = "highquality";
}
} catch (Exception exception) {
Console.WriteLine("Exception@SetSongStreamingQualityAutomatically -> " + exception);
}
}
public async System.Threading.Tasks.Task <string> StartSpeedTestAsync()
{
client = new SpeedTestClient();
settings = await client.GetSettingsAsync();
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
UpdateIndicators("Getting Settings");
});
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
UpdateIndicators("Getting Client's Country");
});
clientCountry = await GetClienCountryAsync();
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
UpdateIndicators("Selecting Best Server by Distance");
});
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
UpdateServerInfo(bestServer);
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
UpdateIndicators("Testing Internet Speed");
});
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
UpdateDownloadUi(downloadSpeed);
//PrintSpeed("Download", downloadSpeed);
Xamarin.Forms.Device.BeginInvokeOnMainThread(() =>
{
UpdateIndicators("Testing Internet Speed");
});
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
//PrintSpeed("Upload", uploadSpeed);
UpdateUploadUi(uploadSpeed);
return("Down: " + Math.Round(downloadSpeed / 1024, 2).ToString() + "Up: " + Math.Round(uploadSpeed / 1024, 2).ToString());
//Console.WriteLine("Press a key to exit.");
//Console.ReadKey();
}
static async Task Main()
{
string speedTestServerURL = Environment.GetEnvironmentVariable("SpeedTestServerURL") ?? "http://localhost:8080/api/speedtest";
string clientName = Environment.GetEnvironmentVariable("ClientName") ?? "Env:ClientName";
System.Console.WriteLine("v0.02 Client: " + clientName + " Target: " + speedTestServerURL);
string publicIPv4 = "NoIP";
bool serverAccessible = false;
try
{
publicIPv4 = await SpeedTestClient.GetPublicIPv4AddressAsync();
await SpeedTestClient.ValidateAPIAccess(speedTestServerURL);
serverAccessible = true;
System.Console.WriteLine("Success - PublicIP: " + publicIPv4 + " Accessible: " + speedTestServerURL);
}
catch (Exception)
{
System.Console.WriteLine("Exception - PublicIP: " + publicIPv4 + " Accessible: " + serverAccessible);
Environment.Exit(0);
}
client = new SpeedTestClient();
settings = client.GetSettings();
//var servers = SelectServers();
var bestServer = SelectDesiredServer(settings.Servers);
foreach (var server in bestServer)
{
SpeedResult speedResult = new SpeedResult();
speedResult.ServerName = server.Sponsor;
speedResult.LatencyMS = server.Latency;
speedResult.ServerID = server.Id;
speedResult.IP = publicIPv4;
speedResult.ClientName = clientName;
speedResult.DistanceKM = Math.Round(server.Distance);
speedResult.DownloadMbps = Math.Round(client.TestDownloadSpeed(server, settings.Download.ThreadsPerUrl) / 1024, 2);
speedResult.UploadMbps = Math.Round(client.TestUploadSpeed(server, settings.Upload.ThreadsPerUrl) / 1024, 2);
await SpeedTestClient.SendSpeedResult(speedResult, speedTestServerURL);
}
}
static void Main(string[] args)
{
string output = "{\"Download\": <<d>>, \"Upload\": <<u>>}";
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
output = output.Replace("<<d>>", CalculateSpeed(downloadSpeed));
output = output.Replace("<<u>>", CalculateSpeed(uploadSpeed));
Console.Write(output);
}
static void Main()
{
Console.WriteLine("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
Console.WriteLine("Testing speed...");
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
PrintSpeed("Download", downloadSpeed);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
PrintSpeed("Upload", uploadSpeed);
Console.WriteLine("Press a key to exit.");
Console.ReadKey();
}
static void Main()
{
Console.WriteLine("-- EchoServer/HelloClient --");
EchoServer.StartEchoServer();
HelloClient.Connect();
Task.Delay(50).Wait(); //Wait 50 milliseconds to let HelloClient finish
Console.WriteLine("-- BasicServer/BasicClient --");
BasicServer.StartBasicServer();
BasicClient.Connect();
Task.Delay(50).Wait(); //Wait 50 milliseconds to let BasicClient finish
Console.WriteLine("-- EasyTcpPacketExample --");
EasyTcpPacketExample.Start();
EasyTcpPacketExample.Connect();
Task.Delay(50).Wait(); //Wait 50 milliseconds to let EasyTcpPacketExample finish
Console.WriteLine("-- EncryptionExample --");
EncryptionExample.Start();
EncryptionExample.Connect();
Task.Delay(50).Wait(); //Wait 50 milliseconds to let EncryptionExample finish
Console.WriteLine("-- FileServer/FileClient --");
FileServer.StartFileServer();
FileClient.Download("TestFile.txt", "DownloadedTestFile.txt");
FileClient.Upload("TestFile.txt", "UploadedTestFile.txt");
Task.Delay(50).Wait(); //Wait 50 milliseconds to let FileClient finish
Console.WriteLine("-- EchoServer/SpeedTestClient --");
SpeedTestClient.RunSpeedTest();
Console.WriteLine("-- ActionEchoServer/ActionSpeedTestClient --");
ActionEchoServer.StartEchoServer();
ActionSpeedTestClient.RunSpeedTest();
Task.Delay(-1).Wait();
}
static void Main()
{
Console.WriteLine("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
Console.WriteLine("Testing speed...");
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
PrintSpeed("Download", downloadSpeed);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
PrintSpeed("Upload", uploadSpeed);
Console.WriteLine("Press a key to exit.");
Console.ReadKey();
}
static void Main()
{
Console.WriteLine("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
Console.WriteLine("Testing speed...");
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
PrintSpeed("Download", downloadSpeed);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
PrintSpeed("Upload", uploadSpeed);
var result = Uploader.Upload(uploadSpeed, downloadSpeed, bestServer).Result;
Thread.Sleep(2000);
}
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.");
}
List <BenchmarkPartialResult> DoInternalBenchmark()
{
var result = new List <BenchmarkPartialResult>();
base.WriteMessage("Getting speedtest.net settings and server list...");
client = new SpeedTestClient();
settings = client.GetSettings();
var servers = SelectServers();
var bestServer = SelectBestServer(servers);
base.WriteMessage("Testing speed...");
var downloadSpeed = client.TestDownloadSpeed(bestServer, settings.Download.ThreadsPerUrl);
PrintSpeed("Download", downloadSpeed);
var uploadSpeed = client.TestUploadSpeed(bestServer, settings.Upload.ThreadsPerUrl);
PrintSpeed("Upload", uploadSpeed);
result.Add(new BenchmarkPartialResult()
{
Description = "UPLOAD",
ResultType = BenchmarkResultType.UPLOAD_SPEED,
Score = Math.Round(uploadSpeed / 1024, 2),
MetricScale = MetricScaleType.MEGABYTE
});
result.Add(new BenchmarkPartialResult()
{
Description = "DOWNLOAD",
ResultType = BenchmarkResultType.DOWNLOAD_SPEED,
Score = Math.Round(downloadSpeed / 1024, 2),
MetricScale = MetricScaleType.MEGABYTE
});
//result.Score = Math.Round((downloadSpeed + uploadSpeed) / 1024, 2);
return(result);
}
public SpeedTestRunner(RegionInfo location)
{
_client = new SpeedTestClient();
_settings = _client.GetSettings();
_location = location;
}
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"));
}
}
public Worker(ILogger <Worker> logger)
{
_logger = logger;
_client = new SpeedTestClient();
_settings = _client.GetSettings();
}
