Method _configure_fwd_limit_req

chirpstack/src/downlink/data.rs:1827–1879

(&mut self)

    }

    async fn _configure_fwd_limit_req(&mut self) -> Result<()> {
        trace!("Configuring Relay Fwd Limit");

        let ds = self.device.get_device_session_mut()?;
        let relay_params = self.device_profile.relay_params.clone().unwrap_or_default();

        // Get the current relay state.
        let relay = if let Some(r) = &ds.relay {
            r.clone()
        } else {
            internal::Relay::default()
        };

        if relay.join_req_limit_reload_rate != relay_params.relay_join_req_limit_reload_rate as u32
            || relay.notify_limit_reload_rate != relay_params.relay_notify_limit_reload_rate as u32
            || relay.global_uplink_limit_reload_rate
                != relay_params.relay_global_uplink_limit_reload_rate as u32
            || relay.overall_limit_reload_rate
                != relay_params.relay_overall_limit_reload_rate as u32
            || relay.join_req_limit_bucket_size
                != relay_params.relay_join_req_limit_bucket_size as u32
            || relay.notify_limit_bucket_size != relay_params.relay_notify_limit_bucket_size as u32
            || relay.global_uplink_limit_bucket_size
                != relay_params.relay_global_uplink_limit_bucket_size as u32
            || relay.overall_limit_bucket_size
                != relay_params.relay_overall_limit_bucket_size as u32
        {
            let set = lrwn::MACCommandSet::new(vec![lrwn::MACCommand::ConfigureFwdLimitReq(
                lrwn::ConfigureFwdLimitReqPayload {
                    reload_rate: lrwn::FwdLimitReloadRatePL {
                        overall_reload_rate: relay_params.relay_overall_limit_reload_rate,
                        global_uplink_reload_rate: relay_params
                            .relay_global_uplink_limit_reload_rate,
                        notify_reload_rate: relay_params.relay_notify_limit_reload_rate,
                        join_req_reload_rate: relay_params.relay_join_req_limit_reload_rate,
                        reset_limit_counter: lrwn::ResetLimitCounter::NoChange,
                    },
                    load_capacity: lrwn::FwdLimitLoadCapacityPL {
                        overall_limit_size: relay_params.relay_overall_limit_bucket_size,
                        global_uplink_limit_size: relay_params
                            .relay_global_uplink_limit_bucket_size,
                        notify_limit_size: relay_params.relay_notify_limit_bucket_size,
                        join_req_limit_size: relay_params.relay_join_req_limit_bucket_size,
                    },
                },
            )]);
            self.mac_commands.push(set);
        }

        ds.relay = Some(relay);

        Ok(())
    }

    async fn _update_filter_list(&mut self) -> Result<()> {
        trace!("Updating Relay filter list");