diff --git a/Cargo.toml b/Cargo.toml index c514ee3..a2718d0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -34,6 +34,7 @@ lazy_static = "1.4.0" log = "0.4" env_logger = "0.8" mavlink = { version = "0.19.1", features = ["dialect-ardupilotmega", "mav2-message-extensions"] } +mavlink_legacy = { package = "mavlink", version = "0.10.14", features = ["ardupilotmega", "emit-extensions"] } paperclip = { version = "0.8", features = ["actix3", "v3", "paperclip-actix", "swagger-ui"] } regex = "1" serde = "1.0.115" diff --git a/src/data.rs b/src/data.rs index 7cfb814..55329f2 100644 --- a/src/data.rs +++ b/src/data.rs @@ -148,24 +148,35 @@ impl MAVLinkVehiclesData { .update(&message); } - pub fn pointer(&self, path: &str) -> String { + pub fn pointer_with_schema( + &self, + path: &str, + schema: crate::legacy::JsonSchema, + ) -> Result { + let value = serde_json::to_value(self).map_err(|error| error.to_string())?; + let value = match schema { + crate::legacy::JsonSchema::Modern => value, + crate::legacy::JsonSchema::Legacy => crate::legacy::modern_to_legacy(&value)?, + }; + if path.is_empty() { - return serde_json::to_string_pretty(self).unwrap(); + return serde_json::to_string_pretty(&value).map_err(|error| error.to_string()); } let path = format!("/{path}"); - dbg!(&path); if path == "/vehicles" { - return serde_json::to_string_pretty(&self.vehicles).unwrap(); - }; + let vehicles = value.get("vehicles").ok_or_else(|| "None".to_string())?; + return serde_json::to_string_pretty(vehicles).map_err(|error| error.to_string()); + } - let value = serde_json::to_value(self).unwrap(); - return match value.pointer(&path) { - Some(content) => serde_json::to_string_pretty(content).unwrap(), - None => "None".into(), - }; + match value.pointer(&path) { + Some(content) => { + serde_json::to_string_pretty(content).map_err(|error| error.to_string()) + } + None => Ok("None".into()), + } } } diff --git a/src/endpoints.rs b/src/endpoints.rs index 29d1fdc..395078d 100644 --- a/src/endpoints.rs +++ b/src/endpoints.rs @@ -10,6 +10,8 @@ use paperclip::actix::{api_v2_operation, Apiv2Schema}; use serde::{Deserialize, Serialize}; use super::data; +use super::legacy; +use super::legacy::JsonSchema; use super::mavlink_vehicle::MAVLinkVehicleArcMutex; use super::websocket_manager::{self, WebsocketActor}; @@ -114,9 +116,24 @@ pub async fn llm() -> actix_web::Result { #[api_v2_operation] /// Provides an object containing all MAVLink messages received by the service pub async fn mavlink(req: HttpRequest) -> actix_web::Result { + mavlink_with_schema(req, JsonSchema::Modern).await +} + +#[api_v2_operation] +/// Provides MAVLink messages using the legacy 0.x JSON schema +pub async fn mavlink_legacy(req: HttpRequest) -> actix_web::Result { + mavlink_with_schema(req, JsonSchema::Legacy).await +} + +async fn mavlink_with_schema( + req: HttpRequest, + schema: JsonSchema, +) -> actix_web::Result { let path = req.match_info().query("path"); - let message = data::messages().pointer(path); - ok_response(message).await + match data::messages().pointer_with_schema(path, schema) { + Ok(message) => ok_response(message).await, + Err(error) => not_found_response(error).await, + } } pub fn parse_query(message: &T) -> String { @@ -125,11 +142,39 @@ pub fn parse_query(message: &T) -> String { serde_json::to_string_pretty(&message).unwrap_or(error_message) } +fn parse_query_schema( + message: &T, + schema: JsonSchema, +) -> Result { + let value = serde_json::to_value(message).map_err(|error| error.to_string())?; + let value = match schema { + JsonSchema::Modern => value, + JsonSchema::Legacy => legacy::modern_to_legacy(&value)?, + }; + serde_json::to_string_pretty(&value).map_err(|error| error.to_string()) +} + #[api_v2_operation] /// Returns an example of a MAVLink message matching the given message name pub async fn helper_mavlink( _req: HttpRequest, query: web::Query, +) -> actix_web::Result { + helper_mavlink_with_schema(query, JsonSchema::Modern).await +} + +#[api_v2_operation] +/// Returns a legacy 0.x JSON example for the given MAVLink message name +pub async fn helper_mavlink_legacy( + _req: HttpRequest, + query: web::Query, +) -> actix_web::Result { + helper_mavlink_with_schema(query, JsonSchema::Legacy).await +} + +async fn helper_mavlink_with_schema( + query: web::Query, + schema: JsonSchema, ) -> actix_web::Result { let message_name = query.into_inner().name; @@ -141,15 +186,15 @@ pub async fn helper_mavlink( }; match result { - Ok(result) => { - let msg = match result { - msg => parse_query(&data::MAVLinkMessage { - header: mavlink::MavHeader::default(), - message: msg, - }), + Ok(msg) => { + let envelope = data::MAVLinkMessage { + header: mavlink::MavHeader::default(), + message: msg, }; - - ok_response(msg).await + match parse_query_schema(&envelope, schema) { + Ok(content) => ok_response(content).await, + Err(error) => not_found_response(error).await, + } } Err(content) => not_found_response(parse_query(&content)).await, } @@ -162,6 +207,26 @@ pub async fn mavlink_post( data: web::Data, _req: HttpRequest, bytes: web::Bytes, +) -> actix_web::Result { + mavlink_post_with_schema(data, bytes, JsonSchema::Modern).await +} + +#[api_v2_operation] +#[allow(clippy::await_holding_lock)] +/// Send a MAVLink message using the legacy 0.x JSON schema +pub async fn mavlink_post_legacy( + data: web::Data, + _req: HttpRequest, + bytes: web::Bytes, +) -> actix_web::Result { + mavlink_post_with_schema(data, bytes, JsonSchema::Legacy).await +} + +#[allow(clippy::await_holding_lock)] +async fn mavlink_post_with_schema( + data: web::Data, + bytes: web::Bytes, + schema: JsonSchema, ) -> actix_web::Result { let json_string = match String::from_utf8(bytes.to_vec()) { Ok(content) => content, @@ -173,35 +238,60 @@ pub async fn mavlink_post( debug!("MAVLink post received: {json_string}"); - match json5::from_str::>( - &json_string, - ) { - Ok(content) => match data.lock().unwrap().send(&content.header, &content.message) { - Ok(_result) => { - websocket_manager::send(&content); - data::update((content.header, content.message)); - return HttpResponse::Ok().await; - } - Err(err) => { - return not_found_response(format!("Failed to send message: {err:?}")).await - } - }, - Err(err) => { - debug!("Failed to parse ardupilotmega message: {err:?}"); - let error_message = - format!("Failed to parse message, not a valid MAVLinkMessage: {err:?}"); - debug!("{error_message}"); - return not_found_response(error_message).await; + let content = match parse_incoming_message(&json_string, schema) { + Ok(content) => content, + Err(error) => return not_found_response(error).await, + }; + + match data.lock().unwrap().send(&content.header, &content.message) { + Ok(_result) => { + websocket_manager::send(&content); + data::update((content.header, content.message)); + HttpResponse::Ok().await } + Err(err) => not_found_response(format!("Failed to send message: {err:?}")).await, } } +pub fn parse_incoming_message( + json_string: &str, + schema: JsonSchema, +) -> Result, String> { + let value: serde_json::Value = + json5::from_str(json_string).map_err(|error| format!("Failed to parse JSON5: {error}"))?; + let value = match schema { + JsonSchema::Modern => value, + JsonSchema::Legacy => legacy::legacy_to_modern(&value)?, + }; + serde_json::from_value(value) + .map_err(|error| format!("Failed to parse message, not a valid MAVLinkMessage: {error:?}")) +} + #[api_v2_operation] /// Websocket used to receive and send MAVLink messages asynchronously pub async fn websocket( req: HttpRequest, query: web::Query, stream: web::Payload, +) -> Result { + websocket_with_schema(req, query, stream, JsonSchema::Modern).await +} + +#[api_v2_operation] +/// Websocket using the legacy 0.x JSON schema +pub async fn websocket_legacy( + req: HttpRequest, + query: web::Query, + stream: web::Payload, +) -> Result { + websocket_with_schema(req, query, stream, JsonSchema::Legacy).await +} + +async fn websocket_with_schema( + req: HttpRequest, + query: web::Query, + stream: web::Payload, + schema: JsonSchema, ) -> Result { let query = query.into_inner(); let filter = match query.filter { @@ -209,9 +299,9 @@ pub async fn websocket( _ => ".*".to_owned(), }; - debug!("New websocket with filter {:#?}", &filter); + debug!("New websocket with filter {filter:#?} schema={schema:?}"); - let actor = WebsocketActor::new(filter, query.system_id, query.component_id); + let actor = WebsocketActor::new(filter, query.system_id, query.component_id, schema); ws::start(actor, &req, stream) } diff --git a/src/legacy/convert.rs b/src/legacy/convert.rs new file mode 100644 index 0000000..2ea2a1e --- /dev/null +++ b/src/legacy/convert.rs @@ -0,0 +1,177 @@ +use mavlink::Message as ModernMessage; +use mavlink_legacy::Message as LegacyMessage; +use serde_json::Value; + +type ModernMavMessage = mavlink::dialects::ardupilotmega::MavMessage; +type LegacyApmMessage = mavlink_legacy::ardupilotmega::MavMessage; +type LegacyCommonMessage = mavlink_legacy::common::MavMessage; + +pub fn modern_to_legacy(value: &Value) -> Result { + let mut out = value.clone(); + convert_tree(&mut out, Direction::ModernToLegacy)?; + Ok(out) +} + +pub fn legacy_to_modern(value: &Value) -> Result { + let mut out = value.clone(); + convert_tree(&mut out, Direction::LegacyToModern)?; + Ok(out) +} + +#[derive(Clone, Copy)] +enum Direction { + ModernToLegacy, + LegacyToModern, +} + +fn convert_tree(value: &mut Value, direction: Direction) -> Result<(), String> { + match value { + Value::Object(map) => { + if let (Some(header), Some(message)) = + (map.get("header").cloned(), map.get("message").cloned()) + { + if message.get("type").and_then(Value::as_str).is_some() { + let converted = match direction { + Direction::ModernToLegacy => modern_message_value_to_legacy(message)?, + Direction::LegacyToModern => legacy_message_value_to_modern(message)?, + }; + map.insert("header".into(), header); + map.insert("message".into(), converted); + return Ok(()); + } + } + if let Some(Value::String(type_name)) = map.get("type").cloned() { + if looks_like_message_body(map) { + let body = Value::Object(map.clone()); + let converted = match direction { + Direction::ModernToLegacy => modern_message_value_to_legacy(body)?, + Direction::LegacyToModern => legacy_message_value_to_modern(body)?, + }; + *value = converted; + return Ok(()); + } + let _ = type_name; + } + for child in map.values_mut() { + convert_tree(child, direction)?; + } + Ok(()) + } + Value::Array(items) => { + for item in items.iter_mut() { + convert_tree(item, direction)?; + } + Ok(()) + } + _ => Ok(()), + } +} + +fn looks_like_message_body(map: &serde_json::Map) -> bool { + map.contains_key("type") && map.len() > 1 && !map.contains_key("header") +} + +fn modern_message_value_to_legacy(message: Value) -> Result { + let modern: ModernMavMessage = serde_json::from_value(message) + .map_err(|error| format!("Failed to parse modern message for legacy convert: {error}"))?; + modern_message_to_legacy_value(&modern) +} + +fn modern_message_to_legacy_value(modern: &ModernMavMessage) -> Result { + let mut payload = [0u8; 255]; + let size = ModernMessage::ser(modern, mavlink::MavlinkVersion::V2, &mut payload); + let legacy = ::parse( + mavlink_legacy::MavlinkVersion::V2, + modern.message_id(), + &payload[..size], + ) + .map_err(|error| { + format!( + "Legacy dialect cannot represent {}: {error:?}", + modern.message_name() + ) + })?; + serialize_legacy_message(&legacy) +} + +fn serialize_legacy_message(message: &LegacyApmMessage) -> Result { + match message { + LegacyApmMessage::common(inner) => serde_json::to_value(inner) + .map_err(|error| format!("Failed to serialize legacy common message: {error}")), + other => serde_json::to_value(other) + .map_err(|error| format!("Failed to serialize legacy message: {error}")), + } +} + +fn legacy_message_value_to_modern(message: Value) -> Result { + let legacy = parse_legacy_message(message)?; + let payload = LegacyMessage::ser(&legacy); + let modern = ::parse( + mavlink::MavlinkVersion::V2, + LegacyMessage::message_id(&legacy), + &payload, + ) + .map_err(|error| { + format!( + "Modern dialect cannot represent {}: {error:?}", + LegacyMessage::message_name(&legacy) + ) + })?; + serde_json::to_value(modern) + .map_err(|error| format!("Failed to serialize modern message: {error}")) +} + +fn parse_legacy_message(message: Value) -> Result { + match serde_json::from_value::(message.clone()) { + Ok(common) => Ok(LegacyApmMessage::common(common)), + Err(common_error) => match serde_json::from_value::(message) { + Ok(message) => Ok(message), + Err(apm_error) => Err(format!( + "Failed to parse legacy MAVLink message: common={common_error}; apm={apm_error}" + )), + }, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn param_set_roundtrip_via_wire() { + let modern = json!({ + "type": "PARAM_SET", + "target_system": 1, + "target_component": 1, + "param_id": "SCR_FSS", + "param_value": 1.5, + "param_type": {"type": "MAV_PARAM_TYPE_REAL32"} + }); + let legacy = modern_to_legacy(&modern).unwrap(); + assert!( + legacy.get("param_id").unwrap().is_array(), + "param_id={legacy:?}" + ); + let back = legacy_to_modern(&legacy).unwrap(); + assert_eq!(back.get("param_id").unwrap(), "SCR_FSS"); + } + + #[test] + fn heartbeat_flags_roundtrip_via_wire() { + let modern = json!({ + "type": "HEARTBEAT", + "custom_mode": 0, + "mavtype": {"type": "MAV_TYPE_GENERIC"}, + "autopilot": {"type": "MAV_AUTOPILOT_GENERIC"}, + "base_mode": "MAV_MODE_FLAG_SAFETY_ARMED | MAV_MODE_FLAG_CUSTOM_MODE_ENABLED", + "system_status": {"type": "MAV_STATE_UNINIT"}, + "mavlink_version": 3 + }); + let legacy = modern_to_legacy(&modern).unwrap(); + assert_eq!(legacy["base_mode"], json!({"bits": 129})); + let back = legacy_to_modern(&legacy).unwrap(); + let mode = back.get("base_mode").unwrap().as_str().unwrap(); + assert!(mode.contains("MAV_MODE_FLAG_SAFETY_ARMED")); + } +} diff --git a/src/legacy/mod.rs b/src/legacy/mod.rs new file mode 100644 index 0000000..d34a32e --- /dev/null +++ b/src/legacy/mod.rs @@ -0,0 +1,9 @@ +mod convert; + +pub use convert::{legacy_to_modern, modern_to_legacy}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum JsonSchema { + Modern, + Legacy, +} diff --git a/src/main.rs b/src/main.rs index 90e581f..1f61e0f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,6 +1,7 @@ mod cli; mod data; mod endpoints; +mod legacy; mod mavlink_vehicle; mod server; mod websocket_manager; @@ -8,6 +9,7 @@ mod websocket_manager; use std::sync::{Arc, Mutex}; use data::MAVLinkMessage; +use legacy::JsonSchema; use log::*; fn main() -> std::io::Result<()> { @@ -38,8 +40,8 @@ fn main() -> std::io::Result<()> { websocket_manager::manager() .lock() .unwrap() - .new_message_callback = Some(Arc::new(move |value| { - ws_callback(inner_vehicle.clone(), value) + .new_message_callback = Some(Arc::new(move |value, schema| { + ws_callback(inner_vehicle.clone(), value, schema) })); loop { @@ -61,23 +63,23 @@ fn ws_callback( Mutex>, >, value: &str, + schema: JsonSchema, ) -> String { - if let Ok(content @ MAVLinkMessage:: { .. }) = - serde_json::from_str(value) - { - let result = inner_vehicle - .lock() - .unwrap() - .send(&content.header, &content.message); - match result { - Ok(_) => { - websocket_manager::send(&content); - data::update((content.header, content.message)); - serde_json::json!({ "result": "ok" }).to_string() + match endpoints::parse_incoming_message(value, schema) { + Ok(content) => { + let result = inner_vehicle + .lock() + .unwrap() + .send(&content.header, &content.message); + match result { + Ok(_) => { + websocket_manager::send(&content); + data::update((content.header, content.message)); + serde_json::json!({ "result": "ok" }).to_string() + } + Err(error) => serde_json::json!({ "error": error.to_string() }).to_string(), } - Err(error) => serde_json::json!({ "error": error.to_string() }).to_string(), } - } else { - serde_json::json!({ "error": "Could not convert input message." }).to_string() + Err(error) => serde_json::json!({ "error": error }).to_string(), } } diff --git a/src/server.rs b/src/server.rs index 9df3592..6b2091c 100644 --- a/src/server.rs +++ b/src/server.rs @@ -31,6 +31,21 @@ fn add_v1_paths(scope: Scope) -> Scope { .service(web::resource("/ws/mavlink").route(web::get().to(endpoints::websocket))) } +fn add_v0_paths(scope: Scope) -> Scope { + scope + .route( + "/helper/mavlink", + web::get().to(endpoints::helper_mavlink_legacy), + ) + .route("/mavlink", web::get().to(endpoints::mavlink_legacy)) + .route("/mavlink", web::post().to(endpoints::mavlink_post_legacy)) + .route( + r"/mavlink/{path:.*}", + web::get().to(endpoints::mavlink_legacy), + ) + .service(web::resource("/ws/mavlink").route(web::get().to(endpoints::websocket_legacy))) +} + // Start REST API server with the desired address pub fn run(server_address: &str, mavlink_vehicle: &MAVLinkVehicleArcMutex) { let server_address = server_address.to_string(); @@ -40,6 +55,7 @@ pub fn run(server_address: &str, mavlink_vehicle: &MAVLinkVehicleArcMutex) { // Start HTTP server thread let _ = System::new("http-server"); HttpServer::new(move || { + let v0 = add_v0_paths(web::scope("/v0")); let v1 = add_v1_paths(web::scope("/v1")); let default = match cli::default_api_version() { 1 => add_v1_paths(web::scope("")), @@ -62,6 +78,7 @@ pub fn run(server_address: &str, mavlink_vehicle: &MAVLinkVehicleArcMutex) { ) .route("/info", web::get().to(endpoints::info)) // Be sure to have default as the latest endpoint, otherwise it does not work + .service(v0) .service(v1) .service(default) .build() diff --git a/src/websocket_manager.rs b/src/websocket_manager.rs index 0b6d405..eea36d9 100644 --- a/src/websocket_manager.rs +++ b/src/websocket_manager.rs @@ -7,7 +7,8 @@ use regex::Regex; use serde::Serialize; use std::sync::{Arc, Mutex}; -use crate::MAVLinkMessage; +use crate::data::MAVLinkMessage; +use crate::legacy::{self, JsonSchema}; pub struct StringMessage(String); @@ -26,6 +27,7 @@ pub struct WebsocketActorContent { pub re: Option, pub system_id: Option, pub component_id: Option, + pub schema: JsonSchema, } #[derive(Derivative, Default)] @@ -34,7 +36,7 @@ pub struct WebsocketActorContent { pub struct WebsocketManager { pub clients: Vec, #[derivative(Debug = "ignore")] - pub new_message_callback: Option String + Send + Sync>>, + pub new_message_callback: Option String + Send + Sync>>, } impl WebsocketManager { @@ -43,16 +45,35 @@ impl WebsocketManager { return; } - let string = serde_json::to_string_pretty(value).unwrap(); + let modern = serde_json::to_string_pretty(value).unwrap(); + let legacy = match legacy::modern_to_legacy(value) { + Ok(legacy_value) => Some(serde_json::to_string_pretty(&legacy_value).unwrap()), + Err(error) => { + log::error!("Failed to convert websocket payload to legacy JSON: {error}"); + None + } + }; + for client in &self.clients { let is_match = client.re.as_ref().map_or(false, |regx| regx.is_match(name)) && client.system_id.map_or(true, |id| id == header.system_id) && client .component_id .map_or(true, |id| id == header.component_id); - if is_match { - client.actor.do_send(StringMessage(string.clone())); + if !is_match { + continue; } + let payload = match client.schema { + JsonSchema::Modern => modern.clone(), + JsonSchema::Legacy => match &legacy { + Some(content) => content.clone(), + None => serde_json::to_string(&WebsocketError { + error: "Failed to convert message to legacy JSON.".to_string(), + }) + .unwrap(), + }, + }; + client.actor.do_send(StringMessage(payload)); } } } @@ -78,15 +99,22 @@ pub struct WebsocketActor { pub filter: String, pub system_id: Option, pub component_id: Option, + pub schema: JsonSchema, } impl WebsocketActor { - pub fn new(message_filter: String, system_id: Option, component_id: Option) -> Self { + pub fn new( + message_filter: String, + system_id: Option, + component_id: Option, + schema: JsonSchema, + ) -> Self { Self { server: MANAGER.clone(), filter: message_filter, system_id, component_id, + schema, } } } @@ -115,6 +143,7 @@ impl StreamHandler> for WebsocketActor { re: Regex::new(&self.filter).ok(), system_id: self.system_id, component_id: self.component_id, + schema: self.schema, }); } @@ -133,8 +162,9 @@ impl StreamHandler> for WebsocketActor { Ok(ws::Message::Text(text)) => { // Release the manager lock before the callback, it sends to the other clients let callback = self.server.lock().unwrap().new_message_callback.clone(); + let schema = self.schema; let text = match callback { - Some(callback) => callback(&text), + Some(callback) => callback(&text, schema), None => serde_json::to_string(&WebsocketError { error: "MAVLink callback does not exist.".to_string(), }) diff --git a/tests/api_schema.py b/tests/api_schema.py new file mode 100755 index 0000000..29e5ce8 --- /dev/null +++ b/tests/api_schema.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""API schema tests for modern (/v1) and legacy (/v0) JSON formats.""" + +import json +import sys +import time + +import requests + +BASE = sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:8088" +V1 = f"{BASE}/v1" +V0 = f"{BASE}/v0" + + +def expect(cond, msg): + if not cond: + raise AssertionError(msg) + + +def post(url, payload): + response = requests.post(url, data=json.dumps(payload), headers={"Content-Type": "application/json"}) + return response + + +def main(): + print("info") + info = requests.get(f"{BASE}/info").json() + expect(info["service"]["name"] == "mavlink2rest", "bad service name") + + print("helper modern PARAM_SET is string") + helper_v1 = requests.get(f"{V1}/helper/mavlink", params={"name": "PARAM_SET"}).json() + expect(isinstance(helper_v1["message"]["param_id"], str), f"v1 param_id={helper_v1['message']['param_id']!r}") + + print("helper legacy PARAM_SET is char array") + helper_v0 = requests.get(f"{V0}/helper/mavlink", params={"name": "PARAM_SET"}).json() + expect(isinstance(helper_v0["message"]["param_id"], list), "v0 param_id should be list") + expect(len(helper_v0["message"]["param_id"]) == 16, "v0 param_id length") + + print("helper modern HEARTBEAT flag string") + hb_v1 = requests.get(f"{V1}/helper/mavlink", params={"name": "HEARTBEAT"}).json() + expect(isinstance(hb_v1["message"]["base_mode"], str), "v1 base_mode string") + + print("helper legacy HEARTBEAT bits object") + hb_v0 = requests.get(f"{V0}/helper/mavlink", params={"name": "HEARTBEAT"}).json() + expect(isinstance(hb_v0["message"]["base_mode"], dict), "v0 base_mode object") + expect("bits" in hb_v0["message"]["base_mode"], "v0 base_mode.bits") + + print("POST modern PARAM_SET then GET both schemas") + modern_param = { + "header": {"system_id": 1, "component_id": 1, "sequence": 0}, + "message": { + "type": "PARAM_SET", + "target_system": 1, + "target_component": 1, + "param_id": "SCR_FSS", + "param_value": 1.25, + "param_type": {"type": "MAV_PARAM_TYPE_REAL32"}, + }, + } + response = post(f"{V1}/mavlink", modern_param) + expect(response.status_code == 200, f"modern post failed: {response.status_code} {response.text}") + + got_v1 = requests.get(f"{V1}/mavlink/vehicles/1/components/1/messages/PARAM_SET").json() + expect(got_v1["message"]["param_id"] == "SCR_FSS", f"v1 get param_id={got_v1['message']['param_id']!r}") + expect(got_v1["message"]["param_value"] == 1.25, "v1 param_value") + + got_v0 = requests.get(f"{V0}/mavlink/vehicles/1/components/1/messages/PARAM_SET").json() + expect(isinstance(got_v0["message"]["param_id"], list), "v0 get param_id list") + expect("".join(ch for ch in got_v0["message"]["param_id"] if ch != "\u0000") == "SCR_FSS", "v0 joined param_id") + + print("POST legacy PARAM_SET with char array") + legacy_param = { + "header": {"system_id": 1, "component_id": 1}, + "message": { + "type": "PARAM_SET", + "target_system": 1, + "target_component": 1, + "param_id": list("LEGACY_P") + ["\u0000"] * (16 - len("LEGACY_P")), + "param_value": 3.5, + "param_type": {"type": "MAV_PARAM_TYPE_REAL32"}, + }, + } + response = post(f"{V0}/mavlink", legacy_param) + expect(response.status_code == 200, f"legacy post failed: {response.status_code} {response.text}") + got = requests.get(f"{V1}/mavlink/vehicles/1/components/1/messages/PARAM_SET").json() + expect(got["message"]["param_id"] == "LEGACY_P", f"after legacy post got {got['message']['param_id']!r}") + + print("POST legacy HEARTBEAT with bits object") + legacy_hb = { + "header": {"system_id": 1, "component_id": 1}, + "message": { + "type": "HEARTBEAT", + "custom_mode": 0, + "mavtype": {"type": "MAV_TYPE_GENERIC"}, + "autopilot": {"type": "MAV_AUTOPILOT_GENERIC"}, + "base_mode": {"bits": 129}, + "system_status": {"type": "MAV_STATE_ACTIVE"}, + "mavlink_version": 3, + }, + } + response = post(f"{V0}/mavlink", legacy_hb) + expect(response.status_code == 200, f"legacy hb post failed: {response.text}") + got = requests.get(f"{V1}/mavlink/vehicles/1/components/1/messages/HEARTBEAT").json() + mode = got["message"]["base_mode"] + expect(isinstance(mode, str), "modern get base_mode string") + expect("MAV_MODE_FLAG_SAFETY_ARMED" in mode, mode) + expect("MAV_MODE_FLAG_CUSTOM_MODE_ENABLED" in mode, mode) + got_legacy = requests.get(f"{V0}/mavlink/vehicles/1/components/1/messages/HEARTBEAT").json() + expect(got_legacy["message"]["base_mode"] == {"bits": 129}, got_legacy["message"]["base_mode"]) + + print("JSON pointer leaf under both schemas") + leaf_v1 = requests.get(f"{V1}/mavlink/vehicles/1/components/1/messages/HEARTBEAT/message/base_mode") + expect(leaf_v1.status_code == 200, leaf_v1.text) + expect("SAFETY_ARMED" in leaf_v1.text, leaf_v1.text) + leaf_v0 = requests.get(f"{V0}/mavlink/vehicles/1/components/1/messages/HEARTBEAT/message/base_mode") + expect(leaf_v0.status_code == 200, leaf_v0.text) + expect('"bits"' in leaf_v0.text, leaf_v0.text) + + print("malformed legacy bits rejected") + bad = { + "header": {"system_id": 1, "component_id": 1}, + "message": { + "type": "HEARTBEAT", + "custom_mode": 0, + "mavtype": {"type": "MAV_TYPE_GENERIC"}, + "autopilot": {"type": "MAV_AUTOPILOT_GENERIC"}, + "base_mode": {"bits": 0x100}, + "system_status": {"type": "MAV_STATE_ACTIVE"}, + "mavlink_version": 3, + }, + } + response = post(f"{V0}/mavlink", bad) + expect(response.status_code == 404, f"expected 404 got {response.status_code}") + expect( + ("unsupported bits" in response.text) + or ("Failed to parse" in response.text) + or ("invalid type" in response.text), + response.text, + ) + + print("malformed modern JSON rejected") + response = post(f"{V1}/mavlink", {"header": {}, "message": {"type": "NOPE"}}) + expect(response.status_code == 404, response.text) + + print("ordinary ATTITUDE helper both schemas match shape") + att_v1 = requests.get(f"{V1}/helper/mavlink", params={"name": "ATTITUDE"}).json() + att_v0 = requests.get(f"{V0}/helper/mavlink", params={"name": "ATTITUDE"}).json() + expect(att_v1["message"]["type"] == "ATTITUDE", "v1 attitude") + expect(att_v0["message"]["type"] == "ATTITUDE", "v0 attitude") + expect(att_v1["message"]["roll"] == att_v0["message"]["roll"], "roll") + + print("websocket modern and legacy") + import asyncio + import aiohttp + + async def ws_check(url, expect_bits_object): + session = aiohttp.ClientSession() + ws = await session.ws_connect(url) + # seed a heartbeat through REST so WS clients see something if quiet + post(f"{V1}/mavlink", { + "header": {"system_id": 1, "component_id": 1}, + "message": { + "type": "NAMED_VALUE_FLOAT", + "time_boot_ms": 1, + "name": list("WSTEST") + ["\u0000"] * (10 - len("WSTEST")) if False else "WSTEST", + "value": 42.0, + }, + }) + # For modern name is string; post modern: + post(f"{V1}/mavlink", { + "header": {"system_id": 1, "component_id": 1}, + "message": { + "type": "NAMED_VALUE_FLOAT", + "time_boot_ms": 1, + "name": "WSTEST", + "value": 42.0, + }, + }) + msg = None + for _ in range(20): + incoming = await asyncio.wait_for(ws.receive(), timeout=2) + if incoming.type == aiohttp.WSMsgType.TEXT: + payload = json.loads(incoming.data) + if payload.get("message", {}).get("type") == "NAMED_VALUE_FLOAT": + msg = payload + break + await ws.close() + await session.close() + expect(msg is not None, f"no NAMED_VALUE_FLOAT on {url}") + name = msg["message"]["name"] + if expect_bits_object: + expect(isinstance(name, list), f"legacy name should be list, got {name!r}") + else: + expect(isinstance(name, str), f"modern name should be str, got {name!r}") + + async def run_ws_checks(): + await ws_check(f"{V1}/ws/mavlink?filter=NAMED_VALUE_FLOAT", False) + await ws_check(f"{V0}/ws/mavlink?filter=NAMED_VALUE_FLOAT", True) + + asyncio.run(run_ws_checks()) + + print("OK") + + +if __name__ == "__main__": + main()