alpaca-websocket 0.3.1

WebSocket client for Alpaca trading platform real-time data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! # WebSocket Configuration
//!
//! This example demonstrates how to configure the WebSocket client
//! with custom settings for reconnection, timeouts, and buffers.
//!
//! ## Prerequisites
//!
//! Set environment variables:
//! - `ALPACA_API_KEY`: Your Alpaca API key
//! - `ALPACA_API_SECRET`: Your Alpaca secret key
//!
//! ## Usage
//!
//! ```bash
//! cargo run -p alpaca-websocket --example ws_websocket_config
//! ```

use alpaca_websocket::{ConnectionState, StreamType, WebSocketConfig};

fn main() {
    println!("=== WebSocket Configuration ===\n");

    // Default configuration
    println!("--- Default Configuration ---");
    let default_config = WebSocketConfig::default();
    println!("  Reconnect enabled: {}", default_config.reconnect_enabled);
    println!(
        "  Max reconnect attempts: {}",
        default_config.reconnect_max_attempts
    );
    println!(
        "  Base reconnect delay: {}ms",
        default_config.reconnect_base_delay_ms
    );
    println!(
        "  Max reconnect delay: {}ms",
        default_config.reconnect_max_delay_ms
    );
    println!("  Ping interval: {}ms", default_config.ping_interval_ms);
    println!(
        "  Message buffer size: {}",
        default_config.message_buffer_size
    );
    println!(
        "  Connection timeout: {}ms",
        default_config.connection_timeout_ms
    );

    // Custom configuration with builder pattern
    println!("\n--- Custom Configuration (Builder Pattern) ---");
    let custom_config = WebSocketConfig::new()
        .max_reconnect_attempts(5)
        .reconnect_base_delay(500)
        .ping_interval(15000)
        .buffer_size(500)
        .connection_timeout(5000);

    println!("  Reconnect enabled: {}", custom_config.reconnect_enabled);
    println!(
        "  Max reconnect attempts: {}",
        custom_config.reconnect_max_attempts
    );
    println!(
        "  Base reconnect delay: {}ms",
        custom_config.reconnect_base_delay_ms
    );
    println!("  Ping interval: {}ms", custom_config.ping_interval_ms);
    println!(
        "  Message buffer size: {}",
        custom_config.message_buffer_size
    );
    println!(
        "  Connection timeout: {}ms",
        custom_config.connection_timeout_ms
    );

    // Disable reconnection
    println!("\n--- No Reconnection Configuration ---");
    let no_reconnect_config = WebSocketConfig::new().no_reconnect();
    println!(
        "  Reconnect enabled: {}",
        no_reconnect_config.reconnect_enabled
    );

    // Stream types and their URLs
    println!("\n--- Stream Types ---");
    let stream_types = [
        (StreamType::Stocks, "Stock market data"),
        (StreamType::Crypto, "Cryptocurrency data"),
        (StreamType::Options, "Options market data"),
        (StreamType::News, "Real-time news"),
        (StreamType::Trading, "Trading updates"),
    ];

    for (stream_type, description) in stream_types {
        println!("\n  {:?} - {}", stream_type, description);
        println!("    Paper URL: {}", stream_type.url(true));
        println!("    Live URL: {}", stream_type.url(false));
    }

    // Connection states
    println!("\n--- Connection States ---");
    let states = [
        (ConnectionState::Disconnected, "Not connected to server"),
        (
            ConnectionState::Connecting,
            "Attempting to establish connection",
        ),
        (ConnectionState::Connected, "Connected and authenticated"),
        (
            ConnectionState::Reconnecting,
            "Reconnecting after disconnect",
        ),
        (ConnectionState::Failed, "Connection failed permanently"),
    ];

    for (state, description) in states {
        println!("  {:?}: {}", state, description);
    }

    // Configuration recommendations
    println!("\n--- Configuration Recommendations ---");
    println!("  High-frequency trading:");
    println!("    - Lower ping interval (10-15 seconds)");
    println!("    - Larger buffer size (2000+)");
    println!("    - Aggressive reconnection (base delay 100-500ms)");
    println!();
    println!("  Standard trading:");
    println!("    - Default ping interval (30 seconds)");
    println!("    - Default buffer size (1000)");
    println!("    - Standard reconnection (base delay 1000ms)");
    println!();
    println!("  Low-latency requirements:");
    println!("    - Shorter connection timeout (3-5 seconds)");
    println!("    - Fewer max reconnect attempts (3-5)");
    println!("    - Consider disabling reconnection for fail-fast");

    println!("\n=== Example Complete ===");
}