├── .eslintrc
├── LICENSE.md
├── README.md
├── bin
    ├── cfn-check.js
    └── scrape.js
├── data
    └── resources.json
├── lib
    ├── check
    │   ├── format.js
    │   ├── index.js
    │   ├── references.js
    │   └── resources.js
    └── parse.js
├── package.json
├── scrape.js
└── test
    ├── checkFormatTest.js
    ├── checkReferencesTest.js
    ├── checkResourcesTest.js
    ├── notJSON.json
    ├── parseTest.js
    └── template.json


/.eslintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "env": {
 3 |     "es6": true,
 4 |     "node": true
 5 |   },
 6 |   "extends": "eslint:recommended",
 7 |   "rules": {
 8 |     "no-console": 0,
 9 |     "quotes": [2, "single"],
10 |     "strict": [2, "global"]
11 |   },
12 |   "globals": {
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | =====================
 3 | 
 4 | Copyright (c) 2015 Versent
 5 | --------------------------------------------
 6 | 
 7 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 8 | 
 9 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
10 | 
11 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # cfn-check
 2 | 
 3 | A command-line tool for validating CloudFormation templates **quickly**.
 4 | 
 5 | ## Overview
 6 | 
 7 | [CloudFormation](https://aws.amazon.com/cloudformation/) is great.
 8 | Unfortunately, the error handling leaves a bit to be desired.
 9 | 
10 | The [AWS CLI](https://aws.amazon.com/cli/) provided
11 | [`validate-template`](http://docs.aws.amazon.com/cli/latest/reference/cloudformation/validate-template.html) command only
12 | checks your
13 | [syntax](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-validate-template.html), not the actual resources, their properties, etc. This means you can *think* you're successfully creating a new stack, and still get a `CREATE_FAIL`. This tool aims to give you quick feedback so you spend less time banging your head against the CloudFormation Console.
14 | 
15 | ## Installation
16 | 
17 |     npm install -g cfn-check
18 | 
19 | ## Usage
20 | 
21 |     Usage: cfn-check [options] <template>
22 | 
23 |     Options:
24 | 
25 |       -h, --help     output usage information
26 |       -V, --version  output the version number
27 |       -w, --watch    Watch template for changes
28 |       -p, --pretty   Print pretty JSON when valid (regardless of character limit)
29 |       -c, --compact  Print compact JSON when valid (regardless of character limit)
30 | 
31 | ### Planned
32 | 
33 | * `quiet` don't output anything, just set return code.
34 | * `verbose` increase the logging level.
35 | 
36 | ## Checks
37 | 
38 | * JSON is valid.
39 | * `Ref`s are valid parameters, resources, or [pseudo
40 |   parameters](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/pseudo-parameter-reference.html).
41 | * All Resource `Type` properties are valid Types as defined in the [Resource
42 |   Types
43 |   Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html),
44 |   including Custom Resources.
45 | * Validate `AWSTemplateFormatVersion`
46 |   * Enforce presence
47 |   * `cfn-check` only validates <= '2010-09-09'
48 | 
49 | ### Planned
50 | 
51 | * Output compact JSON if over character limit (51,200 bytes) or requested
52 | * Validate Intrinsic `Fn` arguments
53 | * `Fn`s can only be used in resource properties, metadata attributes, and update
54 |   policy attributes.
55 | * Validate `Resources`
56 |   * Properties
57 |     * Conditional fields
58 | * Error on
59 |   [limit](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html)
60 |   violations e.g. UserData length, template length, number of resources, etc
61 | * TAP output https://testanything.org/tap-specification.html
62 |   * Only output errors?
63 | 
64 | ## Resource Properties Definitions
65 | 
66 | The resource properties definitions are taken from the [CloudFormation User
67 | Guide Resource Types
68 | Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html).
69 | 
70 | To update the definitions (stored in [data/resources.json](data/resources.json))
71 | run:
72 | 
73 |     npm run scrape
74 | 
75 | ## Testing
76 | 
77 | To run the tests:
78 | 
79 |     npm test
80 | 
81 | To watch them:
82 | 
83 |     npm run test:watch
84 | 
85 | The [template.json](test/template.json) used in tests is taken from [the sample
86 | templates](https://s3-us-west-2.amazonaws.com/cloudformation-templates-us-west-2/AutoScalingMultiAZWithNotifications.template)
87 | that AWS provides.
88 | 
89 | ## To Do
90 | 
91 | * Inline documentation
92 | * Remove all `areValid` tests in favour of CLI-level testing
93 | 


--------------------------------------------------------------------------------
/bin/cfn-check.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 'use strict';
 3 | var _ = require('lodash');
 4 | var fs = require('fs');
 5 | var Promise = require('bluebird');
 6 | var program = require('commander');
 7 | var nodemon = require('nodemon');
 8 | 
 9 | program
10 |   .version('1.0.0')
11 |   .usage('[options] <template>')
12 |   .option('-w, --watch', 'Watch template for changes')
13 |   .option('-p, --pretty', 'Print pretty JSON when valid (regardless of character limit)')
14 |   .option('-c, --compact', 'Print compact JSON when valid (regardless of character limit)')
15 |   .parse(process.argv);
16 | 
17 | if (program.args.length < 1) { program.help(); }
18 | var spacer = 2; // Default to pretty
19 | // TODO: Change printing option depending on length of template
20 | if (program.pretty) { spacer = 2; }
21 | if (program.compact) { spacer = null; }
22 | 
23 | var parse = require('../lib/parse.js');
24 | var check = require('../lib/check');
25 | 
26 | if (program.watch) {
27 |   console.log(`Watching ${program.args}...`);
28 |   var options = {
29 |     'env': {
30 |       'NODE_ENV': 'development'
31 |     },
32 |     'restartable': 'rs',
33 |     'exec': 'cfn-check ' + program.args[0],
34 |     'stdout': true,
35 |     'verbose': false,
36 |     'quiet': true,
37 |     'watch': [
38 |       program.args[0]
39 |     ]
40 |   }
41 |   nodemon(options);
42 | } else {
43 |   parse(fs.readFileSync(program.args[0], 'utf8')).then(function (template) {
44 |     return Promise.join(
45 |       check.references.areValid(template),
46 |       check.resources.areValid(template),
47 |       function (referencesErrors, resourcesErrors) {
48 |         var errors = _.concat(referencesErrors, resourcesErrors);
49 |         if (errors.length > 0) {
50 |           console.log(errors.join('\n'));
51 |           process.exit(1);
52 |         } else {
53 |           console.log(JSON.stringify(template, null, spacer));
54 |           process.exit(0);
55 |         }
56 |       });
57 |   })
58 |   .catch(function (error) {
59 |     console.log(error.message);
60 |     process.exit(1);
61 |   });
62 | }
63 | 


--------------------------------------------------------------------------------
/bin/scrape.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var xray = require('x-ray')();
 3 | 
 4 | const url = 'https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-as-group.html';
 5 | 
 6 | xray(url, 'body', [{
 7 |     type: '.topictitle',
 8 |     properties: ['.variablelist dt'],
 9 |     descriptions: ['.variablelist dd']
10 |   }])
11 |   .paginate('#next .awstoc[accesskey="n"]@href')
12 |   .limit(170) // The number of AWS Resource Type definitions/pages
13 |   .write('data/resources.json');
14 | 


--------------------------------------------------------------------------------
/lib/check/format.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var _ = require('lodash');
 3 | var Promise = require('bluebird');
 4 | 
 5 | var checkVersion = function (template) {
 6 |   return new Promise(function (resolve) {
 7 |     var errors = [];
 8 |     if (!_.has(template, 'AWSTemplateFormatVersion')) {
 9 |       errors.push('Missing suggested "AWSTemplateFormatVersion" property');
10 |     } else {
11 |       // Eventually this should allow multilple versions/dates, but this is the
12 |       // only valid value right now.
13 |       // http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/format-version-structure.html
14 |       if (template.AWSTemplateFormatVersion !== '2010-09-09') {
15 |         errors.push(`Invalid value "${template.AWSTemplateFormatVersion}" for AWSTemplateFormatVersion`);
16 |       }
17 |     }
18 |     resolve(errors);
19 |   });
20 | }
21 | 
22 | module.exports.checkVersion = checkVersion;
23 | 


--------------------------------------------------------------------------------
/lib/check/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | module.exports = {
3 |   resources: require('./resources.js'),
4 |   references: require('./references.js')
5 | };
6 | 


--------------------------------------------------------------------------------
/lib/check/references.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var _ = require('lodash');
 3 | // var log = require('debug')('cfn-check:check:references');
 4 | var verbose = require('debug')('cfn-check:check:references:verbose');
 5 | var Promise = require('bluebird');
 6 | 
 7 | var getReferences = function (template) {
 8 |   verbose('Getting references');
 9 |   var references = [];
10 |   var traverse = function (o, parentPath) {
11 |     _.forOwn(o, function (value, key) {
12 |       var path = _.cloneDeep(parentPath) || [];
13 |       if (_.isPlainObject(value)) {
14 |         // Only add names to path (not array indexes).
15 |         if (!_.isFinite(+key)) { path.push(key); }
16 |         if (value.Ref) { // Is a Ref
17 |           value.path = path;
18 |           references.push(value);
19 |         } else { // Is another object
20 |           traverse(value, path);
21 |         }
22 |       } else if (_.isArray(value)) {
23 |         traverse(value, path);
24 |       }
25 |     });
26 |   };
27 |   traverse(template);
28 | 
29 |   return new Promise(function (resolve) {
30 |     resolve(references);
31 |   });
32 | };
33 | 
34 | var getParameters = function (template) {
35 |   return Promise.resolve(_.keys(template.Parameters));
36 | };
37 | 
38 | // http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/pseudo-parameter-reference.html
39 | var getPseudoParameters = function () {
40 |   return Promise.resolve([
41 |     'AWS::AccountId',
42 |     'AWS::NotificationARNs',
43 |     'AWS::NoValue',
44 |     'AWS::Region',
45 |     'AWS::StackId',
46 |     'AWS::StackName'
47 |   ]);
48 | };
49 | 
50 | var getResources = function (template) {
51 |   return Promise.resolve(_.keys(template.Resources));
52 | };
53 | 
54 | var validate = function (references, parameters, resources, pseudoParameters) {
55 |   var validRefs = _.concat(parameters, resources, pseudoParameters);
56 |   var errors = [];
57 |   return new Promise(function (resolve) {
58 |     _.each(references, function (r) {
59 |       if (_.indexOf(validRefs, r.Ref) < 0) {
60 |         errors.push(`"${r.Ref}" is not a valid Ref (${r.path.join('.')})`);
61 |       }
62 |       if (_.has(r, 'path')) { delete r.path; }
63 |     });
64 |     resolve(errors);
65 |   });
66 | };
67 | 
68 | var areValid = function (template) {
69 |   verbose('Validating template references');
70 |   return Promise.join(
71 |     getReferences(template),
72 |     getParameters(template),
73 |     getResources(template),
74 |     getPseudoParameters(),
75 |     validate);
76 | };
77 | 
78 | module.exports.getReferences = getReferences;
79 | module.exports.getParameters = getParameters;
80 | module.exports.getResources = getResources;
81 | module.exports.getPseudoParameters = getPseudoParameters;
82 | module.exports.areValid = areValid;
83 | 


--------------------------------------------------------------------------------
/lib/check/resources.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | var _ = require('lodash');
  3 | var Promise = require('bluebird');
  4 | 
  5 | const customResourceTypeRegex = /^Custom::.*/;
  6 | const requiredPropertyRegex = /Required: YesType/i;
  7 | 
  8 | // Creates an object (keyed by resource name) of properties that are required.
  9 | var getRequiredProperties = function (resources) {
 10 |   return new Promise(function (resolve) {
 11 |     var requiredProperties = {};
 12 |     _.each(resources, function (r) {
 13 |       requiredProperties[r.type] = [];
 14 |       _.each(r.properties, function (p, i) {
 15 |         var description = r.descriptions[i];
 16 |         if (requiredPropertyRegex.test(description)) {
 17 |           requiredProperties[r.type].push(p);
 18 |         }
 19 |       });
 20 |     });
 21 |     resolve(requiredProperties);
 22 |   });
 23 | };
 24 | 
 25 | var checkTypes = function (template) {
 26 |   return new Promise(function (resolve) {
 27 |     var resources = require('../../data/resources.json');
 28 |     var resourceTypes = _.map(resources, 'type');
 29 |     var errors = _(template.Resources)
 30 |       .map(function (r, name) {
 31 |         if (!r.Type) {
 32 |           return `Missing Type for resource ${name}`;
 33 |         }
 34 |         if (!r.Type.match(customResourceTypeRegex) &&
 35 |             (_.indexOf(resourceTypes, r.Type) < 0)) {
 36 |           return `"${r.Type}" is not a valid type for resource ${name}`;
 37 |         }
 38 |       })
 39 |      .compact()
 40 |      .value();
 41 |     resolve(errors);
 42 |   });
 43 | };
 44 | 
 45 | // Properties are validated at a template level (i.e. all Resources) in case
 46 | // there are dependencies between them (e.g. DependsOn).
 47 | var checkValidProperties = function (template) {
 48 |   return new Promise(function (resolve) {
 49 |     var resources = require('../../data/resources.json');
 50 |     var errors = _(template.Resources)
 51 |       .map(function (r, name) {
 52 |         var definition = _.find(resources, ['type', r.Type])
 53 |         // NOTE: Does not check properties if type is not recognised
 54 |         if (definition) {
 55 |           var properties = _.keys(r.Properties);
 56 |           return _.map(properties, function (p) {
 57 |             if (_.indexOf(definition.properties, p) < 0) {
 58 |               return `"${p}" is not a valid property for resrouce ${name} (${r.Type})`;
 59 |             }
 60 |           });
 61 |         }
 62 |       })
 63 |       .flatten()
 64 |       .compact()
 65 |       .value();
 66 |     resolve(errors);
 67 |   });
 68 | };
 69 | 
 70 | var checkRequiredProperties = function (template) {
 71 |   var resources = require('../../data/resources.json');
 72 |   return getRequiredProperties(resources).then(function (allRequiredProperties) {
 73 |     var errors = _(template.Resources)
 74 |       .map(function (r, name) {
 75 |         var requiredProperties = allRequiredProperties[r.Type];
 76 |         // NOTE: Does not check properties if type is not recognised
 77 |         if (requiredProperties) {
 78 |           var properties = _.keys(r.Properties);
 79 |           return _.map(requiredProperties, function (p) {
 80 |             if (_.indexOf(properties, p) < 0) {
 81 |               return `Required property "${p}" is not present for resource ${name} (${r.Type})`;
 82 |             }
 83 |           });
 84 |         }
 85 |       })
 86 |       .flatten()
 87 |       .compact()
 88 |       .value();
 89 |     return errors;
 90 |   });
 91 | };
 92 | 
 93 | var areValid = function (template) {
 94 |   return Promise.join(
 95 |     checkTypes(template),
 96 |     checkValidProperties(template),
 97 |     checkRequiredProperties(template),
 98 |     function (typeErrors, validPropertiesErrors, requiredPropertiesErrors) {
 99 |       return _.concat(typeErrors,
100 |                       validPropertiesErrors,
101 |                       requiredPropertiesErrors);
102 |     });
103 | };
104 | 
105 | module.exports.getRequiredProperties = getRequiredProperties;
106 | module.exports.checkTypes = checkTypes;
107 | module.exports.checkValidProperties = checkValidProperties;
108 | module.exports.checkRequiredProperties = checkRequiredProperties;
109 | module.exports.areValid = areValid;
110 | 


--------------------------------------------------------------------------------
/lib/parse.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var verbose = require('debug')('cfn-check:parse:verbose');
 3 | var Promise = require('bluebird');
 4 | var jsonlint = require('jsonlint');
 5 | 
 6 | var parse = function (templateString) {
 7 |   return new Promise(function (resolve) {
 8 |     verbose('Validating JSON');
 9 |     // NOTE: parse() throws Error if invalid JSON.
10 |     var template = jsonlint.parse(templateString);
11 |     resolve(template);
12 |   });
13 | };
14 | 
15 | module.exports = parse;
16 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cfn-check",
 3 |   "version": "1.5.0",
 4 |   "description": "CloudFormation template validation tool",
 5 |   "main": "./lib/cfn-check.js",
 6 |   "scripts": {
 7 |     "scrape": "node bin/scrape.js",
 8 |     "test": "NODE_ENV=test tap test/*.js",
 9 |     "test:watch": "nodemon --ext js --exec 'clear && npm test'"
10 |   },
11 |   "bin": {
12 |     "cfn-check": "./bin/cfn-check.js"
13 |   },
14 |   "keywords": ["aws", "cloudformation", "cfn", "validation"],
15 |   "author": "Rowan Udell <rowanu@gmail.com>",
16 |   "license": "ISC",
17 |   "devDependencies": {
18 |     "tap": "^5.7.0",
19 |     "x-ray": "^2.2.0"
20 |   },
21 |   "dependencies": {
22 |     "bluebird": "^3.3.4",
23 |     "commander": "^2.9.0",
24 |     "debug": "^2.2.0",
25 |     "jsonlint": "^1.6.2",
26 |     "lodash": "^4.10.0",
27 |     "nodemon": "^1.9.1"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/scrape.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var rootUrl = 'https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html';
3 | 


--------------------------------------------------------------------------------
/test/checkFormatTest.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var _ = require('lodash');
 3 | var tap = require('tap');
 4 | 
 5 | var format = require('../lib/check/format.js');
 6 | 
 7 | tap.test('checkFormat with a valid template', function (t) {
 8 |   t.plan(1);
 9 |   var template = _.cloneDeep(require('./template.json'));
10 |   return format.checkVersion(template).then(function (errors) {
11 |     t.equal(errors.length, 0, 'has no errors');
12 |   });
13 | });
14 | 
15 | tap.test('checkFormat with no format version', function (t) {
16 |   t.plan(2);
17 |   var template = _.cloneDeep(require('./template.json'));
18 |   _.unset(template, 'AWSTemplateFormatVersion');
19 |   return format.checkVersion(template).then(function (errors) {
20 |     t.equal(errors.length, 1, 'has one error');
21 |     t.match(errors[0], /AWSTemplateFormatVersion/, 'includes the missing key');
22 |   });
23 | });
24 | 
25 | tap.test('checkFormat with format version later than "2010-09-09"', function (t) {
26 |   t.plan(3);
27 |   var template = _.cloneDeep(require('./template.json'));
28 |   template.AWSTemplateFormatVersion = '2016-04-20';
29 |   return format.checkVersion(template).then(function (errors) {
30 |     t.equal(errors.length, 1, 'has one error');
31 |     t.match(errors[0], /AWSTemplateFormatVersion/, 'includes the missing key');
32 |     t.match(errors[0], /2016-04-20/, 'includes the invalid date');
33 |   });
34 | });
35 | 


--------------------------------------------------------------------------------
/test/checkReferencesTest.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var tap = require('tap');
 3 | 
 4 | var references = require('../lib/check/references.js');
 5 | 
 6 | tap.test('getReferences', function (t) {
 7 |   t.plan(1);
 8 |   var template = require('./template.json');
 9 |   return references.getReferences(template).then(function (refs) {
10 |     t.equal(refs.length, 25, 'gets all the refs');
11 |   });
12 | });
13 | 
14 | tap.test('getParameters', function (t) {
15 |   t.plan(2);
16 |   var template = require('./template.json');
17 |   return references.getParameters(template).then(function (params) {
18 |     t.equal(params.length, 4, 'gets all the params');
19 |     t.ok(params.indexOf('SSHLocation') > -1, 'has SSHLocation parameter');
20 |   });
21 | });
22 | 
23 | tap.test('getResources', function (t) {
24 |   t.plan(2);
25 |   var template = require('./template.json');
26 |   return references.getResources(template).then(function (resources) {
27 |     t.equal(resources.length, 9, 'gets all the params');
28 |     t.ok(resources.indexOf('WebServerGroup') > -1,
29 |          'has WebServerGroup resource');
30 |   });
31 | });
32 | 
33 | tap.test('getPseudoParameters', function (t) {
34 |   t.plan(2);
35 |   return references.getPseudoParameters().then(function (pseudos) {
36 |     t.equal(pseudos.length, 6, 'gets all the params');
37 |     t.ok(pseudos.indexOf('AWS::AccountId') > -1,
38 |          'has AWS::AccountId parameter');
39 |   });
40 | });
41 | 
42 | tap.test('areValid with valid template', function (t) {
43 |   t.plan(1);
44 |   var template = require('./template.json');
45 |   return references.areValid(template).then(function (errors) {
46 |     t.equal(errors.length, 0, 'has no errors');
47 |   });
48 | });
49 | 
50 | tap.test('areValid with invalid template', function (t) {
51 |   t.plan(3);
52 |   var template = require('./template.json');
53 |   template
54 |     .Resources
55 |     .WebServerGroup
56 |     .Properties
57 |     .LaunchConfigurationName
58 |     .Ref = 'NotAValidRef';
59 |   return references.areValid(template).then(function (errors) {
60 |     var error = errors[0];
61 |     t.equal(errors.length, 1, 'has one error')
62 |     t.match(error, /NotAValidRef/, 'includes the invalid ref')
63 |     t.match(error,
64 |             /Resources\.WebServerGroup\.Properties\.LaunchConfigurationName/,
65 |             'includes the path to ref')
66 |   });
67 | });
68 | 
69 | tap.test('areValid with an excpetion');
70 | 


--------------------------------------------------------------------------------
/test/checkResourcesTest.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | var _ = require('lodash');
  3 | var tap = require('tap');
  4 | 
  5 | var checkResources = require('../lib/check/resources.js');
  6 | 
  7 | tap.test('checkTypes with valid template', function (t) {
  8 |   t.plan(1);
  9 |   var template = _.cloneDeep(require('./template.json'));
 10 |   return checkResources.checkTypes(template).then(function (errors) {
 11 |     t.equal(errors.length, 0, 'has no errors');
 12 |   });
 13 | });
 14 | 
 15 | tap.test('checkTypes with no resource type', function (t) {
 16 |   t.plan(3);
 17 |   var template = _.cloneDeep(require('./template.json'));
 18 |   _.unset(template, 'Resources.ElasticLoadBalancer.Type');
 19 |   return checkResources.checkTypes(template).then(function (errors) {
 20 |     var error = errors[0];
 21 |     t.equal(errors.length, 1, 'has one error');
 22 |     t.match(error, /ElasticLoadBalancer/, 'has the invalid Resource\'s name');
 23 |     t.match(error, /missing/i, 'is definied as missing');
 24 |   });
 25 | });
 26 | 
 27 | tap.test('checkTypes with invalid resource type', function (t) {
 28 |   t.plan(3);
 29 |   var template = _.cloneDeep(require('./template.json'));
 30 |   var invalidType = template.Resources.ElasticLoadBalancer.Type = 'AWS::Not::A::Resource';
 31 |   return checkResources.checkTypes(template).then(function (errors) {
 32 |     var error = errors[0];
 33 |     t.equal(errors.length, 1, 'has one error');
 34 |     t.match(error, /ElasticLoadBalancer/, 'has the invalid Resource\'s name');
 35 |     t.match(error, new RegExp(invalidType), 'has the invalid type\'s name');
 36 |   });
 37 | });
 38 | 
 39 | tap.test('checkTypes with custom resource', function (t) {
 40 |   t.plan(1);
 41 |   var template = _.cloneDeep(require('./template.json'));
 42 |   // Example taken from CustomResource Type Reference
 43 |   template.Resources.MyFrontEndTest = {
 44 |     'Type': 'Custom::Thing',
 45 |     'Version': '1.0',
 46 |     'Properties': {
 47 |       'ServiceToken': 'arn:aws:sns:us-east-1:84969EXAMPLE:CRTest',
 48 |       'key1': 'string',
 49 |       'key2': [
 50 |         'list'
 51 |       ],
 52 |       'key3': {
 53 |         'key4': 'map'
 54 |       }
 55 |     }
 56 |   }
 57 |   return checkResources.checkTypes(template).then(function (errors) {
 58 |     t.equal(errors.length, 0, 'has no errors');
 59 |   });
 60 | });
 61 | 
 62 | tap.test('checkValidProperties with invalid resource property', function (t) {
 63 |   t.plan(3);
 64 |   var template = _.cloneDeep(require('./template.json'));
 65 |   var invalidProperty = 'NotAProperty';
 66 |   template.Resources.ElasticLoadBalancer.Properties[invalidProperty] = 'AValue';
 67 |   return checkResources.checkValidProperties(template).then(function (errors) {
 68 |     var error = errors[0];
 69 |     t.equal(errors.length, 1, 'has one error');
 70 |     t.match(error, /ElasticLoadBalancer/, 'has the invalid Resource\'s name');
 71 |     t.match(error, new RegExp(invalidProperty), 'has the invalid property\'s name');
 72 |   });
 73 | });
 74 | 
 75 | tap.test('getRequiredProperties generates required properties', function (t) {
 76 |   t.plan(2);
 77 |   var resources = require('../data/resources.json');
 78 |   checkResources.getRequiredProperties(resources).then(function (requiredProperties) {
 79 |     t.same(requiredProperties['AWS::AutoScaling::LaunchConfiguration'],
 80 |            ['ImageId', 'InstanceType'],
 81 |            'LaunchConfiguration has required properties ImageId and InstanceType');
 82 |     t.same(requiredProperties['AWS::WAF::Rule'],
 83 |            ['MetricName', 'Name'],
 84 |            'WAF::Rule has required properties MetricName and Name');
 85 |   });
 86 | })
 87 | 
 88 | tap.test('checkRequiredProperties with missing required property', function (t) {
 89 |   t.plan(3);
 90 |   var template = _.cloneDeep(require('./template.json'));
 91 |   _.unset(template, 'Resources.CPUAlarmLow.Properties.MetricName');
 92 |   checkResources.checkRequiredProperties(template).then(function (errors) {
 93 |     t.equal(errors.length, 1, 'has one error');
 94 |     t.match(errors[0], /CPUAlarmLow/, 'has the invalid Resource\'s name');
 95 |     t.match(errors[0], /MetricName/, 'has the missing property\'s name');
 96 |   });
 97 | });
 98 | 
 99 | tap.test('checkValidProperties with valid DependsOn reference');
100 | tap.test('checkValidProperties with invalid DependsOn reference');
101 | tap.test('checkValidProperties with valid DependsOn reference (multiple)');
102 | tap.test('checkValidProperties with invalid DependsOn reference (multiple)');
103 | tap.test('checkValidProperties with no conditional properties');
104 | tap.test('checkValidProperties with multiple conditional properties');
105 | tap.test('checkValidProperties with invalid property data type'); // e.g. Number vs String
106 | // http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cfn-customresource.html
107 | tap.test('checkValidProperties with CustomResource'); // Only ServiceToken is required
108 | 
109 | tap.test('areValid with valid template', function (t) {
110 |   t.plan(1);
111 |   var template = require('./template.json');
112 |   return checkResources.areValid(template).then(function (errors) {
113 |     t.equal(errors.length, 0, 'has no errors');
114 |   });
115 | });
116 | 
117 | tap.test('areValid with invalid resource type', function (t) {
118 |   t.plan(3);
119 |   var template = _.cloneDeep(require('./template.json'));
120 |   var invalidType = template.Resources.ElasticLoadBalancer.Type = 'AWS::Not::A::Resource';
121 |   return checkResources.areValid(template).then(function (errors) {
122 |     var error = errors[0];
123 |     t.equal(errors.length, 1, 'has one error');
124 |     t.match(error, /ElasticLoadBalancer/, 'has the invalid Resource\'s name');
125 |     t.match(error, new RegExp(invalidType), 'has the invalid type\'s name');
126 |   });
127 | });
128 | 
129 | tap.test('areValid with invalid resource property', function (t) {
130 |   t.plan(3);
131 |   var template = _.cloneDeep(require('./template.json'));
132 |   var invalidProperty = 'NotAProperty';
133 |   template.Resources.LaunchConfig.Properties[invalidProperty] = 'AValue';
134 |   return checkResources.areValid(template).then(function (errors) {
135 |     var error = errors[0];
136 |     t.equal(errors.length, 1, 'has one error');
137 |     t.match(error, /LaunchConfig/, 'has the invalid Resource\'s name');
138 |     t.match(error, new RegExp(invalidProperty), 'has the invalid property\'s name');
139 |   });
140 | });
141 | 
142 | tap.test('areValid with missing required property', function (t) {
143 |   t.plan(3);
144 |   var template = _.cloneDeep(require('./template.json'));
145 |   _.unset(template, 'Resources.CPUAlarmLow.Properties.MetricName');
146 |   checkResources.areValid(template).then(function (errors) {
147 |     t.equal(errors.length, 1, 'has one error');
148 |     t.match(errors[0], /CPUAlarmLow/, 'has the invalid Resource\'s name');
149 |     t.match(errors[0], /MetricName/, 'has the missing property\'s name');
150 |   });
151 | });
152 | 
153 | tap.test('areValid with invalid type and properties', function (t) {
154 |   t.plan(5);
155 |   var template = _.cloneDeep(require('./template.json'));
156 |   var invalidType = template.Resources.ElasticLoadBalancer.Type = 'AWS::Not::A::Resource';
157 |   var invalidProperty = 'NotAProperty';
158 |   template.Resources.LaunchConfig.Properties[invalidProperty] = 'AValue';
159 |   return checkResources.areValid(template).then(function (errors) {
160 |     t.equal(errors.length, 2, 'has one error');
161 |     // Type error
162 |     t.match(errors[0], /ElasticLoadBalancer/, 'has the invalid Resource\'s name');
163 |     t.match(errors[0], new RegExp(invalidType), 'has the invalid type\'s name');
164 |     // Properties error
165 |     t.match(errors[1], /LaunchConfig/, 'has the invalid Resource\'s name');
166 |     t.match(errors[1], new RegExp(invalidProperty), 'has the invalid property\'s name');
167 |   });
168 | });
169 | 
170 | tap.test('areValid with an excpetion');
171 | 


--------------------------------------------------------------------------------
/test/notJSON.json:
--------------------------------------------------------------------------------
1 | These are not the JSONs your are looking for...
2 | 


--------------------------------------------------------------------------------
/test/parseTest.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | var fs = require('fs');
 3 | var tap = require('tap');
 4 | 
 5 | var parse = require('../lib/parse.js');
 6 | 
 7 | tap.test('parse valid JSON', function (t) {
 8 |   var file = fs.readFileSync('test/template.json');
 9 |   return parse(file.toString()).then(function (template) {
10 |     t.type(template, 'object', 'is an object');
11 |     t.ok(template.Parameters, 'has Parameters');
12 |   });
13 | });
14 | 
15 | tap.test('parse invalid JSON', function (t) {
16 |   t.plan(2);
17 |   var file = fs.readFileSync('test/notJSON.json');
18 |   return parse(file.toString()).catch(function (error) {
19 |     t.type(error, Error, 'has an error');
20 |     t.match(error.message, /line 1/, 'includes the line number')
21 |   });
22 | });
23 | 


--------------------------------------------------------------------------------
/test/template.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "AWSTemplateFormatVersion" : "2010-09-09",
  3 | 
  4 |   "Description" : "AWS CloudFormation Sample Template AutoScalingMultiAZWithNotifications: Create a multi-az, load balanced and Auto Scaled sample web site running on an Apache Web Serever. The application is configured to span all Availability Zones in the region and is Auto-Scaled based on the CPU utilization of the web servers. Notifications will be sent to the operator email address on scaling events. The instances are load balanced with a simple health check against the default web page. **WARNING** This template creates one or more Amazon EC2 instances and an Elastic Load Balancer. You will be billed for the AWS resources used if you create a stack from this template.",
  5 | 
  6 |   "Parameters" : {
  7 |     "InstanceType" : {
  8 |       "Description" : "WebServer EC2 instance type",
  9 |       "Type" : "String",
 10 |       "Default" : "t2.small",
 11 |       "AllowedValues" : [ "t1.micro", "t2.nano", "t2.micro", "t2.small", "t2.medium", "t2.large", "m1.small", "m1.medium", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "m3.medium", "m3.large", "m3.xlarge", "m3.2xlarge", "m4.large", "m4.xlarge", "m4.2xlarge", "m4.4xlarge", "m4.10xlarge", "c1.medium", "c1.xlarge", "c3.large", "c3.xlarge", "c3.2xlarge", "c3.4xlarge", "c3.8xlarge", "c4.large", "c4.xlarge", "c4.2xlarge", "c4.4xlarge", "c4.8xlarge", "g2.2xlarge", "g2.8xlarge", "r3.large", "r3.xlarge", "r3.2xlarge", "r3.4xlarge", "r3.8xlarge", "i2.xlarge", "i2.2xlarge", "i2.4xlarge", "i2.8xlarge", "d2.xlarge", "d2.2xlarge", "d2.4xlarge", "d2.8xlarge", "hi1.4xlarge", "hs1.8xlarge", "cr1.8xlarge", "cc2.8xlarge", "cg1.4xlarge"]
 12 | ,
 13 |       "ConstraintDescription" : "must be a valid EC2 instance type."
 14 |     },
 15 | 
 16 |     "OperatorEMail": {
 17 |       "Description": "EMail address to notify if there are any scaling operations",
 18 |       "Type": "String",
 19 |       "AllowedPattern": "([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)",
 20 |       "ConstraintDescription": "must be a valid email address."
 21 |     },
 22 | 
 23 |     "KeyName" : {
 24 |       "Description" : "The EC2 Key Pair to allow SSH access to the instances",
 25 |       "Type" : "AWS::EC2::KeyPair::KeyName",
 26 |       "ConstraintDescription" : "must be the name of an existing EC2 KeyPair."
 27 |     },
 28 | 
 29 |     "SSHLocation" : {
 30 |       "Description" : "The IP address range that can be used to SSH to the EC2 instances",
 31 |       "Type": "String",
 32 |       "MinLength": "9",
 33 |       "MaxLength": "18",
 34 |       "Default": "0.0.0.0/0",
 35 |       "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
 36 |       "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
 37 |     }
 38 |   },
 39 | 
 40 |   "Mappings" : {
 41 |     "Region2Examples" : {
 42 |       "us-east-1"      : { "Examples" : "https://s3.amazonaws.com/cloudformation-examples-us-east-1" },
 43 |       "us-west-2"      : { "Examples" : "https://s3-us-west-2.amazonaws.com/cloudformation-examples-us-west-2" },
 44 |       "us-west-1"      : { "Examples" : "https://s3-us-west-1.amazonaws.com/cloudformation-examples-us-west-1" },
 45 |       "eu-west-1"      : { "Examples" : "https://s3-eu-west-1.amazonaws.com/cloudformation-examples-eu-west-1" },
 46 |       "eu-central-1"   : { "Examples" : "https://s3-eu-central-1.amazonaws.com/cloudformation-examples-eu-central-1" },
 47 |       "ap-southeast-1" : { "Examples" : "https://s3-ap-southeast-1.amazonaws.com/cloudformation-examples-ap-southeast-1" },
 48 |       "ap-northeast-1" : { "Examples" : "https://s3-ap-northeast-1.amazonaws.com/cloudformation-examples-ap-northeast-1" },
 49 |       "ap-northeast-2" : { "Examples" : "https://s3-ap-northeast-2.amazonaws.com/cloudformation-examples-ap-northeast-2" },
 50 |       "ap-southeast-2" : { "Examples" : "https://s3-ap-southeast-2.amazonaws.com/cloudformation-examples-ap-southeast-2" },
 51 |       "sa-east-1"      : { "Examples" : "https://s3-sa-east-1.amazonaws.com/cloudformation-examples-sa-east-1" },
 52 |       "cn-north-1"     : { "Examples" : "https://s3.cn-north-1.amazonaws.com.cn/cloudformation-examples-cn-north-1" }
 53 |     }
 54 | ,
 55 |     "AWSInstanceType2Arch" : {
 56 |       "t1.micro"    : { "Arch" : "PV64"   },
 57 |       "t2.nano"     : { "Arch" : "HVM64"  },
 58 |       "t2.micro"    : { "Arch" : "HVM64"  },
 59 |       "t2.small"    : { "Arch" : "HVM64"  },
 60 |       "t2.medium"   : { "Arch" : "HVM64"  },
 61 |       "t2.large"    : { "Arch" : "HVM64"  },
 62 |       "m1.small"    : { "Arch" : "PV64"   },
 63 |       "m1.medium"   : { "Arch" : "PV64"   },
 64 |       "m1.large"    : { "Arch" : "PV64"   },
 65 |       "m1.xlarge"   : { "Arch" : "PV64"   },
 66 |       "m2.xlarge"   : { "Arch" : "PV64"   },
 67 |       "m2.2xlarge"  : { "Arch" : "PV64"   },
 68 |       "m2.4xlarge"  : { "Arch" : "PV64"   },
 69 |       "m3.medium"   : { "Arch" : "HVM64"  },
 70 |       "m3.large"    : { "Arch" : "HVM64"  },
 71 |       "m3.xlarge"   : { "Arch" : "HVM64"  },
 72 |       "m3.2xlarge"  : { "Arch" : "HVM64"  },
 73 |       "m4.large"    : { "Arch" : "HVM64"  },
 74 |       "m4.xlarge"   : { "Arch" : "HVM64"  },
 75 |       "m4.2xlarge"  : { "Arch" : "HVM64"  },
 76 |       "m4.4xlarge"  : { "Arch" : "HVM64"  },
 77 |       "m4.10xlarge" : { "Arch" : "HVM64"  },
 78 |       "c1.medium"   : { "Arch" : "PV64"   },
 79 |       "c1.xlarge"   : { "Arch" : "PV64"   },
 80 |       "c3.large"    : { "Arch" : "HVM64"  },
 81 |       "c3.xlarge"   : { "Arch" : "HVM64"  },
 82 |       "c3.2xlarge"  : { "Arch" : "HVM64"  },
 83 |       "c3.4xlarge"  : { "Arch" : "HVM64"  },
 84 |       "c3.8xlarge"  : { "Arch" : "HVM64"  },
 85 |       "c4.large"    : { "Arch" : "HVM64"  },
 86 |       "c4.xlarge"   : { "Arch" : "HVM64"  },
 87 |       "c4.2xlarge"  : { "Arch" : "HVM64"  },
 88 |       "c4.4xlarge"  : { "Arch" : "HVM64"  },
 89 |       "c4.8xlarge"  : { "Arch" : "HVM64"  },
 90 |       "g2.2xlarge"  : { "Arch" : "HVMG2"  },
 91 |       "g2.8xlarge"  : { "Arch" : "HVMG2"  },
 92 |       "r3.large"    : { "Arch" : "HVM64"  },
 93 |       "r3.xlarge"   : { "Arch" : "HVM64"  },
 94 |       "r3.2xlarge"  : { "Arch" : "HVM64"  },
 95 |       "r3.4xlarge"  : { "Arch" : "HVM64"  },
 96 |       "r3.8xlarge"  : { "Arch" : "HVM64"  },
 97 |       "i2.xlarge"   : { "Arch" : "HVM64"  },
 98 |       "i2.2xlarge"  : { "Arch" : "HVM64"  },
 99 |       "i2.4xlarge"  : { "Arch" : "HVM64"  },
100 |       "i2.8xlarge"  : { "Arch" : "HVM64"  },
101 |       "d2.xlarge"   : { "Arch" : "HVM64"  },
102 |       "d2.2xlarge"  : { "Arch" : "HVM64"  },
103 |       "d2.4xlarge"  : { "Arch" : "HVM64"  },
104 |       "d2.8xlarge"  : { "Arch" : "HVM64"  },
105 |       "hi1.4xlarge" : { "Arch" : "HVM64"  },
106 |       "hs1.8xlarge" : { "Arch" : "HVM64"  },
107 |       "cr1.8xlarge" : { "Arch" : "HVM64"  },
108 |       "cc2.8xlarge" : { "Arch" : "HVM64"  }
109 |     },
110 | 
111 |     "AWSInstanceType2NATArch" : {
112 |       "t1.micro"    : { "Arch" : "NATPV64"   },
113 |       "t2.nano"     : { "Arch" : "NATHVM64"  },
114 |       "t2.micro"    : { "Arch" : "NATHVM64"  },
115 |       "t2.small"    : { "Arch" : "NATHVM64"  },
116 |       "t2.medium"   : { "Arch" : "NATHVM64"  },
117 |       "t2.large"    : { "Arch" : "NATHVM64"  },
118 |       "m1.small"    : { "Arch" : "NATPV64"   },
119 |       "m1.medium"   : { "Arch" : "NATPV64"   },
120 |       "m1.large"    : { "Arch" : "NATPV64"   },
121 |       "m1.xlarge"   : { "Arch" : "NATPV64"   },
122 |       "m2.xlarge"   : { "Arch" : "NATPV64"   },
123 |       "m2.2xlarge"  : { "Arch" : "NATPV64"   },
124 |       "m2.4xlarge"  : { "Arch" : "NATPV64"   },
125 |       "m3.medium"   : { "Arch" : "NATHVM64"  },
126 |       "m3.large"    : { "Arch" : "NATHVM64"  },
127 |       "m3.xlarge"   : { "Arch" : "NATHVM64"  },
128 |       "m3.2xlarge"  : { "Arch" : "NATHVM64"  },
129 |       "m4.large"    : { "Arch" : "NATHVM64"  },
130 |       "m4.xlarge"   : { "Arch" : "NATHVM64"  },
131 |       "m4.2xlarge"  : { "Arch" : "NATHVM64"  },
132 |       "m4.4xlarge"  : { "Arch" : "NATHVM64"  },
133 |       "m4.10xlarge" : { "Arch" : "NATHVM64"  },
134 |       "c1.medium"   : { "Arch" : "NATPV64"   },
135 |       "c1.xlarge"   : { "Arch" : "NATPV64"   },
136 |       "c3.large"    : { "Arch" : "NATHVM64"  },
137 |       "c3.xlarge"   : { "Arch" : "NATHVM64"  },
138 |       "c3.2xlarge"  : { "Arch" : "NATHVM64"  },
139 |       "c3.4xlarge"  : { "Arch" : "NATHVM64"  },
140 |       "c3.8xlarge"  : { "Arch" : "NATHVM64"  },
141 |       "c4.large"    : { "Arch" : "NATHVM64"  },
142 |       "c4.xlarge"   : { "Arch" : "NATHVM64"  },
143 |       "c4.2xlarge"  : { "Arch" : "NATHVM64"  },
144 |       "c4.4xlarge"  : { "Arch" : "NATHVM64"  },
145 |       "c4.8xlarge"  : { "Arch" : "NATHVM64"  },
146 |       "g2.2xlarge"  : { "Arch" : "NATHVMG2"  },
147 |       "g2.8xlarge"  : { "Arch" : "NATHVMG2"  },
148 |       "r3.large"    : { "Arch" : "NATHVM64"  },
149 |       "r3.xlarge"   : { "Arch" : "NATHVM64"  },
150 |       "r3.2xlarge"  : { "Arch" : "NATHVM64"  },
151 |       "r3.4xlarge"  : { "Arch" : "NATHVM64"  },
152 |       "r3.8xlarge"  : { "Arch" : "NATHVM64"  },
153 |       "i2.xlarge"   : { "Arch" : "NATHVM64"  },
154 |       "i2.2xlarge"  : { "Arch" : "NATHVM64"  },
155 |       "i2.4xlarge"  : { "Arch" : "NATHVM64"  },
156 |       "i2.8xlarge"  : { "Arch" : "NATHVM64"  },
157 |       "d2.xlarge"   : { "Arch" : "NATHVM64"  },
158 |       "d2.2xlarge"  : { "Arch" : "NATHVM64"  },
159 |       "d2.4xlarge"  : { "Arch" : "NATHVM64"  },
160 |       "d2.8xlarge"  : { "Arch" : "NATHVM64"  },
161 |       "hi1.4xlarge" : { "Arch" : "NATHVM64"  },
162 |       "hs1.8xlarge" : { "Arch" : "NATHVM64"  },
163 |       "cr1.8xlarge" : { "Arch" : "NATHVM64"  },
164 |       "cc2.8xlarge" : { "Arch" : "NATHVM64"  }
165 |     }
166 | ,
167 |     "AWSRegionArch2AMI" : {
168 |       "us-east-1"        : {"PV64" : "ami-22111148", "HVM64" : "ami-08111162", "HVMG2" : "ami-ebcec381"},
169 |       "us-west-2"        : {"PV64" : "ami-792bc219", "HVM64" : "ami-c229c0a2", "HVMG2" : "ami-0f28c06f"},
170 |       "us-west-1"        : {"PV64" : "ami-0e087a6e", "HVM64" : "ami-1b0f7d7b", "HVMG2" : "ami-ab9defcb"},
171 |       "eu-west-1"        : {"PV64" : "ami-a5368cd6", "HVM64" : "ami-31328842", "HVMG2" : "ami-d1d652a2"},
172 |       "eu-central-1"     : {"PV64" : "ami-2bde3944", "HVM64" : "ami-e2df388d", "HVMG2" : "ami-5240a73d"},
173 |       "ap-northeast-1"   : {"PV64" : "ami-37020959", "HVM64" : "ami-f80e0596", "HVMG2" : "ami-34a9a35a"},
174 |       "ap-northeast-2"   : {"PV64" : "NOT_SUPPORTED", "HVM64" : "ami-6598510b", "HVMG2" : "NOT_SUPPORTED"},
175 |       "ap-southeast-1"   : {"PV64" : "ami-ff0cc79c", "HVM64" : "ami-e90dc68a", "HVMG2" : "ami-6f6ca70c"},
176 |       "ap-southeast-2"   : {"PV64" : "ami-f5210196", "HVM64" : "ami-f2210191", "HVMG2" : "ami-88c1e1eb"},
177 |       "sa-east-1"        : {"PV64" : "ami-661e930a", "HVM64" : "ami-1e159872", "HVMG2" : "NOT_SUPPORTED"},
178 |       "cn-north-1"       : {"PV64" : "ami-08ef2465", "HVM64" : "ami-49e22924", "HVMG2" : "NOT_SUPPORTED"}
179 |     }
180 | 
181 |   },
182 | 
183 |   "Resources" : {
184 |     "NotificationTopic": {
185 |       "Type": "AWS::SNS::Topic",
186 |       "Properties": {
187 |         "Subscription": [ { "Endpoint": { "Ref": "OperatorEMail" }, "Protocol": "email" } ]
188 |       }
189 |     },
190 | 
191 |     "WebServerGroup" : {
192 |       "Type" : "AWS::AutoScaling::AutoScalingGroup",
193 |       "Properties" : {
194 |         "AvailabilityZones" : { "Fn::GetAZs" : ""},
195 |         "LaunchConfigurationName" : { "Ref" : "LaunchConfig" },
196 |         "MinSize" : "1",
197 |         "MaxSize" : "3",
198 |         "LoadBalancerNames" : [ { "Ref" : "ElasticLoadBalancer" } ],
199 |         "NotificationConfigurations" : {
200 |           "TopicARN" : { "Ref" : "NotificationTopic" },
201 |           "NotificationTypes" : [ "autoscaling:EC2_INSTANCE_LAUNCH",
202 |                                   "autoscaling:EC2_INSTANCE_LAUNCH_ERROR",
203 |                                   "autoscaling:EC2_INSTANCE_TERMINATE",
204 |                                   "autoscaling:EC2_INSTANCE_TERMINATE_ERROR"]
205 |         }
206 |       },
207 |       "CreationPolicy" : {
208 |         "ResourceSignal" : {
209 |           "Timeout" : "PT15M",
210 |           "Count"   : "1"
211 |         }
212 |       },
213 |       "UpdatePolicy": {
214 |         "AutoScalingRollingUpdate": {
215 |           "MinInstancesInService": "1",
216 |           "MaxBatchSize": "1",
217 |           "PauseTime" : "PT15M",
218 |           "WaitOnResourceSignals": "true"
219 |         }
220 |       }
221 |     },
222 | 
223 |     "LaunchConfig" : {
224 |       "Type" : "AWS::AutoScaling::LaunchConfiguration",
225 |       "Metadata" : {
226 |         "Comment" : "Install a simple application",
227 |         "AWS::CloudFormation::Init" : {
228 |           "config" : {
229 |             "packages" : {
230 |               "yum" : {
231 |                 "httpd" : []
232 |               }
233 |             },
234 | 
235 |             "files" : {
236 |               "/var/www/html/index.html" : {
237 |                 "content" : { "Fn::Join" : ["\n", [
238 |                   "<img src=\"", {"Fn::FindInMap" : ["Region2Examples", {"Ref" : "AWS::Region"}, "Examples"]}, "/cloudformation_graphic.png\" alt=\"AWS CloudFormation Logo\"/>",
239 |                   "<h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>"
240 |                 ]]},
241 |                 "mode"    : "000644",
242 |                 "owner"   : "root",
243 |                 "group"   : "root"
244 |               },
245 | 
246 |               "/etc/cfn/cfn-hup.conf" : {
247 |                 "content" : { "Fn::Join" : ["", [
248 |                   "[main]\n",
249 |                   "stack=", { "Ref" : "AWS::StackId" }, "\n",
250 |                   "region=", { "Ref" : "AWS::Region" }, "\n"
251 |                 ]]},
252 |                 "mode"    : "000400",
253 |                 "owner"   : "root",
254 |                 "group"   : "root"
255 |               },
256 | 
257 |               "/etc/cfn/hooks.d/cfn-auto-reloader.conf" : {
258 |                 "content": { "Fn::Join" : ["", [
259 |                   "[cfn-auto-reloader-hook]\n",
260 |                   "triggers=post.update\n",
261 |                   "path=Resources.LaunchConfig.Metadata.AWS::CloudFormation::Init\n",
262 |                   "action=/opt/aws/bin/cfn-init -v ",
263 |                   "         --stack ", { "Ref" : "AWS::StackName" },
264 |                   "         --resource LaunchConfig ",
265 |                   "         --region ", { "Ref" : "AWS::Region" }, "\n",
266 |                   "runas=root\n"
267 |                 ]]}
268 |               }
269 |             },
270 | 
271 |             "services" : {
272 |               "sysvinit" : {
273 |                 "httpd"    : { "enabled" : "true", "ensureRunning" : "true" },
274 |                 "cfn-hup" : { "enabled" : "true", "ensureRunning" : "true",
275 |                               "files" : ["/etc/cfn/cfn-hup.conf", "/etc/cfn/hooks.d/cfn-auto-reloader.conf"]}
276 |               }
277 |             }
278 |           }
279 |         }
280 |       },
281 |       "Properties" : {
282 |         "KeyName" : { "Ref" : "KeyName" },
283 |         "ImageId" : { "Fn::FindInMap" : [ "AWSRegionArch2AMI", { "Ref" : "AWS::Region" },
284 |                                           { "Fn::FindInMap" : [ "AWSInstanceType2Arch", { "Ref" : "InstanceType" }, "Arch" ] } ] },
285 |         "SecurityGroups" : [ { "Ref" : "InstanceSecurityGroup" } ],
286 |         "InstanceType" : { "Ref" : "InstanceType" },
287 |         "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
288 |              "#!/bin/bash -xe\n",
289 |              "yum update -y aws-cfn-bootstrap\n",
290 | 
291 |              "/opt/aws/bin/cfn-init -v ",
292 |              "         --stack ", { "Ref" : "AWS::StackName" },
293 |              "         --resource LaunchConfig ",
294 |              "         --region ", { "Ref" : "AWS::Region" }, "\n",
295 | 
296 |              "/opt/aws/bin/cfn-signal -e $? ",
297 |              "         --stack ", { "Ref" : "AWS::StackName" },
298 |              "         --resource WebServerGroup ",
299 |              "         --region ", { "Ref" : "AWS::Region" }, "\n"
300 |         ]]}}
301 |       }
302 |     },
303 | 
304 |     "WebServerScaleUpPolicy" : {
305 |       "Type" : "AWS::AutoScaling::ScalingPolicy",
306 |       "Properties" : {
307 |         "AdjustmentType" : "ChangeInCapacity",
308 |         "AutoScalingGroupName" : { "Ref" : "WebServerGroup" },
309 |         "Cooldown" : "60",
310 |         "ScalingAdjustment" : "1"
311 |       }
312 |     },
313 |     "WebServerScaleDownPolicy" : {
314 |       "Type" : "AWS::AutoScaling::ScalingPolicy",
315 |       "Properties" : {
316 |         "AdjustmentType" : "ChangeInCapacity",
317 |         "AutoScalingGroupName" : { "Ref" : "WebServerGroup" },
318 |         "Cooldown" : "60",
319 |         "ScalingAdjustment" : "-1"
320 |       }
321 |     },
322 | 
323 |     "CPUAlarmHigh": {
324 |      "Type": "AWS::CloudWatch::Alarm",
325 |      "Properties": {
326 |         "AlarmDescription": "Scale-up if CPU > 90% for 10 minutes",
327 |         "MetricName": "CPUUtilization",
328 |         "Namespace": "AWS/EC2",
329 |         "Statistic": "Average",
330 |         "Period": "300",
331 |         "EvaluationPeriods": "2",
332 |         "Threshold": "90",
333 |         "AlarmActions": [ { "Ref": "WebServerScaleUpPolicy" } ],
334 |         "Dimensions": [
335 |           {
336 |             "Name": "AutoScalingGroupName",
337 |             "Value": { "Ref": "WebServerGroup" }
338 |           }
339 |         ],
340 |         "ComparisonOperator": "GreaterThanThreshold"
341 |       }
342 |     },
343 |     "CPUAlarmLow": {
344 |      "Type": "AWS::CloudWatch::Alarm",
345 |      "Properties": {
346 |         "AlarmDescription": "Scale-down if CPU < 70% for 10 minutes",
347 |         "MetricName": "CPUUtilization",
348 |         "Namespace": "AWS/EC2",
349 |         "Statistic": "Average",
350 |         "Period": "300",
351 |         "EvaluationPeriods": "2",
352 |         "Threshold": "70",
353 |         "AlarmActions": [ { "Ref": "WebServerScaleDownPolicy" } ],
354 |         "Dimensions": [
355 |           {
356 |             "Name": "AutoScalingGroupName",
357 |             "Value": { "Ref": "WebServerGroup" }
358 |           }
359 |         ],
360 |         "ComparisonOperator": "LessThanThreshold"
361 |       }
362 |     },
363 | 
364 |     "ElasticLoadBalancer" : {
365 |       "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
366 |       "Properties" : {
367 |         "AvailabilityZones" : { "Fn::GetAZs" : "" },
368 |         "CrossZone" : "true",
369 |         "Listeners" : [ {
370 |           "LoadBalancerPort" : "80",
371 |           "InstancePort" : "80",
372 |           "Protocol" : "HTTP"
373 |         } ],
374 |         "HealthCheck" : {
375 |           "Target" : "HTTP:80/",
376 |           "HealthyThreshold" : "3",
377 |           "UnhealthyThreshold" : "5",
378 |           "Interval" : "30",
379 |           "Timeout" : "5"
380 |         }
381 |       }
382 |     },
383 | 
384 |     "InstanceSecurityGroup" : {
385 |       "Type" : "AWS::EC2::SecurityGroup",
386 |       "Properties" : {
387 |         "GroupDescription" : "Enable SSH access and HTTP from the load balancer only",
388 |         "SecurityGroupIngress" : [ {
389 |           "IpProtocol" : "tcp",
390 |           "FromPort" : "22",
391 |           "ToPort" : "22",
392 |           "CidrIp" : { "Ref" : "SSHLocation"}
393 |         },
394 |         {
395 |           "IpProtocol" : "tcp",
396 |           "FromPort" : "80",
397 |           "ToPort" : "80",
398 |           "SourceSecurityGroupOwnerId" : {"Fn::GetAtt" : ["ElasticLoadBalancer", "SourceSecurityGroup.OwnerAlias"]},
399 |           "SourceSecurityGroupName" : {"Fn::GetAtt" : ["ElasticLoadBalancer", "SourceSecurityGroup.GroupName"]}
400 |         } ]
401 |       }
402 |     }
403 |   },
404 | 
405 |   "Outputs" : {
406 |     "URL" : {
407 |       "Description" : "The URL of the website",
408 |       "Value" :  { "Fn::Join" : [ "", [ "http://", { "Fn::GetAtt" : [ "ElasticLoadBalancer", "DNSName" ]}]]}
409 |     }
410 |   }
411 | }
412 | 


--------------------------------------------------------------------------------