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()); }