use thiserror::Error;
use crate::{
Address,
operation::{CommandOutcome, DeviceIdentity, Operation, OperationError, ReadDeviceIdentity},
service::{ExchangeError, LinkClient, QueueId, RetryPolicy},
wire::WireError,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SessionProfile {
pub identity: DeviceIdentity,
pub address: Address,
pub request_preambles: u8,
}
#[derive(Debug, Error)]
pub enum SessionError {
#[error(transparent)]
Exchange(#[from] ExchangeError),
#[error(transparent)]
Operation(#[from] OperationError),
#[error(transparent)]
Address(#[from] WireError),
#[error("initial preamble count {0} is outside 2..=40")]
Preambles(u8),
}
#[derive(Debug, Clone)]
pub struct DeviceSession {
link: LinkClient,
profile: SessionProfile,
}
impl DeviceSession {
pub async fn identify_default(
link: LinkClient,
address: Address,
) -> Result<Self, SessionError> {
let identity = link.execute_default(address, &ReadDeviceIdentity).await?;
Self::from_identity(link, address, identity)
}
pub async fn identify(
link: LinkClient,
address: Address,
policy: RetryPolicy,
) -> Result<Self, SessionError> {
let identity = link
.execute(
address,
&ReadDeviceIdentity,
link.default_queue_id(),
policy,
)
.await?;
Self::from_identity(link, address, identity)
}
pub async fn identify_with_preambles(
link: LinkClient,
address: Address,
preambles: u8,
policy: RetryPolicy,
) -> Result<Self, SessionError> {
if !(2..=40).contains(&preambles) {
return Err(SessionError::Preambles(preambles));
}
let operation = ReadDeviceIdentity;
let request = operation.request(address)?.with_preambles(preambles);
let reply = link
.request(request, link.default_queue_id(), policy)
.await?;
let identity = operation.decode_reply(&reply)?;
Self::from_identity(link, address, identity)
}
pub fn from_identity(
link: LinkClient,
address: Address,
identity: DeviceIdentity,
) -> Result<Self, SessionError> {
let request_preambles = identity.request_preambles.max(2);
let address = match address {
Address::Polling { master, .. } => identity.unique_address(master)?,
Address::Unique { .. } => address,
};
Ok(Self {
link,
profile: SessionProfile {
identity,
address,
request_preambles,
},
})
}
pub const fn profile(&self) -> &SessionProfile {
&self.profile
}
pub const fn link(&self) -> &LinkClient {
&self.link
}
pub fn managed(
self,
options: crate::service::DeviceHealthOptions,
) -> Result<crate::service::ManagedDeviceSession, crate::service::DeviceHealthConfigError> {
crate::service::ManagedDeviceSession::new(self, options)
}
pub fn managed_with_defaults(self) -> crate::service::ManagedDeviceSession {
crate::service::ManagedDeviceSession::with_defaults(self)
}
pub fn request<O: crate::Operation>(
&self,
operation: &O,
) -> Result<crate::Request, OperationError> {
Ok(operation
.request(self.profile.address)?
.with_preambles(self.profile.request_preambles))
}
pub async fn execute<O: crate::Operation>(
&self,
operation: &O,
queue: QueueId,
policy: RetryPolicy,
) -> Result<O::Output, SessionError> {
let request = self.request(operation)?;
let reply = self.link.request(request, queue, policy).await?;
operation.decode_reply(&reply).map_err(SessionError::from)
}
pub async fn execute_default<O: crate::Operation>(
&self,
operation: &O,
) -> Result<O::Output, SessionError> {
let request = self.request(operation)?;
let reply = self.link.request_default(request).await?;
operation.decode_reply(&reply).map_err(SessionError::from)
}
pub async fn execute_accepting<O: crate::Operation>(
&self,
operation: &O,
accepted_warnings: &[u8],
queue: QueueId,
policy: RetryPolicy,
) -> Result<CommandOutcome<O::Output>, SessionError> {
let request = self.request(operation)?;
let reply = self.link.request(request, queue, policy).await?;
operation
.decode_reply_accepting(&reply, accepted_warnings)
.map_err(SessionError::from)
}
pub async fn execute_accepting_default<O: crate::Operation>(
&self,
operation: &O,
accepted_warnings: &[u8],
) -> Result<CommandOutcome<O::Output>, SessionError> {
let request = self.request(operation)?;
let reply = self.link.request_default(request).await?;
operation
.decode_reply_accepting(&reply, accepted_warnings)
.map_err(SessionError::from)
}
pub async fn snapshot(
&self,
options: crate::service::SnapshotOptions,
) -> crate::service::DeviceSnapshot {
crate::service::snapshot::capture_snapshot(self, options).await
}
}