342 lines
8.1 KiB
Markdown
342 lines
8.1 KiB
Markdown
# OSIRIS Multi-Instance Support ✅
|
|
|
|
OSIRIS now supports multiple instances in a single Rhai script, allowing you to work with different HeroDB databases simultaneously.
|
|
|
|
## 🎉 Status: FULLY OPERATIONAL
|
|
|
|
```
|
|
✅ OsirisInstance type created
|
|
✅ Dynamic instance creation
|
|
✅ Independent storage per instance
|
|
✅ Same note/event in multiple instances
|
|
✅ Test script working
|
|
```
|
|
|
|
## 🚀 Quick Start
|
|
|
|
### Create Multiple Instances
|
|
|
|
```rhai
|
|
// Create two OSIRIS instances pointing to different databases
|
|
let freezone = osiris("freezone", "redis://localhost:6379", 1);
|
|
let my_osiris = osiris("my_osiris", "redis://localhost:6379", 2);
|
|
|
|
// Create a note
|
|
let my_note = note("notes")
|
|
.title("Shared Note")
|
|
.content("This will be stored in both instances");
|
|
|
|
// Store in both instances
|
|
let id1 = freezone.put_note(my_note);
|
|
let id2 = my_osiris.put_note(my_note);
|
|
```
|
|
|
|
## 📝 Complete Example
|
|
|
|
```rhai
|
|
// Multi-Instance OSIRIS Example
|
|
|
|
print("Creating OSIRIS instances...");
|
|
let freezone = osiris("freezone", "redis://localhost:6379", 1);
|
|
let my_osiris = osiris("my_osiris", "redis://localhost:6379", 2);
|
|
|
|
print(`Created: ${freezone.name()}`);
|
|
print(`Created: ${my_osiris.name()}`);
|
|
|
|
// Create a note
|
|
let my_note = note("shared_notes")
|
|
.title("Multi-Instance Test")
|
|
.content("Stored in multiple OSIRIS instances")
|
|
.tag("shared", "true");
|
|
|
|
// Store in freezone
|
|
let freezone_id = freezone.put_note(my_note);
|
|
print(`Stored in freezone: ${freezone_id}`);
|
|
|
|
// Store in my_osiris
|
|
let my_id = my_osiris.put_note(my_note);
|
|
print(`Stored in my_osiris: ${my_id}`);
|
|
|
|
// Retrieve from each
|
|
let note1 = freezone.get_note("shared_notes", freezone_id);
|
|
let note2 = my_osiris.get_note("shared_notes", my_id);
|
|
|
|
// Query each instance
|
|
let ids1 = freezone.query("shared_notes", "tags:tag", "shared=true");
|
|
let ids2 = my_osiris.query("shared_notes", "tags:tag", "shared=true");
|
|
```
|
|
|
|
## 🎯 Use Cases
|
|
|
|
### 1. **Multi-Tenant Systems**
|
|
```rhai
|
|
// Each tenant has their own OSIRIS instance
|
|
let tenant1 = osiris("tenant1", "redis://localhost:6379", 1);
|
|
let tenant2 = osiris("tenant2", "redis://localhost:6379", 2);
|
|
|
|
// Store tenant-specific data
|
|
tenant1.put_note(tenant1_note);
|
|
tenant2.put_note(tenant2_note);
|
|
```
|
|
|
|
### 2. **Data Replication**
|
|
```rhai
|
|
// Primary and backup instances
|
|
let primary = osiris("primary", "redis://primary:6379", 1);
|
|
let backup = osiris("backup", "redis://backup:6379", 1);
|
|
|
|
// Store in both
|
|
primary.put_note(note);
|
|
backup.put_note(note);
|
|
```
|
|
|
|
### 3. **Environment Separation**
|
|
```rhai
|
|
// Development and production
|
|
let dev = osiris("dev", "redis://dev:6379", 1);
|
|
let prod = osiris("prod", "redis://prod:6379", 1);
|
|
|
|
// Test in dev first
|
|
dev.put_note(test_note);
|
|
|
|
// Then promote to prod
|
|
prod.put_note(test_note);
|
|
```
|
|
|
|
### 4. **Cross-Database Operations**
|
|
```rhai
|
|
// Different databases for different data types
|
|
let notes_db = osiris("notes", "redis://localhost:6379", 1);
|
|
let events_db = osiris("events", "redis://localhost:6379", 2);
|
|
|
|
notes_db.put_note(note);
|
|
events_db.put_event(event);
|
|
```
|
|
|
|
## 📚 API Reference
|
|
|
|
### Creating an Instance
|
|
|
|
```rhai
|
|
let instance = osiris(name, url, db_id);
|
|
```
|
|
|
|
**Parameters:**
|
|
- `name` (string) - Instance name for identification
|
|
- `url` (string) - HeroDB connection URL
|
|
- `db_id` (int) - Database ID (0-15 typically)
|
|
|
|
**Returns:** `OsirisInstance`
|
|
|
|
### Instance Methods
|
|
|
|
#### `name()`
|
|
Get the instance name.
|
|
|
|
```rhai
|
|
let name = instance.name();
|
|
print(`Instance: ${name}`);
|
|
```
|
|
|
|
#### `put_note(note)`
|
|
Store a note in this instance.
|
|
|
|
```rhai
|
|
let id = instance.put_note(note);
|
|
```
|
|
|
|
**Returns:** Note ID (string)
|
|
|
|
#### `get_note(namespace, id)`
|
|
Retrieve a note from this instance.
|
|
|
|
```rhai
|
|
let note = instance.get_note("notes", id);
|
|
```
|
|
|
|
**Returns:** Note object
|
|
|
|
#### `put_event(event)`
|
|
Store an event in this instance.
|
|
|
|
```rhai
|
|
let id = instance.put_event(event);
|
|
```
|
|
|
|
**Returns:** Event ID (string)
|
|
|
|
#### `get_event(namespace, id)`
|
|
Retrieve an event from this instance.
|
|
|
|
```rhai
|
|
let event = instance.get_event("calendar", id);
|
|
```
|
|
|
|
**Returns:** Event object
|
|
|
|
#### `query(namespace, field, value)`
|
|
Query by indexed field in this instance.
|
|
|
|
```rhai
|
|
let ids = instance.query("notes", "title", "My Note");
|
|
```
|
|
|
|
**Returns:** Array of IDs
|
|
|
|
#### `delete_note(note)`
|
|
Delete a note from this instance.
|
|
|
|
```rhai
|
|
let deleted = instance.delete_note(note);
|
|
```
|
|
|
|
**Returns:** Boolean (true if deleted)
|
|
|
|
#### `delete_event(event)`
|
|
Delete an event from this instance.
|
|
|
|
```rhai
|
|
let deleted = instance.delete_event(event);
|
|
```
|
|
|
|
**Returns:** Boolean (true if deleted)
|
|
|
|
## 🏗️ Architecture
|
|
|
|
```
|
|
┌─────────────────────────────────────┐
|
|
│ Rhai Script │
|
|
│ let freezone = osiris(...); │
|
|
│ let my_osiris = osiris(...); │
|
|
└────────────┬────────────────────────┘
|
|
│
|
|
┌────────────▼────────────────────────┐
|
|
│ OsirisInstance (Clone) │
|
|
│ - name: String │
|
|
│ - store: Arc<GenericStore> │
|
|
│ - runtime: Arc<Runtime> │
|
|
└────┬───────────────────┬────────────┘
|
|
│ │
|
|
┌────▼──────────┐ ┌───▼───────────┐
|
|
│ HeroDB DB 1 │ │ HeroDB DB 2 │
|
|
│ (freezone) │ │ (my_osiris) │
|
|
└───────────────┘ └───────────────┘
|
|
```
|
|
|
|
## ✨ Features
|
|
|
|
### 1. **Independent Storage**
|
|
Each instance maintains its own storage, indexes, and namespaces.
|
|
|
|
### 2. **Shared Objects**
|
|
The same note or event object can be stored in multiple instances.
|
|
|
|
### 3. **Clone-Safe**
|
|
Instances are cloneable and can be passed around in scripts.
|
|
|
|
### 4. **Error Isolation**
|
|
Errors in one instance don't affect others.
|
|
|
|
### 5. **Named Instances**
|
|
Each instance has a name for easy identification in logs and errors.
|
|
|
|
## 🧪 Testing
|
|
|
|
### Run the Multi-Instance Test
|
|
|
|
```bash
|
|
cargo run --bin runner --features rhai-support -- test1 --script-file scripts/multi_instance.rhai
|
|
```
|
|
|
|
### Expected Output
|
|
|
|
```
|
|
=== Multi-Instance OSIRIS Test ===
|
|
|
|
Creating OSIRIS instances...
|
|
✓ Created: freezone
|
|
✓ Created: my_osiris
|
|
|
|
Creating note...
|
|
Note created: Multi-Instance Test Note
|
|
|
|
Storing in freezone...
|
|
✓ Stored in freezone with ID: c274731c-678d-4f3e-bc4a-22eb70dae698
|
|
|
|
Storing in my_osiris...
|
|
✓ Stored in my_osiris with ID: c274731c-678d-4f3e-bc4a-22eb70dae698
|
|
|
|
Retrieving from freezone...
|
|
✓ Retrieved from freezone: Multi-Instance Test Note
|
|
|
|
Retrieving from my_osiris...
|
|
✓ Retrieved from my_osiris: Multi-Instance Test Note
|
|
|
|
Querying freezone...
|
|
✓ Found in freezone:
|
|
- c274731c-678d-4f3e-bc4a-22eb70dae698
|
|
|
|
Querying my_osiris...
|
|
✓ Found in my_osiris:
|
|
- c274731c-678d-4f3e-bc4a-22eb70dae698
|
|
|
|
=== Test Complete ===
|
|
✅ Script completed successfully!
|
|
```
|
|
|
|
## 💡 Best Practices
|
|
|
|
### 1. **Use Descriptive Names**
|
|
```rhai
|
|
// Good
|
|
let production = osiris("production", url, 1);
|
|
let staging = osiris("staging", url, 2);
|
|
|
|
// Less clear
|
|
let db1 = osiris("db1", url, 1);
|
|
let db2 = osiris("db2", url, 2);
|
|
```
|
|
|
|
### 2. **Centralize Instance Creation**
|
|
```rhai
|
|
// Create all instances at the start
|
|
let freezone = osiris("freezone", "redis://localhost:6379", 1);
|
|
let my_osiris = osiris("my_osiris", "redis://localhost:6379", 2);
|
|
|
|
// Then use them throughout the script
|
|
freezone.put_note(note1);
|
|
my_osiris.put_note(note2);
|
|
```
|
|
|
|
### 3. **Handle Errors Per Instance**
|
|
```rhai
|
|
// Each instance can fail independently
|
|
try {
|
|
freezone.put_note(note);
|
|
} catch (e) {
|
|
print(`Freezone error: ${e}`);
|
|
}
|
|
|
|
try {
|
|
my_osiris.put_note(note);
|
|
} catch (e) {
|
|
print(`My OSIRIS error: ${e}`);
|
|
}
|
|
```
|
|
|
|
### 4. **Use Different Databases**
|
|
```rhai
|
|
// Separate databases for isolation
|
|
let instance1 = osiris("inst1", "redis://localhost:6379", 1);
|
|
let instance2 = osiris("inst2", "redis://localhost:6379", 2);
|
|
```
|
|
|
|
## 🎉 Success!
|
|
|
|
Multi-instance OSIRIS support is **fully operational** and ready for:
|
|
- ✅ Multi-tenant applications
|
|
- ✅ Data replication
|
|
- ✅ Environment separation
|
|
- ✅ Cross-database operations
|
|
- ✅ Production use
|