Struct stratum_server::MinerList

pub struct MinerList {
    pub miners: Arc<RwLock<HashMap<u32, Miner>>>,
}

Fields

miners: Arc<RwLock<HashMap<u32, Miner>>>

Implementations

impl MinerList

pub fn new() -> Self

Examples found in repository

src/miner_list.rs (line 42)

    fn default() -> Self {
        Self::new()
    }

src/session.rs (line 185)

    pub fn new(
        id_manager: IDManager,
        sender: UnboundedSender<SendInformation>,
        config_manager: ConfigManager,
        cancel_token: CancellationToken,
        // #[cfg(feature = "upstream")] upstream_sender: UnboundedSender<String>,
        // #[cfg(feature = "upstream")] upstream_receiver: UnboundedReceiver<
        //     serde_json::map::Map<String, serde_json::Value>,
        // >,
        state: State,
    ) -> Result<Self> {
        let session_id = id_manager.allocate_session_id()?;
        let id = Uuid::new_v4();

        debug!("Accepting new miner. ID: {}", &id);

        let config = config_manager.current_config();

        let options = MinerOptions {
            retarget_time: config.difficulty.retarget_time,
            target_time: config.difficulty.target_time,
            //@todo these values make no sense so let's trim them a bit.
            min_diff: config.difficulty.minimum_difficulty,
            max_diff: config.difficulty.maximum_difficulty,
            max_delta: 1.0, //@todo make this adjustable, not sure if this is solid or not.
            //@todo probably don't store, get from above and then calcualte the others.
            variance_percent: config.difficulty.variance_percent,
            // share_time_min: 4.2,
            // share_time_max: 7.8,
        };

        Ok(Session {
            id,
            session_id,
            id_manager,
            user_info: Arc::new(Mutex::new(UserInfo {
                account_id: 0,
                mining_account: 0,
                worker_name: None,
            })),
            info: Arc::new(RwLock::new(SessionInfo::new())),
            sender: Arc::new(Mutex::new(sender)),
            // #[cfg(feature = "upstream")]
            // upstream_sender: Arc::new(Mutex::new(upstream_sender)),
            // #[cfg(feature = "upstream")]
            // upstream_receiver: Arc::new(Mutex::new(upstream_receiver)),
            difficulty: Arc::new(Mutex::new(config.difficulty.initial_difficulty)),
            previous_difficulty: Arc::new(Mutex::new(config.difficulty.initial_difficulty)),
            next_difficulty: Arc::new(Mutex::new(None)),
            options: Arc::new(options),
            needs_ban: Arc::new(Mutex::new(false)),
            state: Arc::new(Mutex::new(state)),
            cancel_token,
            miner_list: MinerList::new(),
            connection_miner: Arc::new(Mutex::new(None)),
        })
    }

pub async fn add_miner(&self, session_id: u32, miner: Miner)

Examples found in repository

src/session.rs (line 348)

    pub async fn register_worker(
        &self,
        session_id: u32,
        client_agent: &str,
        worker_name: &str,
        worker_id: Uuid,
    ) {
        let worker = Miner::new(
            worker_id,
            Some(client_agent.to_owned()),
            Some(worker_name.to_owned()),
            Buffer::from(session_id.to_le_bytes().to_vec()),
            self.options.clone(),
            format_difficulty(*self.difficulty.lock().await),
        );

        self.miner_list.add_miner(session_id, worker).await;
    }

pub async fn remove_miner(&self, session_id: u32) -> Option<Miner>

Examples found in repository

src/session.rs (line 352)

    pub async fn unregister_worker(&self, session_id: u32) -> Option<Miner> {
        self.miner_list.remove_miner(session_id).await
    }

pub async fn get_miner_by_id(&self, session_id: u32) -> Option<Miner>

Examples found in repository

src/session.rs (line 361)

    pub async fn get_worker_by_session_id(&self, session_id: u32) -> Option<Miner> {
        self.miner_list.get_miner_by_id(session_id).await
    }

pub async fn update_miner_by_session_id(&self, session_id: u32, miner: Miner)

Examples found in repository

src/session.rs (line 366)

    pub async fn update_worker_by_session_id(&self, session_id: u32, miner: Miner) {
        self.miner_list
            .update_miner_by_session_id(session_id, miner)
            .await;
    }

Trait Implementations

impl Clone for MinerList

fn clone(&self) -> MinerList

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MinerList

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MinerList

fn default() -> Self

Returns the “default value” for a type.