public async Task Start(CancellationToken cancellationToken)
{
var ipAddresses = Enumerable.Range(1, 255).Select(GetAddress);
var pings = _pingService.Ping(ipAddresses);
var logs = pings.Select(t => t.ContinueWith(t1 => Log(t1.Result), cancellationToken));
await Task.WhenAll(logs);
}
public async Task <string> Ping()
{
MiniProfiler profiler = MiniProfiler.Current;
using (profiler.Step("Ping"))
{
return(await PingService.Ping());
}
}
public async Task <ActionResult <PingResponse> > Ping()
{
var response = await _pingService.Ping();
return(Ok(new PingResponse
{
DatabasePing = response.DatabasePing,
DatabaseStatus = response.DatabaseStatus,
ServerTime = response.ServerTime
}));
}
public ActionResult Ping()
{
BasicHttpBinding myBinding = new BasicHttpBinding();
EndpointAddress myEndpoint = new EndpointAddress("http://localhost:51620/PingService.svc");
ChannelFactory <IPingService> myChannelFactory = new ChannelFactory <IPingService>(myBinding, myEndpoint);
IPingService instance = myChannelFactory.CreateChannel();
// Call Service.
object s = instance.Ping();
myChannelFactory.Close();
return(View(s));
}
private async Task PingAndUpdateAsync(string ip)
{
var reply = await _pingService.Ping(ip, _timeout).ConfigureAwait(false);
if (reply.Status == IPStatus.Success)
{
var hostName = await GetHostnameAsync(ip).ConfigureAwait(false);
var macAddress = await GetMacAddressAsync(ip).ConfigureAwait(false);
var newFoundDevice = new NetworkDeviceResponseDto()
{
Name = MakeNameFromHostname(hostName),
Hostname = hostName ?? "Not available",
MacAddress = macAddress ?? "Not available",
Ipv4 = ip ?? "Not available",
Ipv6 = reply.Address.MapToIPv6().ToString()
};
_foundDevices.Add(newFoundDevice);
}
}
public MainWindowViewmodel(IPingTimer pingTimer,
IPingService pingService,
IPingCollectionVectorFactory pingCollectionVectorFactory,
IPingVectorFactory pingVectorFactory,
IVectorComparer vectorComparer,
IIpAddressService ipAddressService,
IDispatcherAccessor dispatcherAccessor,
PingStatsUtil pingStatsUtil,
IPingResponseUtil pingResponseUtil)
{
_pingTimer = pingTimer;
_pingService = pingService;
_pingCollectionVectorFactory = pingCollectionVectorFactory;
_pingVectorFactory = pingVectorFactory;
_vectorComparer = vectorComparer;
_pingStatsUtil = pingStatsUtil;
_pingResponseUtil = pingResponseUtil;
IObservable <long> pingTimerObservable = _pingTimer.Start(() => false);
IDisposable pingResponseSubscription = null;
_targetDatamodels = new ConcurrentDictionary <IPAddress, PingState>();
_stats = new ConcurrentDictionary <IPAddress, PingStats>();
System.Windows.Threading.Dispatcher d = dispatcherAccessor.GetDispatcher();
Subject <int> resortSubject = new Subject <int>();
ResortObservable = resortSubject;
ipAddressService.IpAddressObservable.Subscribe(ipAddresses =>
{
pingResponseSubscription?.Dispose();
IObservable <IEnumerable <Task <IPingResponse> > > pingResponseObservable =
pingTimerObservable.Select(l => _pingService.Ping(ipAddresses));
pingResponseSubscription = pingResponseObservable.Subscribe(async pingResponseTasks =>
{
IPingResponse[] responses = await Task.WhenAll(pingResponseTasks);
IVector[] vectors = responses.Select(pingResponse =>
{
IPingStats stats = GetUpdatedStats(pingResponse);
IVector pingVector = _pingVectorFactory.GetVector(pingResponse, stats);
if (_targetDatamodels.TryGetValue(pingResponse.TargetIpAddress, out PingState pingState))
{
TargetDatamodel targetDatamodelX = pingState.TargetDatamodel;
targetDatamodelX.RoundTripTime = pingResponse.RoundTripTime;
targetDatamodelX.StatusSuccess = GetStatusSuccess(pingResponse.Status);
IVector boring = _pingVectorFactory.GetVector(new PingResponse(IPAddress.Loopback, TimeSpan.Zero, IPStatus.DestinationHostUnreachable, IPAddress.Loopback),
new PingStats(DateTime.Now.AddDays(-1), DateTime.Now)
{
Average25 = 0, Average25Count = 25, StatusHistory = new bool[PingStatsUtil.MaxHistoryCount]
});
double change = _vectorComparer.Compare(boring, pingVector);
targetDatamodelX.Change = change;
if (targetDatamodelX.Change > 0.008)
{
targetDatamodelX.ShowUntil = DateTime.Now.Add(TimeToShowOddTargets);
}
if (targetDatamodelX.ShowUntil <= DateTime.Now)
{
targetDatamodelX.ShowUntil = null;
}
pingState.Previous = pingVector;
}
else
{
TargetDatamodel targetDatamodel = new TargetDatamodel(address: pingResponse.TargetIpAddress,
statusSuccess: GetStatusSuccess(pingResponse.Status),
roundTripTime: pingResponse.RoundTripTime);
_targetDatamodels.Add(pingResponse.TargetIpAddress, new PingState {
TargetDatamodel = targetDatamodel, Previous = pingVector
});
d.Invoke(() => TargetDatamodels.Add(targetDatamodel));
}
return(pingVector);
}).ToArray();
resortSubject.OnNext(0);
});
});
TargetDatamodels = new ObservableCollection <TargetDatamodel>();
}
public void Run()
{
_pingService.Ping("8.8.8.8");
}