WebAssembly как платформа для языков программирования

wit_bindgen::generate!({
    world: "parser",
    exports: {
        "polyglot:log-processor/parser": Parser,
    }
});
 
use exports::polyglot::log_processor::parser::*;
 
struct Parser;
 
impl Guest for Parser {
    fn parse(raw: String) -> Result<LogEntry, ParseError> {
        let mut chars = raw.chars().peekable();
        
        // Парсим timestamp - первое поле до пробела
        let timestamp = parse_timestamp(&mut chars)
            .ok_or(ParseError::MissingField("timestamp".into()))?;
        
        skip_whitespace(&mut chars);
        
        // Извлекаем level - всё в квадратных скобках
        let level = parse_bracketed(&mut chars)
            .ok_or(ParseError::MissingField("level".into()))?;
        
        skip_whitespace(&mut chars);
        
        // Остаток строки - message
        let message: String = chars.collect();
        
        // Metadata извлекаем из key=value пар в конце message
        let (clean_message, metadata) = extract_metadata(&message);
        
        Ok(LogEntry {
            timestamp,
            level,
            message: clean_message,
            metadata,
        })
    }
}
 
fn parse_timestamp<I: Iterator<Item = char>>(
    chars: &mut std::iter::Peekable<I>
) -> Option<u64> {
    let mut digits = String::new();
    
    while let Some(&ch) = chars.peek() {
        if ch.is_ascii_digit() {
            digits.push(ch);
            chars.next();
        } else {
            break;
        }
    }
    
    digits.parse().ok()
}
 
fn parse_bracketed<I: Iterator<Item = char>>(
    chars: &mut std::iter::Peekable<I>
) -> Option<String> {
    // Ожидаем открывающую скобку
    if chars.next()? != '[' {
        return None;
    }
    
    let mut content = String::new();
    
    for ch in chars.by_ref() {
        if ch == ']' {
            return Some(content);
        }
        content.push(ch);
    }
    
    None // Скобка не закрылась
}
 
fn skip_whitespace<I: Iterator<Item = char>>(
    chars: &mut std::iter::Peekable<I>
) {
    while let Some(&ch) = chars.peek() {
        if ch.is_whitespace() {
            chars.next();
        } else {
            break;
        }
    }
}
 
fn extract_metadata(message: &str) -> (String, Vec<(String, String)>) {
    let mut metadata = Vec::new();
    let mut clean = String::new();
    
    // Ищем паттерн key=value в конце строки
    let parts: Vec<&str> = message.split_whitespace().collect();
    let mut last_regular_word = parts.len();
    
    for (idx, part) in parts.iter().enumerate().rev() {
        if let Some(pos) = part.find('=') {
            let key = part[..pos].to_string();
            let value = part[pos + 1..].to_string();
            metadata.insert(0, (key, value));
        } else {
            last_regular_word = idx + 1;
            break;
        }
    }
    
    clean = parts[..last_regular_word].join(" ");
    
    (clean, metadata)
}

wit_bindgen::generate!({
    world: "orchestrator",
});
 
use wasi::cli::terminal_output::get_stdout;
 
fn main() {
    let raw_logs = vec![
        "1234567890 [INFO] Application started user=alice",
        "1234567891 [ERROR] Database connection failed",
        "1234567892 [WARNING] Slow query detected duration=5.2",
    ];
    
    // Парсим через Rust-компонент
    let entries: Vec<_> = raw_logs.iter()
        .filter_map(|raw| {
            polyglot::log_processor::parser::parse(raw).ok()
        })
        .collect();
    
    // Анализируем через Python-компонент
    let stats = polyglot::log_processor::analytics::analyze(&entries);
    
    // Рендерим через JavaScript-компонент  
    let output = polyglot::log_processor::renderer::render(&stats);
    
    // Выводим результат
    let stdout = get_stdout();
    stdout.write(output.as_bytes()).unwrap();
}

use wasi::clocks::monotonic_clock;
 
fn main() {
    let start = monotonic_clock::now();
    
    let parse_start = monotonic_clock::now();
    let entries = parse_logs(raw_logs);
    let parse_duration = monotonic_clock::now() - parse_start;
    
    let analyze_start = monotonic_clock::now();
    let stats = analyze_entries(&entries);
    let analyze_duration = monotonic_clock::now() - analyze_start;
    
    let render_start = monotonic_clock::now();
    let output = render_stats(&stats);
    let render_duration = monotonic_clock::now() - render_start;
    
    let total = monotonic_clock::now() - start;
    
    eprintln!("Timing: parse={parse_duration}ns, analyze={analyze_duration}ns, render={render_duration}ns, total={total}ns");
}

#[derive(Clone, Copy)]
pub struct Money {
    pub whole: i64,
    pub cents: u8,
}
 
impl Money {
    fn to_f64(&self) -> f64 {
        self.whole as f64 + (self.cents as f64 / 100.0)
    }
    
    fn from_f64(value: f64) -> Option<Self> {
        let whole = value.trunc() as i64;
        let cents = ((value.fract().abs() * 100.0).round() as u8);
        
        if cents >= 100 {
            return None; // Переполнение копеек
        }
        
        Some(Money { whole, cents })
    }
}