cargo install --locked bacon
bacon test # run from project folder 

bacon --init

[jobs.check-examples]
command = ["cargo", "run", "--example", "iterators"]
watch = ["examples"]
need_stdout = true

bacon check-examples

bacon run -- -q # сборка и запуск текущего проект
bacon run -- -q --example <файл> # сборка и запуск файла в папке examples

bacon test # запуск unit-тестов (например, определённых для lib.rs)

cargo watch -q -c -x 'run -q --example variables'

cargo new test_project // create project with binary file src/main.rs
// OR
cargo new test_project --lib // create project with library file src/lib.rs 

cd test_project

cargo build # build project for debug, do not run
cargo run # build & run project
cargo check # fast compiling
cargo build --release # slow build with optimizations for speed of release version

cargo doc --open

cargo run --example variables

#[cfg(target_os = "windows")]
fn win_foo() {}

#[cfg_attr(target_os = "linux", path = "linux.rs")]
#[cfg_attr(windows, path = "windows.rs")]
mod os;

let os = if cfg!(unix) {"unix"} else {"windows"};

#[cfg(all(unix, target_pointer_width = "32"))]
fn on_32bit_unix() {}

#[cfg(feature = "debug")] // код сработает только с флагом debug
fn get_data() -> String {
    "мулька".to_string()
}

#[cfg(feature = "mock", feature = "debug")] // код сработает только с флагами mock И debug
fn get_data() -> String {
    "хитрая мулька".to_string()
}

#[cfg(not(feature = "debug"))] // код сработает без флага debug
fn get_data() -> String {
    "реальные данные".to_string()
}

fn main() {
    println!("{}", get_data());
}

[features]
default = ["debug"] # по-умолчанию флаг = ВКЛ
debug = []

#[cfg(feature = "win")]
f use_winapi() {
let void = winapi::ctypes::c_int::from(t : 5);
let f_typ = winapi_util::console::Color::Blue;
}

[features]
default = ["mock"] # включить флаг mock по-умолчанию
mock = ["rand"] # использовать рандимозатор только при включенном флаге
mock-persistent = ["rand"]

[dependencies]
rand = { version = "0.10.0", optional = true } # опциональный рандомизатор

cargo install cargo-bloat
cargo bloat --release

cargo build --timings
# далее открыть target/cargo-timings/cargo-timing.html

cargo install cargo-llvm-lines
cargo llvm-lines --release

[profile.dev]
opt-level = 0          # No optimization (fastest compilation LLVM)
debug = 1              # Line info only (not full debug symbols)
codegen-units = 256    # More parallelism (max is 256)
incremental = true     # Recompile only changed code

[profile.release]
opt-level = 3          # Maximum runtime performance
lto = "thin"           # Faster than "fat" LTO, still good optimization
codegen-units = 1      # Better optimization at cost of compile time

# Установка
cargo install sccache

# Применение
export RUSTC_WRAPPER=sccache
cargo build

cargo install cargo-wizard
cargo wizard

cargo install cargo-machete
cargo machete  # находит неиспользуемые crates

mkdir -p /tmp/rust-target
mount -t tmpfs -o size=8G tmpfs /tmp/rust-target
export CARGO_TARGET_DIR=/tmp/rust-target

cargo build -j $(nproc --ignore=2)

[build]
jobs = 8

[profile.release]
panic = 'abort'

[target.x86_64-unknown-linux-gnu]
linker = "clang"
rustflags = ["-C", "link-arg=-fuse-ld=mold"]

$ readelf -p .comment target/debug/your-app

String dump of section '.comment':
  [     0]  mold 2.4.0 ( ... )

cargo install cargo-cache

# Nightly версия
cargo install --git https://github.com/matthiaskrgr/cargo-cache cargo-cache

cargo cache --info # какие папки у кеша и их размеры
cargo cache --top-cache-items 5 # топ-5 файлов по размеру

cargo cache --dry-run # показать, что будет удалено
cargo cache -a # авто-очистка (autoclean)
cargo cache -e # (дорогая/expensive) чистка + рекомпрессия git-архивов

cargo install cargo-generate

cargo-generate gen --git git@github.com:aagern/cargogen.git projlogged -n smarthouse

cargo install cargo-wizard

cargo wizard

[package]
name = "ardan_workspace"
version = "0.1.0"
edition = "2021"

[dependencies]

[workspace]
members = [ 
  "session1/hello_world",
  "session1/variables",
]

<..>

[dependencies]
examplelib = { path = "../examplelib"}

use examplelib::function01; // фукнкция должна быть публичной (pub fn)

[dependencies]
anyhow.workspace = true

[workspace]
members = ["greeter"]

[workspace.dependencies]
anyhow = "1.0.99"

[dependencies]
anyhow = { workspace = true }

[dependencies] regex = { workspace = true, features = ["unicode"] }

cargo check
cargo tree

cargo install cargo-audit   # установить один раз
cargo audit                 # проверить проект

Crate:         regex
Version:       1.4.0
Title:         Regex panic on crafted input
Severity:      high
Solution:      upgrade to >= 1.5.0

- name: Security audit
  run: |
    cargo install cargo-audit
    cargo audit

1. Пишешь обычные unit-тесты (проверка очевидного)
   ↓
2. Добавляешь proptest (проверка неочевидного)
   ↓
3. Если есть unsafe → запускаешь Miri (проверка правил Rust)
   ↓
4. Для финальной проверки (опционально) → Valgrind
   ↓
5. Использование сторонних библиотек → Cargo Audit

name: Rust CI/CD Pipeline

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1

jobs:
  # Job 1: Format and Lint
  format-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: nightly
          components: rustfmt, clippy
          override: true
      - name: Format check
        run: cargo +nightly fmt -- --check
      - name: Clippy
        run: >-
          cargo clippy --all-targets --all-features --workspace
          -- -D warnings
        
  # Job 2: Build
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      
      - name: Build release
        run: cargo build --release
      
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: binary
          path: target/release/smarthouse

[dev-dependencies]
proptest = "1.4"

# Generate suppressions for false positives
valgrind --gen-suppressions=all ./target/debug/your_binary > valgrind.supp

name: Rust CI/CD Pipeline

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1

jobs:
  # Job 1: Format and Lint
  format-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: nightly
          components: rustfmt, clippy
          override: true
      - name: Format check
        run: cargo +nightly fmt -- --check
      - name: Clippy
        run: >-
          cargo clippy --all-targets --all-features --workspace
          -- -D warnings
        
  # Job 2: Build (original)
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      
      - name: Build release
        run: cargo build --release
      
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: binary
          path: target/release/smarthouse

  # NEW JOB 3: Security Audit (Cargo Audit)
  # Checks if any dependencies have known vulnerabilities
  security-audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      # Install and run cargo-audit
      - name: Install cargo-audit
        run: cargo install cargo-audit
      
      - name: Run security audit
        run: cargo audit
        # This will fail the build if any vulnerabilities found
        # Exit code 1 if vulnerabilities detected
      
  # NEW JOB 4: Property-based Testing (Proptest)
  # Runs extended tests with randomly generated data
  proptest:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      
      # Run tests including proptest (slower than regular tests)
      - name: Run property-based tests
        run: cargo test --release --lib -- --include-ignored proptest
        # --include-ignored runs proptest tests marked with #[ignore]
        # Proptest generates thousands of random inputs to find edge cases
      
      # Alternative: Run all tests with proptest enabled (no ignore)
      - name: Run all tests including proptest (alternative)
        run: cargo test --release -- --nocapture
        # This runs ALL tests, including proptest tests
        # Remove this if you prefer the filtered version above
      
  # NEW JOB 5: Unsafe Code Verification (Miri)
  # Checks for Undefined Behavior in unsafe Rust code
  # WARNING: Miri is VERY slow (100-1000x) but catches critical bugs
  miri-check:
    runs-on: ubuntu-latest
    # Only run if you actually have unsafe code
    # Add a condition to avoid slow checks on simple projects
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: nightly  # Miri requires nightly Rust
          components: miri
          override: true
      
      # Install Miri component
      - name: Install Miri
        run: |
          rustup +nightly component add miri
          cargo +nightly miri setup
      
      # Run Miri on tests (catches UB in unsafe code)
      - name: Run Miri on tests
        run: cargo +nightly miri test
        # This will find:
        # - Invalid memory access
        # - Data races in unsafe code
        # - Violations of Rust's aliasing rules
        # - Using uninitialized memory
      
      # Optional: Run Miri on the main binary
      - name: Run Miri on binary (optional)
        run: cargo +nightly miri run
        # Check if the main program has UB
        continue-on-error: true  # Don't fail the build if this fails
        # Miri is extremely slow, so this might timeout in CI
      
  # NEW JOB 6: Memory Analysis (Valgrind)
  # Finds memory leaks and invalid memory access in compiled binary
  # NOTE: Only useful if you have C/C++ dependencies or complex unsafe code
  valgrind-check:
    runs-on: ubuntu-latest
    # Only run on main branch (Valgrind is slow)
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      
      # Build with debug symbols for better Valgrind output
      - name: Build with debug symbols
        run: cargo build
      
      # Install Valgrind
      - name: Install Valgrind
        run: sudo apt-get update && sudo apt-get install -y valgrind
      
      # Run Valgrind on tests
      - name: Run Valgrind memory check
        run: |
          # Run each test binary through Valgrind
          for test in target/debug/deps/*; do
            if [ -x "$test" ] && [ ! -d "$test" ]; then
              valgrind --leak-check=full \
                       --error-exitcode=1 \
                       --suppressions=valgrind.supp \
                       "$test" 2>&1 | tee -a valgrind.log
            fi
          done
        # This finds:
        # - Memory leaks (Rust usually doesn't have them)
        # - Invalid reads/writes in C/C++ dependencies
        # - Use of uninitialized memory
        continue-on-error: true  # Don't fail the whole pipeline
      
      # Alternative: Run just the main binary
      - name: Run Valgrind on main binary (alternative)
        run: |
          valgrind --leak-check=full \
                   --error-exitcode=1 \
                   target/debug/smarthouse
        # Replace 'smarthouse' with your actual binary name
        continue-on-error: true

  # NEW JOB 7: Coverage Report (Optional)
  # Shows which parts of code are tested (complements Miri/Proptest)
  coverage:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install cargo-tarpaulin
        run: cargo install cargo-tarpaulin
      
      - name: Generate coverage report
        run: cargo tarpaulin --out Html --output-dir ./coverage
      
      - name: Upload coverage report
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: ./coverage

# Only run expensive jobs when unsafe code changes
miri-check:
  if: contains(github.event.pull_request.labels.*.name, 'unsafe-changes')
  
# Cache dependencies to speed up builds
- name: Cache cargo registry
  uses: actions/cache@v3
  with:
    path: ~/.cargo/registry
    key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}

cargo clippy --fix -- \
-W clippy::pedantic \
-W clippy::nursery \
-W clippy::unwrap_used \
-W clippy::expect_used

cargo install mdbook
# Run from top level of your rust-clippy directory:
mdbook serve book --open
# Goto http://localhost:3000 to see the book

#![allow(unused)]
fn main() {}

#![allow(dead_code)]
fn some_func() { todo!() }

rustup toolchain install nightly
rustup +nightly component add miri
cargo +nightly miri test


valgrind ./my_program  # программу уже скомпилировали

use std::alloc::{alloc, dealloc, Layout};

// BUG 1: Use-after-free (we'll read memory after freeing it)
fn use_after_free() -> u8 {
    let layout = Layout::new::<u8>();
    let ptr = unsafe { alloc(layout) };

    // Write something
    unsafe {
        *ptr = 42;
    }

    // Free the memory
    unsafe {
        dealloc(ptr, layout);
    }

    // BUG: Reading after free! This is undefined behavior.
    let value = unsafe { *ptr };
    value
}

// BUG 2: Memory leak (allocate but never free)
fn memory_leak() -> *mut u8 {
    let layout = Layout::new::<u8>();
    let ptr = unsafe { alloc(layout) };
    unsafe {
        *ptr = 99;
    }

    // BUG: We never call dealloc! The memory leaks.
    ptr
}

// BUG 3: Miri-specific - violating Rust's aliasing rules
fn aliasing_violation() {
    let mut x = 5;
    let raw_ptr = &mut x as *mut i32;

    // Create a second mutable pointer to the same memory
    let raw_ptr2 = &mut x as *mut i32;

    unsafe {
        // Miri catches this: two mutable references to same data in scope
        *raw_ptr = 10;
        *raw_ptr2 = 20; // Undefined behavior per Rust's Stacked Borrows rules
    }
}

fn main() {
    println!("Testing use-after-free...");
    let val = use_after_free();
    println!("Read value: {} (this might be garbage)", val);

    println!("\nLeaking memory...");
    let _leaked = memory_leak();
    println!("Memory leaked successfully!");

    println!("\nViolating aliasing rules...");
    aliasing_violation();
    println!("Aliasing violation completed (somehow)");
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_use_after_free() {
        let val = use_after_free();
        // We're just calling it - the bug is inside
        assert!(val == 42 || val != 42); // Always passes, but the UB is the problem
    }

    #[test]
    fn test_aliasing_violation() {
        aliasing_violation(); // Miri should catch this
    }
}

cargo install --locked panamax
panamax init ~/test/my-mirror

panamax sync ~/test/my-mirror

panamax serve ~/test/my-mirror

[source.my-mirror]
registry = "http://panamax.local/crates.io-index"
[source.crates-io]
replace-with = "my-mirror"

use proptest::prelude::*;

// Функция, которая должна работать для любых чисел
fn divide(a: i32, b: i32) -> i32 {
    a / b  // Ой! А если b = 0? Будет паника!
}

// Пишем свойство: "при любых a и b (где b != 0) деление работает"
proptest! {
    #[test]
    fn test_division_doesnt_panic(a: i32, b in 0..1000) {
        let result = divide(a, b);
        prop_assert!(result.is_finite());
    }
}