@brunwig/mup-aws-beanstalk 0.8.1

package/.babelrc

@@ -0,0 +1,6 @@
+{
+  "plugins": [
+    "@babel/plugin-proposal-object-rest-spread",
+    "@babel/plugin-transform-modules-commonjs"
+  ]
+}

package/.eslintignore

@@ -0,0 +1,2 @@
+lib
+tests/validate-tmp

package/.eslintrc.yml

@@ -0,0 +1,10 @@
+parser: babel-eslint
+extends: airbnb
+rules:
+  comma-dangle: [2, 'never']
+  no-plusplus: 0
+  no-param-reassign: 0
+  no-console: 0
+  no-mixed-operators: 0
+  consistent-return: 0
+  no-use-before-define: [2, {functions: false}]

package/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [zodern] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/changelog.md

@@ -0,0 +1,56 @@
+## 0.8.0 - July 18, 2022
+
+- Support `.platform` files (@s7dhansh)
+- If you manually configure the ssl certificate instead of configuring it in the mup config, mup-aws-beanstalk will no longer remove your changes (@filipenovola)
+- `mup beanstalk shell` and `mup beanstalk debug` will temporarily add a rule to the security group to allow ssh access from your ip address
+- Fix configuring nginx when using Amazon Linux 2
+- Fix health checks when using Amazon Linux 2
+- Improve documentation (@filipenevola)
+- Increase s3 upload timeout (@ramijarrar)
+- Improve error when sshKey is not configured
+- When requesting logs, wait for env to be ready
+
+## 0.7.0 - October 19, 2021
+
+New features:
+
+- Add support for custom .ebextensions folder (@s7dhansh)
+- New environments use platforms based on Amazon Linux 2. The docs have instructions for migrating existing environments to the new platforms
+- During deploys, the environment will only be updated a single time. This makes deploys much faster when updating env vars or the settings.json during a deploy, or when longEnvVars is enabled.
+- Add `mup beanstalk shell` to get a production Meteor shell. Look in the docs for how to enable
+- Add `mup beanstalk debug` to allow connecting your local Node debugging tools to the app. Look in the docs for how to enable.
+- Logs if the deploy fails. It also sets the exit code to an error code
+- The environment name can be changed
+
+Bug fixes:
+
+- Fix node version used when rebuilding native npm dependencies
+- Fix unnecessarily updating environment during deploys when longEnvVars is enabled (@alexkyen)
+- Fix few cases where it did not wait until the environment was ready before updating it
+- Fix `mup status` when the environment does not exist
+- Reduce timeout of automation document used for graceful shutdown
+
+## 0.6.4 - June 14, 2020
+
+- Fix compatibility with Meteor Up 1.5
+
+## 0.6.3 - April 18, 2020
+
+- Fix memory leak in health-check.js (@jimrandomh)
+- Fix nginx config for fonts in packages (@cunneen)
+
+## 0.6.2 - November 15, 2018
+
+- Fix `Throttling: Rate exceeded` errors
+
+## 0.6.1 - September 17, 2018
+
+- Fix using longEnvVars in regions other than us-east-1 (@gerwinbrunner and @cunneen)
+
+## 0.6.0 - June 19, 2018
+
+- Add graceful shutdown (sponsored by [Hive](https://hive.com/))
+- Add support for large settings.json files and long environment variables
+- Set `Strict-Transport-Security` when `app.forceSSL` is enabled (@fschaeffler)
+- Use the last git's commit message for the version description
+- Add option to configure number of old application versions to keep

package/docs/getting-started.md

@@ -0,0 +1,83 @@
+# Getting Started with mup-aws-beanstalk
+
+## Install
+
+You can install `mup` and `mup-aws-beanstalk` by running
+
+```bash
+npm i -g mup mup-aws-beanstalk
+```
+
+The AWS Beanstalk plugin requires Node 4 or newer and Meteor Up 1.3.5 or newer.
+
+## Step 1: Initialize your project
+
+In the terminal, run
+
+```bash
+cd path/to/app
+mup init
+```
+
+`mup init` will create a `.deploy` folder and put a Meteor settings file and mup config in it.
+
+## Step 2: Customize your Mup Config
+
+You can replace the mup config in `.deploy/mup.js` with this:
+
+```js
+module.exports = {
+    app: {
+        // Tells mup that the AWS Beanstalk plugin will manage the app
+        type: 'aws-beanstalk',
+        name: 'myApp',
+        path: '../',
+        env: {
+            ROOT_URL: 'http://app.com',
+            MONGO_URL: 'mongodb://user:pass@domain.com'
+        },
+        auth: {
+            id: '12345',
+            secret: '6789'
+        },
+        minInstances: 1
+    },
+    plugins: ['mup-aws-beanstalk']
+};
+```
+
+You will want to modify:
+
+1) The app name. It must be at least 4 characters
+2) `app.env.ROOT_URL`
+3) `app.env.MONGO_URL` You will need to get a database from MongoDB Atlas, ScaleGrid, or another DBaaS provider
+
+The next step will provide the values for the `app.auth` object.
+
+## Step 3: Create AWS user
+
+You will need to [create an Amazon account](https://portal.aws.amazon.com/billing/signup#/start) if you do not have one.
+
+Next, create an IAM user at [https://console.aws.amazon.com/iam/home#/users](https://console.aws.amazon.com/iam/home#/users)
+
+The access type should be `Programmatic access`.
+You can select `Add user to group` and create a new group. The group should have the following permissions:
+
+- `AdministratorAccess-AWSElasticBeanstalk`
+- `IAMFullAccess` This is used to create the roles and Instance Profiles needed by Elastic Beanstalk. After the first deploy, you can replace it with `IAMReadOnlyAccess`
+- `AWSCertificateManagerFullAccess` Used to create and manage SSL certificates for the app
+- `EC2InstanceConnect` is optional. Used when accessing a production Meteor shell or to connect your node developer tools to the app running in Elastic Beanstalk
+- `AmazonEC2FullAccess`
+- `AmazonS3FullAccess`
+
+In your mup config, set `app.auth.id` to the Access Key ID, and `app.auth.secret` to the Secret access key AWS gives you after creating the user.
+
+## Step 4: Deploy
+
+Simply run:
+
+```bash
+mup deploy
+```
+
+It will setup and deploy your app.

package/docs/index.md

@@ -0,0 +1,333 @@
+## Getting Started
+
+Read the [Getting Started tutorial](./getting-started.md).
+
+## Config
+
+- This plugin is configured with the `app` object in your config.
+- `app.type` should be set to `aws-beanstalk` so Meteor Up knows this plugin will deploy and manage the app.
+- You will need to add `mup-aws-beanstalk` to the `plugins` array in your config
+- The `servers` object is not needed
+
+Example config:
+
+```js
+module.exports = {
+    app: {
+        type: 'aws-beanstalk',
+        // Must be at least 4 characters
+        name: 'app-name',
+        path: '../',
+        auth: {
+            // IAM user's Access key ID
+            id: '12345',
+            // IAM user's Secret access key
+            secret: '6789'
+        },
+        env: {
+            ROOT_URL: 'http://website.com',
+            MONGO_URL: 'mongodb://user:pass@domain.com'
+        },
+        // (required) Minimum number of servers running your app
+        minInstances: 2,
+        // (optional, default is minInstances) Maximum number of servers
+        // for autoscale to scale up to
+        maxInstances: 5
+    },
+    plugins: ['mup-aws-beanstalk']
+}
+```
+
+Complete example:
+
+```js
+module.exports = {
+    app: {
+        type: 'aws-beanstalk',
+        // Must be at least 4 characters
+        name: 'app-name',
+        path: '../',
+        auth: {
+            // IAM user's Access key ID
+            id: '12345',
+            // IAM user's Secret access key
+            secret: '6789'
+        },
+        env: {
+            ROOT_URL: 'http://website.com',
+            MONGO_URL: 'mongodb://user:pass@domain.com'
+        },
+
+        // (required) Minimum number of servers running your app
+        minInstances: 2,
+        // (optional, default is inInstances) Maximum number of servers
+        // for autoscale to scale up to
+        maxInstances: 5,
+
+        // (optional, default is t2.micro) Type of instance to use
+        instanceType: 't2.small',
+
+        // (optional) Array of domains to request an ssl certificate for
+        sslDomains: ['app.com', 'www.app.com'],
+
+        // (optional) Redirect http to https
+        forceSSL: true,
+
+        // (optional, default is us-east-1) AWS region to deploy to
+        region: 'us-west-1',
+
+        // (optional, default is "mup-env-<app name>")
+        // Name of AWS Elastic Beanstalk environment
+        envName: 'production', 
+
+        // (optional) Packages to install with the yum package manager
+        yumPackages: {
+            // Property is the version. Leave as an empty string to install the latest version.
+            'cairo': '',
+            'cairo-devel': '',
+            'libjpeg-turbo-devel': '',
+            'pango': '',
+            'pango-devel': '',
+            'giflib-devel': ''
+        },
+
+        // (optional) Send a SIGTERM signal to the app instances 30 seconds before they will be shut down.
+        gracefulShutdown: true,
+
+        // (optional) Supports large environment variables and settings.json by storing them in s3. 
+        longEnvVars: true,
+
+        // (optional, default is 3) Number of old application versions to keep
+        oldVersions: 3,
+
+        // (optional) Same options as when deploying with mup.
+        // The one difference is serverOnly now defaults to true
+        buildOptions: {
+            // Default is true
+            serverOnly: true,
+            debug: false,
+            buildLocation: '../../build',
+            mobileSettings: {},
+            server: 'http://app.com',
+            allowIncompatibleUpdates: true,
+            executable: 'meteor'
+        },
+
+        // (optional) Override or add options in the beanstalk config
+        // this plugin creates.You can customize any option on:
+        // https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options-general.html
+        customBeanstalkConfig: [
+            {
+                namespace: 'aws:autoscaling:asg',
+                option: 'Cooldown',
+                value: '300'
+            }
+        ],
+
+        // (optional) Used by "shell" and "debug" commands
+        // Public key is temporarily added to the server when needed using
+        // EC2 Instance Connect
+        sshKey: {
+          privateKey: '~/.ssh/beanstalk',
+          publicKey: '~/.ssh/beanstalk.pub'
+        }
+    },
+    plugins: ['mup-aws-beanstalk']
+}
+```
+
+Changes to `yumPackages`, `forceSSL`, `buildOptions`, and `longEnvVars` requires deploying a new version to take affect.
+
+## Commands
+
+- `mup deploy` Sets up and deploys your app to AWS Beanstalk
+- `mup setup` Sets up AWS Beanstalk in preperation to deploy. Automatically run by `mup deploy`
+- `mup reconfig` Update Meteor settings and the Beanstalk config. Automatically run by `mup deploy`
+- `mup logs` View last 100 lines of the app's logs
+- `mup logs-nginx` View nginx logs
+- `mup beanstalk logs-eb` View last 100 lines of the logs from Beanstalk setting up the server and the app
+- `mup stop` Scales the app to 0 instances
+- `mup start` Scales the app back up after being stopped
+- `mup restart` Restarts the app
+- `mup beanstalk events` View events from the app's Beanstalk enviroment. Useful when troubleshooting problems.
+- `mup beanstalk clean` Removes old application versions from s3 and Beanstalk. Is automatically run by `mup deploy` 
+- `mup beanstalk ssl` Sets up SSL and shows you it's current status. Automatically run by `mup reconfig` and `mup deploy`
+- `mup beanstalk status` View the app's and server's health and http request stats
+
+## Cost
+
+AWS Elastic Beanstalk is free, but you do pay for the services it uses, including:
+
+- EC2 Instances. By default, it uses `t2.micro`, which costs $8.50/month($0.012 / hour). While the Beanstalk environment is updating, or a new version is being deployed, 25% additional servers will be used.
+- Application Load Balancer. Pricing details are at https://aws.amazon.com/elasticloadbalancing/pricing/
+- S3. 3 - 4 app bundles are stored on s3. Each deploy will make 2 list requests and upload 1 file. Beanstalk might store additional files on s3.
+
+Graceful Shutdown uses the following services:
+
+- Cloud Trail. The trail is stored in s3 and, according to their docs, usually costs less than $3 / month.
+
+## Rolling Deploys
+
+When deploying a new version, there is no downtime, and the number of servers handling requests is not reduced.
+
+Beanstalk is configured to use Rolling updates with additional batch with a batch size of 25%. This means that Beanstalk first creates an additional 25% instances and deploys the new version of the app to them. After the app has started, it will update the remaining servers in batches of 25%, except for the last 25%, which it terminates.
+
+This does not apply when changing the instance type. Instead, Beanstalk terminates the instances and replaces them in batches of 1/3 (rounded to the nearest integer). If you only have one server, there will be downtime until the app is running on the new server. Before changing `instanceType`, increase `minInstances` to at least 2 and run `mup reconfig` to avoid downtime.
+
+## Load balancing
+
+Load balancing is automatically configured and supports web sockets and sticky sessions.
+
+## Scale
+
+To scale your app, modify `app.minInstances` in your mup config to how many servers you want your app deployed to. Then run `mup reconfig`.
+
+You cannot scale to 0 servers. Instead, use `mup stop`.
+
+AWS limits how many instances your account can have. To increase the limit, you will need to contact their customer support. Learn more [here](https://aws.amazon.com/premiumsupport/knowledge-center/manage-service-limits/).
+
+## Autoscaling
+
+To enable autoscaling, make sure that `app.maxInstances` in your mup config is greater than `app.minInstances`.
+
+After modifying `app.maxInstances` or `app.minInstances`, run `mup reconfig`.
+
+The average cpu for the previous 5 minutes is used to trigger autoscaling. When the average is above 75%, it will be scaled up, and an average below 35% scales down.
+
+## Enhanced Health
+
+Enhanced health is enabled for your app. No metrics are configured to be stored in CloudWatch.
+
+You can view the health by running `mup beanstalk status` or on the [AWS Console](https://console.aws.amazon.com/elasticbeanstalk/home).
+
+## Logs
+
+The log commands shows the last 100 lines. You can download a zip file with all of the logs from the [aws console](https://console.aws.amazon.com/elasticbeanstalk/home).
+
+## Meteor and Node versions
+
+This plugin supports meteor 1.2 or newer. It will automatically use the correct Node and npm version.
+
+## SSL
+
+This plugin can request a certificate for you using the [Amazon Certificate Manager (ACM)](https://aws.amazon.com/certificate-manager/).
+
+In your config, add:
+
+```js
+module.exports = {
+    app: {
+        // ... rest of config
+
+        // Enables SSL. Array of domain names to create the certificate for.
+        sslDomains: [
+            'website.com',
+            'www.website.com',
+            'website.net'
+        ],
+
+        // (optional) Redirect http to https
+        forceSSL: true
+    }
+};
+```
+
+Then run `mup deploy` or `mup beanstalk ssl`.
+
+The command will show a list of email addresses that ACM sent an email to with instructions on verifying the domain name. The list includes your domain's registrant, and administrative and technical contact, as well as a few common addresses.
+
+After you have followed the instructions in the email, run `mup beanstalk ssl` to configure Beanstalk to use the certificate.
+
+You can also run `mup beanstalk ssl` to view the certificate's status or to resend the confirmation email.
+
+ACM automatically renews the certificates.
+
+## Graceful Shutdown
+
+This plugin can setup CloudWatch Events to send a `SIGTERM` signal to your app on instances that are being drained by the load balancer. Your app can listen for this signal and gradually disconnect users or do other work needed before shutting down. The signal is sent at least 30 seconds before before the load balancer finishes draining it.
+
+Before enabling this feature, make sure the IAM user has these policies:
+
+- `IAMFullAccess`
+- `AWSCloudTrailFullAccess`
+- `CloudWatchEventsFullAccess`
+- `AmazonSSMFullAccess`
+
+Next, install the [@meteorjs/ddp-graceful-shutdown](https://github.com/meteor/ddp-graceful-shutdown) npm package and add this code to your app's server:
+
+```ts
+import { DDPGracefulShutdown } from '@meteorjs/ddp-graceful-shutdown';
+import { Meteor } from 'meteor/meteor';
+
+new DDPGracefulShutdown({
+  gracePeriodMillis: 1000 * process.env.METEOR_SIGTERM_GRACE_PERIOD_SECONDS,
+  server: Meteor.server,
+}).installSIGTERMHandler();
+```
+
+`METEOR_SIGTERM_GRACE_PERIOD_SECONDS` is set to 30 seconds.
+
+In your config, set `app.gracefulShutdown` to `true`:
+
+```js
+module.exports = {
+    app: {
+        // ... rest of config
+
+        gracefulShutdown: true
+    }
+};
+```
+
+Then run `mup deploy`.
+
+You can now replace the policies you added with their read only equivilents: `AWSCloudTrailReadOnlyAccess`, `CloudWatchEventsReadOnlyAccess`, `IAMReadOnlyAccess`, and `AmazonSSMReadOnlyAccess`.
+
+## Meteor Shell and Debug
+
+To help with debugging issues that happen in production mup-aws-beanstalk provides two commands:
+
+1) `mup beanstalk shell` to open a production Meteor shell. This is the same shell you get with `meteor shell`, but connected to your app running in Elastic Beanstalk. Your app must use the [`qualia:prod-shell`](https://github.com/qualialabs/prod-shell) or equivalent package
+2) `mup beanstalk debug` to allow connecting your local Node developer tools to the app running in production
+
+Requirements:
+
+1) The IAM user to have the `EC2InstanceConnect` policy.
+2) The beanstalk environment should use a platform based on Amazon Linux 2. If mup-aws-beanstalk times out while trying to connect, the platform might be based on an older version of Amazon Linux.
+3) The `app.sshKey` option should be configured in your mup config:
+
+```js
+module.exports = {
+  app: {
+    sshKey: {
+      privateKey: '~/.ssh/beanstalk',
+      publicKey: '~/.ssh/beanstalk.pub'
+    }
+
+    // ... rest of app config
+  }
+}
+```
+
+The public key is temporarily added to the instance when needed using EC2 Instance Connect. Also, a rule will be added to the instance's security group to allow ssh access from your IP address. The rule is removed when mup exits.
+
+## Upgrading to Amazon Linux 2
+
+AWS Elastic Beanstalk requires doing a [blue/green deployment] to update to Amazon Linux 2. This involves:
+
+1) Creating a new environment for the AWS Beanstalk app. An easy way to do this is set `app.envName` in your mup config to a different name, and then run `mup deploy`. It will create a new environment with the new name you set.
+2) After the new environment is ready, make sure the app is working correctly
+3) [Swap the CNAME between the old and new environment](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.CNAMESwap.html). This will move traffic to the new environment
+4) Once the old environment is no longer being used, you can terminate it
+
+## Custom `.ebextensions`
+
+You can create a `.ebextensions` folder to further customize the Elastic Beanstalk environment. More details are in [Elastic Beanstalk's docs](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/ebextensions.html).
+
+mup-aws-beanstalk copies your app's `.ebextensions` folder into the app bundle when deploying your app.
+
+## Troubleshooting
+
+- View the logs with `mup logs` or from the AWS Console
+- View the environment events with `mup beanstalk events`
+- Check the app and instance's health with `mup beanstalk health`

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib');

package/lib/assets/env.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+bucket="<%= bucketName %>"
+VERSION="2018-03-28"
+env_version=`sudo /opt/elasticbeanstalk/bin/get-config environment --key MUP_ENV_FILE_VERSION`
+
+echo "env_version=$env_version"
+
+[[ -z "$env_version" ]] && { echo "Long Env is not enabled."; exit 0; }
+
+export NVM_DIR="/.nvm"
+[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
+
+instance_profile=`curl http://169.254.169.254/$VERSION/meta-data/iam/security-credentials/`
+json=`curl http://169.254.169.254/$VERSION/meta-data/iam/security-credentials/${instance_profile}`
+instance_region=`curl http://169.254.169.254/latest/meta-data/placement/availability-zone | sed 's/.$//'`
+
+function getInstanceProfileProperty () {
+  result=`node -e "console.log(JSON.parse(process.argv.slice(2).join(''))[process.argv[1]])" $1 $json`
+  echo "$result"
+}
+
+aws_access_key_id=`getInstanceProfileProperty "AccessKeyId"`
+aws_secret_access_key=`getInstanceProfileProperty "SecretAccessKey"`
+token=`getInstanceProfileProperty "Token"`
+
+file="env/$env_version.txt"
+resource="${bucket}/${file}"
+
+mkdir -p /etc/app || true
+sudo aws s3 cp s3://${resource} /etc/app/env.txt

package/lib/assets/env.yaml

@@ -0,0 +1,19 @@
+Resources:
+  AWSEBAutoScalingGroup:
+    Metadata:
+      AWS::CloudFormation::Authentication:
+        S3Auth:
+          type: "s3"
+          buckets: ["<%= bucketName %>"]
+          roleName: 
+            "Fn::GetOptionSetting": 
+              Namespace: "aws:autoscaling:launchconfiguration"
+              OptionName: "IamInstanceProfile"
+              DefaultValue: "aws-elasticbeanstalk-ec2-role"
+files:
+  "/opt/elasticbeanstalk/hooks/appdeploy/pre/48env.sh":
+    mode: "000775"
+    owner: root
+    group: users
+    content: |
+<%- padScript(include('./env.sh'), 6) %>

package/lib/assets/graceful_shutdown.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+echo "Setting up"
+mkdir /mup_graceful_shutdown || true
+ID=$(curl http://169.254.169.254/latest/meta-data/instance-id)
+FILE=/mup_graceful_shutdown/$ID
+echo "File $FILE"
+test -e $FILE && exit
+echo "File does not exist"
+echo 'PATH="/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/opt/aws/bin:/home/ec2-user/.local/bin:/home/ec2-user/bin"' >> $FILE
+
+# Platforms based on Amazon Linux 2 use a different user name
+echo 'sudo pkill -SIGTERM -u nodejs -n node || sudo pkill -SIGTERM -u webapp -n node' >> $FILE
+chmod +x $FILE 

package/lib/assets/graceful_shutdown.yaml

@@ -0,0 +1,7 @@
+files:
+    "/opt/elasticbeanstalk/hooks/appdeploy/pre/48graceful_shutdown.sh" :
+        mode: "000775"
+        owner: root
+        group: users
+        content: |
+<%- padScript(include('./graceful_shutdown.sh'), 12) %>

package/lib/assets/health-check.js

@@ -0,0 +1,54 @@
+/* eslint-disable no-var, prefer-template, func-names, prefer-arrow-callback */
+
+/*
+ * The health check expects the response's status code to be 200
+ * Some apps set their status code to something else, which would
+ * cause the health check to always fail.
+ *
+ * The health check gets sent to this server, which checks if
+ * the app is responding to requests, and then sets the correct
+ * status code for the health check.
+ *
+ * This uses the same version of node that the app is using,
+ * so it needs to support Node 0.10.
+ */
+var http = require('http');
+
+var debugEnabled = process.env.HEALTH_CHECK_VERBOSE === 'true';
+
+var log = function log(message, debug) {
+  if (!debug || debugEnabled) {
+    console.log('[HealthCheck] ' + new Date() + ': ' + message);
+  }
+};
+
+var server = http.createServer(function (request, response) {
+  var timeout;
+  var appRequest;
+  log('Received health check request', true);
+  appRequest = http.get('http://127.0.0.1:8081', function (res) {
+    log('Health check succeeded', true);
+    response.statusCode = 200;
+    response.end('Success');
+    clearTimeout(timeout);
+    res.resume();
+  }).on('error', function (e) {
+    log('Request to app failed ' + e);
+    response.statusCode = 500;
+    response.end('Failed');
+    clearTimeout(timeout);
+  });
+  timeout = setTimeout(function () {
+    log('Request to app timed out after 3 seconds');
+    appRequest.abort();
+  }, 3000);
+});
+
+try {
+  server.listen(8039);
+  log('Started health check server', true);
+} catch (e) {
+  // Port is being used, likely from another health-check server running
+  log('Port being used');
+}
+//# sourceMappingURL=health-check.js.map

package/lib/assets/health-check.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/assets/health-check.js"],"names":["http","require","debugEnabled","process","env","HEALTH_CHECK_VERBOSE","log","message","debug","console","Date","server","createServer","request","response","timeout","appRequest","get","res","statusCode","end","clearTimeout","resume","on","e","setTimeout","abort","listen"],"mappings":"AAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,IAAIA,IAAI,GAAGC,OAAO,CAAC,MAAD,CAAlB;;AAEA,IAAIC,YAAY,GAAGC,OAAO,CAACC,GAAR,CAAYC,oBAAZ,KAAqC,MAAxD;;AAEA,IAAIC,GAAG,GAAG,SAASA,GAAT,CAAaC,OAAb,EAAsBC,KAAtB,EAA6B;AACrC,MAAI,CAACA,KAAD,IAAUN,YAAd,EAA4B;AAC1BO,IAAAA,OAAO,CAACH,GAAR,CAAY,mBAAmB,IAAII,IAAJ,EAAnB,GAAgC,IAAhC,GAAuCH,OAAnD;AACD;AACF,CAJD;;AAOA,IAAII,MAAM,GAAGX,IAAI,CAACY,YAAL,CAAkB,UAAUC,OAAV,EAAmBC,QAAnB,EAA6B;AAC1D,MAAIC,OAAJ;AACA,MAAIC,UAAJ;AAEAV,EAAAA,GAAG,CAAC,+BAAD,EAAkC,IAAlC,CAAH;AAEAU,EAAAA,UAAU,GAAGhB,IAAI,CAACiB,GAAL,CAAS,uBAAT,EAAkC,UAAUC,GAAV,EAAe;AAC5DZ,IAAAA,GAAG,CAAC,wBAAD,EAA2B,IAA3B,CAAH;AACAQ,IAAAA,QAAQ,CAACK,UAAT,GAAsB,GAAtB;AACAL,IAAAA,QAAQ,CAACM,GAAT,CAAa,SAAb;AACAC,IAAAA,YAAY,CAACN,OAAD,CAAZ;AACAG,IAAAA,GAAG,CAACI,MAAJ;AACD,GANY,EAMVC,EANU,CAMP,OANO,EAME,UAAUC,CAAV,EAAa;AAC1BlB,IAAAA,GAAG,CAAC,2BAA2BkB,CAA5B,CAAH;AACAV,IAAAA,QAAQ,CAACK,UAAT,GAAsB,GAAtB;AACAL,IAAAA,QAAQ,CAACM,GAAT,CAAa,QAAb;AACAC,IAAAA,YAAY,CAACN,OAAD,CAAZ;AACD,GAXY,CAAb;AAaAA,EAAAA,OAAO,GAAGU,UAAU,CAAC,YAAY;AAC/BnB,IAAAA,GAAG,CAAC,0CAAD,CAAH;AACAU,IAAAA,UAAU,CAACU,KAAX;AACD,GAHmB,EAGjB,IAHiB,CAApB;AAID,CAvBY,CAAb;;AA0BA,IAAI;AACFf,EAAAA,MAAM,CAACgB,MAAP,CAAc,IAAd;AACArB,EAAAA,GAAG,CAAC,6BAAD,EAAgC,IAAhC,CAAH;AACD,CAHD,CAGE,OAAOkB,CAAP,EAAU;AACV;AACAlB,EAAAA,GAAG,CAAC,iBAAD,CAAH;AACD","sourcesContent":["/* eslint-disable no-var, prefer-template, func-names, prefer-arrow-callback */\n\n/*\n * The health check expects the response's status code to be 200\n * Some apps set their status code to something else, which would\n * cause the health check to always fail.\n *\n * The health check gets sent to this server, which checks if\n * the app is responding to requests, and then sets the correct\n * status code for the health check.\n *\n * This uses the same version of node that the app is using,\n * so it needs to support Node 0.10.\n */\n\nvar http = require('http');\n\nvar debugEnabled = process.env.HEALTH_CHECK_VERBOSE === 'true';\n\nvar log = function log(message, debug) {\n  if (!debug || debugEnabled) {\n    console.log('[HealthCheck] ' + new Date() + ': ' + message);\n  }\n};\n\n\nvar server = http.createServer(function (request, response) {\n  var timeout;\n  var appRequest;\n\n  log('Received health check request', true);\n\n  appRequest = http.get('http://127.0.0.1:8081', function (res) {\n    log('Health check succeeded', true);\n    response.statusCode = 200;\n    response.end('Success');\n    clearTimeout(timeout);\n    res.resume();\n  }).on('error', function (e) {\n    log('Request to app failed ' + e);\n    response.statusCode = 500;\n    response.end('Failed');\n    clearTimeout(timeout);\n  });\n\n  timeout = setTimeout(function () {\n    log('Request to app timed out after 3 seconds');\n    appRequest.abort();\n  }, 3000);\n});\n\n\ntry {\n  server.listen(8039);\n  log('Started health check server', true);\n} catch (e) {\n  // Port is being used, likely from another health-check server running\n  log('Port being used');\n}\n"],"file":"health-check.js"}