// Copyright 2017 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

/* eslint-disable prefer-destructuring */

'use strict';

const fs = require('fs');

// [START iot_get_client]

const {google} = require('googleapis');

const iot = require('@google-cloud/iot');

const API_VERSION = 'v1';

const DISCOVERY_API = 'https://cloudiot.googleapis.com/$discovery/rest';

const client = new iot.v1.DeviceManagerClient();

// [END iot_get_client]

if (client === undefined) {

console.log('Did not instantiate client.');

}

// Configures the topic for Cloud IoT Core.

const setupIotTopic = async (topicName) => {

const {PubSub} = require('@google-cloud/pubsub');

const pubsub = new PubSub();

const topic = pubsub.topic(topicName);

const serviceAccount = `serviceAccount:cloud-iot@system.gserviceaccount.com`;

let policy = await topic.iam.getPolicy();

policy = policy[0] || {};

policy.bindings || (policy.bindings = []);

console.log(JSON.stringify(policy, null, 2));

let hasRole = false;

let binding = {

role: 'roles/pubsub.publisher',

members: [serviceAccount],

};

policy.bindings.forEach((_binding) => {

if (_binding.role === binding.role) {

binding = _binding;

hasRole = true;

return false;

}

});

if (hasRole) {

binding.members || (binding.members = []);

if (binding.members.indexOf(serviceAccount) === -1) {

binding.members.push(serviceAccount);

}

} else {

policy.bindings.push(binding);

}

// Updates the IAM policy for the topic

try {

const [updatedPolicy] = await topic.iam.setPolicy(policy);

console.log(JSON.stringify(updatedPolicy, null, 2));

} catch (err) {

console.error('Error updating policy:', err);

}

};

const createIotTopic = async (topicName) => {

// Imports the Google Cloud client library

const {PubSub} = require('@google-cloud/pubsub');

// Instantiates a client

const pubsub = new PubSub();

await pubsub.createTopic(topicName);

await setupIotTopic(topicName);

};

// Lookup the registry, assuming that it exists.

const lookupRegistry = async (client, registryId, projectId, cloudRegion) => {

// [START iot_lookup_registry]

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

try {

const registryName = iotClient.registryPath(

projectId,

cloudRegion,

registryId

);

try {

const responses = await iotClient.getDeviceRegistry({name: registryName});

const response = responses[0];

console.log(response);

} catch (err) {

console.error('Error getting registry', err);

}

} catch (err) {

console.error('Could not look up registry', err);

}

// [END iot_lookup_registry]

};

const createRegistry = async (

client,

registryId,

projectId,

cloudRegion,

pubsubTopicId

) => {

// [START iot_create_registry]

// Client retrieved in callback

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

// function errCb = lookupRegistry; // Lookup registry if already exists.

const iot = require('@google-cloud/iot');

// Lookup the pubsub topic

const topicPath = `projects/${projectId}/topics/${pubsubTopicId}`;

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const newParent = iotClient.locationPath(projectId, cloudRegion);

const deviceRegistry = {

eventNotificationConfigs: [

{

pubsubTopicName: topicPath,

},

],

id: registryId,

};

const request = {

parent: newParent,

deviceRegistry: deviceRegistry,

};

try {

const responses = await iotClient.createDeviceRegistry(request);

const response = responses[0];

console.log('Successfully created registry');

console.log(response);

} catch (err) {

console.error('Could not create registry', err);

}

// [END iot_create_registry]

};

// Create a new device with a given public key format

const createDevice = async (

client,

deviceId,

registryId,

projectId,

cloudRegion,

publicKeyFormat,

publicKeyFile

) => {

// [START iot_create_device]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const regPath = iotClient.registryPath(projectId, cloudRegion, registryId);

const device = {

id: deviceId,

credentials: [

{

publicKey: {

format: publicKeyFormat,

key: fs.readFileSync(publicKeyFile).toString(),

},

},

],

};

const request = {

parent: regPath,

device,

};

try {

const responses = await iotClient.createDevice(request);

const response = responses[0];

console.log('Created device', response);

} catch (err) {

console.error('Could not create device', err);

}

// [END iot_create_device]

};

// Create a new device with the given id. The body defines the parameters for

// the device, such as authentication.

const createUnauthDevice = async (

client,

deviceId,

registryId,

projectId,

cloudRegion

) => {

// [START iot_create_unauth_device]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-unauth-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const regPath = iotClient.registryPath(projectId, cloudRegion, registryId);

const device = {id: deviceId};

const request = {

parent: regPath,

device,

};

try {

const responses = await iotClient.createDevice(request);

const response = responses[0];

console.log('Created device', response);

} catch (err) {

console.error('Could not create device', err);

}

// [END iot_create_unauth_device]

};

// Create a device using RSA256 for authentication.

const createRsaDevice = async (

client,

deviceId,

registryId,

projectId,

cloudRegion,

rsaCertificateFile

) => {

// [START iot_create_rsa_device]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-rsa-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const regPath = iotClient.registryPath(projectId, cloudRegion, registryId);

const device = {

id: deviceId,

credentials: [

{

publicKey: {

format: 'RSA_X509_PEM',

key: fs.readFileSync(rsaCertificateFile).toString(),

},

},

],

};

const request = {

parent: regPath,

device,

};

try {

const responses = await iotClient.createDevice(request);

const response = responses[0];

console.log('Created device', response);

} catch (err) {

console.error('Could not create device', err);

}

// [END iot_create_rsa_device]

};

// Create a device using ES256 for authentication.

const createEsDevice = async (

client,

deviceId,

registryId,

projectId,

cloudRegion,

esCertificateFile

) => {

// [START iot_create_es_device]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-es-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const regPath = iotClient.registryPath(projectId, cloudRegion, registryId);

const device = {

id: deviceId,

credentials: [

{

publicKey: {

format: 'ES256_PEM',

key: fs.readFileSync(esCertificateFile).toString(),

},

},

],

};

const request = {

parent: regPath,

device,

};

try {

const responses = await iotClient.createDevice(request);

const response = responses[0];

console.log('Created device', response);

} catch (err) {

console.error('Could not create device', err);

}

// [END iot_create_es_device]

};

// Add RSA256 authentication to the given device.

const patchRsa256ForAuth = async (

client,

deviceId,

registryId,

rsaPublicKeyFile,

projectId,

cloudRegion

) => {

// [START iot_patch_rsa]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-rsa-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const devPath = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

const device = {

name: devPath,

credentials: [

{

publicKey: {

format: 'RSA_X509_PEM',

key: fs.readFileSync(rsaPublicKeyFile).toString(),

},

},

],

};

try {

const responses = await iotClient.updateDevice({

device: device,

updateMask: {paths: ['credentials']},

});

console.log('Patched device:', deviceId);

console.log('Response', responses[0]);

} catch (err) {

console.error('Error patching device:', deviceId, err);

}

// [END iot_patch_rsa]

};

// Add ES256 authentication to the given device.

const patchEs256ForAuth = async (

client,

deviceId,

registryId,

esPublicKeyFile,

projectId,

cloudRegion

) => {

// [START iot_patch_es]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-es-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const devPath = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

const device = {

name: devPath,

credentials: [

{

publicKey: {

format: 'ES256_PEM',

key: fs.readFileSync(esPublicKeyFile).toString(),

},

},

],

};

try {

const responses = await iotClient.updateDevice({

device: device,

updateMask: {paths: ['credentials']},

});

console.log('Patched device:', deviceId);

console.log('Response', responses[0]);

} catch (err) {

console.error('Error patching device:', deviceId, err);

}

// [END iot_patch_es]

};

// List all of the devices in the given registry.

const listDevices = async (client, registryId, projectId, cloudRegion) => {

// [START iot_list_devices]

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const parentName = iotClient.registryPath(projectId, cloudRegion, registryId);

try {

const responses = await iotClient.listDevices({parent: parentName});

const devices = responses[0];

if (devices.length > 0) {

console.log('Current devices in registry:');

} else {

console.log('No devices in registry.');

}

for (let i = 0; i < devices.length; i++) {

const device = devices[i];

console.log(`Device ${i}: `, device);

}

} catch (err) {

console.error('Could not list devices', err);

}

// [END iot_list_devices]

};

// List all of the registries in the given project.

const listRegistries = async (client, projectId, cloudRegion) => {

// [START iot_list_registries]

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

const iot = require('@google-cloud/iot');

const newClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

// Iterate over all elements.

const formattedParent = newClient.locationPath(projectId, cloudRegion);

try {

const responses = await newClient.listDeviceRegistries({

parent: formattedParent,

});

const resources = responses[0];

console.log('Current registries in project:\n', resources);

} catch (err) {

console.error('Could not list registries', err);

}

// [END iot_list_registries]

};

// Delete the given device from the registry.

const deleteDevice = async (

client,

deviceId,

registryId,

projectId,

cloudRegion

) => {

// [START iot_delete_device]

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const devPath = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

try {

const responses = await iotClient.deleteDevice({name: devPath});

console.log('Successfully deleted device', responses);

} catch (err) {

console.error('Could not delete device', err);

}

// [END iot_delete_device]

};

// Clear the given registry by removing all devices and deleting the registry.

const clearRegistry = async (client, registryId, projectId, cloudRegion) => {

const parentName = `projects/${projectId}/locations/${cloudRegion}`;

const registryName = `${parentName}/registries/${registryId}`;

const requestDelete = {

name: registryName,

};

const request = {

parent: registryName,

};

let devices;

try {

const {data} = await client.projects.locations.registries.devices.list(

request

);

devices = data.devices;

} catch (err) {

console.error('Could not list devices', err);

return;

}

// Delete devices in registry

console.log('Current devices in registry:', devices);

if (devices) {

const promises = devices.map((device, index) => {

console.log(`${device.id} [${index}/${devices.length}] removed`);

return deleteDevice(

client,

device.id,

registryId,

projectId,

cloudRegion

);

});

await Promise.all(promises);

}

// Delete registry

try {

const {data} = await client.projects.locations.registries.delete(

requestDelete

);

console.log(`Successfully deleted registry ${registryName}`);

console.log(data);

} catch (err) {

console.error('Could not delete registry', err);

}

};

// Delete the given registry. Note that this will only succeed if the registry

// is empty.

const deleteRegistry = async (client, registryId, projectId, cloudRegion) => {

// [START iot_delete_registry]

// Client retrieved in callback

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const registryName = iotClient.registryPath(

projectId,

cloudRegion,

registryId

);

try {

const responses = await iotClient.deleteDeviceRegistry({

name: registryName,

});

console.log(responses);

console.log('Successfully deleted registry');

} catch (err) {

console.error('Could not delete registry', err);

}

// [END iot_delete_registry]

};

// Retrieve the given device from the registry.

const getDevice = async (

client,

deviceId,

registryId,

projectId,

cloudRegion

) => {

// [START iot_get_device]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const devicePath = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

try {

const responses = await iotClient.getDevice({name: devicePath});

const data = responses[0];

console.log('Found device:', deviceId, data);

} catch (err) {

console.error('Could not find device:', deviceId);

console.error('Trace:', err);

}

// [END iot_get_device]

};

// Retrieve the given device's state from the registry.

const getDeviceState = async (

client,

deviceId,

registryId,

projectId,

cloudRegion

) => {

// [START iot_get_device_state]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const devicePath = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

try {

const responses = await iotClient.listDeviceStates({name: devicePath});

const states = responses[0].deviceStates;

if (states.length === 0) {

console.log(`No States for device: ${deviceId}`);

} else {

console.log(`States for device: ${deviceId}`);

}

for (let i = 0; i < states.length; i++) {

const state = states[i];

console.log(

'State:',

state,

'\nData:\n',

state.binaryData.toString('utf8')

);

}

} catch (err) {

console.error('Could not find device:', deviceId);

console.error('trace:', err);

}

// [END iot_get_device_state]

};

// Retrieve the given device's configuration history from the registry.

const getDeviceConfigs = async (

client,

deviceId,

registryId,

projectId,

cloudRegion

) => {

// [START iot_get_device_configs]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const devicePath = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

try {

const responses = await iotClient.listDeviceConfigVersions({

name: devicePath,

});

const configs = responses[0].deviceConfigs;

if (configs.length === 0) {

console.log(`No configs for device: ${deviceId}`);

} else {

console.log(`Configs:`);

}

for (let i = 0; i < configs.length; i++) {

const config = configs[i];

console.log(

'Config:',

config,

'\nData:\n',

config.binaryData.toString('utf8')

);

}

} catch (err) {

console.error('Could not find device:', deviceId);

console.error('trace:', err);

}

// [END iot_get_device_configs]

};

// Send configuration data to device.

const setDeviceConfig = async (

client,

deviceId,

registryId,

projectId,

cloudRegion,

data,

version

) => {

// [START iot_set_device_config]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

// const data = 'test-data';

// const version = 0;

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const formattedName = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

const binaryData = Buffer.from(data).toString('base64');

const request = {

name: formattedName,

versionToUpdate: version,

binaryData: binaryData,

};

try {

const responses = await iotClient.modifyCloudToDeviceConfig(request);

console.log('Success:', responses[0]);

} catch (err) {

console.error('Could not update config:', deviceId);

console.error('Message:', err);

}

// [END iot_set_device_config]

};

// sends a command to a specified device subscribed to the commands topic

const sendCommand = async (

deviceId,

registryId,

projectId,

cloudRegion,

commandMessage

) => {

// [START iot_send_command]

// const cloudRegion = 'us-central1';

// const deviceId = 'my-device';

// const commandMessage = 'message for device';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const formattedName = iotClient.devicePath(

projectId,

cloudRegion,

registryId,

deviceId

);

const binaryData = Buffer.from(commandMessage);

const request = {

name: formattedName,

binaryData: binaryData,

};

try {

const responses = await iotClient.sendCommandToDevice(request);

console.log('Sent command: ', responses[0]);

} catch (err) {

console.error('Could not send command:', err);

}

// [END iot_send_command]

};

// Retrieve the given device from the registry.

const getRegistry = async (client, registryId, projectId, cloudRegion) => {

// [START iot_get_registry]

// Client retrieved in callback

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

try {

const registryName = iotClient.registryPath(

projectId,

cloudRegion,

registryId

);

try {

const responses = await iotClient.getDeviceRegistry({name: registryName});

const response = responses[0];

console.log('Found registry:', registryId);

console.log(response);

} catch (err) {

console.error('Could not get device registry', err);

}

} catch (err) {

console.error('Could not find registry:', registryId);

console.error('Trace:', err);

}

// [END iot_get_registry]

};

// Returns an authorized API client by discovering the Cloud IoT Core API with

// the provided API key.

const getClient = async (serviceAccountJson) => {

// the getClient method looks for the GCLOUD_PROJECT and GOOGLE_APPLICATION_CREDENTIALS

// environment variables if serviceAccountJson is not passed in

const authClient = await google.auth.getClient({

keyFilename: serviceAccountJson,

scopes: ['https://www.googleapis.com/auth/cloud-platform'],

});

const discoveryUrl = `${DISCOVERY_API}?version=${API_VERSION}`;

google.options({

auth: authClient,

});

try {

return google.discoverAPI(discoveryUrl);

} catch (err) {

console.error('Error during API discovery.', err);

}

};

// Retrieves the IAM policy for a given registry.

const getIamPolicy = async (client, registryId, projectId, cloudRegion) => {

// [START iot_get_iam_policy]

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const formattedResource = iotClient.registryPath(

projectId,

cloudRegion,

registryId

);

let bindings, etag;

try {

const responses = await iotClient.getIamPolicy({

resource: formattedResource,

});

const response = responses[0];

bindings = response.bindings;

etag = response.etag;

console.log('ETAG:', etag);

bindings = bindings || [];

bindings.forEach((_binding) => {

console.log(`Role: ${_binding.role}`);

_binding.members || (_binding.members = []);

_binding.members.forEach((_member) => {

console.log(`\t${_member}`);

});

});

} catch (err) {

console.error('Could not find policy for: ', registryId);

console.error('Trace: ', err);

}

// [END iot_get_iam_policy]

};

// Sets the IAM permissions for a given registry to a single member / role.

const setIamPolicy = async (

client,

registryId,

projectId,

cloudRegion,

member,

role

) => {

// [START iot_set_iam_policy]

// const cloudRegion = 'us-central1';

// const projectId = 'adjective-noun-123';

// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

const iotClient = new iot.v1.DeviceManagerClient({

// optional auth parameters.

});

const resource = iotClient.registryPath(projectId, cloudRegion, registryId);

const policy = {

bindings: [

{

members: [member],

role: role,

},

],

};

const request = {

resource: resource,

policy: policy,

};

let bindings, etag;

try {

const responses = await iotClient.setIamPolicy(request);

const response = responses[0];

bindings = response.bindings;