considerations

Context

• https://godoc.org/golang.org/x/net/context

---

executable

runtime

• nodeinfo mgt

  • self info (lib/node)
  • other node info (lib/node)
    • nodename -> {rpcaddr, live}

• module mgt

  • each module is a resource mgr
    • has wrappers for resource access
    • has dynamic argument type checking

• rpc call/return

  • rpc basedef (lib/rpcdef)
  • call dispatcher (lib/callret)

• node smurf mgt

  • add node (onboarding, accesses w/ source-node/addr)
  • simple builtin query
  • device mgt function
    • nodes in a device (CRUD)
    • modules in a node (CRUD)

• node deployment

system modules

• wrap node smuft mgt (enabled/disabled)

• system module #1: node deployer

  • node deploy function wrappers (so that RPC can access them)

module compiler

• .mgo -> .go transformation
  • server-side code gen (to be imported)
  • client-side code gen (to be imported)

node deployer (lib/deploy)

• generate: driver/scaffolding code
  • main.go
    • all deployment-time customization code
  • register.go (for modules)
    • registers modules
      • registers resources to module
    • import server-side code
    • import client-side code
• invoke "go compile"

=======================================================================================
[mg_runtime]

0. Handles to runtime data structures
   - MGRT_RPCAddr
   - MGRT_Device
   - MGRT_Module
   - MGRT_Resource

1. node info
   a. self info
      - MGRT_Self() string
   b. remote node table
      - MGRT_LookupDevice("dev0")
      - MGRT_AddDevice("dev1")
      - MGRT_NewRPCAddr("192.168.8.192') MG_RPCAddr
      - MGRT_RegisterDevice("dev1", addr MG_RPCAddr)

2. local modules
   a. module CRUD
      - MGRT_GetModule()
      - MGRT_NewProp()
      - MGRT_NewEvent()
      - MGRT_NewFunc()
      - MGRT_NewProc()

3. local resources
   a. resource access
      - MGRT_Call()
      - MGRT_Return()
      - MGRT_Cancel()


=======================================================================================
[mg_security]
   a. MG_GetKey() key


=======================================================================================
[mg_resource]
1. registration  (not for user)
   a. module
      - MG_RegisterModule("m0")
   b. local resource
      - MG_RegisterEvent("m0", "ev0")
      - MG_RegisterTimer("m0", "t0", time)
      - MG_RegisterProp("m0", "p0", R.GetPropF, R.SetPropF)
      - MG_RegisterFunc("m0", "func", R.CallFuncF)
      - MG_RegisterProc("m0", "proc", R.ProcF(startchan, stopchan, resumechan))
   c. remote resource (proxy)
      - MG_RegisterRemoteEvent("erdos:ev0") (or MG_Subscribe)
2. resource access  (user)
   a. local resource
      - MG_Get("erdos:m0", "p0")
      - MG_Set("erdos:m0", "p0", 3.14)
      - MG_Call(".", "SaveState", GetTime()) retval
      - MG_Fire("ev0", value)
      - MG_Wait("ev1") value
      - MG_Run(".", "proc0")
      - MG_Stop(".", "proc0")
      - MG_Resume(".", "proc0")
      - MG_Quit(".", "proc0")
      - MG_Save(".", "proc0", "savename")  // save what? values @which time?, if midstate
      - MG_Restore(".", "proc0", "restorename")
   b. remote resource
      - MG_Wait("erdos:ev0") value

3.

===
* Notion of primitives;  mg_prim.go;   then customize/call it
====
[initiation]
  * server
    - register.go
      - import S0 "github.com/modgo/mods/counter/impl"
      - func RegisterModules() {
         S0.Register("custom data")
        }
    - main.go

  * client
    - my code.go

[callout flow]
  * MG_Call("erdos:m0", "foo", 10)
    - CODEGEN:
      - import X0 "github.com/modgo/mods/counter/export"
      - X0.type decls included
        - // binding time when (1) compile-time (2) node smurf deploy time (3) run-time
      - X0.BindDevice("erdos", "m0")
      - ??? C0.foo(arg)
      - X0.foo(arg) {
           // should be bound already
           if Unbound() error()
           retval := MGRT_FuncCall("erdos", "m0", "foo", arg)
        }

    - CODEGEN: retval := MGRT_FuncCall("erdos", "m0", "foo", 10)
      - callret.FuncCall()
        - calldata := outseq.Leave()
        - m := ComposeMessage()
        - outputQ <- m
        - WaitCallid(calldata) // blocking wait

[callin flow]
  * callret.dispatcher
    - m := inq;
    - res := getmod("m0").getresource(m.body.resource)
    - res.Call(tok, m.Body.Args)
      - f.callf(args)
        - argument type checking(?)

          - import X0 "github.com/devel/mods/counter"
          - MG_FooWrapper(args) {
              at := args.{X0.Type}
            }