Skip to content

[8/11] feat: add exit/2 for sending exit signals to processes#77

Closed
unbalancedparentheses wants to merge 13 commits intolambdaclass:mainfrom
unbalancedparentheses:pr/8-exit-signal
Closed

[8/11] feat: add exit/2 for sending exit signals to processes#77
unbalancedparentheses wants to merge 13 commits intolambdaclass:mainfrom
unbalancedparentheses:pr/8-exit-signal

Conversation

@unbalancedparentheses
Copy link
Contributor

@unbalancedparentheses unbalancedparentheses commented Jan 8, 2026

Summary

Adds process_table::exit(from, to, reason) - the Erlang equivalent of exit(Pid, Reason) for sending exit signals to processes.

Behavior (follows Erlang semantics)

Reason Target trapping exits? Result
Kill Any Process is killed (untrappable)
Normal Self Process exits normally
Normal Other Ignored (can't force another to exit "normally")
Other No Process is killed with that reason
Other Yes Process receives SystemMessage::Exit

API

// Kill a process unconditionally
process_table::exit(my_pid, target_pid, ExitReason::Kill)?;

// Send a custom exit reason (will be trapped if target is trapping)
process_table::exit(my_pid, target_pid, ExitReason::error("shutdown requested"))?;

// Convenience for external shutdown requests
process_table::exit_self(target_pid, ExitReason::Shutdown)?;

Test plan

  • Test Kill is untrappable (even with trap_exit)
  • Test Normal to self exits normally
  • Test Normal to other process is ignored
  • Test error kills non-trapping process
  • Test error is trapped when trapping exits
  • Test Shutdown behavior
  • Test error on nonexistent process
  • Test exit_self convenience function
  • All 131 tests pass
  • Clippy clean

PR Chain

PR #8 in the stacked PR chain, building on PR #7 (typed registry).

🤖 Generated with Claude Code

@unbalancedparentheses
feat: unify GenServer with Backend enum for runtime selection
ce09417 
Consolidate the two separate GenServer implementations (async/tokio and
threads) into a single implementation with a Backend enum parameter.
Breaking change: start() now requires a Backend argument:
- Backend::Async - tokio async tasks (default)
- Backend::Blocking - tokio's blocking thread pool
- Backend::Thread - dedicated OS thread
This provides runtime flexibility without code duplication, allowing
users to mix different execution backends in the same application.
- Add Backend enum to gen_server.rs
- Change start() signature to accept Backend parameter
- Update all examples and tests
- Remove thread-based example crates
@unbalancedparentheses
test: add comprehensive tests for Backend enum
34b0ae3 
Add 10 new tests covering:
- Backend enum traits (Default, Copy, Clone, Debug, PartialEq, Eq)
- All three backends handle call/cast correctly
- Backend::Thread isolates blocking work from async runtime
- Multiple backends can run concurrently with independent state
- Backend::default() works in start()
@unbalancedparentheses
docs: add comprehensive Backend enum documentation
27ed72e 
Document each backend option with:
- Comparison table showing execution model, best use cases, and limitations
- Code examples for each backend
- Detailed "When to Use" guide with advantages and avoid-when advice
- Per-variant documentation with specific use cases
@unbalancedparentheses
test: add property-based testing and fuzzing for GenServer
143d5f3 
Property-based tests (proptest):
- Counter preserves initial state
- N increments result in initial + N
- Get is idempotent (multiple calls return same value)
- All backends produce working GenServers
- Multiple GenServers maintain independent state
- Cast followed by Get reflects the cast
Fuzzing (cargo-fuzz):
- Add fuzz target for GenServer operations
- Test random sequences of call/cast operations
- Verify state consistency across all backends
- Run with: cd concurrency/fuzz && cargo fuzz run fuzz_genserver_operations
@unbalancedparentheses
test: add integration tests for backend equivalence and cross-backend…
e57754e 
… communication

- Backend equivalence tests: verify all backends produce identical results
- Cross-backend communication: test GenServers on different backends calling each other
- Stress tests: concurrent operations, mixed call/cast
- Init/teardown: verify lifecycle hooks work on all backends
- State consistency: large operations, alternating operations
@unbalancedparentheses unbalancedparentheses mentioned this pull request Jan 8, 2026
Closed
4 tasks
unbalancedparentheses and others added 8 commits January 8, 2026 19:55
@unbalancedparentheses
refactor: flatten module structure, remove threads directory
5c08565 
- Remove concurrency/src/threads/ directory (replaced by Backend enum)
- Move files from concurrency/src/tasks/ to concurrency/src/
- Update all imports from spawned_concurrency::tasks:: to spawned_concurrency::
- Update internal crate imports accordingly
- Update examples README to reflect current architecture

The Backend enum (Async, Blocking, Thread) now provides all the
functionality previously split between tasks and threads modules,
offering a cleaner and more unified API.
@unbalancedparentheses
feat: add Pid and process linking primitives
eb45d5c 
- Add Pid struct with unique process identifiers (AtomicU64)
- Add HasPid trait for types that have a process ID
- Add ExitReason enum (Normal, Shutdown, Error, Killed)
- Add MonitorRef for tracking monitors
- Add SystemMessage enum (Down, Exit, Timeout)

These are the foundational types for OTP-style process management.
@unbalancedparentheses
feat: add global process table for link/monitor management
3270156 
- Add ProcessTable with global process tracking
- Implement bidirectional linking (link/unlink)
- Implement unidirectional monitoring (monitor/demonitor)
- Add trap_exit support for catching linked process exits
- Add SystemMessageSender trait for delivering DOWN/EXIT messages
- Handle exit propagation to linked processes

The process table is the central registry for all running processes
and manages the relationships between them.
@unbalancedparentheses
feat: add process registry for name-based lookup
5e831f2 
- Add global Registry for name -> Pid mapping
- Implement register/unregister functions
- Add whereis for name lookup
- Add name_of for reverse lookup (Pid -> name)
- Prevent duplicate names and multiple names per process
- Add comprehensive tests with mutex for isolation

Enables Erlang-style named processes for easier discovery.
@unbalancedparentheses
feat: add link/monitor/registry integration to tasks GenServer
bbb6aa8 
Integrate the Pid, link, monitor, and registry functionality into the
tasks-based GenServer:

- Add Pid field to GenServerHandle for process identification
- Implement HasPid trait for GenServerHandle
- Add system message handling via handle_info callback
- Add link/unlink methods for bidirectional process linking
- Add monitor/demonitor methods for process monitoring
- Add trap_exit/is_trapping_exit for exit signal handling
- Add register/unregister/registered_name for process registry
- Add start_linked and start_monitored convenience methods
- Update lib.rs to export link, pid, process_table, registry modules
- Add comprehensive Pid and registry tests
@unbalancedparentheses
feat: add Supervisor and DynamicSupervisor
10d4a45 
Implements Erlang/OTP-style supervision for fault-tolerant systems:

Supervisor:
- Manages a static set of child processes defined at start
- Monitors children and restarts them according to restart strategy
- Supports restart strategies: OneForOne, OneForAll, RestForOne
- Child specs with: restart type, shutdown behavior, child type

DynamicSupervisor:
- Manages dynamically spawned children
- Supports start_child/terminate_child for runtime management
- Configurable max_children limit

Features:
- Automatic restart on child crash (permanent, temporary, transient)
- Max restart intensity to prevent restart loops
- Graceful shutdown with configurable timeout
- Type-safe child handle abstraction
- Full integration with GenServer Backend system
- Comprehensive test suite (unit + integration tests)
@unbalancedparentheses @claude
feat: add typed registry with register_handle and lookup
eafa159 
Add support for storing and retrieving typed GenServerHandle<G> by name:

- register_handle<G>(): stores both Pid and typed handle
- lookup<G>(): returns Option<GenServerHandle<G>> for direct messaging
- has_handle(): checks if name has a typed handle stored

The existing register()/whereis() functions continue to work for
Pid-only registration. The typed registry enables name-based
messaging without keeping handle references:

    registry::register_handle("counter", handle)?;
    // Later, anywhere in the code:
    if let Some(h) = registry::lookup::<Counter>("counter") {
        h.call(Increment).await;
    }

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
@unbalancedparentheses @claude
feat: add exit/2 for sending exit signals to processes
014e802 
Add `process_table::exit(from, to, reason)` - the Erlang equivalent of
`exit(Pid, Reason)`. The behavior follows Erlang semantics:

- Kill: Unconditionally terminates the process (untrappable)
- Normal to self: Process exits normally
- Normal to other: Ignored (can't force another to exit "normally")
- Other reasons: Kills process, or sends EXIT message if trapping

Also adds `exit_self(pid, reason)` convenience function for external
shutdown requests.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
@unbalancedparentheses
Copy link
Contributor Author

unbalancedparentheses commented Jan 9, 2026

Reorganizing PR sequence for coherent implementation order. This content will be included in the new PR series.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@unbalancedparentheses