Objective

The purpose of the document is to provide a reference to the edgeEngine Context Object and the other objects that is part of the edge Serverless computing environment

Intended Readers

The intended readers of this document are software developers that will be programming using the edgeEngine Context Object as well as the other objects that are available in the edge Serverless computing environment

What You Need To Know To Use This Reference

This document assumes that you have a basic knowledge of:

• working with the edgeEngine Runtime
• working with the edgeEngine Context Object.

Object Model Reference

context 
context
context()
The class context represents the serverless context object. The context object provides properties for sending HTTP requests using the built-in HTTP client and storing data locally, getting information in environment variables.
Examples
Copy
1: import Router from 'router';
2: 
3: const app = Router({
4:     mergeParams: true
5: });
6: 
7: mimikModule.exports = (context, request, response) => {
8:     global.context = context;
9:     app(request, response, (e) => {
10:         request.end(JSON.stringify({
11:             code: e ? 400 : 404,
12:             message: e || 'Not Found'
13:         }));
14:     });
15: };
16: 
17: app.get('/', (request, response) => {
18:     response.end('Hello World!');
19: });
edge()
Member of the class, context
The read-only property edge returns an edge object. The edge object provides functions that decrypt the encrypted messages that come in from the Node Discovery API. Also the edge object can make requests to the mimik Global Backend Services in order to create a private tunnel which is a Bearer Endpoint (BEP).
Type object
Examples
info()
Member of the class, context
This read-only property info returns a info object. The info object contains general information about the container in which the given microservice is running.
Type info
Examples
env()
Member of the class, context
The read-only property env object returns an env object. The env object has the environment variables that have been passed into the microservice container upon initialization.
Type env
Examples
storage()
Member of the class, context
The read-only property storage returns a storage object. The storage object contains methods for storing and retrieving key-value information and files using the edgeEngine Runtime's internal data storage mechanism.
Type storage
Examples
http()
Member of the class, context
The read-only property http returns an http object. The http object provides functions for working the http client that is built into the edgeEngine Runtime environment.
Type http
Examples
edge 
edge
edge()
The class edge provides functions that enable a node to receive information about the cluster and back-end tunneling information. Also, the edgeEngine Runtime provides a function, requestBep(requestBepOption) that creates a private tunnel, which is a Bearer Endpoint (BEP). All communication conducted by the edge class is done securely.
Examples
decryptEncryptedNodesJson(decryptNodesOption)
Member of class, edge
The function decryptEncryptedNodesJson decrypts information received from the edgeEngine Service Mesh.
Parameters
Name
Description
decryptNodesOption
type(decryptNodesOption)
The configuration options is an object that describes the options for extracting information from a cluster within the edgeEngine Service Mesh.
Examples
Copy
1: app.get('/localDevices', (request, response) => {
2:     context.http.request(({
3:         url: 'http://127.0.0.1:8083/mds/v1/nodes?clusters=linkLocal',
4:         success: function(r) {
5:             if (!request.authorization) {
6:                 response.status = 403;
7:                 response.end(JSON.stringify({
8:                     'msg': 'missing bearer token'
9:                 }, 2, null));
10:                 return;
11:             }
12:             const authorization = request.authorization.split(' ');
13:             if (authorization.length < 2) {
14:                 response.status = 403;
15:                 response.end(JSON.stringify({
16:                     'msg': 'missing bearer token'
17:                 }, 2, null));
18:                 return;
19:             }
20:             const token = authorization[1];
21:             const nodes = JSON.parse(r.data);
22:             const data = JSON.stringify(nodes.data);
23: 
24:             context.edge.decryptEncryptedNodesJson({
25:                 type: 'local',
26:                 data,
27:                 token,
28:                 success: function(result) { // success option
29:                     response.end(JSON.stringify(JSON.parse(result.data), null, 2));
30:                 },
31:                 error: function(err) {
32:                     response.end(err.message);
33:                 }
34:             });
35:         },
36:         error: function(err) {
37:             response.end(err.message);
38:         }
39:     }));
40: });
requestBep(requestBepOption)
Member of the class, edge
The function requestBep(requestBepOption) requests a BEP tunnel from the edgeEngine Runtime If a BEP has not already been created, the function creates a new Bearer Endpoint (BEP). If a BEP has already been created, the function returns the existing BEP.
Parameters
Name
Description
requestBepOption
type(requestBepOption)
The BEP request configuration options for receiving a private communication tunnel.
Examples
Copy
1: app.get('/localDevices', (request, response) => {
2:     context.edge.requestBep({
3:         success: (result) => {
4:             console.log(result.data);
5:         }
6:     });
7:     // ...
8: });
http 
http()
The class http describes the  HTTP request client that is built into the edgeEngine Runtime environment. The http class publishes a method request that is used to implement an HTTP request from an edge microservice.
Examples
request(httpClientOptions)
Member of the class, http.
This property is a function that takes the httpClientOptions and parses it as an instance of a HTTP client interface.
Parameters
Name
Description
httpClientOptions
type(httpClientOptions)
The HTTP request configuration options for making requests within the edge microservice context.
Examples
Copy
1: app.post('/data', (request, response) => {
2:     context.http.request(({
3:         type: 'POST',
4:         data: '{}',
5:         url: 'http://www.example.com/data',
6:         authorization: 'Bearer token123',
7:         success: (result) => {
8:             response.end(result.data);
9:         },
10:         error: (err) => {
11:             console.log(err);
12:         }
13:     }));
14: });
request 
request
request()
This object represents the HTTP request parameter that is passed in to an HTTP method handler within a given microservice.
Examples
url()
Member of the class, request
Returns the URL of the request.
Type string
Examples
Copy
1: app.get('/photos', (req, res) => {
2:     const callingURl = req.url
3:     // ... more code
4: });
method()
Member of the class, request
Returns HTTP method of the request, such as GET, POST, DELETE, PUT, etc.
Type string
Examples
Copy
1: app.get('/photos', (req, res) => {
2:     const method = req.method
3:     // ... more code
4: });
authorization()
Member of the class, request
Returns the HTTP Authorization Header.
Type string
Examples
Copy
1: app.get('/photos', (req, res) => {
2:     const authorization = req.authorization
3:     // ... more code
4: });
body()
Member of the class, request
Returns the body of the POST or PUT request when the content-type of the request is application/json.
Type string
Examples
Copy
1: app.get('/photos', (req, res) => {
2:     const mybody = req.body
3:     // ... more code
4: });
handleFormRequest(formRequestOptions,formRequestOption)
Member of the class, request
The function handleFormRequest(formRequestOption) handles HTTP POST with a content type ‘multipart/form-data’. The function takes a formRequestOption object provided by the developer. The function handleFormRequest(formRequestOption)  has internal behavior that executes when called from within an HTTP POST method handler. Developers can enhance this behavior by adding callback functions to the parameter formRequestOptions.
Parameters
Name
Description
formRequestOptions
type
formRequestOption
type(formRequestOption)
passes the callback function required by request.handleFormRequest() to handle the HTTP Form POST.
Examples
Copy
1: app.post('/form', (request, response) => {
2:     const formRequestOptions = {};
3:     formRequestOptions.found = (name, filename) => {
4:         const formToDo = null;
5:         if (filename) {
6:             console.log(`Received a multipart/form-data for a file - name : ${name}, filename: ${filename}`);
7:             //if it's a photo of a cat, don't process it
8:             if (filename.startsWith(name.toLowerCase()) == 'cat') {
9:                 formToDo = {
10:                     action: 'skip'
11:                 };
12:             } else {
13:                 formToDo = {
14:                     action: 'store',
15:                     path: filename
16:                 };
17:             }
18:         } else {
19:             console.log(`Received a multipart/form-data for text - name : ${name}`);
20:             formToDo = {
21:                 action: 'get'
22:             };
23:         }
24:         return formToDo;
25:     };
26:     formRequestOptions.get = (name, value) => {
27:         console.log(`Received a multipart/form-data for a text - name : ${name}, value: ${value}`)
28:     };
29:     formRequestOptions.store = (filepath, byteStored) => {
30:         console.log(`Saved a file in a multipart/form-data request - path : ${path}, bytesSaved: ${bytesSaved}`)
31:     };
32: 
33:     req.handleFormRequest(formRequestOptions);
34: 
35:     response.end();
36: });
response 
response
response()
The class response describes an HTTP response that is the result of an HTTP request made by HTTP client that's built in to the edgeEngine Runtime
Examples
statusCode()
Member of class, response
Returns the HTTP response code. The default is 200.
Examples
end(body)
Inserts an a string as the body of the response .
Parameters
Name
Description
body
type(string)
The string that will be inserted into the body of the HTTP response.
Examples
Copy
1: app.get('/', (request, response) => {
2:     response.statusCode = 200;
3:     response.end('<h1>Hello World!</h1>');
4: });
writeMimeFile(filePath,mimeType)
Member of class, response
Inserts a mime file into the HTTP response.
Parameters
Name
Description
filePath
type(string)
The path of the file that response.writeMimeFile() returns in the response
mimeType
type(string)
The file type of the return file. The default is application/json
Examples
Copy
1: app.get('/', (request, response) => {
2:     response.statusCode = 200;
3:     const filePath = '/home/usr/example.jpeg';
4:     response.writeMimeFile(filepath, 'image/jpeg');
5: });
httpClientOptions 
httpClientOptions()
The edgeEngine Runtime has a built-in HTTP client that enables making requests to external targets running on the internet. The built in HTTP client is represented by the http object. The class httpClientOptions describes the HTTP request configuration options that the built-in HTTP client uses when executing requests within an edge microservice. The important thing to understand about the built-in HTTP client is that the only way to tell it how to make a request is by providing information about the intended request via the httpClientOptions. The httpClientOptions object is passed to the constructor of the http class, like so: context.http.request(httpClientOptions).
Examples
successCallback(result)
Member of the class, httpClientOptions.
Type Function
Parameters
Name
Description
result
type(string)
Result of the HTTP request to the callback function.
Examples
errorCallback(error)
Member of the class, httpClientOptions.
Type Function
Parameters
Name
Description
error
type(string)
The error of HTTP request to the callback function
Examples
httpMethod()
Member of the class, httpClientOptions.
Use this property to assign the HTTP method that the built-in HTTP client uses when making a request. For example, if you want the built-in HTTP client to make a GET request, assign the following, httpClientOptions.httpMethod = "GET". If you want to the HTTP client to make a POST request, assign the following:  httpClientOptions.httpMethod = "POST"
Type string
Examples
Copy
1: // to make a GET request
2: httpClientOptions.httpMethod = "GET"
3: // to make a POST request
4: httpClientOptions.httpMethod = "POST"
data()
Member of the class, httpClientOptions.
Use this this property to set the body of a request that is to be executed by the built-in HTTP client. Typically the data property is set when implementing a POST or PUT request.
Type string
Examples
Copy
 httpClientOptions.data = "All good things take time."
url()
Member of the class, httpClientOptions.
Use this property to set the target URL that the built-in HTTP client targets when making a request.
Type string
Examples
Copy
 httpClientOptions.url = "https://api.example.com/movies"
authorization()
Member of the class, httpClientOptions.
Use this property to set the HTTP authorization header that the built-in HTTP client uses when making a request.
Type string
Examples
Copy
 httpClientOptions.authorization = "Bearer mytoken123"
success()
Member of the class, httpClientOptions.
Use this property to set the callback function that gets invoked when a request executed by the built-in HTTP client is successful.
Type successCallback
Examples
Copy
1: httpClientOptions.success = (result) => {
2:     console.log(`The request was successful. The result is: ${result}`)
3: };
error()
Member of the class, httpClientOptions.
Use this property to set the callback function that gets invoked when a request executed by the built-in http client throws an error.
Type errorCallback
Examples
Copy
1: httpClientOptions.error = (error) => {
2:     console.error(`The request was has an error. The error is: ${error}`)
3: };
decryptNodesOptions 
decryptNodesOptions()
The class decryptNodesOption describes the  configuration options for extracting sensitive information from clusters.
Examples
type()
Member of the class, decryptNodesOptions
Use this property to set the cluster type. The possible values are  account, proximity or local.
Type string
Examples
Copy
 decryptNodesOptions.type = 'account';
token()
Member of the class, decryptNodesOptions
Use this property to set the edge Access Token that was obtained through the mimik Identity Server API.
Type string
Examples
Copy
 decryptNodesOptions.token = 'token123';
data()
Member of the class, decryptNodesOptions
Use this property to set the data that will be decrypted internally and then made available for decryption by way of edge.decryptEncryptedNodesJson(decryptNodesOption).
Type string
Examples
Copy
 decryptNodesOptions.data = 'A penny saved is a penny earned.';
success()
Member of the class, decryptNodesOptions
Use this property to set the callback function that gets executed upon success of the decryption attempt.
BE ADVISED! The result passed into success callback function will be the encrypted data that was [MORE TO COME]
Type successCallback
Examples
Copy
1: decryptNodesOptions.success = (result) => {
2:     console.log(`The decryption was successful. The result is: ${result}`)
3: };
error()
Member of the class, decryptNodesOptions
Use this property to set the callback function that gets invoked when an decryption attempt throws an error.
Type errorCallback
Examples
Copy
1: httpClientOptions.error = (error) => {
2:     console.error(`The request was has an error. The error is: ${error}`)
3: };
requestBepOptions 
requestBepOptions()
The class requestBepOption sets the BEP request configuration options for receiving a private communication tunnel. The options are callback functions for handling success and error events.
Examples
successCallback(result)
Type Function
Parameters
Name
Description
result
type(string)
Result of the success request to the callback function.
Examples
errorCallback(error)
Type Function
Parameters
Name
Description
error
type(string)
The error of request to the callback function.
Examples
success()
Member of the class, requestBepOptions
Sets the callback function that gets executed upon success.
Type successCallback
Examples
Copy
1: success: (result) => {
2:     // Bep URL
3:     response.end(result.data);
4:     // https://i-06078eccb9a82b3b1-mss.mimik360.com/bep/v1/8102/1afc1665-a139-45cd-a3ec-361c8f24b649
5: }
error()
Member of the class, requestBepOptions
Sets the callback function that gets executed upon error.
Type errorCallback
Examples
Copy
1: error: (err) => {
2:     console.log(`bep request has error ${err.message}`);
3: }
formRequestToDo 
formRequestToDo
formRequestToDo()
This object is returned from callback functions that defined that are defined in the formRequestOptions that is passed as a parameter in the method, request.handleFormRequest(formRequestOptions).
The object formRequestToDo publishes a property action that indicates the action that is a required for the the method request.handleFormRequest() to handle the HTTP Form POST.
Examples
action()
Member of class, formRequestToDo
The possible return value of this read-only property are:
abort aborts the entire form request.
skip skips the current key of the form request.
store handles the form request using the store function provided in formRequestOption.
get handles the form request using the get function provided in formRequestOption.
Type string
Examples
Copy
 const actionType = formRequestToDo.action
path()
Member of class, formRequestToDo
This read-only property returns the path to the file that has been saved
by default in the edgeEngine Runtime,
Type string
Examples
Copy
 const filePath = formRequestToDo.path
formRequestOptions 
formRequestOption
formRequestOption()
The class formRequestOption publishes a methods that define how to work with the method handleFormRequest() in order to handle the HTTP Form POST.
Examples
found(name,filename)
Member of class, formRequestOption
The callback function that gets executed as each part
in a multipart/form request is processed
Parameters
Name
Description
name
type(string)
The key of the form element.
filename
type(string)
The filename corresponding to the key if the form element is a file
Returns 
formRequestToDo
The todo action in response to the found analysis
Examples
Copy
1: formRequestOptions.found = (name, filename) => {
2:     const formToDo = null;
3:     if (filename) {
4:         console.log(`Received a multipart/form-data for a file - name : ${name}, filename: ${filename}`);
5:         //if it's a photo of a cat, don't process it
6:         if (filename.startsWith(name.toLowerCase()) == 'cat') {
7:             formToDo = {
8:                 action: 'skip'
9:             };
10:         } else {
11:             formToDo = {
12:                 action: 'store',
13:                 path: filename
14:             };
15:         }
16:     } else {
17:         console.log(`Received a multipart/form-data for text - name : ${name}`);
18:         formToDo = {
19:             action: 'get'
20:         };
21:     }
22:     return formToDo;
23: };
get(name,value)
Member of class, formRequestOption
The callback function that gets executed when the
internal found()method identifies a text segment
of multipart/form request
Parameters
Name
Description
name
type(string)
The key of the form element.
value
type(string)
The value of the form element corresponding to the name.
Returns 
formRequestToDo
The todo action in response to the get execution
Examples
Copy
1: formRequestOptions.get = (name, value) => {
2:     console.log(`Received a multipart/form-data for a text - name : ${name}, value: ${value}`)
3: };
store(path,size)
Member of class, formRequestOption
The callback function that gets executed when the
internal found()method identifies a file in a
multipart/form segment
of multipart/form request
Parameters
Name
Description
path
type(string)
The stored file path of the form element
size
type(string)
The stored file size of the form element
Returns 
formRequestToDo
The todo action in response to the store execution
Examples
Copy
1: formRequestOptions.store = (filepath, byteStored) => {
2:     console.log(`Saved a file in a multipart/form-data request - path : ${path}, bytesSaved: ${bytesSaved}`)
3: };
storage 
storage
storage()
The class storage facilitates saving and retrieving data from the internal storage mechanism within the edgeEngine Runtime.
Examples
getItem(key)
Member of the class, storage
The function getItem(key) returns the data from the internal storage mechanism within the edgeEngine Runtime.
Parameters
Name
Description
key
type(string)
The key value to use to lookup data within internal storage
Returns 
string
the value associated to the key
Examples
Copy
1: app.get('/', (request, response) => {
2:     const value = context.storage.getItem('key');
3:     response.end(value);
4: });
setItem(key,value)
Member of the class, storage
The function, setItem(key, value) stores data in internal storage as a key-value pair.
Parameters
Name
Description
key
type(string)
The key by which data will be stored
value
type(string)
The value to store
Examples
Copy
1: app.post('/form', (request, response) => {
2:     const {
3:         name
4:     } = JSON.parse(request.body);
5:     context.storage.setItem('name', name);
6:     response.end('value stored successfully.');
7: });
eachItem(callback)
Member of the class, storage
The function, eachItem iterates through internal storage and makes a callback for each record in the result.
Parameters
Name
Description
callback
type(callBackItem)
The callback that handles eachItem object exposed during the iteration  of query against internal storage.
Examples
Copy
1: app.get('/', (request, response) => {
2:     context.storage.eachItem((key, value) => {
3:         // do something....
4:     });
5:     response.end('done');
6: });
removeItem(key)
Member of the class, storage
The function removeItem(key) removes a data entry from internal storage according to the key.
Parameters
Name
Description
key
type(string)
The key in a key-value pair indicated the key-value to remove from internal storage
Examples
Copy
1: app.delete('/form', (request, response) => {
2:     context.storage.removeItem('name');
3:     response.end('item remove successfully.');
4: });
saveFile(fileName,base64EncodedString)
Member of the class, storage
The function saveFile(fileName, base64EncodedString)  saves a file to internal storage.
Parameters
Name
Description
fileName
type(string)
The name of the file. to save
base64EncodedString
type(string)
The content of the file to save as a base64Encoded binary data.
Examples
Copy
1: app.post('/file', (request, response) => {
2:     const base64 = '..........';
3:     const fileName = 'base64.jpeg';
4:     context.storage.saveFile(fileName, base64);
5:     response.end('item save successfully.');
6: });
deleteFile(fileName)
Member of the class, storage
The function deleteFile(fileName) deletes a file from internal storage.
Parameters
Name
Description
fileName
type(string)
The name of the file to delete.
Examples
Copy
1: app.delete('/file', (request, response) => {
2:     const fileName = 'base64.jpeg';
3:     context.storage.deleteFile(fileName);
4:     response.end('item delete successfully.');
5: });
callBackItem
callBackItem(key,value)
Member of the class, storage
Type Function
Parameters
Name
Description
key
type(string)
The key from the database for the item
value
type(string)
The value in the database associate with the key.
Examples
key()
The key from the database for the item
Type string
Examples
value()
The value in the database associate with the key.
Type string
Examples