feat(cdk): unify the way APIs are configured

Previously there were two ways to configure APIs
(one for UnwiredLabs and one for GitHub).

This is now unified and there is a CLI to set
these configuration settings as well.

In addition all SSM Parameters are now prefixed with the
stack name so multiple instances can exist in the same
account.

This is not marked as a breaking change because
the documentation was not yet published

Author: coderbyheart

cdk/apps/AssetTracker.ts

@@ -20,7 +20,6 @@ export class AssetTrackerApp extends App {
 		sourceCodeBucketName: string
 		packedLambdas: PackedLambdas<AssetTrackerLambdas>
 		packedCDKLambdas: PackedLambdas<CDKLambdas>
-		enableUnwiredApi: boolean
 		context?: Record<string, any>
 	}) {
 		super({ context: args.context })

cdk/apps/Test.ts

@@ -21,7 +21,6 @@ export class TestApp extends App {
 		super({ context: args.context })
 		new AssetTrackerStack(this, {
 			...args,
-			enableUnwiredApi: false, // FIXME: implement e2e test
 		})
 		new FirmwareCIStack(this, args)
 	}

cdk/cloudformation.ts

@@ -5,13 +5,18 @@ import {
 	prepareCDKLambdas,
 } from './prepare-resources'
 import { SSMClient } from '@aws-sdk/client-ssm'
-import { getApiSettings } from '../cellGeolocation/stepFunction/unwiredlabs'
+import { getUnwiredLabsApiSettings } from '../cellGeolocation/stepFunction/unwiredlabs'
 import { warn } from './helper/note'
 import { STSClient } from '@aws-sdk/client-sts'
 import { loadContext } from './helper/loadContext'
+import { CORE_STACK_NAME } from './stacks/stackName'
+import { getApiSettings } from '../util/apiConfiguration'
+import * as chalk from 'chalk'
 
-const fetchUnwiredLabsApiSettings = getApiSettings({
-	ssm: new SSMClient({}),
+const ssm = new SSMClient({})
+const fetchUnwiredLabsApiSettings = getUnwiredLabsApiSettings({
+	ssm,
+	stackName: CORE_STACK_NAME,
 })
 
 const rootDir = process.cwd()
@@ -30,25 +35,47 @@ Promise.all([
 			rootDir,
 		}),
 	})),
-	fetchUnwiredLabsApiSettings({ api: 'unwiredlabs' }).catch(() => {
-		warn(
-			'Cell Geolocation',
-			'No UnwiredLabs API key configured. Feature will be disabled.',
-		)
-		return {}
-	}),
+	fetchUnwiredLabsApiSettings().catch(() => ({})),
+	getApiSettings({
+		ssm,
+		stackName: CORE_STACK_NAME,
+		scope: 'codebuild',
+		api: 'github',
+	})().catch(() => ({})),
 	loadContext({ sts: new STSClient({}) }),
 ])
-	.then(([args, ulApiSettings, context]) =>
-		new AssetTrackerApp({
+	.then(([args, ulApiSettings, codebuildSettings, context]) => {
+		const ctx = {
+			version: process.env.VERSION ?? '0.0.0-development',
+			...context,
+		} as Record<string, any>
+		const enableUnwiredApi = 'apiKey' in ulApiSettings
+		if (!enableUnwiredApi) {
+			warn(
+				'Cell Geolocation',
+				'No UnwiredLabs API key configured. Feature will be disabled.',
+			)
+			warn(
+				'Cell Geolocation',
+				`Use ${chalk.greenBright(
+					`node cli configure-api codebuild github token <token>`,
+				)} to set the token`,
+			)
+			ctx.unwiredlabs = '0'
+		}
+		const enableCD = 'token' in codebuildSettings
+		if (!enableCD) {
+			warn(
+				'Continuous Deployment',
+				'No GitHub API key configured. Continuous deployment will be disabled.',
+			)
+			ctx.cd = '0'
+		}
+		return new AssetTrackerApp({
 			...args,
-			enableUnwiredApi: 'apiKey' in ulApiSettings,
-			context: {
-				version: process.env.VERSION ?? '0.0.0-development',
-				...context,
-			},
-		}).synth(),
-	)
+			context: ctx,
+		}).synth()
+	})
 	.catch((err) => {
 		console.error(err)
 		process.exit(1)

cdk/helper/note.ts

@@ -1,12 +1,12 @@
 import * as chalk from 'chalk'
 
 export const warn = (category: string, note: string): void => {
-	console.warn('', chalk.magenta(' ℹ '), chalk.cyan(category), chalk.grey(note))
+	console.warn('', chalk.magenta('ℹ'), chalk.cyan(category), chalk.grey(note))
 }
 export const info = (category: string, note: string): void => {
 	console.debug(
 		'',
-		chalk.blue(' ℹ '),
+		chalk.blue('ℹ'),
 		chalk.white.dim(category),
 		chalk.gray(note),
 	)

cdk/resources/CellGeolocation.ts

@@ -12,6 +12,8 @@ import { StateMachineType } from '@aws-cdk/aws-stepfunctions'
 import { Role } from '@aws-cdk/aws-iam'
 import * as SQS from '@aws-cdk/aws-sqs'
 import { LambdasWithLayer } from './LambdasWithLayer'
+import { CORE_STACK_NAME } from '../stacks/stackName'
+import { enabledInContext } from '../helper/enabledInContext'
 
 /**
  * Provides the resources for geolocating LTE/NB-IoT network cells
@@ -28,10 +30,8 @@ export class CellGeolocation extends CloudFormation.Resource {
 		id: string,
 		{
 			lambdas,
-			enableUnwiredApi,
 		}: {
 			lambdas: LambdasWithLayer<AssetTrackerLambdas>
-			enableUnwiredApi: boolean
 		},
 	) {
 		super(parent, id)
@@ -165,31 +165,37 @@ export class CellGeolocation extends CloudFormation.Resource {
 
 		// Optional step
 		let fromUnwiredLabs: Lambda.IFunction | undefined = undefined
-		if (enableUnwiredApi) {
-			fromUnwiredLabs = new Lambda.Function(this, 'fromUnwiredLabs', {
-				layers: lambdas.layers,
-				handler: 'index.handler',
-				runtime: Lambda.Runtime.NODEJS_12_X,
-				timeout: CloudFormation.Duration.seconds(10),
-				memorySize: 1792,
-				code: lambdas.lambdas.geolocateCellFromUnwiredLabsStepFunction,
-				description: 'Resolve cell geolocation using the UnwiredLabs API',
-				initialPolicy: [
-					logToCloudWatch,
-					new IAM.PolicyStatement({
-						actions: ['ssm:GetParametersByPath'],
-						resources: [
-							`arn:aws:ssm:${parent.region}:${parent.account}:parameter/asset-tracker/cellGeoLocation/unwiredlabs`,
-						],
-					}),
-				],
-				environment: {
-					VERSION: this.node.tryGetContext('version'),
-				},
-			})
+		const checkFlag = enabledInContext(this.node)
+		const unwiredLabsEnabled = checkFlag({
+			key: 'unwiredlabs',
+			component: 'UnwiredLabs API',
+			onUndefined: 'disabled',
+			onEnabled: () => {
+				fromUnwiredLabs = new Lambda.Function(this, 'fromUnwiredLabs', {
+					layers: lambdas.layers,
+					handler: 'index.handler',
+					runtime: Lambda.Runtime.NODEJS_12_X,
+					timeout: CloudFormation.Duration.seconds(10),
+					memorySize: 1792,
+					code: lambdas.lambdas.geolocateCellFromUnwiredLabsStepFunction,
+					description: 'Resolve cell geolocation using the UnwiredLabs API',
+					initialPolicy: [
+						logToCloudWatch,
+						new IAM.PolicyStatement({
+							actions: ['ssm:GetParametersByPath'],
+							resources: [
+								`arn:aws:ssm:${parent.region}:${parent.account}:parameter/${CORE_STACK_NAME}/cellGeoLocation/unwiredlabs`,
+							],
+						}),
+					],
+					environment: {
+						VERSION: this.node.tryGetContext('version'),
+					},
+				})
 
-			new LambdaLogGroup(this, 'fromUnwiredLabsLogs', fromUnwiredLabs)
-		}
+				new LambdaLogGroup(this, 'fromUnwiredLabsLogs', fromUnwiredLabs)
+			},
+		})
 
 		const isGeolocated = StepFunctions.Condition.booleanEquals(
 			'$.cellgeo.located',
@@ -243,7 +249,7 @@ export class CellGeolocation extends CloudFormation.Resource {
 								)
 								.otherwise(
 									(() => {
-										if (!fromUnwiredLabs) {
+										if (!unwiredLabsEnabled) {
 											return new StepFunctions.Fail(this, 'Failed (No API)', {
 												error: 'NO_API',
 												cause:
@@ -255,7 +261,7 @@ export class CellGeolocation extends CloudFormation.Resource {
 											'Resolve using UnwiredLabs API',
 											{
 												task: new StepFunctionTasks.InvokeFunction(
-													fromUnwiredLabs,
+													(fromUnwiredLabs as unknown) as Lambda.IFunction,
 												),
 												resultPath: '$.cellgeo',
 											},

cdk/stacks/AssetTracker.ts

@@ -30,13 +30,11 @@ export class AssetTrackerStack extends CloudFormation.Stack {
 			sourceCodeBucketName,
 			packedLambdas,
 			packedCDKLambdas,
-			enableUnwiredApi,
 		}: {
 			mqttEndpoint: string
 			sourceCodeBucketName: string
 			packedLambdas: PackedLambdas<AssetTrackerLambdas>
 			packedCDKLambdas: PackedLambdas<CDKLambdas>
-			enableUnwiredApi: boolean
 		},
 	) {
 		super(parent, CORE_STACK_NAME)
@@ -435,7 +433,6 @@ export class AssetTrackerStack extends CloudFormation.Stack {
 
 		const cellgeo = new CellGeolocation(this, 'cellGeolocation', {
 			lambdas,
-			enableUnwiredApi,
 		})
 
 		cellgeo.stateMachine.grantStartExecution(userRole)

cdk/stacks/ContinuousDeployment.ts

@@ -106,7 +106,7 @@ export class ContinuousDeploymentStack extends CloudFormation.Stack {
 			this,
 			'ghtoken',
 			{
-				parameterName: '/codebuild/github-token',
+				parameterName: `/${CORE_STACK_NAME}/codebuild/github/token`,
 				version: 1,
 			},
 		)

cellGeolocation/stepFunction/unwiredlabs.ts

@@ -1,44 +1,43 @@
-import { GetParametersByPathCommand, SSMClient } from '@aws-sdk/client-ssm'
+import { SSMClient } from '@aws-sdk/client-ssm'
 import { request as nodeRequest } from 'https'
-import { parse } from 'url'
+import { URL } from 'url'
 import { MaybeCellGeoLocation } from './types'
 import { Cell } from '../geolocateCell'
+import { fromEnv } from '../../util/fromEnv'
+import { getApiSettings } from '../../util/apiConfiguration'
 
-export const getApiSettings = ({ ssm }: { ssm: SSMClient }) => async ({
-	api,
+export const getUnwiredLabsApiSettings = ({
+	ssm,
+	stackName,
 }: {
-	api: 'unwiredlabs'
-}): Promise<{ apiKey: string; endpoint: string }> => {
-	const Path = `/asset-tracker/cellGeoLocation/${api}`
-	const { Parameters } = await ssm.send(
-		new GetParametersByPathCommand({
-			Path,
-			Recursive: true,
-		}),
-	)
-
-	const apiKey = Parameters?.find(
-		({ Name }) => Name?.replace(`${Path}/`, '') === 'apiKey',
-	)?.Value
+	ssm: SSMClient
+	stackName: string
+}) => async (): Promise<{ apiKey: string; endpoint: string }> => {
+	const p = await getApiSettings({
+		ssm,
+		stackName,
+		scope: 'cellGeoLocation',
+		api: 'unwiredlabs',
+	})()
+	const { apiKey, endpoint } = p
 	if (apiKey === undefined) throw new Error('No API key configured!')
-	const endpoint =
-		Parameters?.find(({ Name }) => Name?.replace(`${Path}/`, '') === 'endpoint')
-			?.Value ?? 'https://eu1.unwiredlabs.com/'
-
 	return {
 		apiKey,
-		endpoint,
+		endpoint: endpoint ?? 'https://eu1.unwiredlabs.com/',
 	}
 }
 
-const fetchSettings = getApiSettings({ ssm: new SSMClient({}) })
+const { stackName } = fromEnv({ stackName: 'STACK_NAME' })(process.env)
+
+const fetchSettings = getUnwiredLabsApiSettings({
+	ssm: new SSMClient({}),
+	stackName,
+})
 
 export const handler = async (cell: Cell): Promise<MaybeCellGeoLocation> => {
 	try {
-		const { apiKey, endpoint } = await fetchSettings({
-			api: 'unwiredlabs',
-		})
-		const { hostname, path } = parse(endpoint)
+		const { apiKey, endpoint } = await fetchSettings()
+		const { hostname, pathname } = new URL(endpoint)
 
 		// See https://eu1.unwiredlabs.com/docs-html/index.html#response
 		const {
@@ -61,7 +60,7 @@ export const handler = async (cell: Cell): Promise<MaybeCellGeoLocation> => {
 		} = await new Promise((resolve, reject) => {
 			const options = {
 				host: hostname,
-				path: `${path?.replace(/\/*$/, '') ?? ''}/v2/process.php`,
+				path: `${pathname?.replace(/\/*$/, '') ?? ''}/v2/process.php`,
 				method: 'POST',
 				agent: false,
 			}

cli/asset-tracker.ts cli/cli.tscli/asset-tracker.ts renamed to cli/cli.ts

@@ -22,6 +22,7 @@ import { firmwareCICommand } from './commands/firmware-ci'
 import { certsDir as provideCertsDir } from './jitp/certsDir'
 import { flashCommand } from './commands/flash'
 import { deviceUIConfigCommand } from './commands/device-ui-config'
+import { configureAPICommand } from './commands/configure-api'
 
 const iot = new IoTClient({})
 const version = JSON.parse(
@@ -79,6 +80,7 @@ const assetTrackerCLI = async ({ isCI }: { isCI: boolean }) => {
 		cdCommand(),
 		purgeIotUserPolicyPrincipals(),
 		logsCommand(),
+		configureAPICommand(),
 	]
 
 	if (isCI) {

cli/commands/cd-update-token.ts

@@ -3,35 +3,27 @@ import {
 	GetPipelineCommand,
 	UpdatePipelineCommand,
 } from '@aws-sdk/client-codepipeline'
-import {
-	DeleteParameterCommand,
-	PutParameterCommand,
-	SSMClient,
-} from '@aws-sdk/client-ssm'
+import { SSMClient } from '@aws-sdk/client-ssm'
 import { CommandDefinition } from './CommandDefinition'
 import * as chalk from 'chalk'
 import { listPipelines } from '../cd/listPipelines'
+import { CORE_STACK_NAME } from '../../cdk/stacks/stackName'
+import { putApiSetting } from '../../util/apiConfiguration'
 
 export const cdUpdateTokenCommand = (): CommandDefinition => ({
 	command: 'cd-update-token <token>',
 	action: async (token: string) => {
 		const ssm = new SSMClient({})
-		try {
-			await ssm.send(
-				new DeleteParameterCommand({
-					Name: '/codebuild/github-token',
-				}),
-			)
-		} catch {
-			// pass
-		}
-		await ssm.send(
-			new PutParameterCommand({
-				Name: '/codebuild/github-token',
-				Value: token,
-				Type: 'String',
-			}),
-		)
+
+		await putApiSetting({
+			ssm,
+			stackName: CORE_STACK_NAME,
+			scope: 'codebuild',
+			api: 'github',
+		})({
+			property: 'token',
+			value: token,
+		})
 
 		const cp = new CodePipelineClient({})
 		const pipelines = await listPipelines()