@naanlang/naan 1.0.0

package/plugins/serviceAws/lambda_naan_control.nlg

@@ -0,0 +1,175 @@
+/*
+ * lambda_naan_control.nlg
+ * serviceAws
+ *
+ *     Access remote AWS lambda from local Naan.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2019-2021 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * lancoRest
+ *
+ *    REST interface to the remote lambda.
+ *
+ */
+
+closure lancoRest(local url, client) {
+    client = new(object, this)
+    client.url = "https://s3cn49ir43.execute-api.us-east-1.amazonaws.com"
+
+    // clientRequest() - general request routine
+
+    closure clientRequest(method, path, options, cbReq, local request) {
+        request = xnew(js.w.XMLHttpRequest)
+        request.addEventListener("load", function (event) {
+            cbReq(false, request, event)
+        })
+
+        request.addEventListener("error", function reqFailed(event, local errtext) {
+            if request.status == 0
+                errtext = "connectivity"
+            ellse
+                errtext = "request failed"
+            error = Error(errtext, {
+                status: request.status
+                method: method
+                path: path
+            })
+            cbReq(error, request, event)
+        })
+
+        request.open(method, path, true)
+        if options.responseType
+            request.responseType = options.responseType
+        request.send(options.putdata)
+    }
+
+    //
+    // test()
+    //
+
+    client.test = closure test() {
+        clientRequest("GET", client.url.concat("/"), false, function (error, req, event) {
+            printline(req.responseText)
+        })
+    }
+    
+    // finis
+    
+    client
+};
+
+
+/*
+ * lancoWs
+ *
+ *    WebSockets interface to the remote lambda.
+ *
+ */
+
+closure lancoWs(local url, laws) {
+    laws = new(object, this)
+    laws.url = "wss://8h5htw8bfj.execute-api.us-east-1.amazonaws.com/dev"
+    laws.name = name
+    
+    // connect
+    // Connect with the host if not already connected.
+    function connect() {
+        if !laws.ws
+            laws.ws = xnew(js.w.WebSocket, laws.url)
+    
+        // onopen
+        // The WebSocket connection is now open.
+        laws.ws.onopen = function onopen(e) {
+            debuglog("ws open")
+        }
+
+        // onmessage
+        // A message was received from the worker via WebSockets.
+        
+        laws.ws.onmessage = function onmessage(e, local message, msg) {
+            laws.doMessage(e.data)
+        }
+        
+        // onerror
+        // An error occurred on the WebSocket connection.
+        laws.ws.onerror = function onerror(e) {
+            debuglog("ws error:", totuple(e))
+        }
+        
+        // onclose
+        // The WebSocket connection was closed.
+        laws.ws.onclose = function onclose(e) {
+            debuglog("ws close:", e.code, e.reason)
+            laws.ws = false
+        }
+    }
+    
+    //
+    // doMessage
+    //
+    //     Process the specified undecoded message.
+    laws.doMessage = function doMessage(text, local message, msg) {
+        try {
+            message = new(JSONparse(text))
+        } catch {
+            if true
+                return (debuglog("can't decode incoming ws message:", exception))
+        }
+        if message.respOp == "msgout"
+            { }
+        else
+            debuglog("unknown host response message:", message.respOp)
+    }
+    
+    //
+    // sendControl
+    //
+    //     Send a message to the worker controller.
+
+    laws.sendControl = function sendControl(action, payload) {
+        laws.ws.send(JSONstringify({
+            action: action
+            payload: payload
+        }))
+    }
+    
+    //
+    // test()
+    //
+
+    laws.test = closure test() {
+        sendControl("test", "my load is large")
+    }
+    
+    // finis
+    
+    connect()                                                               // connect right away to start receiving messages
+    laws
+};
+
+
+/*
+ * lancoInit
+ *
+ *     Initialize the lambda control module.
+ *
+ */
+
+function lancoInit(local manifest) {
+
+    manifest = `(lancoRest, lancoWs, lancoInit)
+
+    Naan.module.build(module.id, "lambda_naan_control", function(modobj, compobj) {
+        require("serviceAws/serviceAws.nlg")
+        compobj.manifest = manifest
+        modobj.exports.LambdaRest = lancoRest
+        modobj.exports.LambdaWs = lancoWs
+    })
+
+} ();

package/plugins/serviceAws/psm_aws.nlg

@@ -0,0 +1,258 @@
+/*
+ * psm_aws.nlg
+ * serviceAws
+ *
+ *     PSM connector for AWS storage for browser and NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2020-2021 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * psmaConnector
+ *
+ *     Make a PSM connector for AWS bucket-based tables.
+ *
+ */
+
+closure psmaConnector(psm, local connClassID, connector, watch) {
+    connClassID = "S3DB"
+    require("./dbt_aws.nlg")
+    connector = new(object, this)
+    connector.psm = psm
+    connector.vault = psm.vault(connClassID, connector)
+    connector.label = "AWS S3"
+    watch = psm.watchable(connector)
+
+    // uifields
+    //
+    // Report the UI fields we need to add a resource
+    connector.uifields = function uifields() {
+        [{
+            label:          "Key ID"
+            placeholder:    "IAM keyID"
+            key:            "keyID" },
+        {
+            label:          "Key Secret"
+            placeholder:    "IAM keySecret"
+            key:            "keySecret"
+            type:           "password" },
+        {
+            label:          "AWS region"
+            placeholder:    "e.g. us-east-1"
+            key:            "region" },
+        {
+            label:          "Bucket"
+            placeholder:    "e.g. myBucketName"
+            key:            "bucketName" }
+        ]
+    }
+        
+    // hashResourceID
+    //
+    // Make a stable hash based on the resource credentials that we can persist or share between
+    // different domains accessing the same resource.
+    connector.hashResourceID = function hashResourceID(resource, local ident) {
+        ident = resource.region.concat(resource.region, resource.bucketName)
+        if resource.label
+            ident = ident.concat(resource.label)
+        HashSHA256(ident)
+    }
+
+    // findResource
+    //
+    // Find a resource with the specified contents, returning the resID or false. The loose criteria
+    // is: if added, would the specified contents be redundant to an existing resource?
+    connector.findResource = function findResource(resource, local resID, creds) {
+        for resID in listResources().1 {
+            creds = access(resID).1
+            if resource.region == creds.region && resource.bucketName == creds.bucketName
+                && (!resource.label || resource.label == creds.name)
+                return (resID)
+        }
+        false
+    }
+
+    // addResource
+    //
+    // Add credentials for a named resource. The label is a string. The resource is a dictionary
+    // comprising these keys:
+    //      label       - [optional] label we use for this resource
+    //      keyID       - AWS IAM keyID
+    //      keySecret   - AWS IAM keySecret
+    //      region      - AWS region
+    //      bucketName  - AWS bucketName
+    //      hidden      - [optional] don't enumerate to user
+    //      locked      - [optional] don't allow user delete
+    // The return value is (error, result) tuple. Error, if non-false, is a dictionary of field
+    // keys and error diagnostic strings. The special key "label" refers to the label string.
+    connector.addResource = function addResource(resource, local label, errors, creds, error, resID, data) {
+        function badField(str) { !string(str) || str.trim().length == 0 } 
+        creds = { 
+            keyID: resource.keyID,
+            keySecret: resource.keySecret,
+            region: resource.region,
+            bucketName: resource.bucketName
+        }
+        errors = { }
+        if resource.label
+            creds.label = resource.label
+        else
+            creds.label = resource.region.concat("-", resource.bucketName)
+        if badField(creds.label)
+            errors.label = "invalid label"
+        if badField(resource.keyID)
+            errors.keyID = "required field"
+        if badField(resource.keySecret)
+            errors.keySecret = "required field"
+        if badField(resource.region)
+            errors.region = "required field"
+        if badField(resource.bucketName)
+            errors.bucketName = "required field"
+        if length(errors) > 0
+            error = errors
+        else {
+            if resource.hidden
+                creds.hidden = resource.hidden
+            if resource.locked
+                creds.locked = resource.locked
+            resID = hashResourceID(resource)
+            `(error, data) = connector.vault.addResource(resID, creds)
+            if data {
+                watch.notify(connClassID, { added: [resID] })
+                data = resID }
+        }
+        list(error, data)
+    }
+    
+    // getResource
+    //
+    // Get credentials for a named resource, matching the dictionary semantics of addResource. The
+    // result is a standard result tuple.
+    connector.getResource = function getResource(resID, local error, creds, resource) {
+        `(error, creds) = connector.vault.accessResource(resID)
+        if error
+            return (list(error))
+        resource = {
+            classID: connClassID
+            label: creds.label
+        }
+        if string(creds.keyID)
+            resource.keyID = creds.keyID
+        if string(creds.keySecret)
+            resource.keySecret = creds.keySecret
+        if string(creds.region)
+            resource.region = creds.region
+        if string(creds.bucketName)
+            resource.bucketName = creds.bucketName
+        list(false, resource)
+    }
+
+    // deleteResource
+    //
+    // Delete credentials for a resource
+    connector.deleteResource = function deleteResource(resID) {
+        connector.vault.deleteResource(resID)
+        watch.notify(connClassID, { deleted: [resID] })
+        list(false, { ok: true})
+    }
+        
+    // listResources
+    //
+    // List saved resources in our database
+    connector.listResources = function listResources() {
+        connector.vault.listResources()
+    }
+    
+    // info
+    //
+    // Return info for a resource.
+    connector.info = function info(resID, local error, creds, info) {
+        info = {
+            classID: "AWS S3"
+            type: "AWS S3 bucket"
+            services: ["DBT", "FS"]
+        }
+        `(error, creds) = connector.vault.accessResource(resID)
+        if creds {
+            if creds.label
+                info.name = creds.label
+            if creds.locked
+                info.locked = true
+            if creds.hidden
+                info.hidden = true
+            info.where = creds.bucketName.concat(" (", creds.region, ")")
+        }
+        list(false, info)
+    }
+
+    // access
+    //
+    // Return an S3 access object, which is the credentials to access an AWS S3 bucket.
+
+    connector.access = function access(resID, local error, creds, s3) {
+        `(error, creds) = connector.vault.accessResource(resID)
+        if error
+            return (list(error))                                            // can't access that resource
+        s3 = xnew(awsSDK.S3, {
+            apiVersion:         "2006-03-01",
+            accessKeyId:        creds.keyID,
+            secretAccessKey:    creds.keySecret,
+            region:             creds.region
+            params: {
+                Bucket:         creds.bucketName }})
+        list(false, s3)
+    }
+
+    // connect
+    //
+    // Connect to an AWS bucket filesystem, returning a view.
+    
+    connector.connect = function connect(resID, service, args, local error,  s3, db, table) {
+        `(error, s3) = connector.access(resID)
+        if !error
+            `(error, db) = S3DB(s3)                                         // get S3 as a database
+        if error
+            list(error)
+        else if service == "NideDB"
+            list(false, db)
+        else if service == "NideFS" {
+            rootpath = args.0                                               // connect to a NideFS filesystem
+            if !rootpath
+                return (Error("mandatory rootpath missing"))
+            `(error, table) = db.table(rootpath)
+            if error
+                list(error)
+            else
+                require("frameworks/storage/psm_dbtables.nlg").FSview(table, rootpath)
+        } else
+            list(Error("unsupported service", service))
+    }
+
+    // finis
+
+    psm.register(connClassID, connector)
+    connector
+};
+
+
+/*
+ * psmaInit
+ *
+ *     Initialize the AWS module.
+ *
+ */
+
+function psmaInit(local manifest) {
+
+    manifest = `(psmaConnector, psmaInit)
+
+    Naan.module.build(module.id, "psm_aws", function(modobj, compobj) {
+        compobj.manifest = manifest
+        modobj.exports.AwsConnector = psmaConnector
+        require("./serviceAws.nlg")
+    })
+} ();

package/plugins/serviceAws/serviceAws.nlg

@@ -0,0 +1,38 @@
+/*
+ * serviceAws.nlg
+ * serviceAws
+ *
+ *     ServiceAWS module configuration and management for browser and NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2020-2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * sawsInit
+ *
+ *     Initialize the AWS module.
+ *
+ */
+
+function sawsInit(local manifest) {
+    manifest = `(sawsInit)
+
+    Naan.module.build(module.id, "serviceAws", function(modobj, compobj) {
+        compobj.manifest = manifest
+        require("frameworks/common").LiveImport()
+        function sawsPostload() {
+            if js.g
+                awsSDK = js.r("aws-sdk")
+            else
+                awsSDK = JsLoadScript(JSpath.join(module.locpath, "./aws/aws-sdk.min.js"), "AWS")
+            module.exports.awsSDK = awsSDK
+            if App.psm
+                require("./psm_aws.nlg").AwsConnector(App.psm)
+        }()
+        module.postload = sawsPostload
+    })
+} ();