TIL: Rust Development Ecosystem and Advanced Tooling

 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

// Understanding Rust compiler phases through examples

// Example showing how Rust code transforms through compiler phases
use std::collections::HashMap;

// 1. Source Code (what we write)
fn analyze_text(text: &str) -> HashMap<char, usize> {
    let mut counts = HashMap::new();
    
    for ch in text.chars() {
        *counts.entry(ch).or_insert(0) += 1;
    }
    
    counts
}

// 2. After macro expansion and desugaring (simplified HIR-like representation)
// The compiler transforms this into something conceptually like:
/*
fn analyze_text(text: &str) -> HashMap<char, usize> {
    let mut counts: HashMap<char, usize> = HashMap::new();
    
    let iter = <str as IntoIterator>::into_iter(text.chars());
    loop {
        match iter.next() {
            Some(ch) => {
                let entry = counts.entry(ch);
                let value = match entry {
                    Entry::Occupied(mut occ) => {
                        let old = occ.get_mut();
                        *old += 1;
                        old
                    },
                    Entry::Vacant(vac) => vac.insert(0 + 1),
                };
            },
            None => break,
        }
    }
    
    counts
}
*/

// 3. MIR (Mid-level IR) represents control flow and borrows explicitly
// This enables the borrow checker to verify memory safety

// Example of advanced Rust features that showcase compiler sophistication
use std::marker::PhantomData;
use std::ptr::NonNull;

// Zero-cost abstractions: This compiles to the same assembly as raw pointer operations
struct TypedPtr<T> {
    ptr: NonNull<T>,
    _marker: PhantomData<T>,
}

impl<T> TypedPtr<T> {
    fn new(value: &mut T) -> Self {
        Self {
            ptr: NonNull::from(value),
            _marker: PhantomData,
        }
    }
    
    unsafe fn as_ref(&self) -> &T {
        self.ptr.as_ref()
    }
    
    unsafe fn as_mut(&mut self) -> &mut T {
        self.ptr.as_mut()
    }
}

// The compiler ensures this is memory-safe while generating optimal code
fn demonstrate_zero_cost_abstraction() {
    let mut value = 42;
    let typed_ptr = TypedPtr::new(&mut value);
    
    // This compiles to direct memory access, no overhead
    unsafe {
        println!("Value: {}", typed_ptr.as_ref());
    }
}

 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

// Demonstrating struct field ordering optimization
use std::mem;

// Poorly ordered struct - causes padding
#[repr(C)]  // Prevents reordering for demonstration
struct PoorlyOrdered {
    a: u8,     // 1 byte
    b: u64,    // 8 bytes (7 bytes padding before this)
    c: u8,     // 1 byte  
    d: u32,    // 4 bytes (3 bytes padding before this)
}

// Well-ordered struct - minimal padding
#[repr(C)]
struct WellOrdered {
    b: u64,    // 8 bytes
    d: u32,    // 4 bytes
    a: u8,     // 1 byte
    c: u8,     // 1 byte (2 bytes padding at end for alignment)
}

// Rust automatically reorders fields for optimal layout (without #[repr(C)])
struct AutoOptimized {
    a: u8,
    b: u64,
    c: u8,
    d: u32,
}

fn analyze_struct_sizes() {
    println!("Struct size analysis:");
    println!("PoorlyOrdered: {} bytes", mem::size_of::<PoorlyOrdered>());
    println!("WellOrdered: {} bytes", mem::size_of::<WellOrdered>());
    println!("AutoOptimized: {} bytes", mem::size_of::<AutoOptimized>());
    
    // Advanced memory layout analysis
    println!("\nAlignment requirements:");
    println!("u8 align: {}", mem::align_of::<u8>());
    println!("u32 align: {}", mem::align_of::<u32>());
    println!("u64 align: {}", mem::align_of::<u64>());
}

// Generic programming with zero-cost abstractions
trait DataProcessor<T> {
    fn process(&self, data: &[T]) -> Vec<T>;
}

struct FilterProcessor<F> {
    filter: F,
}

impl<T, F> DataProcessor<T> for FilterProcessor<F>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    fn process(&self, data: &[T]) -> Vec<T> {
        // This compiles to highly optimized code with inlining
        data.iter()
            .filter(|&item| (self.filter)(item))
            .cloned()
            .collect()
    }
}

// Usage demonstrates zero-cost abstraction
fn demonstrate_generic_optimization() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let processor = FilterProcessor {
        filter: |&x| x % 2 == 0,  // This closure is inlined
    };
    
    let result = processor.process(&data);
    println!("Filtered (even numbers): {:?}", result);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# NuShell examples - structured data processing

# List files with structured output
ls | where size > 1KB | sort-by modified | reverse

# Process JSON data
curl -s "https://api.github.com/users/octocat/repos" | from json | select name stars_count | sort-by stars_count | reverse

# Work with CSV files
open sales.csv | where region == "West" | group-by product | sum

# System information as structured data
sys | get cpu | select brand cores max_freq | print

# Network operations with structured output
netstat | where port == 8080 | select pid process

# Git integration
git log --oneline | lines | split column " " commit message | first 10

  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

// Advanced command-line scripting in Rust
use cmd_lib::*;

// Execute shell commands with Rust syntax
fn system_administration_tasks() -> CmdResult {
    // Basic command execution
    run_cmd!(echo "Starting system checks...")?;
    
    // Capture command output
    let disk_usage = run_fun!(df -h)?;
    println!("Disk usage:\n{}", disk_usage);
    
    // Conditional execution
    if run_cmd!(systemctl is-active postgresql).is_ok() {
        println!("PostgreSQL is running");
        
        // Complex pipeline
        let db_sizes = run_fun!(
            psql -c "SELECT datname, pg_size_pretty(pg_database_size(datname)) 
                     FROM pg_database ORDER BY pg_database_size(datname) DESC;"
        )?;
        println!("Database sizes:\n{}", db_sizes);
    }
    
    // File operations with error handling
    run_cmd!(
        mkdir -p /tmp/rust_scripts;
        cp important_config.toml /tmp/rust_scripts/;
        chmod 600 /tmp/rust_scripts/important_config.toml
    )?;
    
    // Log rotation example
    let log_files = run_fun!(find /var/log -name "*.log" -size +100M)?;
    for log_file in log_files.lines() {
        println!("Large log file found: {}", log_file);
        run_cmd!(gzip $log_file)?;
    }
    
    Ok(())
}

// Advanced process management
use std::process::{Command, Stdio};
use std::thread;
use std::time::Duration;

struct ProcessManager {
    processes: Vec<std::process::Child>,
}

impl ProcessManager {
    fn new() -> Self {
        Self {
            processes: Vec::new(),
        }
    }
    
    fn spawn_monitored(&mut self, command: &str, args: &[&str]) -> std::io::Result<()> {
        let child = Command::new(command)
            .args(args)
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()?;
        
        println!("Started process {} with PID {}", command, child.id());
        self.processes.push(child);
        Ok(())
    }
    
    fn monitor_processes(&mut self) {
        self.processes.retain_mut(|child| {
            match child.try_wait() {
                Ok(Some(status)) => {
                    println!("Process {} exited with status: {}", child.id(), status);
                    false // Remove from list
                }
                Ok(None) => true, // Still running
                Err(e) => {
                    eprintln!("Error checking process {}: {}", child.id(), e);
                    false // Remove on error
                }
            }
        });
    }
    
    fn terminate_all(&mut self) {
        for child in &mut self.processes {
            if let Err(e) = child.kill() {
                eprintln!("Failed to kill process {}: {}", child.id(), e);
            }
        }
        self.processes.clear();
    }
}

// Usage example
fn demonstrate_process_management() -> std::io::Result<()> {
    let mut manager = ProcessManager::new();
    
    // Start multiple background processes
    manager.spawn_monitored("ping", &["-c", "10", "google.com"])?;
    manager.spawn_monitored("sleep", &["30"])?;
    
    // Monitor for 20 seconds
    for _ in 0..20 {
        manager.monitor_processes();
        thread::sleep(Duration::from_secs(1));
    }
    
    // Clean up any remaining processes
    manager.terminate_all();
    Ok(())
}

 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

// Rust-Objective-C interop example
use objc::runtime::{Object, Sel};
use objc::{msg_send, sel, sel_impl, class};
use cocoa::base::{id, nil};
use cocoa::foundation::{NSString, NSArray};

// Safe wrapper around Objective-C objects
struct NSStringWrapper {
    inner: id,
}

impl NSStringWrapper {
    fn from_str(s: &str) -> Self {
        unsafe {
            let ns_string: id = msg_send![class!(NSString), stringWithUTF8String: s.as_ptr()];
            Self { inner: ns_string }
        }
    }
    
    fn to_string(&self) -> String {
        unsafe {
            let utf8_ptr: *const i8 = msg_send![self.inner, UTF8String];
            let c_str = std::ffi::CStr::from_ptr(utf8_ptr);
            c_str.to_string_lossy().into_owned()
        }
    }
    
    fn length(&self) -> usize {
        unsafe {
            let len: usize = msg_send![self.inner, length];
            len
        }
    }
}

// Memory-safe interop patterns
fn safe_objc_interop() {
    let rust_string = "Hello from Rust!";
    let ns_string = NSStringWrapper::from_str(rust_string);
    
    println!("Original: {}", rust_string);
    println!("Round-trip: {}", ns_string.to_string());
    println!("Length: {}", ns_string.length());
}

// RAII pattern for resource management
use std::ptr::NonNull;

struct ManagedResource<T> {
    ptr: NonNull<T>,
    cleanup: fn(*mut T),
}

impl<T> ManagedResource<T> {
    fn new(value: T, cleanup: fn(*mut T)) -> Self {
        let boxed = Box::new(value);
        let ptr = NonNull::new(Box::into_raw(boxed)).unwrap();
        
        Self { ptr, cleanup }
    }
    
    fn get(&self) -> &T {
        unsafe { self.ptr.as_ref() }
    }
    
    fn get_mut(&mut self) -> &mut T {
        unsafe { self.ptr.as_mut() }
    }
}

impl<T> Drop for ManagedResource<T> {
    fn drop(&mut self) {
        unsafe {
            (self.cleanup)(self.ptr.as_ptr());
        }
    }
}

// Custom cleanup function
fn custom_cleanup(ptr: *mut i32) {
    println!("Cleaning up resource at {:p}", ptr);
    unsafe {
        drop(Box::from_raw(ptr));
    }
}

fn demonstrate_raii() {
    let resource = ManagedResource::new(42, custom_cleanup);
    println!("Resource value: {}", resource.get());
    
    // Resource is automatically cleaned up when it goes out of scope
}

  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

// Advanced Linux system programming in Rust
use std::fs::{File, OpenOptions};
use std::io::{self, Read, Write, BufRead, BufReader};
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::{AsRawFd, RawFd};
use std::path::Path;

// System resource monitoring
struct SystemMonitor {
    proc_stat: File,
    proc_meminfo: File,
}

impl SystemMonitor {
    fn new() -> io::Result<Self> {
        Ok(Self {
            proc_stat: File::open("/proc/stat")?,
            proc_meminfo: File::open("/proc/meminfo")?,
        })
    }
    
    fn read_cpu_usage(&mut self) -> io::Result<Vec<u64>> {
        let mut contents = String::new();
        self.proc_stat.read_to_string(&mut contents)?;
        
        // Parse first line (overall CPU stats)
        let first_line = contents.lines().next().unwrap_or("");
        let values: Vec<u64> = first_line
            .split_whitespace()
            .skip(1) // Skip "cpu" label
            .filter_map(|s| s.parse().ok())
            .collect();
        
        Ok(values)
    }
    
    fn read_memory_info(&mut self) -> io::Result<std::collections::HashMap<String, u64>> {
        let mut contents = String::new();
        self.proc_meminfo.read_to_string(&mut contents)?;
        
        let mut memory_info = std::collections::HashMap::new();
        
        for line in contents.lines() {
            if let Some((key, value)) = line.split_once(':') {
                let value_str = value.trim().trim_end_matches(" kB");
                if let Ok(value_num) = value_str.parse::<u64>() {
                    memory_info.insert(key.to_string(), value_num * 1024); // Convert to bytes
                }
            }
        }
        
        Ok(memory_info)
    }
}

// File system operations with proper error handling
fn secure_file_operations() -> io::Result<()> {
    // Create file with specific permissions
    let mut file = OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(true)
        .mode(0o600) // Owner read/write only
        .open("/tmp/secure_config.conf")?;
    
    // Write configuration data
    writeln!(file, "# Secure configuration file")?;
    writeln!(file, "secret_key=abcdef123456")?;
    file.sync_all()?; // Ensure data is written to disk
    
    // Read with proper error handling
    let config_file = File::open("/tmp/secure_config.conf")?;
    let reader = BufReader::new(config_file);
    
    for (line_num, line) in reader.lines().enumerate() {
        let line = line?;
        if !line.starts_with('#') && line.contains('=') {
            println!("Config line {}: {}", line_num + 1, line);
        }
    }
    
    Ok(())
}

// Process management and signaling
use nix::sys::signal::{self, Signal};
use nix::unistd::Pid;

fn manage_processes() -> Result<(), Box<dyn std::error::Error>> {
    // Start a background process
    let child = std::process::Command::new("sleep")
        .arg("60")
        .spawn()?;
    
    let pid = Pid::from_raw(child.id() as i32);
    println!("Started process with PID: {}", pid);
    
    // Wait a moment then send SIGTERM
    std::thread::sleep(std::time::Duration::from_secs(2));
    
    match signal::kill(pid, Signal::SIGTERM) {
        Ok(()) => println!("Sent SIGTERM to process {}", pid),
        Err(e) => eprintln!("Failed to send signal: {}", e),
    }
    
    // Clean up
    match child.wait_with_output() {
        Ok(output) => {
            println!("Process exited with status: {}", output.status);
        }
        Err(e) => eprintln!("Error waiting for process: {}", e),
    }
    
    Ok(())
}

  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

// Building command-line tools with clap and other utilities
use clap::{App, Arg, SubCommand};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize)]
struct Config {
    name: String,
    version: String,
    features: HashMap<String, bool>,
}

// Advanced CLI application structure
fn build_cli_app() -> App<'static, 'static> {
    App::new("advanced-tool")
        .version("1.0.0")
        .author("Developer <[email protected]>")
        .about("Advanced command-line tool built with Rust")
        .arg(Arg::with_name("config")
            .short("c")
            .long("config")
            .value_name("FILE")
            .help("Sets a custom config file")
            .takes_value(true))
        .arg(Arg::with_name("verbose")
            .short("v")
            .long("verbose")
            .multiple(true)
            .help("Sets the level of verbosity"))
        .subcommand(SubCommand::with_name("analyze")
            .about("Analyze input data")
            .arg(Arg::with_name("INPUT")
                .help("Sets the input file to analyze")
                .required(true)
                .index(1)))
        .subcommand(SubCommand::with_name("report")
            .about("Generate reports")
            .arg(Arg::with_name("format")
                .short("f")
                .long("format")
                .possible_values(&["json", "yaml", "table"])
                .default_value("table")
                .help("Output format")))
}

// Async I/O with tokio
use tokio::fs::File;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

async fn async_file_processing() -> io::Result<()> {
    // Read file asynchronously
    let mut file = File::open("large_dataset.txt").await?;
    let mut contents = Vec::new();
    file.read_to_end(&mut contents).await?;
    
    // Process data (simulate CPU-intensive work)
    let processed = tokio::task::spawn_blocking(move || {
        // This runs on a thread pool to avoid blocking the async runtime
        contents.iter()
            .filter(|&&byte| byte.is_ascii_alphanumeric())
            .cloned()
            .collect::<Vec<u8>>()
    }).await.unwrap();
    
    // Write results asynchronously
    let mut output_file = File::create("processed_output.txt").await?;
    output_file.write_all(&processed).await?;
    output_file.sync_all().await?;
    
    Ok(())
}

// Error handling with anyhow and thiserror
use anyhow::{Context, Result};

#[derive(thiserror::Error, Debug)]
enum ProcessingError {
    #[error("Invalid input format: {message}")]
    InvalidFormat { message: String },
    
    #[error("Configuration error")]
    Config(#[from] toml::de::Error),
    
    #[error("I/O error")]
    Io(#[from] std::io::Error),
}

fn robust_data_processing(input: &str) -> Result<String> {
    let config: Config = toml::from_str(input)
        .context("Failed to parse configuration file")?;
    
    if config.name.is_empty() {
        return Err(ProcessingError::InvalidFormat {
            message: "Name field cannot be empty".to_string(),
        }.into());
    }
    
    // Process configuration
    let result = format!("Processed config for: {}", config.name);
    Ok(result)
}