Modeled Coverage - Phase 1

Cargo.toml

@@ -85,8 +85,8 @@ prost = "*"
 once_cell = "1"
 lazy_static = "1"
 config = {version="0", default-features=false, features=["toml"]}
-h3o = "0"
-xorf = {version = "0", features = ["serde"] }
+h3o = {version = "0", features = ["serde"]}
+xorf = {version = "0", features = ["serde"]}
 bytes = "*"
 structopt = "0"
 bincode = "1"
@@ -99,6 +99,7 @@ itertools = "*"
 data-credits = {git = "https://github.com/helium/helium-program-library.git", tag = "v0.1.0"}
 helium-sub-daos = {git = "https://github.com/helium/helium-program-library.git", tag = "v0.1.0"}
 price-oracle = {git = "https://github.com/helium/helium-program-library.git", tag = "v0.1.0"}
+uuid = {version = "1.3.4", features = ["v4", "serde"]}
 
 [patch.crates-io]
 sqlx = { git = "https://github.com/helium/sqlx.git", rev = "92a2268f02e0cac6fccb34d3e926347071dbb88d" }

file_store/Cargo.toml

@@ -46,6 +46,8 @@ sqlx = {workspace = true}
 async-trait = {workspace = true}
 derive_builder = "0"
 retainer = {workspace = true}
+uuid = {workspace = true}
+h3o = {workspace = true}
 
 [dev-dependencies]
 hex-literal = "0"

file_store/src/coverage.rs

@@ -0,0 +1,104 @@
+use crate::{
+    error::DecodeError,
+    traits::{MsgDecode, TimestampDecode},
+    Error, Result,
+};
+use chrono::{DateTime, Utc};
+use helium_crypto::PublicKeyBinary;
+use helium_proto::services::poc_mobile::{
+    CoverageObjectIngestReportV1, CoverageObjectReqV1,
+    RadioHexSignalLevel as RadioHexSignalLevelProto, SignalLevel,
+};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct RadioHexSignalLevel {
+    pub location: h3o::CellIndex,
+    pub signal_level: SignalLevel,
+    pub signal_power: i32,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CoverageObject {
+    pub pub_key: PublicKeyBinary,
+    pub uuid: Uuid,
+    pub cbsd_id: String,
+    pub coverage_claim_time: DateTime<Utc>,
+    pub indoor: bool,
+    pub coverage: Vec<RadioHexSignalLevel>,
+    pub signature: Vec<u8>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CoverageObjectIngestReport {
+    pub received_timestamp: DateTime<Utc>,
+    pub report: CoverageObject,
+}
+
+impl MsgDecode for CoverageObject {
+    type Msg = CoverageObjectReqV1;
+}
+
+impl MsgDecode for CoverageObjectIngestReport {
+    type Msg = CoverageObjectIngestReportV1;
+}
+
+impl TryFrom<CoverageObjectIngestReportV1> for CoverageObjectIngestReport {
+    type Error = Error;
+
+    fn try_from(v: CoverageObjectIngestReportV1) -> Result<Self> {
+        Ok(Self {
+            received_timestamp: v.received_timestamp.to_timestamp_millis()?,
+            report: v
+                .report
+                .ok_or_else(|| Error::not_found("ingest coverage object report"))?
+                .try_into()?,
+        })
+    }
+}
+
+impl TryFrom<CoverageObjectReqV1> for CoverageObject {
+    type Error = Error;
+
+    fn try_from(v: CoverageObjectReqV1) -> Result<Self> {
+        let coverage: Result<Vec<RadioHexSignalLevel>> = v
+            .coverage
+            .into_iter()
+            .map(RadioHexSignalLevel::try_from)
+            .collect();
+        Ok(Self {
+            pub_key: v.pub_key.into(),
+            uuid: Uuid::from_slice(&v.uuid).map_err(DecodeError::from)?,
+            cbsd_id: v.cbsd_id,
+            coverage_claim_time: v.coverage_claim_time.to_timestamp()?,
+            indoor: v.indoor,
+            coverage: coverage?,
+            signature: v.signature,
+        })
+    }
+}
+
+impl TryFrom<RadioHexSignalLevelProto> for RadioHexSignalLevel {
+    type Error = Error;
+
+    fn try_from(v: RadioHexSignalLevelProto) -> Result<Self> {
+        Ok(Self {
+            signal_level: SignalLevel::from_i32(v.signal_level).ok_or_else(|| {
+                DecodeError::unsupported_signal_level("coverage_object_req_v1", v.signal_level)
+            })?,
+            signal_power: v.signal_power,
+            location: v.location.parse().map_err(DecodeError::from)?,
+        })
+    }
+}
+
+impl From<RadioHexSignalLevel> for RadioHexSignalLevelProto {
+    fn from(rhsl: RadioHexSignalLevel) -> RadioHexSignalLevelProto {
+        RadioHexSignalLevelProto {
+            signal_level: rhsl.signal_level as i32,
+            signal_power: rhsl.signal_power,
+            location: rhsl.location.to_string(),
+        }
+    }
+}

file_store/src/error.rs

@@ -54,8 +54,14 @@ pub enum DecodeError {
     UnsupportedParticipantSide(String, i32),
     #[error("unsupported verification status, type: {0}, value: {1}")]
     UnsupportedStatusReason(String, i32),
+    #[error("unsupported signal level, type: {0}, value: {1}")]
+    UnsupportedSignalLevel(String, i32),
     #[error("invalid unix timestamp {0}")]
     InvalidTimestamp(u64),
+    #[error("Uuid error: {0}")]
+    UuidError(#[from] uuid::Error),
+    #[error("Invalid cell index error: {0}")]
+    InvalidCellIndexError(#[from] h3o::error::InvalidCellIndex),
 }
 
 #[derive(Error, Debug)]
@@ -127,6 +133,10 @@ impl DecodeError {
     pub fn unsupported_status_reason<E: ToString>(msg1: E, msg2: i32) -> Error {
         Error::Decode(Self::UnsupportedInvalidReason(msg1.to_string(), msg2))
     }
+
+    pub fn unsupported_signal_level(msg1: impl ToString, msg2: i32) -> Error {
+        Error::Decode(Self::UnsupportedSignalLevel(msg1.to_string(), msg2))
+    }
 }
 
 impl From<helium_crypto::Error> for Error {

file_store/src/file_info.rs

@@ -127,7 +127,9 @@ pub const VALID_DATA_TRANSFER_SESSION: &str = "valid_data_transfer_session";
 pub const PRICE_REPORT: &str = "price_report";
 pub const MOBILE_REWARD_SHARE: &str = "mobile_reward_share";
 pub const MAPPER_MSG: &str = "mapper_msg";
+pub const COVERAGE_OBJECT: &str = "coverage_object";
 pub const COVERAGE_OBJECT_INGEST_REPORT: &str = "coverage_object_ingest_report";
+pub const SENIORITY_UPDATE: &str = "seniority_update";
 
 #[derive(Debug, PartialEq, Eq, Clone, Serialize, Copy, strum::EnumCount)]
 #[serde(rename_all = "snake_case")]
@@ -163,7 +165,9 @@ pub enum FileType {
     SubscriberLocationIngestReport,
     VerifiedSubscriberLocationIngestReport,
     MapperMsg,
+    CoverageObject,
     CoverageObjectIngestReport,
+    SeniorityUpdate,
 }
 
 impl fmt::Display for FileType {
@@ -204,7 +208,9 @@ impl fmt::Display for FileType {
             Self::PriceReport => PRICE_REPORT,
             Self::MobileRewardShare => MOBILE_REWARD_SHARE,
             Self::MapperMsg => MAPPER_MSG,
+            Self::CoverageObject => COVERAGE_OBJECT,
             Self::CoverageObjectIngestReport => COVERAGE_OBJECT_INGEST_REPORT,
+            Self::SeniorityUpdate => SENIORITY_UPDATE,
         };
         f.write_str(s)
     }
@@ -248,7 +254,9 @@ impl FileType {
             Self::PriceReport => PRICE_REPORT,
             Self::MobileRewardShare => MOBILE_REWARD_SHARE,
             Self::MapperMsg => MAPPER_MSG,
+            Self::CoverageObject => COVERAGE_OBJECT,
             Self::CoverageObjectIngestReport => COVERAGE_OBJECT_INGEST_REPORT,
+            Self::SeniorityUpdate => SENIORITY_UPDATE,
         }
     }
 }
@@ -292,7 +300,9 @@ impl FromStr for FileType {
             PRICE_REPORT => Self::PriceReport,
             MOBILE_REWARD_SHARE => Self::MobileRewardShare,
             MAPPER_MSG => Self::MapperMsg,
+            COVERAGE_OBJECT => Self::CoverageObject,
             COVERAGE_OBJECT_INGEST_REPORT => Self::CoverageObjectIngestReport,
+            SENIORITY_UPDATE => Self::SeniorityUpdate,
             _ => return Err(Error::from(io::Error::from(io::ErrorKind::InvalidInput))),
         };
         Ok(result)

file_store/src/heartbeat.rs

@@ -6,6 +6,7 @@ use chrono::{DateTime, Utc};
 use helium_crypto::PublicKeyBinary;
 use helium_proto::services::poc_mobile::{CellHeartbeatIngestReportV1, CellHeartbeatReqV1};
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct CellHeartbeat {
@@ -18,6 +19,13 @@ pub struct CellHeartbeat {
     pub operation_mode: bool,
     pub cbsd_category: String,
     pub cbsd_id: String,
+    pub coverage_object: Vec<u8>,
+}
+
+impl CellHeartbeat {
+    pub fn coverage_object(&self) -> Option<Uuid> {
+        Uuid::from_slice(&self.coverage_object).ok()
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -47,6 +55,7 @@ impl TryFrom<CellHeartbeatReqV1> for CellHeartbeat {
             operation_mode: v.operation_mode,
             cbsd_category: v.cbsd_category,
             cbsd_id: v.cbsd_id,
+            coverage_object: v.coverage_object,
         })
     }
 }

file_store/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod cli;
+pub mod coverage;
 pub mod entropy_report;
 mod error;
 mod file_info;

mobile_verifier/Cargo.toml

@@ -43,4 +43,6 @@ reward-scheduler = {path = "../reward_scheduler"}
 price = {path = "../price"}
 rand = {workspace = true}
 async-trait = {workspace = true}
-retainer = {workspace = true}
+retainer = {workspace = true}
+uuid = {workspace = true}
+h3o = {workspace = true}

mobile_verifier/migrations/15_modeled_coverage.sql

@@ -0,0 +1,28 @@
+CREATE TYPE signal_level AS ENUM (
+       'none',
+       'low',
+       'medium',
+       'high'
+);
+
+CREATE TABLE hex_coverage (
+       uuid UUID NOT NULL,
+       hex BIGINT NOT NULL,
+       indoor BOOLEAN NOT NULL,
+       cbsd_id TEXT NOT NULL,
+       signal_level signal_level NOT NULL,
+       coverage_claim_time TIMESTAMPTZ NOT NULL,
+       inserted_at TIMESTAMPTZ NOT NULL,
+       PRIMARY KEY (uuid, hex)
+);
+
+CREATE TABLE seniority (
+       cbsd_id TEXT NOT NULL,
+       seniority_ts TIMESTAMPTZ NOT NULL,
+       last_heartbeat TIMESTAMPTZ NOT NULL,
+       uuid UUID NOT NULL,
+       PRIMARY KEY (cbsd_id, seniority_ts)
+);
+
+-- Coverage object can be NULL
+ALTER TABLE heartbeats ADD COLUMN coverage_object UUID;