Merge pull request #390 from helium/madninja/packet_immediate

Adds immediate time support for downlink packets

src/api/mod.rs

@@ -5,9 +5,7 @@ const LISTEN_ADDR: &str = "127.0.0.1";
 
 pub use client::LocalClient;
 pub use helium_proto::{
-    services::local::{
-        AddGatewayReq, AddGatewayRes, PubkeyReq, PubkeyRes, RegionReq, RegionRes, SignReq, SignRes,
-    },
+    services::local::{AddGatewayReq, AddGatewayRes, PubkeyReq, PubkeyRes, RegionReq, RegionRes},
     GatewayStakingMode,
 };
 pub use server::LocalServer;

src/api/server.rs

@@ -1,6 +1,5 @@
 use super::{
-    listen_addr, AddGatewayReq, AddGatewayRes, PubkeyReq, PubkeyRes, RegionReq, RegionRes, SignReq,
-    SignRes,
+    listen_addr, AddGatewayReq, AddGatewayRes, PubkeyReq, PubkeyRes, RegionReq, RegionRes,
 };
 use crate::{
     region_watcher, settings::StakingMode, Error, Keypair, PublicKey, Result, Settings,
@@ -62,16 +61,6 @@ impl Api for LocalServer {
         }))
     }
 
-    async fn sign(&self, request: Request<SignReq>) -> ApiResult<SignRes> {
-        let data = request.into_inner().data;
-        let signature = self
-            .keypair
-            .sign(&data)
-            .map_err(|_err| Status::internal("Failed signing data"))?;
-        let reply = SignRes { signature };
-        Ok(Response::new(reply))
-    }
-
     async fn add_gateway(&self, request: Request<AddGatewayReq>) -> ApiResult<AddGatewayRes> {
         let request = request.into_inner();
         let _ = PublicKey::from_bytes(&request.owner)

src/beaconer.rs

@@ -6,7 +6,7 @@ use crate::{
     impl_msg_sign, region_watcher,
     service::{entropy::EntropyService, poc::PocIotService},
     settings::Settings,
-    sync, Base64, Keypair, MsgSign, Packet, RegionParams, Result,
+    sync, Base64, Keypair, MsgSign, PacketUp, RegionParams, Result,
 };
 use futures::TryFutureExt;
 use helium_proto::{services::poc_lora, Message as ProtoMessage};
@@ -29,7 +29,7 @@ impl_msg_sign!(poc_lora::LoraWitnessReportReqV1, signature);
 /// Message types that can be sent to `Beaconer`'s inbox.
 #[derive(Debug)]
 pub enum Message {
-    ReceivedBeacon(Packet),
+    ReceivedBeacon(PacketUp),
 }
 
 pub type MessageSender = sync::MessageSender<Message>;
@@ -40,7 +40,7 @@ pub fn message_channel() -> (MessageSender, MessageReceiver) {
 }
 
 impl MessageSender {
-    pub async fn received_beacon(&self, packet: Packet) {
+    pub async fn received_beacon(&self, packet: PacketUp) {
         self.send(Message::ReceivedBeacon(packet)).await
     }
 }
@@ -196,7 +196,10 @@ impl Beaconer {
         Ok(report)
     }
 
-    async fn mk_witness_report(&self, packet: Packet) -> Result<poc_lora::LoraWitnessReportReqV1> {
+    async fn mk_witness_report(
+        &self,
+        packet: PacketUp,
+    ) -> Result<poc_lora::LoraWitnessReportReqV1> {
         let mut report = poc_lora::LoraWitnessReportReqV1::try_from(packet)?;
         report.pub_key = self.keypair.public_key().to_vec();
         report.signature = report.sign(self.keypair.clone()).await?;
@@ -221,11 +224,11 @@ impl Beaconer {
         };
     }
 
-    async fn handle_received_beacon(&mut self, packet: Packet) {
+    async fn handle_received_beacon(&mut self, packet: PacketUp) {
         info!("received possible PoC payload: {packet:?}");
 
         if let Some(last_beacon) = &self.last_beacon {
-            if packet.payload == last_beacon.data {
+            if packet.payload() == last_beacon.data {
                 info!("ignoring last self beacon witness");
                 return;
             }

src/error.rs

@@ -53,20 +53,16 @@ pub enum DecodeError {
     Prost(#[from] prost::DecodeError),
     #[error("lorawan decode")]
     LoraWan(#[from] lorawan::LoraWanError),
-    #[error("semtech decode")]
-    Semtech(#[from] semtech_udp::data_rate::ParseError),
     #[error("packet crc")]
     InvalidCrc,
     #[error("unexpected transaction in envelope")]
     InvalidEnvelope,
     #[error("no rx1 window in downlink packet")]
     NoRx1Window,
-    #[error("no datarate found in packet")]
-    NoDataRate,
     #[error("packet is not a beacon")]
     NotBeacon,
-    #[error("invalid beacon datarate: {0}")]
-    InvalidBeaconDataRate(String),
+    #[error("invalid datarate: {0}")]
+    InvalidDataRate(String),
 }
 
 #[derive(Error, Debug)]
@@ -123,7 +119,6 @@ from_err!(DecodeError, serde_json::Error);
 from_err!(DecodeError, net::AddrParseError);
 from_err!(DecodeError, prost::DecodeError);
 from_err!(DecodeError, lorawan::LoraWanError);
-from_err!(DecodeError, semtech_udp::data_rate::ParseError);
 
 impl DecodeError {
     pub fn invalid_envelope() -> Error {
@@ -146,12 +141,8 @@ impl DecodeError {
         Error::Decode(DecodeError::NoRx1Window)
     }
 
-    pub fn no_data_rate() -> Error {
-        Error::Decode(DecodeError::NoDataRate)
-    }
-
-    pub fn invalid_beacon_data_rate(datarate: String) -> Error {
-        Error::Decode(DecodeError::InvalidBeaconDataRate(datarate))
+    pub fn invalid_data_rate(datarate: String) -> Error {
+        Error::Decode(DecodeError::InvalidDataRate(datarate))
     }
 
     pub fn not_beacon() -> Error {

src/gateway.rs

@@ -1,5 +1,6 @@
 use crate::{
-    beaconer, packet_router, region_watcher, sync, Packet, RegionParams, Result, Settings,
+    beaconer, packet, packet_router, region_watcher, sync, PacketDown, PacketUp, RegionParams,
+    Result, Settings,
 };
 use beacon::Beacon;
 use lorawan::PHYPayload;
@@ -26,7 +27,7 @@ pub struct BeaconResp {
 
 #[derive(Debug)]
 pub enum Message {
-    Downlink(Packet),
+    Downlink(PacketDown),
     TransmitBeacon(Beacon, sync::ResponseSender<Result<BeaconResp>>),
 }
 
@@ -46,7 +47,7 @@ pub fn message_channel() -> (MessageSender, MessageReceiver) {
 }
 
 impl MessageSender {
-    pub async fn downlink(&self, packet: Packet) {
+    pub async fn downlink(&self, packet: PacketDown) {
         self.send(Message::Downlink(packet)).await
     }
 
@@ -134,7 +135,7 @@ impl Gateway {
             Event::ClientDisconnected((mac, addr)) => {
                 info!(%mac, %addr, "disconnected packet forwarder")
             }
-            Event::PacketReceived(rxpk, _gateway_mac) => match Packet::try_from(rxpk) {
+            Event::PacketReceived(rxpk, _gateway_mac) => match PacketUp::try_from(rxpk) {
                 Ok(packet) if packet.is_potential_beacon() => {
                     self.beacons.received_beacon(packet).await
                 }
@@ -153,7 +154,7 @@ impl Gateway {
         Ok(())
     }
 
-    async fn handle_uplink(&mut self, packet: Packet, received: Instant) {
+    async fn handle_uplink(&mut self, packet: PacketUp, received: Instant) {
         info!(downlink_mac = %self.downlink_mac, uplink = %packet, "received uplink");
         self.uplinks.uplink(packet, received).await;
     }
@@ -246,7 +247,7 @@ impl Gateway {
         });
     }
 
-    async fn handle_downlink(&mut self, downlink: Packet) {
+    async fn handle_downlink(&mut self, downlink: PacketDown) {
         let tx_power = match self.max_tx_power() {
             Ok(tx_power) => tx_power,
             Err(err) => {
@@ -299,9 +300,8 @@ impl Gateway {
 }
 
 pub fn beacon_to_pull_resp(beacon: &Beacon, tx_power: u64) -> Result<pull_resp::TxPk> {
-    let datr = beacon.datarate.to_string().parse()?;
-    // convert hz to mhz
-    let freq = beacon.frequency as f64 / 1e6;
+    let datr = packet::datarate::from_proto(beacon.datarate)?;
+    let freq = packet::to_mhz(beacon.frequency as f64);
     let data: Vec<u8> = PHYPayload::proprietary(beacon.data.as_slice()).try_into()?;
 
     Ok(pull_resp::TxPk {

src/lib.rs

@@ -21,7 +21,7 @@ pub use beacon::{Region, RegionParams};
 pub use error::{Error, Result};
 pub use keyed_uri::KeyedUri;
 pub use keypair::{Keypair, PublicKey};
-pub use packet::Packet;
+pub use packet::{PacketDown, PacketUp};
 pub use settings::Settings;
 pub(crate) use traits::*;