ipckit 0.1.6

A cross-platform IPC (Inter-Process Communication) library for Rust and Python
Documentation 
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! # ipckit
//!
//! A cross-platform IPC (Inter-Process Communication) library for Rust and Python.
//!
//! ## Features
//!
//! - **Pipes**: Anonymous and named pipes for parent-child process communication
//! - **Shared Memory**: Fast data sharing between processes using memory-mapped regions
//! - **Unix Domain Sockets / Named Pipes**: Bidirectional communication channels
//! - **Message Channels**: High-level message passing with serialization support
//! - **File Channel**: Simple file-based IPC for frontend-backend communication
//! - **Thread Channel**: High-performance intra-process thread communication
//! - **Event Stream**: Real-time publish-subscribe event system
//! - **Task Manager**: Task lifecycle management with progress tracking
//! - **Socket Server**: Multi-client socket server (like Docker's socket)
//! - **API Server**: HTTP-over-Socket RESTful API service
//! - **Metrics**: Performance monitoring and metrics collection
//! - **Waker**: Event loop integration for GUI/async frameworks
//!
//! ## Example
//!
//! ```rust,no_run
//! use ipckit::{NamedPipe, IpcError};
//!
//! fn main() -> Result<(), IpcError> {
//!     // Create a named pipe server
//!     let server = NamedPipe::create("my_pipe")?;
//!
//!     // In another process, connect as client
//!     // let client = NamedPipe::connect("my_pipe")?;
//!
//!     Ok(())
//! }
//! ```

pub mod api_server;
pub mod channel;
pub mod cli_bridge;
pub mod error;
pub mod event_stream;
pub mod file_channel;
pub mod graceful;
pub mod local_socket;
pub mod metrics;
pub mod pipe;
pub mod shm;
pub mod socket_server;
pub mod task_manager;
pub mod thread_channel;
pub mod waker;

// Async channel support
#[cfg(feature = "async")]
pub mod async_channel;

#[cfg(unix)]
pub mod unix;

#[cfg(windows)]
pub mod windows;

// Re-exports
pub use channel::{IpcChannel, IpcReceiver, IpcSender};
pub use error::{IpcError, Result};
pub use event_stream::{
    event_types, Event, EventBus, EventBusConfig, EventFilter, EventPublisher, EventSubscriber,
};
pub use file_channel::{FileChannel, FileMessage, MessageType as FileMessageType};
pub use graceful::{
    GracefulChannel, GracefulIpcChannel, GracefulNamedPipe, GracefulWrapper, OperationGuard,
    ShutdownState,
};
pub use local_socket::{LocalSocketListener, LocalSocketStream};
pub use pipe::{AnonymousPipe, NamedPipe, PipeReader, PipeWriter};
pub use shm::SharedMemory;
pub use socket_server::{
    Connection, ConnectionHandler, ConnectionId, ConnectionMetadata, FnHandler, Message,
    SocketClient, SocketServer, SocketServerConfig,
};
pub use task_manager::{
    CancellationToken, TaskBuilder, TaskFilter, TaskHandle, TaskInfo, TaskManager,
    TaskManagerConfig, TaskStatus,
};
pub use thread_channel::{ThreadChannel, ThreadReceiver, ThreadSender};

// API Server exports
pub use api_server::{
    ApiClient, ApiServer, ApiServerConfig, Method, PathPattern, Request, Response, ResponseBody,
    Router,
};

// Metrics exports
pub use metrics::{
    metered_pair, AggregatedMetrics, ChannelMetrics, IntoMetered, MeteredChannel, MeteredReceiver,
    MeteredSender, MeteredWrapper, MetricsSnapshot, WithMetrics,
};

// Waker exports
pub use waker::{
    BroadcastWaker, CallbackWaker, EventLoopWaker, ThreadWaker, WakeableChannel, WakeableWrapper,
};

#[cfg(feature = "async")]
pub use waker::TokioWaker;

// CLI Bridge exports
pub use cli_bridge::{
    parsers, CliBridge, CliBridgeConfig, CommandOutput, OutputType, ProgressInfo, ProgressParser,
    WrappedChild, WrappedCommand, WrappedWriter,
};

// Async channel exports
#[cfg(feature = "async")]
pub use async_channel::{AsyncIpcChannel, AsyncIpcReceiver, AsyncIpcSender};

#[cfg(feature = "async")]
pub use async_channel::tokio_channel::{
    AsyncThreadChannel, AsyncThreadReceiver, AsyncThreadSender,
};

#[cfg(feature = "async")]
pub use async_channel::{broadcast, oneshot};

// Async local socket exports (when both async and backend-interprocess features are enabled)
#[cfg(all(feature = "async", feature = "backend-interprocess"))]
pub use local_socket::{AsyncLocalSocketListener, AsyncLocalSocketStream};

// Python bindings (organized into submodules for better maintainability)
#[cfg(feature = "python-bindings")]
pub mod bindings;

#[cfg(feature = "python-bindings")]
pub use bindings::*;