hardliner66/uaf - Change IGL4QVNKJN6CBABXN3DMDT62S6SQ4NX3CK7VHRSD47IUN5V6YJYAC

add readme and improve protocol

Created by hardliner66 on February 19, 2024

IGL4QVNKJN6CBABXN3DMDT62S6SQ4NX3CK7VHRSD47IUN5V6YJYAC

Dependencies

In channels

main

Change contents

File deletion: LOG.TXT

BF:BFD[3.1] → [2.4540:4571]

BF:BFD[2.4571] → [2.4572:4572]

B:BD[2.4572] → [2.4573:4981]

0{"type":"Message","from":null,"to":"35c87090-2182-4d5a-9a64-6cd105722066","payload":{"id":"35c87090-2182-4d5a-9a64-6cd105722066"}}
{"type":"Message","from":null,"to":"35c87090-2182-4d5a-9a64-6cd105722066","payload":{"id":"35c87090-2182-4d5a-9a64-6cd105722066"}}
{"type":"Message","from":"35c87090-2182-4d5a-9a64-6cd105722066","to":"35c87090-2182-4d5a-9a64-6cd105722066","payload":{"status":"ok","count":1}}

Replacement in src/main.rs at line 15 [4.49]

B:BD[4.387] → [5.51:95]

use uaf::{LogMessage, Message, SpawnActor};

[4.387]

[4.437]

use uaf::{Data, LogMessage, Message, Props};

Insertion in src/main.rs at line 21 [4.49]
[4.518]
[4.634]
```
    args: Vec<String>,
```
Replacement in src/main.rs at line 29 [4.49]
B:BD[2.235] → [2.235:264]
```
    spawn_actor: SpawnActor,
```
[2.235]
[2.264]
```
    spawn_actor: &Props,
```

Replacement in src/main.rs at line 31 [4.49]

B:BD[2.281] → [2.281:326]

    tx: UnboundedSender<(Uuid, SpawnActor)>,

[2.281]

[2.326]

    tx: UnboundedSender<(Uuid, Props)>,

Replacement in src/main.rs at line 44 [4.49]

B:BD[4.1049] → [2.629:718]

    let mut child = Command::new(spawn_actor.executable)
        .args(spawn_actor.args)

[4.1049]

[4.1094]

    let uuid = Uuid::new_v4();
    let mut child = Command::new(&spawn_actor.executable)
        .arg(uuid.to_string())
        .args(&spawn_actor.args)

Deletion in src/main.rs at line 52 [4.49]
B:BD[4.1208] → [4.1208:1240]
```
    let uuid = Uuid::new_v4();
```

Replacement in src/main.rs at line 59 [4.49]

B:BD[5.440] → [5.440:522]

                if let Ok(mut message) = serde_json::from_str::<Message>(&line) {

[5.440]

[5.522]

                if let Ok(mut message) = serde_json::from_str::<Data>(&line) {

Replacement in src/main.rs at line 64 [4.49]

B:BD[5.723] → [2.719:781]

                        if let Err(e) = other.send(message) {

[5.723]

[5.953]

                        if let Err(e) = other.send(Message::Data(message)) {

Replacement in src/main.rs at line 68 [4.49]

B:BD[5.1047] → [5.1047:1135]

                } else if let Ok(message) = serde_json::from_str::<SpawnActor>(&line) {

[5.1047]

[2.782]

                } else if let Ok(message) = serde_json::from_str::<Props>(&line) {

Replacement in src/main.rs at line 116 [4.49]

B:BD[2.1414] → [2.1414:1455]

            let init_message = Message {

[2.1414]

[2.1455]

            let init_message = Data {

Replacement in src/main.rs at line 123 [4.49]

B:BD[2.1621] → [2.1621:1655]

            tx.send(init_message)

[2.1621]

[2.1655]

            tx.send(Message::Data(init_message))

Replacement in src/main.rs at line 140 [4.49]

B:BD[4.2806] → [4.2806:2851]

    let Args { executable } = Args::parse();

[4.2806]

[4.2851]

    let Args { executable, args } = Args::parse();

Replacement in src/main.rs at line 142 [4.49]

B:BD[4.2852] → [2.1815:1900]

    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<(Uuid, SpawnActor)>();

[4.2852]

[2.1900]

    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<(Uuid, Props)>();

Replacement in src/main.rs at line 149 [4.49]

B:BD[2.2047] → [2.2047:2121]

                    match spawn_actor(request, false, tx.clone()).await {

[2.2047]

[2.2121]

                    match spawn_actor(&request, false, tx.clone()).await {

Replacement in src/main.rs at line 151 [4.49]

B:BD[2.2162] → [2.2162:2586]

                            let message = Message {
                                from: None,
                                to: uuid,
                                payload: serde_json::json!({
                                    "type": "spawned",
                                    "status": "ok",
                                    "id": new_uid,
                                }),
                            };

[2.2162]

[2.2586]

                            let message = Message::Spawned { id: Ok(new_uid), props: request };

Replacement in src/main.rs at line 157 [4.49]

B:BD[2.2836] → [2.2836:3242]

                            let message = Message {
                                from: None,
                                to: uuid,
                                payload: serde_json::json!({
                                    "type": "spawned",
                                    "status": "error",
                                    "error": format!("{e}"),
                                }),

[2.2836]

[2.3242]

                            let message = Message::Spawned {
                                id: Err(e.to_string()),
                                props: request,

Replacement in src/main.rs at line 172 [4.49]

B:BD[4.2893] → [2.3617:3777]

    _ = spawn_actor(
        SpawnActor {
            executable,
            args: Vec::new(),
        },
        true,
        tx.clone(),
    )
    .await?;

[4.2893]

[5.3549]

    _ = spawn_actor(&Props { executable, args }, true, tx.clone()).await?;

Replacement in src/lib.rs at line 6 [4.2938]
∅:D[5.3609] → [4.3035:3079]
B:BD[4.3035] → [4.3035:3079]
```
#[serde(tag = "type")]
pub struct Message {
```
[5.3609]
[5.3610]
```
pub struct Data {
```

Replacement in src/lib.rs at line 12 [4.2938]

B:BD[2.3779] → [2.3779:3864]

//'{"type": "message", "to": "73f31d83-a71e-4e32-a74a-263d3139f54d", "payload": {}}'

[2.3779]

[4.3167]

#[derive(Debug, Serialize, Deserialize)]
pub enum Message {
    Data(Data),
    Spawned { id: Result<Uuid, String>, props: Props },
}

Replacement in src/lib.rs at line 19 [4.2938]
∅:D[5.3698] → [4.3202:3225]
B:BD[4.3202] → [4.3202:3225]
B:BD[4.3225] → [5.3699:3723]
```
#[serde(tag = "type")]
pub struct SpawnActor {
```
[5.3698]
[5.3723]
```
pub struct Props {
```

Insertion in src/lib.rs at line 24 [4.2938]

[4.3281]


//'{"type": "message", "to": "73f31d83-a71e-4e32-a74a-263d3139f54d", "payload": {}}'

Deletion in src/lib.rs at line 28 [4.2938]
∅:D[5.3805] → [4.3316:3339]
B:BD[4.3316] → [4.3316:3339]
```
#[serde(tag = "type")]
```
Replacement in src/lib.rs at line 32 [4.2938]
B:BD[4.3462] → [4.3462:3463]
```
}
```
[4.3462]
```
}
```
Insertion in src/bin/test-actor.rs at line 1 [5.3861]
[5.3861]
[5.3893]
```
use clap::Parser;
```
Insertion in src/bin/test-actor.rs at line 4 [5.3861]
[2.3937]
[2.3937]
```
use stringlit::s;
```

Replacement in src/bin/test-actor.rs at line 6 [5.3861]

B:BD[2.3997] → [2.3997:4041]

use uaf::{LogMessage, Message, SpawnActor};

[2.3997]

[5.3979]

use uaf::{Data, LogMessage, Message, Props};
use uuid::Uuid;
#[derive(Debug, Parser)]
struct Args {
    my_id: Uuid,
    #[clap(default_value = "10")]
    max_count: usize,
}

Insertion in src/bin/test-actor.rs at line 34 [5.3861]
[5.4434]
[2.4088]
```
    let Args { max_count, .. } = Args::parse();
```

Replacement in src/bin/test-actor.rs at line 42 [5.3861]

B:BD[5.4628] → [5.4628:4835]

        let message: Message = serde_json::from_str(&line).expect("Failed to parse message");
        // Handle incoming data message
        log("info", &format!("Received message({count}): {message:?}"));

[5.4628]

[2.4276]

        match serde_json::from_str(&line).expect("Failed to parse message") {
            Message::Spawned { id, props } => match id {
                Ok(id) => log("info", &format!("Spawned actor {id}")),
                Err(e) => log("error", &format!("Failed to spawn actor ({props:?}): {e}")),
            },
            Message::Data(Data { from, to, payload }) => {
                // Handle incoming data message
                log(
                    "info",
                    &format!(
                        "Received message({count}): {:?}",
                        Data { from, to, payload }
                    ),
                );
                if count == 5 {
                    send_message(&Props {
                        executable: std::path::PathBuf::from("/usr/bin/cat"),
                        args: vec![s!("-h")],
                    });
                }

Replacement in src/bin/test-actor.rs at line 64 [5.3861]

B:BD[2.4277] → [2.4277:4482]

        if count == 5 {
            send_message(&SpawnActor {
                executable: std::path::PathBuf::from("/usr/bin/cat"),
                args: vec!["-h".to_string()],
            });
        }

[2.4277]

[2.4482]

//

Insertion in src/bin/test-actor.rs at line 66 [5.3861]

[2.4483]

[5.4835]

                if count >= max_count {
                    return;
                }

Replacement in src/bin/test-actor.rs at line 70 [5.3861]

B:BD[5.4836] → [2.4484:4528]

        if count == 8 {
            return;

[5.4836]

[2.4528]

                // Example of sending a message back
                let response = Data {
                    from: None,
                    to,
                    payload: serde_json::json!({"status": "ok", "count": count}),
                };
                send_message(&response);
            }

Deletion in src/bin/test-actor.rs at line 79 [5.3861]

B:BD[2.4538] → [2.4538:4539]

∅:D[2.4539] → [5.4836:5084]

B:BD[5.4836] → [5.4836:5084]


        // Example of sending a message back
        let response = Message {
            from: None,
            to: message.to,
            payload: serde_json::json!({"status": "ok", "count": count}),
        };
        send_message(&response);

File addition: README.md (----------)

[3.1]

# Unified Actor Framework
This is an experiment to use unix processes as actors.
## Getting Started
1) Get sources
   1) With pijul
   ```bash
   pijul clone https://nest.pijul.com/hardliner66/uaf
   ```
   2) With git
   ```bash
   git clone https://github.com/hardliner66/uaf
   ```
2) Build the framework and the test actor
```bash
cargo build --release --all
```
3) Run the test actor
```bash
./target/release/uaf ./target/release/test-actor
```