bsherriff/aviation
1
1
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Updated airport data, fixed loader/header

Browse Source
This commit is contained in:
Ben Sherriff
2023-12-21 14:19:17 -05:00
parent 8438acc68b
commit 0b2ef94b99
26 changed files with 472068 additions and 62093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
service/src/airports/model.rs
View File

@@ -10,23 +10,41 @@ use log::error;
use postgis_diesel::types::*;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub struct Runway {
pub id: String,
pub length_ft: f32,
pub width_ft: f32,
pub surface: String,
}
#[derive(Serialize, Deserialize)]
pub struct Frequency {
pub id: String,
pub frequency_mhz: f32,
}
#[derive(Serialize, Deserialize)]
pub struct Airport {
pub icao: String,
pub category: AirportCategory,
#[serde(skip_serializing_if = "Option::is_none")]
pub iata: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub local: Option<String>,
pub name: String,
pub elevation_ft: f32,
pub category: AirportCategory,
pub iso_country: String,
pub iso_region: String,
pub municipality: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub iata_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub local_code: Option<String>,
pub elevation_ft: f32,
pub latitude: f64,
pub longitude: f64,
#[serde(skip_serializing_if = "Option::is_none")]
pub has_tower: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub has_beacon: Option<bool>,
pub runways: Vec<Runway>,
pub frequencies: Vec<Frequency>,
}
impl Into<QueryAirport> for Airport {

2
service/src/main.rs
View File

@@ -22,7 +22,7 @@ async fn main() -> std::io::Result<()> {
dotenv().ok();
env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "warn,service=info"));
db::init();
scheduler::update_airports();
// scheduler::update_airports();
let host = env::var("SERVICE_HOST").unwrap_or("localhost".to_string());
let port = env::var("SERVICE_PORT").unwrap_or("5000".to_string());

140
service/src/metars/model.rs
View File

@@ -225,31 +225,50 @@ impl Metar {
// Wind Direction and Speed
let wind_re = regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}(?:KT|MPS)$").unwrap();
let wind_gust_re = regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}G[0-9]{2}(?:KT|MPS)$").unwrap();
if !metar_parts.is_empty() && wind_re.is_match(metar_parts[0]) {
let wind = metar_parts[0];
// Handle input error where there is a space between the numbers and units
let mut value: Option<String> = None;
if metar_parts.len() >= 2 && metar_parts[0].len() == 5 && (metar_parts[1] == "KT" || metar_parts[1] == "MPS") {
value = Some(format!("{}{}", metar_parts[0], metar_parts[1]));
metar_parts.remove(0);
metar_parts.remove(0);
} else if metar_parts.len() >= 2 && metar_parts[0].len() == 7 && metar_parts[0].contains("G") && (metar_parts[1] == "KT" || metar_parts[1] == "MPS") {
value = Some(format!("{}{}", metar_parts[0], metar_parts[1]));
metar_parts.remove(0);
metar_parts.remove(0);
} else if !metar_parts.is_empty() && wind_re.is_match(metar_parts[0]) {
value = Some(metar_parts[0].to_string());
metar_parts.remove(0);
let wind_dir_degrees = &wind[0..3];
metar.wind_dir_degrees = Some(wind_dir_degrees.to_string());
let mut wind_speed_kt = wind[3..5].to_string();
// Convert m/s to kt
if wind.len() == 8 {
wind_speed_kt = (wind_speed_kt.parse::<f64>().unwrap() * 1.94384).to_string();
}
metar.wind_speed_kt = Some(wind_speed_kt.parse::<f64>().unwrap());
} else if !metar_parts.is_empty() && wind_gust_re.is_match(metar_parts[0]) {
let wind = metar_parts[0];
value = Some(metar_parts[0].to_string());
metar_parts.remove(0);
let wind_dir_degrees = &wind[0..3];
metar.wind_dir_degrees = Some(wind_dir_degrees.to_string());
let mut wind_speed_kt = wind[3..5].to_string();
let mut wind_gust_kt = wind[6..8].to_string();
// Convert m/s to kt
if wind.len() == 9 {
wind_speed_kt = (wind_speed_kt.parse::<f64>().unwrap() * 1.94384).to_string();
wind_gust_kt = (wind_gust_kt.parse::<f64>().unwrap() * 1.94384).to_string();
}
metar.wind_speed_kt = Some(wind_speed_kt.parse::<f64>().unwrap());
metar.wind_gust_kt = Some(wind_gust_kt.parse::<f64>().unwrap());
}
match value {
Some(wind) => {
if wind_re.is_match(&wind) {
let wind_dir_degrees = &wind[0..3];
metar.wind_dir_degrees = Some(wind_dir_degrees.to_string());
let mut wind_speed_kt = wind[3..5].to_string();
// Convert m/s to kt
if wind.len() == 8 {
wind_speed_kt = (wind_speed_kt.parse::<f64>().unwrap() * 1.94384).to_string();
}
metar.wind_speed_kt = Some(wind_speed_kt.parse::<f64>().unwrap());
} else if wind_gust_re.is_match(&wind) {
let wind_dir_degrees = &wind[0..3];
metar.wind_dir_degrees = Some(wind_dir_degrees.to_string());
let mut wind_speed_kt = wind[3..5].to_string();
let mut wind_gust_kt = wind[6..8].to_string();
// Convert m/s to kt
if wind.len() == 9 {
wind_speed_kt = (wind_speed_kt.parse::<f64>().unwrap() * 1.94384).to_string();
wind_gust_kt = (wind_gust_kt.parse::<f64>().unwrap() * 1.94384).to_string();
}
metar.wind_speed_kt = Some(wind_speed_kt.parse::<f64>().unwrap());
metar.wind_gust_kt = Some(wind_gust_kt.parse::<f64>().unwrap());
}
},
None => {}
}
// Variable Wind Direction
@@ -516,17 +535,18 @@ impl Metar {
}
None => 5.0 // Assume VFR if no visibility is present
};
// Ceiling is the lowest cloud base that is BKN or OVC
let ceiling = match metar.sky_condition.first() {
Some(s) => {
if s.sky_cover == "CLR" || s.sky_cover == "SKC" || s.sky_cover == "NSC" || s.sky_cover == "NCD" {
3000.0
} else if s.sky_cover == "VV" {
if s.sky_cover == "VV" {
0.0
} else {
} else if s.sky_cover == "BKN" || s.sky_cover == "OVC" {
match s.cloud_base_ft_agl {
Some(c) => c as f64,
None => 0.0
}
} else {
3000.0 // Assume VFR if no BKN or OVC sky condition is present
}
},
None => 3000.0 // Assume VFR if no sky condition is present
@@ -564,7 +584,7 @@ impl Metar {
return missing_metar_icaos;
}
async fn get_remote_metars(icaos: Vec<String>) -> Vec<Metar> {
async fn get_remote_metars(icaos: Vec<String>) -> Result<Vec<Metar>, ServiceError> {
let gov_api_url = std::env::var("GOV_API_URL").expect("GOV_API_URL must be set");
// Query the remote API for the missing METAR data 10 at a time
let icao_chunks = icaos.chunks(10).map(|chunk| chunk.join(",")).collect::<Vec<String>>();
@@ -572,54 +592,27 @@ impl Metar {
for icao_chunk in icao_chunks {
let url = format!("{}/metar.php?ids={}", gov_api_url, icao_chunk);
let mut m = match reqwest::get(url).await {
Ok(r) => match r.text().await {
Ok(r) => {
let metar_chunk = r.trim().split("\n").filter(|m| !m.trim().is_empty()).collect();
match Metar::parse(metar_chunk) {
Ok(m) => m,
Err(err) => {
warn!("{}", err);
return metars;
Ok(r) => {
// Check if the status code is 200
if r.status() != 200 {
return Err(ServiceError::new(500, format!("Unable to get METAR request: {}", r.status())));
}
match r.text().await {
Ok(r) => {
let metar_chunk = r.trim().split("\n").filter(|m| !m.trim().is_empty()).collect();
match Metar::parse(metar_chunk) {
Ok(m) => m,
Err(err) => return Err(err)
}
}
},
Err(err) => {
warn!("Unable to parse METAR request: {}", err);
return metars;
},
Err(err) => return Err(ServiceError::new(500, format!("Unable to parse METAR request: {}", err)))
}
},
Err(err) => {
warn!("Unable to get METAR request: {}", err);
return metars;
}
Err(err) => return Err(ServiceError::new(500, format!("Unable to get METAR request: {}", err)))
};
metars.append(&mut m);
}
let icaos_string = icaos.join(",");
let url = format!("{}/metar.php?ids={}", gov_api_url, icaos_string);
match reqwest::get(url).await {
Ok(r) => match r.text().await {
Ok(r) => {
let metar_strings = r.trim().split("\n").filter(|m| !m.trim().is_empty()).collect();
match Metar::parse(metar_strings) {
Ok(m) => m,
Err(err) => {
warn!("{}", err);
return metars;
}
}
},
Err(err) => {
warn!("Unable to parse METAR request: {}", err);
return metars;
}
},
Err(err) => {
warn!("Unable to get METAR request: {}", err);
return metars;
}
}
return Ok(metars);
}
fn from_query(query_metars: Vec<QueryMetar>) -> Vec<Self> {
@@ -671,7 +664,14 @@ impl Metar {
Err(_) => {}
}
});
let mut missing_metars = Self::get_remote_metars(missing_icaos_string).await;
let missing_result = Self::get_remote_metars(missing_icaos_string).await;
let mut missing_metars = match missing_result {
Ok(m) => m,
Err(err) => {
warn!("Unable to get remote METAR data; {}", err);
vec![]
}
};
if missing_metars.len() > 0 {
let insert_metars = Self::to_insert(&missing_metars);
match InsertMetar::insert(&insert_metars) {

30
service/src/scheduler.rs
View File

@@ -6,6 +6,8 @@ use crate::metars::Metar;
pub fn update_airports() {
tokio::spawn(async {
let mut airports: Vec<QueryAirport> = vec![];
let limit = 100;
loop {
debug!("METAR update start");
let total = match QueryAirport::get_count(&QueryFilters::default()) {
@@ -15,17 +17,19 @@ pub fn update_airports() {
break
}
};
let limit = 50;
let pages = ((total as f32) / (if limit <= 0 { 1 } else { limit} as f32)).ceil() as i32;
let mut airports: Vec<QueryAirport> = vec![];
for page in 1..(pages + 1) {
match QueryAirport::get_all(&QueryFilters::default(), limit, page) {
Ok(mut a) => {
airports.append(&mut a)
},
Err(err) => {
warn!("{}", err);
break
if total != airports.len() as i64 {
debug!("{} cached airports, expected {}", airports.len(), total);
airports = vec![];
let pages = ((total as f32) / (if limit <= 0 { 1 } else { limit} as f32)).ceil() as i32;
for page in 1..(pages + 1) {
match QueryAirport::get_all(&QueryFilters::default(), limit, page) {
Ok(mut a) => {
airports.append(&mut a)
},
Err(err) => {
warn!("{}", err);
break
}
}
}
}
@@ -36,6 +40,7 @@ pub fn update_airports() {
let mut observation_time = chrono::Utc::now().timestamp();
if peekable.peek().is_none() {
debug!("No airports to update, sleeping for 1 hour");
sleep(Duration::from_secs(3600)).await;
continue;
}
@@ -52,12 +57,13 @@ pub fn update_airports() {
observation_time = metar.observation_time.timestamp();
}
}
sleep(Duration::from_millis(100)).await;
},
Err(err) => {
warn!("{}", err);
}
}
// Sleep for 100ms between chunks to avoid rate limiting
sleep(Duration::from_millis(100)).await;
}
debug!("METAR update complete");
// Sleep until the earliest observation time is 1 hour old