public async Task <IActionResult> KmlFromCallToRaw([FromQuery] FromUrlQueryQuerierOptions options, [FromQuery] ToLocationFromQuery toLocation, [FromQuery] FromLocationFromQuery fromLocation, [FromQuery] KmlSettingsFromQuery kmlSettings)
{
Program.RequestStatistics.ApiV1KmlRequests++;
if (fromLocation == null)
{
return(this.BadRequest("Error: fromLocation is null"));
}
if (toLocation == null)
{
return(this.BadRequest("Error: location is null"));
}
IQuerierOptions optionsInUse = this.CreateOptions(options);
try
{
var action = new KmlAction(fromLocation, toLocation, optionsInUse as FromUrlQueryQuerierOptions, this.hamnetDbAccess);
var kmlString = await action.Execute();
if ((kmlSettings != null) && (kmlSettings.AsText))
{
return(this.Ok(kmlString));
}
return(this.File(Encoding.UTF8.GetBytes(kmlString), KmlContentType, $"raw-From-To-{DateTime.Now:yyyyMMddTHHmmss}.kml"));
}
catch (Exception ex)
{
return(this.BadRequest($"Error: {ex.Message}"));
}
}
/// <summary>
/// Initializes a new instance of the KmlAction
/// </summary>
/// <param name="fromLocation">The from site location.</param>
/// <param name="toLocation">The to site location.</param>
/// <param name="fromUrlQueryQuerierOptions">The querier options.</param>
/// <param name="hamnetDbAccess">The accessor to HamnetDB (needed to get coordinates for callsigns).</param>
public KmlAction(ToolController.FromLocationFromQuery fromLocation, ToolController.ToLocationFromQuery toLocation, FromUrlQueryQuerierOptions fromUrlQueryQuerierOptions, IHamnetDbAccess hamnetDbAccess)
{
this.fromLocation = fromLocation;
this.toLocation = toLocation;
this.fromUrlQueryQuerierOptions = fromUrlQueryQuerierOptions;
this.hamnetDbAccess = hamnetDbAccess;
}
public async Task <IActionResult> Kml(string fromSite, string toSite, [FromQuery] FromUrlQueryQuerierOptions options, [FromQuery] KmlSettingsFromQuery kmlSettings)
{
Program.RequestStatistics.ApiV1KmlRequests++;
if (string.IsNullOrWhiteSpace(fromSite))
{
return(this.BadRequest("Error: fromSite is null, empty or white-space-only"));
}
if (string.IsNullOrWhiteSpace(toSite))
{
return(this.BadRequest("Error: toSite is null, empty or white-space-only"));
}
IQuerierOptions optionsInUse = this.CreateOptions(options);
try
{
var action = new KmlAction(WebUtility.UrlDecode(fromSite), WebUtility.UrlDecode(toSite), optionsInUse as FromUrlQueryQuerierOptions, this.hamnetDbAccess);
var kmlString = await action.Execute();
if ((kmlSettings != null) && (kmlSettings.AsText))
{
return(this.Ok(kmlString));
}
return(this.File(Encoding.UTF8.GetBytes(kmlString), KmlContentType, $"{fromSite}-{toSite}-{DateTime.Now:yyyyMMddTHHmmss}.kml"));
}
catch (Exception ex)
{
return(this.BadRequest($"Error: {ex.Message}"));
}
}
/// <summary>
/// Initializes a new instance of the KmlAction
/// </summary>
/// <param name="fromCall">The from site callsign.</param>
/// <param name="toCall">The to site callsign.</param>
/// <param name="fromUrlQueryQuerierOptions">The querier options.</param>
/// <param name="hamnetDbAccess">The accessor to HamnetDB (needed to get coordinates for callsigns).</param>
public KmlAction(string fromCall, string toCall, FromUrlQueryQuerierOptions fromUrlQueryQuerierOptions, IHamnetDbAccess hamnetDbAccess)
{
this.hamnetDbAccess = hamnetDbAccess;
this.fromCall = fromCall;
this.toCall = toCall;
this.fromUrlQueryQuerierOptions = fromUrlQueryQuerierOptions;
}
public async Task <ActionResult <IStatusReply> > PingHost(string host, [FromQuery] FromUrlQueryQuerierOptions options)
{
Program.RequestStatistics.ApiV1BgpHostSpecificRequests++;
IQuerierOptions optionsInUse = this.CreateOptions(options);
return(await new BgpPeersAction(WebUtility.UrlDecode(host), null, optionsInUse as FromUrlQueryQuerierOptions).Execute());
}
/// <summary>
/// Construct for a specific host.
/// </summary>
/// <param name="host">The host or IP address to ping.</param>
/// <param name="remotePeerAddress">The address of the remote peer to get the data for. If null or empty, all peer's data.</param>
/// <param name="count">The number of packets to send.</param>
/// <param name="timeout">The timeout of a single ping.</param>
/// <param name="maxHops">The maximum number of hops.</param>
/// <param name="querierOptions">The querier options to use.</param>
public TracerouteAction(string host, string remotePeerAddress, int count, TimeSpan timeout, int maxHops, FromUrlQueryQuerierOptions querierOptions)
{
this.maxHops = maxHops;
this.timeout = timeout;
if (string.IsNullOrWhiteSpace(host))
{
throw new ArgumentNullException(nameof(host), "Host is null, empty or white-space-only");
}
this.host = host;
this.remotePeerAddress = remotePeerAddress;
this.count = count;
this.querierOptions = querierOptions ?? new FromUrlQueryQuerierOptions();
this.querierOptions.AllowedApis = QueryApis.VendorSpecific; // currently we only support vendor-specific API - no matter what user requests
}
/// <summary>
/// Creates the querier options prioritizing query URL over the confiugration settings.
/// </summary>
/// <param name="options">The options from query URL.</param>
/// <returns>The assembled options to use.</returns>
private IQuerierOptions CreateOptions(FromUrlQueryQuerierOptions options)
{
FromUrlQueryQuerierOptions optionsInUse = options;
var monitoringAccountsSection = this.configuration.GetSection(Program.MonitoringAccountsSectionKey).GetSection(Program.BgpAccountSectionKey);
var loginUserName = monitoringAccountsSection.GetValue <string>("User");
if (string.IsNullOrWhiteSpace(optionsInUse.LoginUser) && !string.IsNullOrWhiteSpace(loginUserName))
{
optionsInUse.LoginUser = loginUserName;
}
var loginPassword = monitoringAccountsSection.GetValue <string>("Password");
if (string.IsNullOrWhiteSpace(optionsInUse.LoginPassword) && !string.IsNullOrWhiteSpace(loginPassword))
{
optionsInUse.LoginPassword = loginPassword;
}
return(optionsInUse);
}
public async Task <ActionResult <IStatusReply> > TracerouteHost(string fromHost, string toHost, [FromQuery] FromUrlQueryQuerierOptions options, int count = 1, double timeoutSeconds = 1.0, int maxHops = MaxTracerouteMaxHops / 4)
{
Program.RequestStatistics.ApiV1TraceRouteRequests++;
IQuerierOptions optionsInUse = this.CreateOptions(options);
if ((count < 1) || (count > MaxTracerouteSendCount))
{
return(new ErrorReply(new ArgumentOutOfRangeException(nameof(count), $"count must be in range [1; {MaxTracerouteSendCount}] but was found as {count}")));
}
if ((timeoutSeconds < MinTracerouteTimeoutSeconds) || (timeoutSeconds > MaxTracerouteTimeoutSeconds))
{
return(new ErrorReply(new ArgumentOutOfRangeException(nameof(timeoutSeconds), $"timeoutSeconds must be in range [{MinTracerouteTimeoutSeconds}; {MaxTracerouteTimeoutSeconds}] but was found as {timeoutSeconds}")));
}
if ((maxHops < MinTracerouteMaxHops) || (maxHops > MaxTracerouteMaxHops))
{
return(new ErrorReply(new ArgumentOutOfRangeException(nameof(maxHops), $"maxHops must be in range [{MinTracerouteMaxHops}; {MaxTracerouteMaxHops}] but was found as {maxHops}")));
}
try
{
return(await new TracerouteAction(WebUtility.UrlDecode(fromHost), WebUtility.UrlDecode(toHost), count, TimeSpan.FromSeconds(timeoutSeconds), maxHops, optionsInUse as FromUrlQueryQuerierOptions).Execute());
}
catch (Exception ex)
{
return(this.BadRequest($"Error: {ex.Message}"));
}
}
public async Task <ActionResult <IStatusReply> > LinkTest(string host1, string host2, [FromQuery] FromUrlQueryQuerierOptions options)
{
Program.RequestStatistics.ApiV1LinkTestLinkRequests++;
return(await new LinkTest(WebUtility.UrlDecode(host1), WebUtility.UrlDecode(host2), options).Execute());
}
public async Task <ActionResult <IStatusReply> > HostInfo(string host, [FromQuery] FromUrlQueryQuerierOptions options)
{
Program.RequestStatistics.ApiV1LinkTestInfoRequests++;
return(await new HostInfo(WebUtility.UrlDecode(host), this.logger, this.configuration, options).Execute());
}
