Fast inter-process RPC using shared memory

Rpc.fs

open SharedMemory
open MBrace.FsPickler

module Rpc =
    type RpcContext<'command, 'message> = 
        { name: string; buffer: RpcBuffer; post: 'command -> Async<'message>} with
        interface IDisposable with 
            member this.Dispose() = this.buffer.Dispose()

    let createHost name (handler : 'command -> Async<'message>) =
        let pickler = FsPickler.CreateBinarySerializer()        
        let onReceive data = Async.StartAsTask <| async {
                let command = pickler.UnPickle data
                let! message = handler command
                return pickler.Pickle message
        }
        { name = name; buffer = new RpcBuffer(name, (fun _ data -> onReceive data)); post = handler }
    
    let createClient name =
        let pickler = FsPickler.CreateBinarySerializer()        
        let buffer = new RpcBuffer(name)        
        let onSend command = async {
                let data = pickler.Pickle command
                let! response = buffer.RemoteRequestAsync data |> Async.AwaitTask
                if not response.Success then
                    failwith "Failed to get response"
                
                return pickler.UnPickle response.Data
        }            
        { name = name; buffer = new RpcBuffer(name); post = onSend }

usage

type Command = Print of string | Clear | Scroll
type Message = OK | Fail

let handler cmd = async {
       return
           match cmd with 
           | Print text -> Console.WriteLine text; OK
           | Clear -> Console.Clear(); OK
           | _ -> Fail
   }

use host = Rpc.createHost "test-rpc" handler
use client = Rpc.createClient "test-rpc"            
let result: Message = client.post (Print "Hello") |> Async.RunSynchronously // Returns OK

https://twitter.com/deviousasti/status/1289247538319462400
I'll make do with this for now - to be replaced Fable.Remoting.Ipc someday. 😉