Data commit

Task/Distributed-programming/Wren/distributed-programming-1.wren

@@ -0,0 +1,20 @@
+/* distributed_programming_server.wren */
+
+class Rpc {
+    foreign static register()
+
+    foreign static handleHTTP()
+}
+
+foreign class Listener {
+    construct listen(network, address) {}
+}
+
+class HTTP {
+    foreign static serve(listener)
+}
+
+Rpc.register()
+Rpc.handleHTTP()
+var listener = Listener.listen("tcp", ":1234")
+HTTP.serve(listener)

Task/Distributed-programming/Wren/distributed-programming-2.wren

@@ -0,0 +1,8 @@
+/* distributed_programming_server2.wren */
+
+class TaxComputer {
+    static tax(amount, rate) {
+        if (amount < 0) Fiber.abort("Negative values not allowed.")
+        return amount * rate
+    }
+}

Task/Distributed-programming/Wren/distributed-programming-3.wren

@@ -0,0 +1,85 @@
+/* go run distributed_programming_server.go */
+
+package main
+
+import(
+    wren "github.com/crazyinfin8/WrenGo"
+    "log"
+    "net"
+    "net/http"
+    "net/rpc"
+)
+
+type any = interface{}
+
+type TaxComputer float64
+
+var vm2 *wren.VM
+
+var fileName  = "distributed_programming_server.wren"
+var fileName2 = "distributed_programming_server2.wren"
+
+func (taxRate TaxComputer) Tax(x float64, r *float64) error {
+    wrenVar, _ := vm2.GetVariable(fileName2, "TaxComputer")
+    wrenClass, _ := wrenVar.(*wren.Handle)
+    defer wrenClass.Free()
+    wrenMethod, _ := wrenClass.Func("tax(_,_)")
+    defer wrenMethod.Free()
+    ret, _ := wrenMethod.Call(x, float64(taxRate))
+    *r = ret.(float64)
+    return nil
+}
+
+func register(vm *wren.VM, parameters []any) (any, error) {
+    c := TaxComputer(0.05) // 5% tax rate
+    rpc.Register(c)
+    return nil, nil
+}
+
+func handleHTTP(vm *wren.VM, parameters []any) (any, error) {
+    rpc.HandleHTTP()
+    return nil, nil
+}
+
+func serve(vm *wren.VM, parameters []any) (any, error) {
+    handle := parameters[1].(*wren.ForeignHandle)
+    ifc, _ := handle.Get()
+    listener := ifc.(*net.Listener)
+    http.Serve(*listener, nil)
+    return nil, nil
+}
+
+func listen(vm *wren.VM, parameters []any) (any, error) {
+    network := parameters[1].(string)
+    address := parameters[2].(string)
+    listener, err := net.Listen(network, address)
+    if err != nil {
+        log.Fatal(err)
+    }
+    return &listener, nil
+}
+
+func main() {
+    vm := wren.NewVM()
+    vm2 = wren.NewVM()
+    vm2.InterpretFile(fileName2)
+
+    rpcMethodMap := wren.MethodMap {
+        "static register()": register,
+        "static handleHTTP()": handleHTTP,
+    }
+
+    httpMethodMap := wren.MethodMap { "static serve(_)":serve }
+
+    classMap := wren.ClassMap {
+        "Listener": wren.NewClass(listen, nil, nil),
+        "Rpc"     : wren.NewClass(nil, nil, rpcMethodMap),
+        "HTTP"    : wren.NewClass(nil, nil, httpMethodMap),
+    }
+
+    module := wren.NewModule(classMap)
+    vm.SetModule(fileName, module)
+    vm.InterpretFile(fileName)
+    vm.Free()
+    vm2.Free()
+}

Task/Distributed-programming/Wren/distributed-programming-4.wren

@@ -0,0 +1,16 @@
+/* distributed_programming_client.wren */
+
+import "./fmt" for Fmt
+
+foreign class Client {
+    construct dialHTTP(network, address) {}
+
+    foreign call(serviceMethod, arg)
+}
+
+var client = Client.dialHTTP("tcp", "localhost:1234")
+var amounts = [3, 5.6]
+for (amount in amounts) {
+    var tax = client.call("TaxComputer.Tax", amount)
+    Fmt.print("Tax on $0.2f = $0.2f", amount, tax)
+}

Task/Distributed-programming/Wren/distributed-programming-5.wren

@@ -0,0 +1,56 @@
+/* go run distributed_programming_client.go */
+
+package main
+
+import(
+    wren "github.com/crazyinfin8/WrenGo"
+    "log"
+    "net/rpc"
+    "strings"
+)
+
+type any = interface{}
+
+func dialHTTP(vm *wren.VM, parameters []any) (any, error) {
+    network := parameters[1].(string)
+    address := parameters[2].(string)
+    client, err := rpc.DialHTTP(network, address)
+    if err != nil {
+        log.Fatal(err)
+    }
+    return &client, nil
+}
+
+func call(vm *wren.VM, parameters []any) (any, error) {
+    handle := parameters[0].(*wren.ForeignHandle)
+    ifc, _ := handle.Get()
+    client := ifc.(**rpc.Client)
+    serviceMethod := parameters[1].(string)
+    amount := parameters[2].(float64)
+    var tax float64
+    err := (*client).Call(serviceMethod, amount, &tax)
+    if err != nil {
+        log.Fatal(err)
+    }
+    return tax, nil
+}
+
+func moduleFn(vm *wren.VM, name string) (string, bool) {
+    if name != "meta" && name != "random" && !strings.HasSuffix(name, ".wren") {
+        name += ".wren"
+    }
+    return wren.DefaultModuleLoader(vm, name)
+}
+
+func main() {
+    cfg := wren.NewConfig()
+    cfg.LoadModuleFn = moduleFn
+    vm := cfg.NewVM()
+    fileName := "distributed_programming_client.wren"
+    clientMethodMap := wren.MethodMap { "call(_,_)": call }
+    classMap := wren.ClassMap { "Client": wren.NewClass(dialHTTP, nil, clientMethodMap) }
+    module := wren.NewModule(classMap)
+    vm.SetModule(fileName, module)
+    vm.InterpretFile(fileName)
+    vm.Free()
+}