aws-amicleaner 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) widdix GmbH
+
+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:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+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.

package/README.md

@@ -0,0 +1,72 @@
+To clean up your AWS AMIs: 
+1. Include AMIs by name or tag.
+2. Exclude AMIs in use, younger than N days, or the newest N images.
+3. Manually confirm the list of AMIs for deletion.
+
+## Examples
+
+To delete all AMIs in eu-west-1 where the name starts with amiprefix-, are older than 5 days, and not the newest 3 images, run:
+```bash
+aws-amicleaner --region eu-west-1 --include-name 'amiprefix-*' --exclude-newest 3 --exclude-days 5 --exclude-in-use --verbose
+```
+
+A typical confirmation screen:
+
+```
++-----------+-------------+----------------------+--------------------------+---------+-----------------+-------------------------+
+| Region    | ID          | Name                 | Creation Date            | Delete? | Include reasons | Exclude reasons         | 
++-----------+-------------+----------------------+--------------------------+---------+-----------------+-------------------------+
+| eu-west-1 | ami-0a...72 | amiprefix-1685107232 | 2023-05-27T13:32:21.000Z | no      | name match      | days not passed, newest | 
+| eu-west-1 | ami-02...3f | amiprefix-1685103569 | 2023-05-27T12:30:50.000Z | no      | name match      | days not passed, newest | 
+| eu-west-1 | ami-09...d5 | amiprefix-1685095689 | 2023-05-27T10:19:59.000Z | no      | name match      | days not passed, newest | 
+| eu-west-1 | ami-0f...c7 | amiprefix-1685039741 | 2023-05-26T18:47:37.000Z | no      | name match      | days not passed         | 
+| eu-west-1 | ami-0f...f0 | amiprefix-1685018189 | 2023-05-26T12:49:02.000Z | no      | name match      | days not passed         | 
+| eu-west-1 | ami-06...a8 | amiprefix-1685015512 | 2023-05-26T12:04:39.000Z | no      | name match      | days not passed         | 
+| eu-west-1 | ami-04...44 | amiprefix-1684998014 | 2023-05-25T07:14:42.000Z | yes     | name match      |                         |
+| eu-west-1 | ami-02...6e | amiprefix-1684954911 | 2023-05-24T19:15:37.000Z | yes     | name match      |                         |
+| eu-west-1 | ami-0e...da | amiprefix-1684952424 | 2023-05-24T18:32:06.000Z | yes     | name match      |                         |
+| eu-west-1 | ami-0b...54 | amiprefix-1684949922 | 2023-05-24T17:50:26.000Z | yes     | name match      |                         |
+| eu-west-1 | ami-0b...2c | amiprefix-1684937102 | 2023-05-24T14:17:53.000Z | yes     | name match      |                         |
+| eu-west-1 | ami-0e...aa | amiprefix-1684915092 | 2023-05-24T08:09:42.000Z | yes     | name match      |                         |
++-----------+-------------+----------------------+--------------------------+---------+-----------------+-------------------------+
+
+Do you want to continue and remove 6 AMIs [y/N] ? : 
+```
+
+To delete all AMIs in eu-west-* (eu-west-1, eu-west-2, eu-west-3) tagged with CostCenter=X342-*-1111, are older than 7 days (default), are not the newest 5 images (default), and are not in use (default), run:
+```bash
+aws-amicleaner --region 'eu-west-*' --include-tag-key CostCenter --include-tag-value 'X342-*-1111'
+```
+
+Run the command without confirmation (useful in scripts):
+```bash
+aws-amicleaner --region 'eu-west-*' --include-tag-key CostCenter --include-tag-value 'X342-*-1111' --force-delete
+```
+
+To disable the defaults, run:
+```bash
+aws-amicleaner --include-name 'amiprefix-*' --exclude-newest 0 --exclude-days 0 --no-exclude-in-use --no-verbose
+```
+
+## Arguments
+
+```
+-h, --help            show this help message and exit
+--region REGION       The AWS region, e.g. us-east-1, arg can be used more than once, wildcard * supported
+--include-name INCLUDENAME
+                      The name that must be present, wildcard * supported
+--include-tag-key INCLUDETAGKEY
+                      The tag key that must be present
+--include-tag-value INCLUDETAGVALUE
+                      The tag value (for the tag key) that must be present, wildcard * supported
+--exclude-newest EXCLUDENEWEST
+                      Exclude the newest N AMIs
+--exclude-days EXCLUDEDAYS
+                      Exclude AMIs from deletion that are younger than N days
+--exclude-in-use, --no-exclude-in-use
+                      Exclude AMIs from deletion that are in use by EC2 instances, ASGs, Launch Configurations, and Launch Templates (default: true)
+-f, --force-delete, --no-force-delete
+                      Skip confirmation before deletion (default: false)
+--verbose, --no-verbose
+                      Display additional information (default: true)
+```

package/index.js

@@ -0,0 +1,144 @@
+const { createInterface } = require('node:readline');
+const { ArgumentParser, BooleanOptionalAction } = require('argparse');
+const { fetchAMIs, deleteAMI, fetchRegions} = require('./lib.js');
+const pLimit = require('p-limit');
+
+const AWS = require('aws-sdk');
+const PrettyTable = require('./prettytable.js');
+
+const rl = createInterface({
+  input: process.stdin,
+  output: process.stdout,
+}); 
+
+async function input(query) {
+  return new Promise(resolve => {
+    rl.question(query, answer => resolve(answer));
+  });
+}
+
+async function run({
+  regions: rawRegions,
+  includeName,
+  includeTagKey,
+  includeTagValue,
+  excludeNewest,
+  excludeInUse,
+  excludeDays,
+  forceDelete,
+  verbose
+}) {
+  const now = Date.now();
+
+  const ec2 = {};
+  const autoscaling = {};
+  const ec2Client = (region) => {
+    if (!(region in ec2)) {
+      ec2[region] = new AWS.EC2({apiVersion: '2016-11-15', region});
+    }
+    return ec2[region];
+  };
+  const autoscalingClient = (region) => {
+    if (!(region in autoscaling)) {
+      autoscaling[region] = new AWS.AutoScaling({apiVersion: '2011-01-01', region});
+    }
+    return autoscaling[region];
+  };
+
+  let amis = [];
+
+  const regions = await fetchRegions(ec2Client('us-east-1'), rawRegions);
+  for (const region of regions) {
+    let regionalAMIs = await fetchAMIs(now, ec2Client(region), autoscalingClient(region), includeName, includeTagKey, includeTagValue, excludeNewest, excludeInUse, excludeDays);
+    regionalAMIs = regionalAMIs.map(ami => ({
+      region,
+      ...ami
+    }));
+    amis = [...amis, ...regionalAMIs];
+  }
+
+  if (verbose === true) {
+    const pt = new PrettyTable();
+    pt.sortTable('Name');
+    pt.create(['Region', 'ID', 'Name', 'Creation Date', 'Delete?', 'Include reasons', 'Exclude reasons'], amis.map(ami => [
+      ami.region,
+      ami.id,
+      ami.name,
+      new Date(ami.creationDate).toISOString(),
+      (ami.included === true && ami.excluded === false) ? 'yes' : 'no',
+      (ami.included === true) ? ami.includeReasons.join(', ') : '',
+      (ami.excluded === true) ? ami.excludeReasons.join(', ') : ''
+    ]));
+    pt.print();
+  }
+
+  amis = amis.filter(ami => ami.included === true && ami.excluded === false);
+
+  if (amis.length === 0) {
+    return;
+  }
+
+  let del = false;
+  if (forceDelete === true) {
+    del = true;
+  } else {
+    const answer = await input(`Do you want to continue and remove ${amis.length} AMIs [y/N] ? : `);
+    del = answer === 'y';
+  }
+
+  if (del === true) {
+    const limit = pLimit(5);
+    await Promise.all(amis.map(ami => limit(() => deleteAMI(ec2Client(ami.region), ami))));
+  } else {
+    return;
+  }
+}
+
+function readArgs() {
+  const parser = new ArgumentParser({
+    prog: 'aws-amicleaner',
+    description: 'To clean up your AWS AMIs: First, include AMIs by name or tag. Second, exclude AMIs in use, younger than N days, or the newest N images. Third, manually confirm the list of AMIs for deletion.',
+    usage: `To delete all AMIs where the name starts with amiprefix-, are older than 5 days, and not the newest 3 images, run:
+aws-amicleaner --include-name 'amiprefix-*' --exclude-newest 3 --exclude-days 5 --exclude-in-use --verbose
+
+To delete all AMIs tagged with CostCenter=X342-*-1111, are older than 7 days (default), are not the newest 5 images (default), and are not in use (default), run:
+aws-amicleaner --include-tag-key CostCenter --include-tag-value 'X342-*-1111'
+
+Run the command without confirmation (useful in scripts):
+aws-amicleaner --include-tag-key CostCenter --include-tag-value 'X342-*-1111' --force-delete
+
+To disable the defaults, run:
+aws-amicleaner --include-name 'amiprefix-*' --exclude-newest 0 --exclude-days 0 --no-exclude-in-use --no-verbose
+`
+  });
+  parser.add_argument('--region', {dest: 'regions',  type: 'string', action: 'append', default: [], help: 'The AWS region, e.g. us-east-1, arg can be used more than once, wildcard * supported'});
+  parser.add_argument('--include-name', {dest: 'includeName', type: 'string', help: 'The name that must be present, wildcard * supported'});
+  parser.add_argument('--include-tag-key', {dest: 'includeTagKey', type: 'string', help: 'The tag key that must be present'});
+  parser.add_argument('--include-tag-value', {dest: 'includeTagValue', type: 'string', help: 'The tag value (for the tag key) that must be present, wildcard * supported'});
+  parser.add_argument('--exclude-newest', {dest: 'excludeNewest', type: 'int', default: 5, help: 'Exclude the newest N AMIs'});
+  parser.add_argument('--exclude-days', {dest: 'excludeDays', type: 'int', default: 7, help: 'Exclude AMIs from deletion that are younger than N days'});
+  parser.add_argument('--exclude-in-use', {dest: 'excludeInUse', default: true, action: BooleanOptionalAction, help: 'Exclude AMIs from deletion that are in use by EC2 instances, ASGs, Launch Configurations, and Launch Templates'});
+  parser.add_argument('-f', '--force-delete', {dest: 'forceDelete', default: false, action: BooleanOptionalAction, help: 'Skip confirmation before deletion'});
+  parser.add_argument('--verbose', {dest: 'verbose', default: true, action: BooleanOptionalAction, help: 'Display additional information'});
+  const args = parser.parse_args();
+
+  if (args.includeName === undefined && args.includeTagKey === undefined) {
+    throw new Error('--include-name or --include-tag-key missing');
+  }
+  if (args.includeName !== undefined && args.includeTagKey !== undefined) {
+    throw new Error('Use either --include-name or --include-tag-key');
+  }
+  if (args.includeTagKey !== undefined && args.includeTagValue === undefined) {
+    throw new Error('--include-tag-value missing');
+  }
+
+  return args;
+}
+
+const args = readArgs();
+
+if (args.verbose === true) {
+  console.log('args', args);
+}
+
+run(args).then(() => process.exit(0));

package/lib.js

@@ -0,0 +1,203 @@
+const wildcard = require('wildcard');
+const pLimit = require('p-limit');
+
+const MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE = 50;
+
+function mapAMI(raw) {
+  return {
+    id: raw.ImageId,
+    name: raw.Name,
+    creationDate: Date.parse(raw.CreationDate),
+    tags: raw.Tags.reduce((acc, {Key: key, Value: value}) => {
+      acc[key] = value;
+      return acc;
+    }, {}),
+    blockDeviceMappings: raw.BlockDeviceMappings.map(raw => ({snapshotId: raw.Ebs.SnapshotId})),
+    excluded: false,
+    excludeReasons: [],
+    included: false,
+    includeReasons: []
+  };
+}
+
+async function fetchRegions(ec2, rawRegions) {
+  const regions = new Set();
+
+  if (rawRegions.length === 0) {
+    regions.add(undefined);
+  }
+
+  rawRegions.filter(region => !region.includes('*')).forEach(region => regions.add(region));
+
+  const rawRegionsWithWildcard = rawRegions.filter(region => region.includes('*'));
+  if (rawRegionsWithWildcard.length !== 0) {
+    const {Regions} = await ec2.describeRegions({}).promise();
+    rawRegionsWithWildcard.forEach(rawRegionWithWildcard => {
+      wildcard(rawRegionWithWildcard, Regions.map(r => r.RegionName)).forEach(region => regions.add(region));
+    });
+  }
+
+  return regions;
+}
+exports.fetchRegions = fetchRegions;
+
+async function fetchInUseAMIIDs(ec2, autoscaling) {
+  const inUseAMIIDs = new Set();
+
+  for await (const reservation of (async function*() {
+    let nextToken = '';
+    while (nextToken !== undefined) {
+      const {Reservations: reservations, NextToken} = await ec2.describeInstances({
+        NextToken: (nextToken === '') ? undefined : nextToken,
+        Filters: [{
+          Name: 'instance-state-name',
+          Values: [
+            'pending',
+            'running',
+            'shutting-down',
+            'stopping',
+            'stopped'
+          ]
+        }]
+      }).promise();
+      yield* reservations;
+      nextToken = NextToken;
+    }
+  })()) {
+    reservation.Instances.forEach(instance => inUseAMIIDs.add(instance.ImageId));
+  }
+
+  const asgs = [];
+  for await (const asg of (async function*() {
+    let nextToken = '';
+    while (nextToken !== undefined) {
+      const {AutoScalingGroups, NextToken} = await autoscaling.describeAutoScalingGroups({
+        NextToken: (nextToken === '') ? undefined : nextToken
+      }).promise();
+      yield* AutoScalingGroups;
+      nextToken = NextToken;
+    }
+  })()) {
+    asgs.push(asg);
+  }
+
+  // in use by ASG -> Launch Configuration
+  const inUseLCNames = asgs.filter(asg => 'LaunchConfigurationName' in asg).map(asg => asg.LaunchConfigurationName);
+  if (inUseLCNames.length > 0) {
+    for (let i = 0; i < Math.ceil(inUseLCNames.length/MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE); i++) {
+      const {LaunchConfigurations: lcs} = await autoscaling.describeLaunchConfigurations({
+        LaunchConfigurationNames: inUseLCNames.slice(i*MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE, (i+1)*MAX_ITEMS_PER_LAUNCH_CONFIGURATION_PAGE)
+      }).promise();
+      lcs.forEach(lc => inUseAMIIDs.add(lc.ImageId));
+    }
+  }
+
+  const inUseLTs = [
+    ...asgs.filter(asg => 'LaunchTemplate' in asg).map(asg => ({id: asg.LaunchTemplate.LaunchTemplateId, version: asg.LaunchTemplate.Version})),
+    ...asgs.filter(asg => 'MixedInstancesPolicy' in asg).map(asg => ({id: asg.MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.LaunchTemplateId, version: asg.MixedInstancesPolicy.LaunchTemplate.LaunchTemplateSpecification.Version}))
+  ];
+  const limit = pLimit(5);
+  await Promise.all(
+    inUseLTs.map(({id, version}) => limit(() => 
+      ec2.describeLaunchTemplateVersions({
+        LaunchTemplateId: id,
+        Versions: [version]
+      }).promise().then(data => data.LaunchTemplateVersions[0].LaunchTemplateData.ImageId))
+    )
+  ).then(amiIDs => amiIDs.forEach(amiID => inUseAMIIDs.add(amiID)));
+
+  return inUseAMIIDs;
+}
+exports.fetchInUseAMIIDs = fetchInUseAMIIDs;
+
+async function fetchAMIs(now, ec2, autoscaling, includeName, includeTagKey, includeTagValue, excludeNewest, excludeInUse, excludeDays) {
+  let amis = [];
+  for await (const rawAMI of (async function*() {
+    let nextToken = '';
+    while (nextToken !== undefined) {
+      const params = {
+        Owners: ['self']
+      };
+      if (includeTagKey !== undefined) {
+        params.Filters = [{
+          Name: 'tag-key',
+          Values: [includeTagKey]
+        }];
+      }
+      if (nextToken !== '') {
+        params.NextToken = nextToken;
+      }
+      const {Images, NextToken} = await ec2.describeImages(params).promise();
+      yield* Images;
+      nextToken = NextToken;
+    }
+  })()) {
+    amis.push(mapAMI(rawAMI));
+  }
+
+  if (includeName !== undefined) {
+    amis = amis.filter(ami => wildcard(includeName, ami.name)).map(ami => {
+      ami.included = true;
+      ami.includeReasons.push('name match');
+      return ami;
+    });
+  } else if (includeTagKey !== undefined) {
+    amis = amis.filter(ami => wildcard(includeTagValue, ami.tags[includeTagKey])).map(ami => {
+      ami.included = true;
+      ami.includeReasons.push('tag match');
+      return ami;
+    });
+  } else {
+    throw new Error('no include defined');
+  }
+
+  if (excludeInUse === true) {
+    const inUseAMIIDs = await fetchInUseAMIIDs(ec2, autoscaling);
+    amis = amis.map(ami => {
+      if (inUseAMIIDs.has(ami.id)) {
+        ami.excluded = true;
+        ami.excludeReasons.push('in use');
+      }
+      return ami;
+    });
+  }
+
+  if (excludeDays > 0) {
+    const ts = now-(excludeDays*24*60*60*1000);
+    amis = amis.map(ami => {
+      if (ami.creationDate > ts) {
+        ami.excluded = true;
+        ami.excludeReasons.push('days not passed');
+      }
+      return ami;
+    });
+
+  }
+
+  if (excludeNewest > 0) {
+    amis = amis.sort((a, b) => b.creationDate-a.creationDate).map((ami, i) => {
+      if (i < excludeNewest) {
+        ami.excluded = true;
+        ami.excludeReasons.push('newest');
+      }
+      return ami;
+    });
+  }
+
+  return amis;
+}
+exports.fetchAMIs = fetchAMIs;
+
+async function deleteAMI(ec2, ami) {
+  await ec2.deregisterImage({
+    ImageId: ami.id
+  }).promise();
+  console.log(`AMI ${ami.id} deregistered`);
+  for (const blockDevice of ami.blockDeviceMappings) {
+    await ec2.deleteSnapshot({
+      SnapshotId: blockDevice.snapshotId
+    }).promise();
+    console.log(`snapshot ${blockDevice.snapshotId} of AMI ${ami.id} deleted`);
+  }
+}
+exports.deleteAMI = deleteAMI;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "aws-amicleaner",
+  "version": "1.0.0",
+  "description": "To clean up your AWS AMIs: First, include AMIs by name or tag. Second, exclude AMIs in use, younger than N days, or the newest N images. Third, manually confirm the list of AMIs for deletion.",
+  "main": "index.js",
+  "scripts": {
+    "test": "eslint . && c8 mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/widdix/aws-amicleaner.git"
+  },
+  "author": "Michael Wittig <michael@widdix.de>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/widdix/aws-amicleaner/issues"
+  },
+  "homepage": "https://github.com/widdix/aws-amicleaner#readme",
+  "dependencies": {
+    "aws-sdk": "2.1387.0",
+    "p-limit": "3.1.0",
+    "wildcard": "2.0.1"
+  },
+  "devDependencies": {
+    "c8": "7.13.0",
+    "eslint": "8.41.0",
+    "mocha": "10.2.0"
+  },
+  "mocha": {
+    "timeout": 10000
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ]
+  }
+}

package/prettytable.js

@@ -0,0 +1,241 @@
+// Not used via module prettytabl;e becausde of error:
+// Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './lib/sync' is not defined by "exports" in /Users/michael/Projects/widdix/aws-amicleaner/node_modules/csv-parse/package.json
+//     at new NodeError (node:internal/errors:387:5)
+//     at throwExportsNotFound (node:internal/modules/esm/resolve:365:9)
+//     at packageExportsResolve (node:internal/modules/esm/resolve:649:3)
+//     at resolveExports (node:internal/modules/cjs/loader:554:36)
+//     at Function.Module._findPath (node:internal/modules/cjs/loader:594:31)
+//     at Function.Module._resolveFilename (node:internal/modules/cjs/loader:1012:27)
+//     at Function.Module._load (node:internal/modules/cjs/loader:871:27)
+//     at Module.require (node:internal/modules/cjs/loader:1098:19)
+//     at require (node:internal/modules/cjs/helpers:108:18)
+//     at Object.<anonymous> (/Users/michael/Projects/widdix/aws-amicleaner/node_modules/prettytable/prettytable.js:1:13) {
+//   code: 'ERR_PACKAGE_PATH_NOT_EXPORTED'
+// }
+
+// Source https://github.com/jyotiska/prettytable
+
+// The MIT License (MIT)
+// 
+// Copyright (c) 2016 Jyotiska NK
+// 
+// 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:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// 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.
+
+var PrettyTable = function () {
+  // Skeleton structure of table with list of column names, row and max width of each column element
+  this.table = {
+    'columnNames': [],
+    'rows': [],
+    'maxWidth': []
+  };
+  this.version = '0.3.1';
+};
+
+// Define list of columns for the table
+PrettyTable.prototype.fieldNames = function (names) {
+  this.table.columnNames = names;
+  for (var i = 0; i < names.length; i++) {
+    this.table.maxWidth.push(names[i].length);
+  }
+};
+
+// Add a single row to the table
+PrettyTable.prototype.addRow = function (row) {
+  this.table.rows.push(row);
+  for (var i = 0; i < row.length; i++) {
+    if (row[i].toString().length > this.table.maxWidth[i]) {
+      this.table.maxWidth[i] = row[i].toString().length;
+    }
+  }
+};
+
+// Single function to create table when headers and array of rows passed
+PrettyTable.prototype.create = function (headers, rows) {
+  // Add table headers
+  this.fieldNames(headers);
+
+  // Add rows one by one
+  for (var i = 0; i < rows.length; i++) {
+    this.addRow(rows[i]);
+  }
+};
+
+// Convert the table to string
+PrettyTable.prototype.toString = function () {
+  var finalTable = '';
+  var columnString = '| ';
+  var rowString = '';
+  var lengthDifference = '';
+
+  // Draw a line based on the max width of each column and return
+  var drawLine = function (table) {
+    var finalLine = '+';
+    for (var i = 0; i < table.maxWidth.length; i++) {
+      finalLine += Array(table.maxWidth[i] + 3).join('-') + '+';
+    }
+    return finalLine;
+  };
+
+  // If no columns present, return empty string
+  if (this.table.columnNames.length === 0) {
+    return finalTable;
+  }
+
+  // Create the table header from column list
+  for (var i = 0; i < this.table.columnNames.length; i++) {
+    columnString += this.table.columnNames[i];
+    // Adjust for max width of the column and pad spaces
+    if (this.table.columnNames[i].length < this.table.maxWidth[i]) {
+      lengthDifference = this.table.maxWidth[i] - this.table.columnNames[i].length;
+      columnString += Array(lengthDifference + 1).join(' ');
+    }
+    columnString += ' | ';
+  }
+  finalTable += drawLine(this.table) + '\n';
+  finalTable += columnString + '\n';
+  finalTable += drawLine(this.table) + '\n';
+
+  // Construct the table body
+  for (i = 0; i < this.table.rows.length; i++) {
+    var tempRowString = '| ';
+    for (var k = 0; k < this.table.rows[i].length; k++) {
+      tempRowString += this.table.rows[i][k];
+      // Adjust max width of each cell and pad spaces as necessary
+      if (this.table.rows[i][k].toString().length < this.table.maxWidth[k]) {
+        lengthDifference = this.table.maxWidth[k] - this.table.rows[i][k].toString().length;
+        tempRowString += Array(lengthDifference + 1).join(' ');
+      }
+      tempRowString += ' | ';
+    }
+    rowString += tempRowString + '\n';
+  }
+  // Remove newline from the end of the table string
+  rowString = rowString.slice(0, -1);
+  // Append to the final table string
+  finalTable += rowString + '\n';
+  // Draw last line and return
+  finalTable += drawLine(this.table) + '\n';
+  return finalTable;
+};
+
+// Write the table string to the console
+PrettyTable.prototype.print = function () {
+  console.log(this.toString());
+};
+
+// Write the table string to the console as HTML table formats
+PrettyTable.prototype.html = function (attributes) {
+  // If attributes provided, add them as inline properties, else create default table tag
+  var htmlTable = '';
+  if (typeof attributes == 'undefined') {
+    htmlTable = '<table>';
+  }
+  else {
+    var attributeList = [];
+    for (var key in attributes) {
+      attributeList.push(key + '=\'' + attributes[key] + '\'');
+    }
+    var attributeString = attributeList.join(' ');
+    htmlTable = '<table ' + attributeString + '>';
+  }
+
+  // Define the table headers in <thead> from table column list
+  var tableHead = '<thead><tr>';
+  for (var i = 0; i < this.table.columnNames.length; i++) {
+    var headerString = '<th>' + this.table.columnNames[i] + '</th>';
+    tableHead += headerString;
+  }
+  tableHead += '</tr></thead>';
+  htmlTable += tableHead;
+
+  // Construct the table body from the array of rows
+  var tableBody = '<tbody>';
+  for (i = 0; i < this.table.rows.length; i++) {
+    var rowData = '<tr>';
+    for (var k = 0; k < this.table.rows[i].length; k++) {
+      var cellData = '<td>' + this.table.rows[i][k] + '</td>';
+      rowData += cellData;
+    }
+    rowData += '</tr>';
+    tableBody += rowData;
+  }
+  // Close all tags and return
+  tableBody += '</tbody>';
+  htmlTable += tableBody;
+  htmlTable += '</table>';
+
+  return htmlTable;
+};
+
+// Sort the table given a column in ascending or descending order
+PrettyTable.prototype.sortTable = function (colname, reverse) {
+  // Find the index of the column given the name
+  var colindex = this.table.columnNames.indexOf(colname);
+
+  // Comparator method which takes the column index and sort direction
+  var Comparator = function ( a, b) {
+    if (typeof reverse === 'boolean' && reverse === true) {
+      if (a[colindex] < b[colindex]) {
+        return 1;
+      }
+      else if (a[colindex] > b[colindex]) {
+        return -1;
+      }
+      else {
+        return 0;
+      }
+    }
+    else {
+      if (a[colindex] < b[colindex]) {
+        return -1;
+      }
+      else if (a[colindex] > b[colindex]) {
+        return 1;
+      }
+      else {
+        return 0;
+      }
+    }
+  };
+  // Sort array of table rows
+  this.table.rows = this.table.rows.sort(Comparator);
+};
+
+// Delete a single row from the table given row number
+PrettyTable.prototype.deleteRow = function (rownum) {
+  if (rownum <= this.table.rows.length && rownum > 0) {
+    this.table.rows.splice(rownum - 1, 1);
+  }
+};
+
+// Clear the contents from the table, but keep columns and structure
+PrettyTable.prototype.clearTable = function () {
+  this.table.rows = [];
+};
+
+// Delete the entire table
+PrettyTable.prototype.deleteTable = function () {
+  this.table = {
+    'columnNames': [],
+    'rows': [],
+    'maxWidth': []
+  };
+};
+
+module.exports = PrettyTable;