azer0s / quacktors Goto Github PK

The verifier forwards a message to a Verificator and caches the message. As soon as the verifier gets a "Read" message, the cached message is removed. If the verifier gets a "DownMessage", a resend of all cached messages to the verifier is scheduled and the verifier restarts the verificator

At first we just want to be able to resolve and connect to a remote system

All tests should pass. The arch change to control channel is important so that there is no weird raisyness in the quit behaviour. This is testable via

for run in {1..50}; do go test -run TestGenServerCallWithTimeout; done

Great project is to still active?

Any plan to continue developing this framework?

This component is able to yield values to another PID.

type FileGenerator struct {
    Path string
}

func (f *FileGenerator) Run(ctx *yield.Context) error {
    file, err := os.Open(f.Path)
    if err != nil {
        return err
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        ctx.Yield(quacktors.StringMessage(scanner.Text()))
    }

    if err := scanner.Err(); err != nil {
        return err
    }

    return nil
}

pid := quacktors.Spawn(func(ctx *quacktors.Context, message quacktors.Message) {
    fmt.Println(m.Value)
})

g := yield.New(FileGenerator{Path: "/path/to/file.txt"})
g.AddReceiver(pid)

quacktors.SpawnStateful(g)

The link component would link two actors together. If one goes down, so does the other.

This will be tough but I want quacktors to be able to run on tinygo

Sometimes there is a blocking call. Which is weird cause Go should panic due to deadlock.
This either happens when killing an actor or while deleting the monitor abort channels. Consider adding mutex to both.

synchronizer.Call sends a message and expects a response

Panic message in genserver api is not very descriptive. Therefore it is not clear what caused this error.

Result:

Same as supervisor, but returns PIDs to relays that relay to the named PIDs of the supervisor component

Investigation required but as of right now, gob is suboptimal.
Thought about going for BSON + some custom encoder.
Want to, ideally, get rid of quacktors.Message and replace it with interface{}. This will make sending messages to remote actors more difficult tho as this would mean we'd have a lot of combinations for decoding.

As an extra project tho??