',
28 | InvocationType: 'RequestResponse',
29 | ClientContext: clientContext,
30 | Payload: JSON.stringify({ message: 'payload message' }),
31 | };
32 |
33 | lambdaClient.invoke(params, (err, data) => {
34 | if (err) {
35 | console.error(err, err.stack);
36 | } else {
37 | console.log(data);
38 | }
39 | });
40 | };
41 |
--------------------------------------------------------------------------------
/greengrassExamples/ShadowOperations/index.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | */
4 |
5 | /*
6 | * Demonstrates a shadow operation using Greengrass Core NodeJS SDK
7 | * This lambda function will retrieve underlying platform information and
8 | * update the reported state of 'platform' shadow with that message.
9 | */
10 |
11 | const ggSdk = require('aws-greengrass-core-sdk');
12 |
13 | const iotClient = new ggSdk.IotData();
14 | const os = require('os');
15 | const util = require('util');
16 |
17 | const myPlatform = util.format('%s-%s', os.platform(), os.release());
18 | const shadowUpdateParams = {
19 | thingName: 'platform',
20 | payload: JSON.stringify({ state: { reported: { platform: myPlatform } } }),
21 | };
22 | const shadowGetParams = {
23 | thingName: 'platform',
24 | };
25 |
26 | exports.handler = function handler(event, context) {
27 | console.log(context);
28 |
29 | // Update Thing Shadow
30 | console.log('Update Thing Operation');
31 | iotClient.updateThingShadow(shadowUpdateParams, (err, data) => {
32 | if (err) {
33 | console.log(err);
34 | } else {
35 | console.log(data);
36 | }
37 | });
38 |
39 | // Get Thing Shadow
40 | console.log('Shadow Get Operation');
41 | iotClient.getThingShadow(shadowGetParams, (err, data) => {
42 | if (err) {
43 | console.log(err);
44 | } else {
45 | console.log(data);
46 | }
47 | });
48 | };
49 |
--------------------------------------------------------------------------------
/greengrassExamples/StreamManagerIoTSiteWise/index.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | */
4 |
5 | /*
6 | * This example will create a Greengrass StreamManager stream called "SomeStream".
7 | * It will then start writing data into that stream and StreamManager will
8 | * automatically export the written data to the customer-created property alias.
9 | * The property alias should be created before running this example.
10 | * This example will run forever, until the program is killed.
11 |
12 | * The size of the StreamManager stream on disk will not exceed the default (which is 256 MB).
13 | * Any data appended after the stream reaches the size limit, will continue to be appended, and
14 | * StreamManager will delete the oldest data until the total stream size is back under 256MB.
15 | */
16 |
17 | const {
18 | StreamManagerClient, ExportDefinition,
19 | IoTSiteWiseConfig, MessageStreamDefinition, StrategyOnFull,
20 | ResourceNotFoundException, AssetPropertyValue, PutAssetPropertyValueEntry, Quality, TimeInNanos, Variant,
21 | util,
22 | } = require('aws-greengrass-core-sdk').StreamManager;
23 |
24 | const STREAM_NAME = 'SomeStream';
25 | const PROPERTY_ALIAS = 'SomePropertyAlias';
26 | const ENTRY_ID_PREFIX = 'SomeEntryId-';
27 |
28 | const c = new StreamManagerClient();
29 |
30 | function getRandomPutAssetPropertyValueEntry(i) {
31 | const maxTimeRandomness = 60;
32 | const maxOffsetRandomness = 10000;
33 | const randomValue = Math.random();
34 | // Note: Inorder to create a new asset property data, you should use the classes defined in the
35 | // aws-greengrass-core-sdk StreamManager module.
36 | const timestamp = new TimeInNanos()
37 | .withTimeInSeconds(Math.round(Date.now() / 1000) - Math.floor(Math.random() - maxTimeRandomness))
38 | .withOffsetInNanos(Math.floor(Math.random() * maxOffsetRandomness));
39 | const entry = new AssetPropertyValue()
40 | .withValue(new Variant().withDoubleValue(randomValue))
41 | .withQuality(Quality.GOOD)
42 | .withTimestamp(timestamp);
43 |
44 | return new PutAssetPropertyValueEntry()
45 | .withEntryId(`${ENTRY_ID_PREFIX}${i}`)
46 | .withPropertyAlias(PROPERTY_ALIAS)
47 | .withPropertyValues([entry]);
48 | }
49 |
50 | c.onConnected(async () => {
51 | // Try deleting the stream (if it exists) so that we have a fresh start
52 | try {
53 | await c.deleteMessageStream(STREAM_NAME);
54 | } catch (e) {
55 | // Rethrow the error if it wasn't the expected error
56 | if (!(e instanceof ResourceNotFoundException)) {
57 | throw e;
58 | }
59 | }
60 |
61 | try {
62 | const exports = new ExportDefinition()
63 | .withIotSitewise([new IoTSiteWiseConfig()
64 | .withIdentifier(`IoTSiteWise-${STREAM_NAME}`)
65 | .withBatchSize(5)]);
66 |
67 | // Then create the stream with the IoTSiteWise export definition.
68 | await c.createMessageStream(
69 | new MessageStreamDefinition()
70 | .withName(STREAM_NAME)
71 | .withStrategyOnFull(StrategyOnFull.OverwriteOldestData)
72 | .withExportDefinition(exports),
73 | );
74 |
75 | let index = 0;
76 | // Now start putting in random SiteWise entries.
77 | const interval = setInterval(async () => {
78 | try {
79 | console.log('Appending new random SiteWise entries to stream');
80 | await c.appendMessage(STREAM_NAME, util.validateAndSerializeToJsonBytes(getRandomPutAssetPropertyValueEntry(index++)));
81 | } catch {
82 | clearInterval(interval);
83 | c.close();
84 | }
85 | }, 1000);
86 | } catch (e) {
87 | console.log(e);
88 | c.close();
89 | }
90 | });
91 |
92 | // Dummy handler because this example should run as a long-lived lambda
93 | module.exports.handler = function handler() {
94 | return '';
95 | };
96 |
--------------------------------------------------------------------------------
/greengrassExamples/StreamManagerKinesis/index.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | */
4 |
5 | /*
6 | * This example will create a Greengrass StreamManager stream called "SomeStream".
7 | * It will then start writing data into that stream and StreamManager will
8 | * automatically export the written data to a Kinesis Data Stream called "MyKinesisStream".
9 | * This example will run forever, until the program is killed.
10 | *
11 | * The size of the StreamManager stream on disk will not exceed the default (which is 256 MB).
12 | * Any data appended after the stream reaches the size limit, will continue to be appended, and
13 | * StreamManager will delete the oldest data until the total stream size is back under 256MB.
14 | * The Kinesis Data Stream in the cloud has no such bound, so all the data from this script
15 | * will be uploaded to Kinesis and you will be charged for that usage.
16 | */
17 |
18 | const {
19 | StreamManagerClient, ReadMessagesOptions, ExportDefinition,
20 | KinesisConfig, MessageStreamDefinition, StrategyOnFull,
21 | ResourceNotFoundException,
22 | } = require('aws-greengrass-core-sdk').StreamManager;
23 |
24 | const STREAM_NAME = 'SomeStream';
25 | const KINESIS_STREAM_NAME = 'MyKinesisStream';
26 |
27 | const c = new StreamManagerClient();
28 | c.onConnected(async () => {
29 | // Try deleting the stream (if it exists) so that we have a fresh start
30 | try {
31 | await c.deleteMessageStream(STREAM_NAME);
32 | } catch (e) {
33 | // Rethrow the error if it wasn't the expected error
34 | if (!(e instanceof ResourceNotFoundException)) {
35 | throw e;
36 | }
37 | }
38 |
39 | try {
40 | const exports = new ExportDefinition()
41 | .withKinesis([new KinesisConfig()
42 | .withIdentifier(`KinesisExport${STREAM_NAME}`)
43 | .withKinesisStreamName(KINESIS_STREAM_NAME)]);
44 |
45 | await c.createMessageStream(
46 | new MessageStreamDefinition()
47 | .withName(STREAM_NAME)
48 | .withStrategyOnFull(StrategyOnFull.OverwriteOldestData)
49 | .withExportDefinition(exports),
50 | );
51 |
52 | // Append 2 messages and print their sequence numbers
53 | console.log(`Successfully appended message to stream with sequence number ${await c.appendMessage(STREAM_NAME, Buffer.from('ABCDEFGHIJKLMNO', 'utf-8'))}`);
54 | console.log(`Successfully appended message to stream with sequence number ${await c.appendMessage(STREAM_NAME, Buffer.from('PQRSTUVWXYZ', 'utf-8'))}`);
55 |
56 | // Try reading the 2 messages we just appended and print them out
57 | console.log(`Successfully read 2 messages: ${
58 | await c.readMessages(STREAM_NAME,
59 | new ReadMessagesOptions()
60 | .withMinMessageCount(2)
61 | .withReadTimeoutMillis(1000))}`);
62 |
63 | console.log('Now going to start writing random integers between 0 and 255 to the stream');
64 |
65 | // Now start putting in random data between 0 and 255 to emulate device sensor input
66 | const interval = setInterval(async () => {
67 | try {
68 | console.log('Appending new random integer to stream');
69 | const buf = Buffer.alloc(1);
70 | buf.writeUInt8(Math.floor(Math.random() * 255), 0);
71 | await c.appendMessage(STREAM_NAME, buf);
72 | } catch {
73 | clearInterval(interval);
74 | c.close();
75 | }
76 | }, 1000);
77 | } catch {
78 | c.close();
79 | }
80 | });
81 |
82 | // Dummy handler because this example should run as a pinned lambda
83 | module.exports.handler = function handler() {
84 | return '';
85 | };
86 |
--------------------------------------------------------------------------------
/greengrassExamples/StreamManagerS3/index.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | */
4 |
5 | /*
6 | * This example creates a local stream named 'SomeStream', and a status stream named 'SomeStatusStream.
7 | * It adds 1 S3 Export task into the 'SomeStream' stream and then stream manager automatically exports
8 | * the data to a customer-created S3 bucket named 'SomeBucket'.
9 | * The S3 bucket should be created before running this example.
10 | * This example runs until the customer-created file at URL 'SomeURL' has been uploaded to the S3 bucket.
11 | */
12 |
13 | const {
14 | StreamManagerClient, ReadMessagesOptions, ExportDefinition,
15 | MessageStreamDefinition, StrategyOnFull, ResourceNotFoundException,
16 | S3ExportTaskDefinition, Status, StatusConfig, StatusLevel, StatusMessage, S3ExportTaskExecutorConfig,
17 | util,
18 | } = require('aws-greengrass-core-sdk').StreamManager;
19 |
20 | const STREAM_NAME = 'SomeStream';
21 | const STATUS_STREAM_NAME = 'SomeStatusStream';
22 | const BUCKET = 'SomeBucket';
23 | const KEY = 'SomeKey';
24 | const FILE_URL = 'file:/path/to/some/file.someExtension';
25 |
26 | const c = new StreamManagerClient();
27 | c.onConnected(async () => {
28 | // Try deleting the stream (if it exists) so that we have a fresh start
29 | try {
30 | await c.deleteMessageStream(STATUS_STREAM_NAME);
31 | } catch (e) {
32 | // Rethrow the error if it wasn't the expected error
33 | if (!(e instanceof ResourceNotFoundException)) {
34 | throw e;
35 | }
36 | }
37 | // Try deleting the stream (if it exists) so that we have a fresh start
38 | try {
39 | await c.deleteMessageStream(STREAM_NAME);
40 | } catch (e) {
41 | // Rethrow the error if it wasn't the expected error
42 | if (!(e instanceof ResourceNotFoundException)) {
43 | throw e;
44 | }
45 | }
46 |
47 | try {
48 | const exports = new ExportDefinition()
49 | .withS3TaskExecutor([new S3ExportTaskExecutorConfig()
50 | .withIdentifier(`S3Export-${STREAM_NAME}`)
51 | .withStatusConfig(new StatusConfig()
52 | .withStatusLevel(StatusLevel.INFO)
53 | .withStatusStreamName(STATUS_STREAM_NAME))]);
54 |
55 | // Create the export status stream first.
56 | await c.createMessageStream(
57 | new MessageStreamDefinition()
58 | .withName(STATUS_STREAM_NAME)
59 | .withStrategyOnFull(StrategyOnFull.OverwriteOldestData),
60 | );
61 |
62 | // Then create the stream with the S3 Export definition.
63 | await c.createMessageStream(
64 | new MessageStreamDefinition()
65 | .withName(STREAM_NAME)
66 | .withStrategyOnFull(StrategyOnFull.OverwriteOldestData)
67 | .withExportDefinition(exports),
68 | );
69 |
70 | // Append a S3 export task definition and print the sequence number.
71 | const taskDefinition = new S3ExportTaskDefinition()
72 | .withBucket(BUCKET)
73 | .withKey(KEY)
74 | .withInputUrl(FILE_URL);
75 |
76 | console.log(`Successfully appended message to stream with sequence number
77 | ${await c.appendMessage(STREAM_NAME, util.validateAndSerializeToJsonBytes(taskDefinition))}`);
78 |
79 | console.log('Now going to start reading statuses from the export status stream.');
80 | let isS3UploadComplete = false;
81 | while (!isS3UploadComplete) {
82 | try {
83 | // Read the statuses from the export status stream
84 | const messages = await c.readMessages(STATUS_STREAM_NAME,
85 | new ReadMessagesOptions()
86 | .withMinMessageCount(1)
87 | .withReadTimeoutMillis(1000));
88 |
89 | messages.forEach((message) => {
90 | // Deserialize the status message first.
91 | const statusMessage = util.deserializeJsonBytesToObj(message.payload, StatusMessage);
92 | // Check the status of the status message. If the status is 'Success', the file was successfully uploaded to S3.
93 | // If the status was either 'Failure' or 'Cancelled', the server was unable to upload the file to S3.
94 | // We will print the message for why the upload to S3 failed from the status message.
95 | // If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
96 | if (statusMessage.status === Status.Success) {
97 | console.log(`Successfully uploaded file at path ${FILE_URL} to S3.`);
98 | isS3UploadComplete = true;
99 | } else if (statusMessage.status === Status.Failure || statusMessage.status === Status.Canceled) {
100 | console.log(`Unable to upload file at path ${FILE_URL} to S3. Message: ${statusMessage.message}`);
101 | isS3UploadComplete = true;
102 | }
103 | });
104 | // Sleep for sometime for the S3 upload task to complete before trying to read the status message.
105 | await new Promise((r) => setTimeout(r, 5000));
106 | } catch (e) {
107 | // Ignored
108 | }
109 | }
110 | } catch (e) {
111 | c.close();
112 | }
113 | });
114 |
115 | // Dummy handler because this example should run as a pinned lambda
116 | module.exports.handler = function handler() {
117 | return '';
118 | };
119 |
--------------------------------------------------------------------------------
/greengrassExamples/TES/README:
--------------------------------------------------------------------------------
1 | The TES example package contains a Lambda function that, when run,
2 | will attempt to retrieve AWS credentials. The goal of TES is to allow
3 | users to retrieve credentials without having them hard-coded on the
4 | system itself.
5 |
6 | Assuming no credentials exist on the system, when the Lambda function
7 | is run, temporary credentials will be sourced from the cloud.
8 |
9 | The credential retrieval is retrieved with an incremental backoff
10 | in case of an error. Users must be aware that the retrieval may not
11 | always succeed on the first try and retry should be performed with care.
12 |
13 | ### SETUP ###
14 | 1. Copy the included index.js to your Lambda function.
15 |
16 | 2. Install aws-sdk by performing "npm install aws-sdk".
17 |
18 | 3. Unzip the Greengrass Core SDK for NodeJS into node_modules folder.
19 |
20 | 4. Zip the folder with index.js on the top level.
21 |
22 | 5. Create a Lambda in the Lambda Console.
23 | Handler: index.handler
24 | Runtime: Node.js 8.10
25 | Timeout: 3s
26 | Role: any basic execution role can be used here
27 |
28 | 6. Create a group that contains your Greengrass Core and the Lambda
29 | function you've just created.
30 |
31 | 7. In the Greengrass console, click on the Lambda function and set
32 | the Memory limit is at least 40MB and "Lambda lifecycle" is set to
33 | "Make this function long-lived and keep it running indefinitely".
34 |
35 | 8. Under Settings page of the group, make sure the Group Role is
36 | set to the role you want to use within Greengrass when
37 | performing actions against AWS.
38 |
39 | 9. Deploy the latest Greengrass to your device.
40 |
41 | 10. Local log should display the access key, secret key and session token.
42 |
--------------------------------------------------------------------------------
/greengrassExamples/TES/index.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | */
4 |
5 | /*
6 | * Demonstrates retrieving a Group Role Credential if one is set.
7 | */
8 |
9 | const AWS = require('aws-sdk');
10 | const util = require('util');
11 |
12 | const credChain = new AWS.CredentialProviderChain();
13 |
14 | // Max retry every 30 seconds to retrieve the credentials
15 | const maxRetryInterval = 30;
16 | // Initially, try with one second retry interval
17 | const initialRetryInterval = 1;
18 |
19 | function getCredential(retryInterval) {
20 | const promise = credChain.resolvePromise();
21 |
22 | promise.then((creds) => {
23 | console.log(util.format('Access Key: %s\nSecret Key: %s\nSession Key: %s\n', creds.accessKeyId, creds.secretAccessKey, creds.sessionToken));
24 | },
25 | (err) => {
26 | console.log(err);
27 | // Try again with incremental backoff
28 | setTimeout(() => {
29 | getCredential(Math.min(maxRetryInterval, retryInterval * 2));
30 | }, retryInterval);
31 | });
32 | }
33 |
34 | getCredential(initialRetryInterval);
35 |
36 | // This is a handler which does nothing for this example
37 | exports.handler = function handler(event, context) {
38 | console.log(event);
39 | console.log(context);
40 | };
41 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | ## AWS Greengrass Core SDK for JavaScript
2 |
3 | The **AWS Greengrass Core SDK for JavaScript** allows developers to write JavaScript Lambda functions which will run within Greengrass.
4 |
5 | ## Overview
6 |
7 | This document provides instructions for preparing your Greengrass Core environment to run Lambda functions written in JavaScript. It also includes examples on how to develop a Lambda function in JavaScript as well as packaging and running an example Hello World file in JavaScript for your Greengrass core.
8 |
9 | ## Preparing your Greengrass to run NodeJS Lambda functions
10 |
11 | The environment where Greengrass is running on needs to be able to run NodeJS 12.x applications.
12 |
13 | * Install NodeJS 12 for your platform. You can download the newest NodeJS from [https://nodejs.org/en/download/](https://nodejs.org/en/download/).
14 | * When you untar the package downloaded from NodeJS website, you will find `node` file under `bin` directory.
15 | * Copy the file to _**/usr/bin**_ or _**/usr/local/bin**_ folder.
16 | * Rename the file to _**nodejs12.x**_
17 |
18 | ## Getting Started - Hello World
19 |
20 | * Copy `greengrassExamples/HelloWorld` folder to your workspace.
21 | * Create a folder `node_modules` under `HelloWorld` folder.
22 | * Unzip aws-greengrass-core-sdk-js.zip into the folder. It should create a folder HelloWorld/node_modules/aws-greengrass-core-sdk
23 | * Use NPM to install the required dependency, cbor. `npm i cbor@5.0.1`.
24 | * Zip up the content of HelloWorld folder so that the index.js is on the top of the zip file structure.
25 | * Go to AWS Lambda Console.
26 | * Create a new function.
27 | * Choose the Runtime as `Node.js 12.x`
28 | * Upload the zip file in _Lambda function code_ section.
29 | * Handler is _index.handler_
30 | * Choose any role as the role is not used within Greengrass.
31 | * After creating the function, publish the Lambda.
32 | * Create an Alias and point to the Published version (not $LATEST).
33 | * Go to your Greengrass Group and add the Lambda under Lambdas section.
34 | * Click on the Lambda and change the _Lambda lifecycle_ to _Make this function long-lived and keep it running indefinitely._
35 | * Add a Subscription with the following configuration:
36 | * Source: Lambda which you just created and added to the group
37 | * Target: IoT Cloud
38 | * Topic: hello/world
39 | * Deploy. A message from your Lambda should be published to the topic _hello/world_ in the cloud every 5 seconds. You can check this by going to AWS IoT's _Test_ page and subscribing to topic _hello/world_.
40 |
41 | ## Including aws-greengrass-core-sdk with your function
42 |
43 | Unzip the SDK into your node_modules folder of your function. This should create a aws-greengrass-core-sdk folder which includes the SDK.
44 |
45 | ## Logging in NodeJS Lambdas
46 |
47 | Your _console.log_ operation will be logged as INFO. A _console.error_ operation will be logged as ERROR. Currently, our NodeJS SDK only allows you to log at INFO or ERROR level only.
48 |
49 | ## Supported Datatypes
50 |
51 | From GGC version 1.5, you can send both JSON and binary data as a payload when you invoking other Lambdas or publishing a message using IotData service. In order to make your lambda be able to handle binary payload, you need to configure the lambda in Greengrass console to mark it using binary input payload so that GGC can know how to deal with the data.
52 |
53 | ## Supported Context
54 |
55 | In Greengrass, you can send a context object in a JSON format to be passed to another Lambda that is being invoked. The context format looks like this: `{ custom: { customData: 'customData', }, }`
56 |
57 |
58 |
59 | ## Compatibility[¶](#compatibility "Permalink to this headline")
60 |
61 | As new features are added to AWS IoT Greengrass, newer versions of the AWS IoT Greengrass SDK may be incompatible with older versions of the AWS IoT Greengrass core. The following table lists the compatible SDKs for all GGC releases.
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 | | GGC Version |
71 |
72 | Compatible SDK Versions |
73 |
74 |
75 |
76 |
77 |
78 | | 1.0.x-1.6.x |
79 |
80 | 1.0.x-1.2.x |
81 |
82 |
83 |
84 |
85 |
86 | | 1.7.x-1.8.x |
87 |
88 | 1.0.x-1.3.x |
89 |
90 |
91 |
92 |
93 |
94 | | 1.9.x |
95 |
96 | 1.0.x-1.4.x |
97 |
98 |
99 |
100 |
101 |
102 | | 1.10.x |
103 |
104 | 1.0.x-1.6.x |
105 |
106 |
107 |
108 |
109 |
110 | | 1.11.x |
111 |
112 | 1.0.x-1.7.x |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
123 |
124 | ## 1.7.0 Updates[¶](#1.7.0updates "Permalink to this headline")
125 |
126 | Stream manager supports automatic data export to AWS S3 and AWS IoT SiteWise, provides new API method to update existing streams, and pause or resume exporting.
127 |
128 |
129 |
130 |
131 |
132 | ## 1.6.0 Updates[¶](#1.6.0updates "Permalink to this headline")
133 |
134 | Added support for StreamManager, see [AWS Docs](https://docs.aws.amazon.com/greengrass/latest/developerguide/stream-manager.html)
135 | for more information.
136 |
137 | ### Compatibility
138 |
139 | StreamManager has adds a new dependency to this package, `cbor==5.0.1`.
140 | Please make sure to include it in your lambda or else the SDK will not function.
141 | In addition to the new dependency, the 1.6.0 version of this SDK now requires NodeJS version 12
142 | or greater since NodeJS 6 and 8 are end-of-life. See [https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html](https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html).
143 |
144 | ### StreamManager Usage
145 |
146 | ```javascript
147 | const {
148 | StreamManagerClient
149 | } = require('aws-greengrass-core-sdk').StreamManager;
150 |
151 | const c = new StreamManagerClient({
152 | onConnectCb: async () => {
153 | try {
154 | // Let's start with something simple.
155 | // Just print out all the available stream names on the server
156 | console.log(await c.listStreams());
157 | } finally {
158 | c.close(); // Always close the client when you're done
159 | }
160 | }
161 | });
162 | ```
163 |
164 |
165 |
166 |
167 |
168 | ## 1.5.0 Updates[¶](#1.5.0updates "Permalink to this headline")
169 |
170 | Added support for publish() parameter queueFullPolicy which can be set to 'AllOrError' to enforce that the published message is either delivered to all subscription destinations or delivered to no destinations and returns an error when Greengrass Core's internal work queue is full.
171 |
172 |
173 |
174 |
175 |
176 | ## 1.4.0 Updates[¶](#1.4.0updates "Permalink to this headline")
177 |
178 | Added support for Node.js 8.10 Lambda runtime. Lambda functions that use Node.js 8.10 runtime can now run on an AWS IoT Greengrass core. (Existing Lambda functions that use Node.js 6.10 runtime can still run on Greengrass core, but they can't be updated after 5/30/2019. Please refer to [AWS Lambda Runtimes Support Policy](https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html).)
179 |
180 |
181 |
182 |
183 |
184 | ## 1.3.1 Updates[¶](#1.3.1updates "Permalink to this headline")
185 |
186 | Improved log level granularity.
187 |
188 |
189 |
190 |
191 |
192 | ## 1.3.0 Updates[¶](#1.3.0updates "Permalink to this headline")
193 |
194 | SDK supports SecretsManager client.
195 |
196 |
197 |
198 |
199 |
200 | ## 1.2.0 Updates[¶](#1.2.0updates "Permalink to this headline")
201 |
202 | SDK and GGC compatibility check takes place in the background.
203 |
204 |
205 |
206 |
207 |
208 | ## 1.1.0 Updates[¶](#1.1.0updates "Permalink to this headline")
209 |
210 | Lambda only accepted payload in JSON format. With this update, Invoking or publishing binary payload to a lambda is supported.
211 |
212 |
213 |
214 |
215 |
216 | ## 1.0.1 Updates[¶](#1.0.1updates "Permalink to this headline")
217 |
218 | Shadow operations were not receiving responses from the local shadow properly. This has been fixed.
219 |
220 | Lambda Invoke function's InvocationType's default value was Event. This has been changed to RequestResponse.
221 |
222 |
223 |
224 | ## Getting Help
225 |
226 | * [Ask on a Greengrass forum](https://forums.aws.amazon.com/forum.jspa?forumID=254)
227 |
228 | ## License
229 |
230 | Apache 2.0
231 |
--------------------------------------------------------------------------------