KiteTicker Async Manager

High-performance async WebSocket client for the Kite Connect API with multi-connection support and dynamic subscription management.

📚 Documentation | 🚀 Getting Started | 📝 Examples | 🔧 API Reference

✨ Key Features

• 🚀 Multi-Connection Support - Utilize all 3 allowed WebSocket connections (9,000 symbol capacity)
• ⚡ High Performance - Dedicated parser tasks, optimized buffers, sub-microsecond latency
• 🔄 Dynamic Subscriptions - Add/remove symbols at runtime without reconnection
• 📊 Load Balancing - Automatic symbol distribution across connections
• 💪 Production Ready - Comprehensive error handling, health monitoring, reconnection
• 🔧 Async-First Design - Built with Tokio, follows Rust async best practices

🚀 Quick Start

Installation

Add to your Cargo.toml:

[dependencies]
kiteticker-async-manager = "0.2.1"
tokio = { version = "1.0", features = ["full"] }

Basic Usage

use kiteticker_async_manager::{KiteTickerManager, KiteManagerConfig, Mode, TickerMessage};

#[tokio::main]
async fn main() -> Result<(), String> {
    // Setup credentials
    let api_key = std::env::var("KITE_API_KEY").unwrap();
    let access_token = std::env::var("KITE_ACCESS_TOKEN").unwrap();
    
    // Create high-performance manager
    let config = KiteManagerConfig {
        max_connections: 3,
        max_symbols_per_connection: 3000,
        enable_dedicated_parsers: true,
        default_mode: Mode::LTP,
        ..Default::default()
    };
    
    // Start manager
    let mut manager = KiteTickerManager::new(api_key, access_token, config);
    manager.start().await?;
    
    // Subscribe to symbols (automatically distributed across connections)
    let symbols = vec![256265, 408065, 738561]; // NIFTY 50, HDFC Bank, Reliance
    manager.subscribe_symbols(&symbols, Some(Mode::Quote)).await?;
    
    // Process data from independent channels
    let channels = manager.get_all_channels();
    for (channel_id, mut receiver) in channels {
        tokio::spawn(async move {
            while let Ok(message) = receiver.recv().await {
                if let TickerMessage::Ticks(ticks) = message {
                    for tick in ticks {
                        println!("Channel {:?}: {} @ ₹{:.2}",
                            channel_id, 
                            tick.instrument_token,
                            tick.content.last_price.unwrap_or(0.0));
                    }
                }
            }
        });
    }
    
    // Add symbols dynamically
    manager.subscribe_symbols(&[5633, 884737], Some(Mode::Full)).await?;
    
    // Remove symbols
    manager.unsubscribe_symbols(&[408065]).await?;
    
    // Change subscription mode
    manager.change_mode(&[256265], Mode::Full).await?;
    
    Ok(())
}

📊 Performance Comparison

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                    KiteTickerManager                        │
├─────────────────────────────────────────────────────────────┤
│  📊 Symbol Distribution (9,000 symbols max)                │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐          │
│  │Connection 1 │ │Connection 2 │ │Connection 3 │          │
│  │3,000 symbols│ │3,000 symbols│ │3,000 symbols│          │
│  └─────────────┘ └─────────────┘ └─────────────┘          │
├─────────────────────────────────────────────────────────────┤
│  ⚡ Dedicated Parser Tasks (CPU Optimized)                 │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐          │
│  │   Parser 1  │ │   Parser 2  │ │   Parser 3  │          │
│  │  ~1µs latency│ │  ~1µs latency│ │  ~1µs latency│          │
│  └─────────────┘ └─────────────┘ └─────────────┘          │
├─────────────────────────────────────────────────────────────┤
│  📡 Independent Output Channels                            │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐          │
│  │  Channel 1  │ │  Channel 2  │ │  Channel 3  │          │
│  │broadcast::Rx│ │broadcast::Rx│ │broadcast::Rx│          │
│  └─────────────┘ └─────────────┘ └─────────────┘          │
└─────────────────────────────────────────────────────────────┘

📚 Documentation

• 📖 Getting Started - Complete beginner's guide
• 🔧 API Reference - Detailed API documentation
• 📝 Examples - Practical code examples
• 🔄 Dynamic Subscriptions - Runtime symbol management
• ⚡ Performance Guide - Optimization techniques

📁 Examples

🔰 Basic Examples

• Single Connection - Simple WebSocket usage
• Portfolio Monitor - Track portfolio stocks
• Runtime Subscriptions - Dynamic symbol management

🎯 Advanced Examples

• Dynamic Demo - Complete dynamic workflow
• Manager Demo - Multi-connection setup
• Market Scanner - High-volume scanning

⚡ Performance Examples

• Performance Demo - Benchmarking
• High Frequency - Maximum throughput

🎯 Use Cases

⚙️ Configuration Presets

Development

let config = KiteManagerConfig {
    max_connections: 1,
    max_symbols_per_connection: 100,
    default_mode: Mode::Full,
    ..Default::default()
};

Production

let config = KiteManagerConfig {
    max_connections: 3,
    max_symbols_per_connection: 3000,
    connection_buffer_size: 20000,
    parser_buffer_size: 50000,
    enable_dedicated_parsers: true,
    default_mode: Mode::LTP,
    ..Default::default()
};

🆚 Comparison with Official Library

🛠️ Development

Prerequisites

# Install Rust and tools
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo install just  # Task runner

Building

# Clone and build
git clone https://github.com/SPRAGE/kiteticker-async-manager.git
cd kiteticker-async-manager
just build

Running Examples

# Set API credentials
export KITE_API_KEY=your_api_key
export KITE_ACCESS_TOKEN=your_access_token

# Run examples
cargo run --example single_connection
cargo run --example dynamic_subscription_demo

Available Tasks

just --list

📦 Features

• Multi-Connection Management - Utilize all 3 WebSocket connections
• Dynamic Subscriptions - Add/remove symbols without reconnection
• Load Balancing - Automatic symbol distribution
• High Performance - Dedicated parsers, optimized buffers
• Type Safety - Fully typed market data structures
• Error Resilience - Comprehensive error handling and recovery
• Health Monitoring - Real-time connection health tracking
• Async-First - Built for modern Rust async ecosystems

🤝 Contributing

Contributions are welcome! Please see our contribution guidelines.

Development Setup

Use just to run development tasks:

just --list  # Show available tasks
just build   # Build the project
just check   # Check code formatting and lints

📄 License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

🔗 Links

• Kite Connect API Documentation
• Crates.io
• Documentation
• GitHub Repository

⭐ Star this repository if you find it useful!