Struct IgSession 

pub struct IgSession {
    pub cst: String,
    pub token: String,
    pub account_id: String,
    pub base_url: String,
    pub client_id: String,
    pub lightstreamer_endpoint: String,
    pub api_key: String,
    pub token_timer: Arc<Mutex<TokenTimer>>,
    /* private fields */
}

Session information for IG Markets API authentication

Fields

cst: String

Client Session Token (CST) used for authentication

token: String

Security token used for authentication

account_id: String

Account ID associated with the session

base_url: String

Base URL for API requests

client_id: String

Client ID for API requests

lightstreamer_endpoint: String

Lightstreamer endpoint for API requests

api_key: String

API key for API requests

token_timer: Arc<Mutex<TokenTimer>>

Timer for managing token expiration and automatic refresh cycles

Implementations

impl IgSession

pub fn new(cst: String, token: String, account_id: String) -> Self

Creates a new session with the given credentials

This is a simplified version for tests and basic usage. Uses default values for most fields and a default rate limiter.

pub fn new_with_config( base_url: String, cst: String, security_token: String, client_id: String, account_id: String, lightstreamer_endpoint: String, api_key: String, rate_limit_type: RateLimitType, rate_limit_safety_margin: f64, ) -> Self

Creates a new session with the given parameters

This creates a thread-safe session that can be shared across multiple threads. The rate limiter is wrapped in an Arc to ensure proper synchronization.

pub fn with_rate_limiter( cst: String, token: String, account_id: String, limit_type: RateLimitType, ) -> Self

Creates a new session with the given credentials and a rate limiter

This creates a thread-safe session that can be shared across multiple threads.

pub fn from_config( cst: String, token: String, account_id: String, config: &Config, ) -> Self

Creates a new session with the given credentials and rate limiter configuration from Config

pub async fn respect_rate_limit(&self) -> Result<(), AppError>

Waits if necessary to respect rate limits before making a request

This method will always use a rate limiter - either the one configured in the session, or a default one if none is configured.

This method is thread-safe and can be called from multiple threads concurrently.

Returns

• Ok(()) - If the rate limit is respected
• Err(AppError::RateLimitExceeded) - If the rate limit has been exceeded and cannot be respected

pub async fn get_rate_limit_stats(&self) -> Option<RateLimiterStats>

Gets statistics about the current rate limit usage

pub fn refresh_token_timer(&self)

Refreshes the token timer to extend token validity This should be called after each successful API request

Trait Implementations

impl Clone for IgSession

fn clone(&self) -> IgSession

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IgSession

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

Formats the value using the given formatter.