product-os-command-control 0.0.27

Product OS : Command and Control provides a set of tools for running command and control across a distributed set of Product OS : Servers.
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

# Product OS : Command and Control

[![Crates.io](https://img.shields.io/crates/v/product-os-command-control)](https://crates.io/crates/product-os-command-control)
[![Documentation](https://docs.rs/product-os-command-control/badge.svg)](https://docs.rs/product-os-command-control)
[![License: GPL-3.0](https://img.shields.io/badge/License-GPL%203.0-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

Product OS : Command and Control provides a distributed command and control system for coordinating multiple Product OS server instances. It enables secure communication, service discovery, and workload distribution across a cluster of nodes.

## What is Product OS?

Product OS is a collection of packages that provide different tools and features that can work together to build products more easily for the Rust ecosystem.

## Features

- **Secure Communication**: Authentication framework using Diffie-Hellman key exchange
- **Service Discovery**: Automatic node registration and discovery
- **Load Balancing**: Smart routing to available nodes based on capabilities
- **Health Monitoring**: Pulse checks and automatic failure detection
- **Feature Management**: Dynamic feature and service registration
- **No-std Support**: Works in `no_std` environments with alloc

## Installation

Add Product OS : Command and Control to your `Cargo.toml`:

```toml
[dependencies]
product-os-command-control = { version = "0.0.25" }
```

## Quick Start

```rust
use product_os_command_control::ProductOSController;
use product_os_configuration::Configuration;
use product_os_security::certificates::Certificates;

async fn example() {
    // Create configuration and certificates
    let config = Configuration::new();
    let certs = Certificates::new_self_signed(
        vec![("CN".to_string(), "localhost".to_string())],
        None, None, None, None, None,
    );

    // Initialize the controller
    let controller = ProductOSController::new(
        config,
        certs,
        None, // Optional key-value store
    );

    // Access the registry
    let registry = controller.get_registry();
    let my_node = registry.get_me();
    println!("Node ID: {}", my_node.get_identifier());
}
```

## Feature Flags

- `default`: Standard library support with monitoring
- `monitor`: Enable monitoring service
- `tokio`: Enable Tokio async executor
- `distributed`: Enable distributed node discovery and communication
- `postgres_store`: PostgreSQL relational store support
- `sqlite_store`: SQLite relational store support
- `redis_key_value_store`: Redis key-value store support
- `memory_key_value_store`: In-memory key-value store support
- `file_key_value_store`: File-based key-value store support
- `redis_queue_store`: Redis queue store support
- `memory_queue_store`: In-memory queue store support

## Architecture

The command and control system consists of several key components:

- **ProductOSController**: Main coordinator that manages nodes and services
- **Registry**: Tracks available nodes and their capabilities
- **Node**: Represents a single server instance in the cluster
- **Commands**: Structured way to send instructions to remote nodes

## Security

All node-to-node communication is secured using:
- TLS/SSL certificates for transport security
- Diffie-Hellman key exchange for establishing shared secrets
- Message authentication using HMAC

## Service Management

```rust
use product_os_command_control::ProductOSController;
use std::sync::Arc;

async fn manage_services(controller: &mut ProductOSController) {
    // Add a service
    let service = /* ... */;
    controller.add_service(service).await;
    
    // Start all services
    controller.start_services().await;
    
    // Start a specific service
    controller.start_service("my-service").await;
    
    // Stop a service
    controller.stop_service("my-service").await;
}
```

## Node Discovery

```rust
use product_os_command_control::ProductOSController;

async fn discover(controller: &mut ProductOSController) {
    // Discover other nodes in the cluster
    controller.discover_nodes().await;
    
    // Get the registry with all known nodes
    let registry = controller.get_registry();
}
```

## Testing

```bash
# Run all tests
cargo test --all-features

# Run with specific features
cargo test --features "monitor,tokio"

# Generate documentation
cargo doc --all-features --open
```

## License

[GNU GPLv3](https://choosealicense.com/licenses/gpl-3.0/)

## Contributing

Contributions are welcome! Please ensure:

- All tests pass: `cargo test --all-features`
- Code is formatted: `cargo fmt`
- No clippy warnings: `cargo clippy --all-features`
- Documentation is updated for public APIs

## Minimum Supported Rust Version (MSRV)

Rust 1.69 or later.