Merge pull request #123 from QuantumEntangledAndy/fix/async_lookup_and_register

Fix/async lookup and register
This commit is contained in:
Andrew King authored and GitHub committed 2023-08-03 13:33:25 +07:00
commit 5c7de6181c
4 files changed
+100 -115

No files matched your search

+14 -5
View File
@@ -126,6 +126,7 @@ impl BcCamera {
/// Try to connect to the camera via appropaite methods and return
/// the location that should be used
async fn find_camera(options: &BcCameraOpt) -> Result<CameraLocation> {
let discovery = Discovery::new().await?;
if let ConnectionProtocol::Tcp | ConnectionProtocol::TcpUdp = options.protocol {
let mut sockets = vec![];
match options.port {
@@ -145,7 +146,7 @@ impl BcCamera {
info!("{}: Trying TCP discovery", options.name);
for socket in sockets.drain(..) {
let channel_id: u8 = options.channel_id;
if let Ok(addr) = Discovery::check_tcp(socket, channel_id).await.map(|_| {
if let Ok(addr) = discovery.check_tcp(socket, channel_id).await.map(|_| {
info!("{}: TCP Discovery success at {:?}", options.name, &socket);
socket
}) {
@@ -184,10 +185,16 @@ impl BcCamera {
DiscoveryMethods::Debug => (false, false, false, true),
};
let reg_result = if allow_remote || allow_map || allow_relay {
Some(discovery.get_registration(uid).await?)
} else {
None
};
if allow_local {
let uid_local = uid.clone();
info!("{}: Trying local discovery", options.name);
let result = Discovery::local(&uid_local, Some(sockets)).await;
let result = discovery.local(&uid_local, Some(sockets)).await;
if let Ok(disc) = result {
info!(
"{}: Local discovery success {} at {}",
@@ -201,7 +208,9 @@ impl BcCamera {
if allow_remote {
let uid_remote = uid.clone();
info!("{}: Trying remote discovery", options.name);
let result = Discovery::remote(&uid_remote).await;
let result = discovery
.remote(&uid_remote, reg_result.as_ref().unwrap())
.await;
if let Ok(disc) = result {
info!(
"{}: Remote discovery success {} at {}",
@@ -215,7 +224,7 @@ impl BcCamera {
if allow_map {
let uid_map = uid.clone();
info!("{}: Trying map discovery", options.name);
let result = Discovery::map(&uid_map).await;
let result = discovery.map(reg_result.as_ref().unwrap()).await;
if let Ok(disc) = result {
info!(
"{}: Map success {} at {}",
@@ -229,7 +238,7 @@ impl BcCamera {
if allow_relay {
let uid_relay = uid.clone();
info!("{}: Trying relay discovery", options.name);
let result = Discovery::relay(&uid_relay).await;
let result = discovery.relay(reg_result.as_ref().unwrap()).await;
if let Ok(disc) = result {
info!(
"{}: Relay success {} at {}",
@@ -11,7 +11,7 @@ use crate::bcudp::xml::*;
use crate::{Error, Result};
use futures::{
sink::SinkExt,
stream::{FuturesUnordered, StreamExt},
stream::{FuturesUnordered, Stream, StreamExt},
};
use lazy_static::lazy_static;
use local_ip_address::local_ip;
@@ -34,7 +34,7 @@ use tokio_stream::wrappers::ReceiverStream;
use tokio_util::udp::UdpFramed;
#[derive(Debug, Clone)]
struct RegisterResult {
pub(crate) struct RegisterResult {
reg: SocketAddr,
dev: Option<SocketAddr>,
dmap: Option<SocketAddr>,
@@ -57,8 +57,6 @@ struct UidLookupResults {
relay: SocketAddr,
}
pub(crate) struct Discovery {}
const MTU: u32 = 1350;
lazy_static! {
static ref P2P_RELAY_HOSTNAMES: [&'static str; 10] = [
@@ -154,10 +152,8 @@ impl Discoverer {
})
}
async fn into_socket(self) -> (Arc<UdpSocket>, JoinSet<()>) {
let socket = self.socket.clone();
let handle = self.handle.into_inner();
(socket, handle)
async fn get_socket(&self) -> Arc<UdpSocket> {
self.socket.clone()
}
async fn subscribe(&self, tid: u32) -> Result<Receiver<Result<(UdpDiscovery, SocketAddr)>>> {
@@ -214,32 +210,6 @@ impl Discoverer {
&self.local_addr
}
async fn retry_send_multi<F, T>(
&self,
mut disc: UdpDiscovery,
dests: &[SocketAddr],
map: F,
) -> Result<T>
where
F: Fn(UdpDiscovery, SocketAddr) -> Option<T>,
{
trace!("Retrying send");
disc.tid = 0; // Must be random to avoid simulatenous subscription errors
let mut set = FuturesUnordered::new();
for dest in dests.iter() {
set.push(self.retry_send(disc.clone(), *dest, &map));
}
// Get what ever completes first
while let Some(result) = set.next().await {
trace!("Result: {}", result.is_ok());
if let Ok(ret) = result {
return Ok(ret);
}
}
Err(Error::DiscoveryTimeout)
}
async fn retry_send<F, T>(&self, mut disc: UdpDiscovery, dest: SocketAddr, map: F) -> Result<T>
where
F: Fn(UdpDiscovery, SocketAddr) -> Option<T>,
@@ -357,13 +327,10 @@ impl Discoverer {
Ok(result)
}
/// This function will contact the p2p relay servers
///
/// It will ask each of the servers for details on a specific UID
///
/// On success it returns the M2cQr that the p2p relay
/// server has about the UID
async fn uid_loopup(&self, uid: &str) -> Result<UidLookupResults> {
async fn uid_lookup_all<'a>(
&'a self,
uid: &'a str,
) -> Result<impl Stream<Item = UidLookupResults> + 'a> {
let task = tokio::task::spawn_blocking(move || {
let mut addrs = vec![];
for p2p_relay in P2P_RELAY_HOSTNAMES.iter() {
@@ -376,8 +343,22 @@ impl Discoverer {
}
addrs
});
let addrs = timeout(*MAXIMUM_WAIT, task).await??;
let mut addrs = timeout(*MAXIMUM_WAIT, task).await??;
trace!("Uid lookup to: {:?}", addrs);
Ok(addrs
.drain(..)
.map(|addr| self.uid_lookup(uid, addr))
.collect::<FuturesUnordered<_>>()
.filter_map(|f| async { f.ok() }))
}
/// This function will contact the p2p relay servers
///
/// It will ask each of the servers for details on a specific UID
///
/// On success it will returns an async iter that yields the M2cQr that the p2p relay
/// server has about the UID
async fn uid_lookup(&self, uid: &str, addr: SocketAddr) -> Result<UidLookupResults> {
let msg = UdpDiscovery {
tid: 0,
payload: UdpXml {
@@ -390,7 +371,7 @@ impl Discoverer {
};
trace!("Sending look up {:?}", msg);
let (packet, _) = self
.retry_send_multi(msg, addrs.as_slice(), |bc, addr| match bc {
.retry_send(msg, addr, |bc, addr| match bc {
UdpDiscovery {
tid: _,
payload:
@@ -939,11 +920,49 @@ impl Discoverer {
}
}
pub(crate) struct Discovery {
discoverer: Discoverer,
client_id: i32,
}
impl Discovery {
pub(crate) async fn new() -> Result<Self> {
Ok(Self {
discoverer: Discoverer::new().await?,
client_id: generate_cid(),
})
}
pub(crate) async fn get_registration(&self, uid: &str) -> Result<RegisterResult> {
let lookups = self.discoverer.uid_lookup_all(uid).await?;
let reg_result = Box::pin(
lookups
.then(|lookup| {
let discoverer = &self.discoverer;
let client_id = self.client_id;
async move {
trace!("lookup: {:?}", lookup);
let reg_result = discoverer.register_address(uid, client_id, &lookup).await;
trace!("reg_result: {:?}", reg_result);
reg_result
}
})
.filter_map(|f| async { f.ok() }),
)
.next()
.await
.ok_or(Error::Other(
"No reolink registers returned valid device data.",
))?;
Ok(reg_result)
}
// Check if TCP is possible
//
// To do this we send a dummy login and see if it replies with any BC packet
pub(crate) async fn check_tcp(addr: SocketAddr, channel_id: u8) -> Result<()> {
pub(crate) async fn check_tcp(&self, addr: SocketAddr, channel_id: u8) -> Result<()> {
let username = "admin";
let password = Some("123456");
let mut tcp_source =
@@ -979,18 +998,17 @@ impl Discovery {
// Perform UDP broadcast lookup and connection
pub(crate) async fn local(
&self,
uid: &str,
mut optional_addrs: Option<Vec<SocketAddr>>,
) -> Result<DiscoveryResult> {
let discoverer = Discoverer::new().await?;
let client_id = generate_cid();
let mut dests = get_broadcasts(&[2015, 2018])?;
if let Some(mut optional_addrs) = optional_addrs.take() {
trace!("Also sending to {:?}", optional_addrs);
dests.append(&mut optional_addrs);
}
let discoverer_ref = &discoverer;
let discoverer_ref = &self.discoverer;
let client_id = self.client_id;
let mut futures = FuturesUnordered::new();
for addr in dests.iter().copied() {
futures.push(async move {
@@ -1018,10 +1036,9 @@ impl Discovery {
drop(futures);
// drop(discoverer_ref);
let (socket, keep_alive_tasks) = discoverer.into_socket().await;
let socket = self.discoverer.get_socket().await;
Ok(DiscoveryResult {
socket,
keep_alive_tasks,
addr: connect_result.addr,
camera_id: connect_result.camera_id,
client_id: connect_result.client_id,
@@ -1039,33 +1056,22 @@ impl Discovery {
// This method is best when broadcasts are not possible but we can contact the camera
// directly
#[allow(unused)]
pub(crate) async fn remote(uid: &str) -> Result<DiscoveryResult> {
pub(crate) async fn remote(
&self,
uid: &str,
reg_result: &RegisterResult,
) -> Result<DiscoveryResult> {
trace!("Start remote");
let mut discoverer = Discoverer::new().await?;
let client_id = generate_cid();
trace!("client_id: {}", client_id);
let lookup = discoverer.uid_loopup(uid).await?;
trace!("lookup: {:?}", lookup);
let reg_addr = lookup.reg;
let relay_addr = lookup.relay;
let reg_result = discoverer.register_address(uid, client_id, &lookup).await?;
trace!("reg_result: {:?}", reg_result);
let connect_result = tokio::select! {
v = discoverer.client_initiated_dev(&reg_result) => {v},
v = discoverer.device_initiated_dev(&reg_result) => {v},
v = self.discoverer.client_initiated_dev(reg_result) => {v},
v = self.discoverer.device_initiated_dev(reg_result) => {v},
}?;
trace!("connect_result: {:?}", connect_result);
let (socket, keep_alive_tasks) = discoverer.into_socket().await;
let socket = self.discoverer.get_socket().await;
Ok(DiscoveryResult {
socket,
keep_alive_tasks,
addr: connect_result.addr,
client_id,
client_id: self.client_id,
camera_id: connect_result.camera_id,
})
}
@@ -1078,27 +1084,15 @@ impl Discovery {
//
// This method should be used when the camera is behind a NAT or firewall but we are
// reachable
pub(crate) async fn map(uid: &str) -> Result<DiscoveryResult> {
let discoverer = Discoverer::new().await?;
let client_id = generate_cid();
trace!("client_id: {}", client_id);
let lookup = discoverer.uid_loopup(uid).await?;
trace!("lookup: {:?}", lookup);
let reg_result = discoverer.register_address(uid, client_id, &lookup).await?;
trace!("reg_result: {:?}", reg_result);
let connect_result = discoverer.device_initiated_map(&reg_result).await?;
pub(crate) async fn map(&self, reg_result: &RegisterResult) -> Result<DiscoveryResult> {
let connect_result = self.discoverer.device_initiated_map(reg_result).await?;
trace!("connect_result: {:?}", connect_result);
let (socket, keep_alive_tasks) = discoverer.into_socket().await;
let socket = self.discoverer.get_socket().await;
Ok(DiscoveryResult {
socket,
keep_alive_tasks,
addr: connect_result.addr,
client_id,
client_id: self.client_id,
camera_id: connect_result.camera_id,
})
}
@@ -1108,27 +1102,15 @@ impl Discovery {
// This method should work if all else fails but it will require
// us to trust reolink with our data once more...
//
pub(crate) async fn relay(uid: &str) -> Result<DiscoveryResult> {
let discoverer = Discoverer::new().await?;
let client_id = generate_cid();
trace!("client_id: {}", client_id);
let lookup = discoverer.uid_loopup(uid).await?;
trace!("lookup: {:?}", lookup);
let reg_result = discoverer.register_address(uid, client_id, &lookup).await?;
trace!("reg_result: {:?}", reg_result);
let connect_result = discoverer.client_initiated_relay(&reg_result).await?;
pub(crate) async fn relay(&self, reg_result: &RegisterResult) -> Result<DiscoveryResult> {
let connect_result = self.discoverer.client_initiated_relay(reg_result).await?;
trace!("connect_result: {:?}", connect_result);
let (socket, keep_alive_tasks) = discoverer.into_socket().await;
let socket = self.discoverer.get_socket().await;
Ok(DiscoveryResult {
socket,
keep_alive_tasks,
addr: connect_result.addr,
client_id,
client_id: self.client_id,
camera_id: connect_result.camera_id,
})
}
@@ -6,7 +6,7 @@
//!
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::{net::UdpSocket, task::JoinSet};
use tokio::net::UdpSocket;
mod bcconn;
mod bcsub;
@@ -22,16 +22,11 @@ pub(crate) use self::{
pub(crate) struct DiscoveryResult {
socket: Arc<UdpSocket>,
addr: SocketAddr,
keep_alive_tasks: JoinSet<()>,
client_id: i32,
camera_id: i32,
}
impl DiscoveryResult {
/// Stop all keep alive and any remaining tasks that the discover is managing
pub(crate) async fn shutdown(&mut self) {
self.keep_alive_tasks.shutdown().await;
}
/// Get the address discovered
pub(crate) fn get_addr(&self) -> &SocketAddr {
&self.addr
@@ -49,13 +49,12 @@ impl UdpSource {
Self::new_from_socket(stream, addr, client_id, camera_id, username, password).await
}
pub(crate) async fn new_from_discovery<T: Into<String>, U: Into<String>>(
mut discovery: DiscoveryResult,
discovery: DiscoveryResult,
username: T,
password: Option<U>,
) -> Result<Self> {
// Ensure that the discovery keep alive are all stopped here
// We now handle all coms in UdpSource
discovery.shutdown().await;
Self::new_from_socket(
discovery.socket,
discovery.addr,