refactor(doip): address PR review comments and Improvement

- Consolidate errors into DoipError; add TryFrom<u8> on all enums
- Strongly type activation_type field (ActivationType, not u8)
- Add DoipParseable / DoipSerializable traits + DoipPayload dispatch enum
- Override serialized_len() on all impls; fix array size magic numbers
- Make ParseError pub(crate); add serde(default), tracing

Author: VinaykumarRS1995

Cargo.lock

@@ -10,21 +10,24 @@ tokio-util = { version = "0.7", features = ["codec"] }
 
 # Serialization
 serde = { version = "1.0", features = ["derive"] }
-toml = "0.9.11+spec-1.1.0"
+toml = "0.9"
 
 # Logging
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 # Error handling
-thiserror = "2.0.18"
+thiserror = "2.0"
 anyhow = "1.0"
 
 # Data structures
-bytes = "1.10.1"
-dashmap = "6.1.0"
+bytes = "1.0"
+dashmap = "6.0"
 parking_lot = "0.12"
 
 # Utilities
 uuid = { version = "1.6", features = ["v4"] }
-clap = { version = "4.4", features = ["derive"] }
+clap = { version = "4.4", features = ["derive"] }
+
+[features]
+test-handlers = []

Cargo.toml

@@ -1,37 +1,39 @@
+/*
+ * Copyright (c) 2026 The Contributors to Eclipse OpenSOVD (see CONTRIBUTORS)
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 //! Alive Check handlers (ISO 13400-2)
 
-use bytes::{BufMut, Bytes, BytesMut};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Error {
-    PayloadTooShort { expected: usize, actual: usize },
-}
-
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::PayloadTooShort { expected, actual } => {
-                write!(f, "payload too short: need {} bytes, got {}", expected, actual)
-            }
-        }
-    }
-}
-
-impl std::error::Error for Error {}
+use bytes::{BufMut, BytesMut};
+use tracing::warn;
+use crate::DoipError;
+use super::{DoipParseable, DoipSerializable};
 
 // Alive Check Request (0x0007) - no payload
 // Server sends this to check if tester is still connected
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct Request;
 
-impl Request {
-    pub fn parse(_payload: &[u8]) -> Result<Self, Error> {
+impl DoipParseable for Request {
+    fn parse(_payload: &[u8]) -> std::result::Result<Self, DoipError> {
         Ok(Self)
     }
+}
 
-    pub fn to_bytes(&self) -> Bytes {
-        Bytes::new()
+impl DoipSerializable for Request {
+    fn serialized_len(&self) -> Option<usize> {
+        Some(0)
     }
+
+    fn write_to(&self, _buf: &mut BytesMut) {}
 }
 
 // Alive Check Response (0x0008) - 2 byte source address
@@ -41,39 +43,45 @@ pub struct Response {
     pub source_address: u16,
 }
 
-impl Response {
-    pub const LEN: usize = 2;
-
-    pub fn new(source_address: u16) -> Self {
-        Self { source_address }
-    }
-
-    pub fn parse(payload: &[u8]) -> Result<Self, Error> {
-        if payload.len() < Self::LEN {
-            return Err(Error::PayloadTooShort {
-                expected: Self::LEN,
-                actual: payload.len(),
-            });
-        }
-
-        let source_address = u16::from_be_bytes([payload[0], payload[1]]);
+impl DoipParseable for Response {
+    fn parse(payload: &[u8]) -> std::result::Result<Self, DoipError> {
+        let bytes: [u8; 2] = payload
+            .get(..Self::LEN)
+            .and_then(|s| s.try_into().ok())
+            .ok_or_else(|| {
+                let e = DoipError::PayloadTooShort { expected: Self::LEN, actual: payload.len() };
+                warn!("AliveCheck Response parse failed: {}", e);
+                e
+            })?;
+
+        let source_address = u16::from_be_bytes(bytes);
         Ok(Self { source_address })
     }
+}
 
-    pub fn to_bytes(&self) -> Bytes {
-        let mut buf = BytesMut::with_capacity(Self::LEN);
-        self.write_to(&mut buf);
-        buf.freeze()
+impl DoipSerializable for Response {
+    fn serialized_len(&self) -> Option<usize> {
+        Some(Self::LEN)
     }
 
-    pub fn write_to(&self, buf: &mut BytesMut) {
+    fn write_to(&self, buf: &mut BytesMut) {
         buf.put_u16(self.source_address);
     }
 }
 
+impl Response {
+    pub const LEN: usize = 2;
+
+    #[must_use]
+    pub fn new(source_address: u16) -> Self {
+        Self { source_address }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::doip::{DoipParseable, DoipSerializable};
 
     #[test]
     fn parse_request() {