server-control-s3 0.0.11

package/README.md

@@ -0,0 +1,74 @@
+# server-control-s3
+
+* create AMI with supervisor, git and node
+* create user node with home in /var/node
+* clone your project
+
+sample config to add to your app:
+
+```javascript
+
+sc.init(app, {
+	prefix: '/',
+    repo_dir: '/var/node/project',
+    secret: "update-secret"
+});
+
+```
+
+* assign an IAM role with the following configuration:
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "Stmt1412101976000",
+      "Effect": "Allow",
+      "Action": [
+        "ec2:DescribeInstances"
+      ],
+      "Resource": [
+        "*"
+      ]
+    },
+    {
+      "Sid": "Stmt1412101976001",
+      "Effect": "Allow",
+      "Action": [
+        "ec2:DescribeLaunchTemplateVersions",
+        "ec2:ModifyLaunchTemplate",
+        "ec2:CreateLaunchTemplateVersion"
+      ],
+      "Resource": [
+        "*"
+      ]
+    },
+    {
+      "Sid": "Stmt1412102095000",
+      "Effect": "Allow",
+      "Action": [
+        "autoscaling:DescribeAutoScalingGroups"
+      ],
+      "Resource": [
+        "*"
+      ]
+    }
+  ]
+}
+```
+
+* also make sure you role can passrole itself
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": "iam:PassRole",
+            "Resource": "arn:aws:iam::833562685972:role/<rolename>"
+        }
+    ]
+}
+```
+
+* launch!

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "server-control-s3",
+  "version": "0.0.11",
+  "author": {
+    "name": "Jim Lake"
+  },
+  "license": "MIT",
+  "description": "Easy updating of Amazon AWS instances from s3 packages",
+  "keywords": [
+    "aws",
+    "update",
+    "asg",
+    "ec2"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:jim-lake/server-control-s3.git"
+  },
+  "files": [
+    "src/*",
+    "scripts/*"
+  ],
+  "main": "src/index.js",
+  "scripts": {
+    "lint": "eslint src --ext js",
+    "pretty": "prettier --write src/*.js"
+  },
+  "dependencies": {
+    "async": "3.2.4",
+    "aws-sdk": "2.1366.0",
+    "body-parser": "1.20.2",
+    "cookie-parser": "1.4.6",
+    "request": "2.88.2"
+  }
+}

package/scripts/instance_update.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+source <( wget "http://169.254.169.254/latest/user-data" -O - 2>/dev/null )
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+if [ "${SC_UPDATE_URL}" != "" ]; then
+  echo `date` ": Updating using URL: $SC_UPDATE_URL" >>/tmp/instance-update.log
+  pushd $SC_REPO_DIR >/dev/null 2>/dev/null
+  su node -c "${SCRIPT_DIR}/update_to_hash.sh ${SC_UPDATE_URL}" >>/tmp/instance-update.log 2>&1
+  popd >/dev/null 2>/dev/null
+else
+  echo `date` ": No SC_UPDATE_URL so not doing anything" >>/tmp/instance-update.log
+fi

package/scripts/remove_old_target.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+if [ "$#" -lt 1 ]; then
+  echo "Usage: $(basename $0) <repo_dir>"
+  exit 1
+fi
+
+REPO_DIR=$1
+REAL_REPO_DIR=$(readlink -fn "$REPO_DIR")
+
+OLD_TARGET_FILE="$REPO_DIR/.sc_old_target"
+if ! [[ -f "$OLD_TARGET_FILE" ]] ; then
+  echo "Old target file doesnt exist, quitting"
+  exit 0
+fi
+
+OLD_TARGET=$(cat "$OLD_TARGET_FILE")
+if ! [[ -d "$OLD_TARGET" ]] ; then
+  echo "Old target: $OLD_TARGET is not a dir, ignoring"
+  rm -f "$OLD_TARGET_FILE"
+  exit 0
+fi
+
+if [[ -L "$OLD_TARGET" ]]; then
+  echo " - WARNING!!! Old Target: $OLD_TARGET is a link?!"
+  rm -f "$OLD_TARGET_FILE"
+  exit 0
+fi
+
+REAL_OLD_TARGET=$(readlink -fn "$OLD_TARGET")
+if [[ "$REAL_REPO_DIR" = "$REAL_OLD_TARGET" ]] ; then
+  echo "Old and new are the same, not removing"
+  rm -f "$OLD_TARGET_FILE"
+  exit 0
+fi
+
+echo "removing old target: $OLD_TARGET"
+rm -rf "$OLD_TARGET"
+if [ "$?" -ne 0 ]; then
+  echo "Remove old target failed"
+  exit 2
+fi
+
+rm -f "$OLD_TARGET_FILE"
+exit 0

package/scripts/update_to_hash.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+
+if [ "$#" -lt 1 ]; then
+  echo "Usage: $(basename $0) <url>"
+  echo " - script should be run from the repo dir"
+  exit 1
+fi
+
+URL=$1
+REPO_DIR=`pwd`
+OLD_TARGET=$(readlink -fn "$REPO_DIR")
+TARGET_NAME=$(basename "$REPO_DIR")
+PARENT_DIR=$(dirname "$REPO_DIR")
+ARCHIVE_NAME=${URL##*/}
+ARCHIVE_BASE_NAME=${ARCHIVE_NAME%%.tar.gz}
+DATE=$(date +%Y%m%d-%H%M%S)
+TMP_DIR="$PARENT_DIR/$ARCHIVE_BASE_NAME-$DATE"
+
+echo "updating repo with url: $URL"
+echo " - whoami: $(whoami)"
+echo " - HOME: $HOME"
+echo " - REPO_DIR: $REPO_DIR"
+echo " - OLD_TARGET: $OLD_TARGET"
+
+if ! [[ -L "$REPO_DIR" ]]; then
+  echo " - WARNING!!! REPO_DIR is not a link, this script wont work"
+fi
+
+echo " - mkdir for tmp dir: $TMP_DIR"
+mkdir "$TMP_DIR"
+if [ "$?" -ne 0 ]; then
+  echo " - mkdir failed with parent $PARENT_DIR"
+  exit 2
+fi
+
+pushd "$TMP_DIR"
+echo " - downloading file to temp dir: $TMP_DIR"
+if [[ $URL == http* ]] ; then
+  wget "$URL" -O output.tar.gz
+else
+  aws s3 cp "$URL" output.tar.gz
+fi
+if [ "$?" -ne 0 ]; then
+  echo " - pull $URL failed"
+  rm -rf "$TMP_DIR"
+  popd
+  exit 3
+fi
+
+echo " - untar output.tar.gz"
+tar xzf output.tar.gz
+if [ "$?" -ne 0 ]; then
+  echo " - untar failed"
+  rm -rf "$TMP_DIR"
+  popd
+  exit 4
+fi
+rm output.tar.gz
+
+echo " - npm ci"
+npm ci
+if [ "$?" -ne 0 ]; then
+  echo " - npm ci failed"
+  rm -rf "$TMP_DIR"
+  popd
+  exit 5
+fi
+
+echo " - link $TMP_DIR over $REPO_DIR"
+if [[ $OSTYPE == darwin* ]]; then
+  ln -shf "$TMP_DIR" "$REPO_DIR"
+else
+  ln -sTf "$TMP_DIR" "$REPO_DIR"
+fi
+if [ "$?" -ne 0 ]; then
+  echo " - link failed"
+  rm -rf "$TMP_DIR"
+  popd
+  exit 6
+fi
+
+echo "$OLD_TARGET" > "$TMP_DIR/.sc_old_target"
+
+popd
+exit 0

package/src/index.js

@@ -0,0 +1,617 @@
+const async = require('async');
+require('aws-sdk/lib/maintenance_mode_message').suppress = true;
+const AWS = require('aws-sdk');
+const body_parser = require('body-parser');
+const child_process = require('child_process');
+const cookie_parser = require('cookie-parser');
+const fs = require('fs');
+const { join: pathJoin } = require('path');
+const { webRequest, headUrl, fetchFileContents } = require('./request');
+
+exports.init = init;
+exports.getGitCommitHash = getGitCommitHash;
+
+const MAX_WAIT_COUNT = 12;
+const SERVER_WAIT_MS = 10 * 1000;
+const DEFAULT_CONFIG = {
+  route_prefix: '',
+  secret: 'secret',
+  sc_update_url_key_name: 'SC_UPDATE_URL',
+  restart_function: _defaultRestartFunction,
+  service_port: 80,
+  http_proto: 'http',
+  auth_middleware: false,
+  repo_dir: process.env.PWD,
+  console_log: console.log,
+  error_log: console.error,
+  update_launch_default: true,
+  remove_old_target: true,
+};
+const g_config = {};
+let g_gitCommitHash = false;
+let g_updateHash = '';
+
+function init(app, config) {
+  Object.assign(g_config, DEFAULT_CONFIG, config);
+  if (typeof g_config.route_prefix !== 'string') {
+    throw 'server-control route_prefix required';
+  }
+  if (!g_config.remote_repo_prefix) {
+    throw 'server-control remote_repo_prefix required';
+  }
+  g_config.route_prefix.replace(/\/$/, '');
+  g_config.remote_repo_prefix.replace(/\/$/, '');
+
+  _getAwsRegion();
+  getGitCommitHash();
+  const { route_prefix } = g_config;
+  if (g_config.remove_old_target) {
+    _removeOldTarget();
+  }
+
+  app.get(
+    route_prefix + '/server_data',
+    _parseQuery,
+    body_parser.json(),
+    body_parser.urlencoded({ extended: false }),
+    cookie_parser(),
+    _secretOrAuth,
+    _serverData
+  );
+  app.get(
+    route_prefix + '/group_data',
+    _parseQuery,
+    body_parser.json(),
+    body_parser.urlencoded({ extended: false }),
+    cookie_parser(),
+    _secretOrAuth,
+    _groupData
+  );
+  app.get(
+    route_prefix + '/update_group',
+    _parseQuery,
+    body_parser.json(),
+    body_parser.urlencoded({ extended: false }),
+    cookie_parser(),
+    _secretOrAuth,
+    _updateGroup
+  );
+  app.get(
+    route_prefix + '/update_server',
+    _parseQuery,
+    body_parser.json(),
+    body_parser.urlencoded({ extended: false }),
+    cookie_parser(),
+    _secretOrAuth,
+    _updateServer
+  );
+}
+function _parseQuery(req, res, next) {
+  if (typeof req.query === 'string') {
+    const query = {};
+    req.query.split('&').forEach((key_val) => {
+      const split = key_val.split('=');
+      query[split[0]] = split[1] || '';
+    });
+    req.query = query;
+  }
+  next();
+}
+function _secretOrAuth(req, res, next) {
+  if (req.headers && req.headers['x-sc-secret'] === g_config.secret) {
+    next();
+  } else if (
+    req.body &&
+    req.body.secret &&
+    req.body.secret === g_config.secret
+  ) {
+    next();
+  } else if (
+    req.cookies &&
+    req.cookies.secret &&
+    req.cookies.secret === g_config.secret
+  ) {
+    next();
+  } else if (g_config.auth_middleware) {
+    g_config.auth_middleware(req, res, next);
+  } else {
+    res.sendStatus(403);
+  }
+}
+function _serverData(req, res) {
+  res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+
+  getGitCommitHash((err, git_commit_hash) => {
+    const body = {
+      git_commit_hash,
+      uptime: process.uptime(),
+    };
+    if (err) {
+      res.status(500);
+      body.err = err;
+    }
+    res.send(body);
+  });
+}
+
+function _groupData(req, res) {
+  res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+
+  _getGroupData((err, result) => {
+    const body = {
+      LATEST: result.latest || 'unknown',
+      InstanceId: result.InstanceId || 'unknown',
+      instance_list: result.instance_list,
+    };
+
+    if (result.auto_scale_group) {
+      body.auto_scale_group = {
+        AutoScalingGroupName: result.auto_scale_group.AutoScalingGroupName,
+        LaunchTemplate: result.auto_scale_group.LaunchTemplate,
+      };
+      if (result.launch_template) {
+        body.launch_template = result.launch_template;
+      }
+    }
+
+    if (err) {
+      res.status(500).send({ err, body });
+    } else {
+      res.send(body);
+    }
+  });
+}
+
+function _getGroupData(done) {
+  const autoscaling = _getAutoscaling();
+  const ec2 = _getEC2();
+  let latest = false;
+  let InstanceId = false;
+  let asg = false;
+  let instance_list = false;
+  let launch_template = false;
+
+  async.series(
+    [
+      (done) => {
+        _getLatest((err, result) => {
+          if (err) {
+            _errorLog('_getGroupData: latest err:', err);
+          }
+          latest = result;
+          done();
+        });
+      },
+      (done) => {
+        const meta = _getMetadataService();
+        meta.request('/latest/meta-data/instance-id', (err, results) => {
+          if (err) {
+            _errorLog('_getGroupData: Failed to get instance id:', err);
+          }
+          InstanceId = results || '';
+          done();
+        });
+      },
+      (done) => {
+        autoscaling.describeAutoScalingGroups({}, (err, data) => {
+          if (err) {
+            _errorLog('_getGroupData: find asg err:', err);
+          } else {
+            asg = data.AutoScalingGroups.find((group) => {
+              return (
+                group.AutoScalingGroupName === g_config.asg_name ||
+                group.Instances.find((i) => i.InstanceId === InstanceId)
+              );
+            });
+            if (!asg) {
+              err = 'asg_not_found';
+            }
+          }
+          done(err);
+        });
+      },
+      (done) => {
+        const opts = {
+          InstanceIds: asg.Instances.map((i) => i.InstanceId),
+        };
+        ec2.describeInstances(opts, (err, results) => {
+          if (err) {
+            _errorLog('_getGroupData: describeInstances err:', err);
+          } else {
+            instance_list = [];
+            results.Reservations.forEach((reservation) => {
+              reservation.Instances.forEach((i) => {
+                instance_list.push({
+                  InstanceId: i.InstanceId,
+                  PrivateIpAddress: i.PrivateIpAddress,
+                  PublicIpAddress: i.PublicIpAddress,
+                  LaunchTime: i.LaunchTime,
+                  ImageId: i.ImageId,
+                  InstanceType: i.InstanceType,
+                  State: i.State,
+                });
+              });
+            });
+          }
+          done(err);
+        });
+      },
+      (done) => {
+        const list = instance_list.filter((i) => i.State.Name === 'running');
+        async.each(
+          list,
+          (instance, done) => {
+            _getServerData(instance, (err, body) => {
+              instance.git_commit_hash = body && body.git_commit_hash;
+              instance.uptime = body && body.uptime;
+              done(err);
+            });
+          },
+          done
+        );
+      },
+      (done) => {
+        const opts = {
+          LaunchTemplateId: asg.LaunchTemplate.LaunchTemplateId,
+          Versions: [asg.LaunchTemplate.Version],
+        };
+        ec2.describeLaunchTemplateVersions(opts, (err, data) => {
+          if (err) {
+            _errorLog('_getGroupData: launch template fetch error:', err);
+          } else if (data && data.LaunchTemplateVersions.length === 0) {
+            err = 'launch_template_not_found';
+          } else {
+            launch_template = data.LaunchTemplateVersions[0];
+            const ud = launch_template.LaunchTemplateData.UserData;
+            if (ud) {
+              const s = Buffer.from(ud, 'base64').toString('utf8');
+              launch_template.LaunchTemplateData.UserData = s;
+            }
+          }
+          done(err);
+        });
+      },
+    ],
+    (err) => {
+      const ret = {
+        latest,
+        InstanceId,
+        auto_scale_group: asg,
+        launch_template,
+        instance_list,
+      };
+      done(err, ret);
+    }
+  );
+}
+
+function _getServerData(instance, done) {
+  const proto = g_config.http_proto;
+  const ip = instance.PrivateIpAddress;
+  const port = g_config.service_port;
+  const prefix = g_config.route_prefix;
+  const url = `${proto}://${ip}:${port}${prefix}/server_data`;
+  const opts = {
+    strictSSL: false,
+    url,
+    method: 'GET',
+    headers: {
+      'x-sc-secret': g_config.secret,
+    },
+    json: {
+      secret: g_config.secret,
+    },
+  };
+  webRequest(opts, (err, body) => {
+    if (err) {
+      _errorLog('_getServerData: request err:', err);
+    }
+    done(err, body);
+  });
+}
+function _updateServer(req, res) {
+  res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+  const hash = req.body.hash || req.query.hash;
+  if (hash) {
+    _updateSelf(hash, (err) => {
+      if (err) {
+        res.status(500).send(err);
+      } else {
+        res.send('Restarting server');
+        g_config.restart_function();
+      }
+    });
+  } else {
+    res.status(400).send('hash is required');
+  }
+}
+function _updateSelf(hash, done) {
+  const dir = g_config.repo_dir;
+  const url = `${g_config.remote_repo_prefix}/${hash}.tar.gz`;
+  const cmd = `cd ${dir} && ${__dirname}/../scripts/update_to_hash.sh ${url}`;
+  child_process.exec(cmd, (err, stdout, stderr) => {
+    if (err) {
+      _errorLog(
+        '_updateSelf: update_to_hash.sh failed with err:',
+        err,
+        'stdout:',
+        stdout,
+        'stderr:',
+        stderr
+      );
+      err = 'update_failed';
+    } else {
+      g_updateHash = hash;
+    }
+    done(err);
+  });
+}
+function _removeOldTarget() {
+  const dir = g_config.repo_dir;
+  const cmd = `${__dirname}/../scripts/remove_old_target.sh ${dir}`;
+  child_process.exec(cmd, (err, stdout, stderr) => {
+    if (err) {
+      _errorLog(
+        '_removeOldTarget: remove_old_target.sh failed with err:',
+        err,
+        'stdout:',
+        stdout,
+        'stderr:',
+        stderr
+      );
+    }
+  });
+}
+
+function _updateGroup(req, res) {
+  res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+
+  const hash = req.body.hash || req.query.hash;
+  if (hash) {
+    const url = `${g_config.remote_repo_prefix}/${hash}.tar.gz`;
+    const key_name = g_config.sc_update_url_key_name;
+    const ami_id = req.body.ami_id || req.query.ami_id || false;
+
+    const ec2 = _getEC2();
+    let group_data = false;
+    let old_data = '';
+    let new_version;
+    const server_result = {};
+    async.series(
+      [
+        (done) => {
+          _getGroupData((err, result) => {
+            if (!err) {
+              group_data = result;
+              const data = result.launch_template.LaunchTemplateData.UserData;
+              data.split('\n').forEach((line) => {
+                if (line.length && line.indexOf(key_name) === -1) {
+                  old_data += line + '\n';
+                }
+              });
+            }
+            done(err);
+          });
+        },
+        (done) => {
+          headUrl(url, (err) => {
+            if (err) {
+              _errorLog('_updateGroup: head url:', url, 'err:', err);
+              err = 'url_not_found';
+            }
+            done(err);
+          });
+        },
+        (done) => {
+          const new_data = `${old_data}${key_name}=${url}\n`;
+          const opts = {
+            LaunchTemplateId: group_data.launch_template.LaunchTemplateId,
+            SourceVersion: String(group_data.launch_template.VersionNumber),
+            LaunchTemplateData: {
+              UserData: Buffer.from(new_data, 'utf8').toString('base64'),
+            },
+          };
+          if (ami_id) {
+            opts.LaunchTemplateData.ImageId = ami_id;
+          }
+          ec2.createLaunchTemplateVersion(opts, (err, data) => {
+            if (err) {
+              _errorLog('_updateGroup: failed to create version, err:', err);
+            } else {
+              new_version = data.LaunchTemplateVersion.VersionNumber;
+            }
+            done(err);
+          });
+        },
+        (done) => {
+          if (g_config.update_launch_default) {
+            const opts = {
+              DefaultVersion: String(new_version),
+              LaunchTemplateId: group_data.launch_template.LaunchTemplateId,
+            };
+            ec2.modifyLaunchTemplate(opts, function (err) {
+              if (err) {
+                _errorLog('_updateGroup: failed to update default, err:', err);
+              }
+              done(err);
+            });
+          } else {
+            done();
+          }
+        },
+        (done) => {
+          let group_err;
+          async.each(
+            group_data.instance_list,
+            (instance, done) => {
+              if (instance.InstanceId === group_data.InstanceId) {
+                done();
+              } else {
+                _updateInstance(hash, instance, (err) => {
+                  if (err) {
+                    _errorLog(
+                      '_updateGroup: update instance:',
+                      instance.InstanceId,
+                      'err:',
+                      err
+                    );
+                    group_err = err;
+                  }
+                  server_result[instance.InstanceId] = err;
+                  done();
+                });
+              }
+            },
+            () => done(group_err)
+          );
+        },
+        (done) => {
+          _updateSelf(hash, (err) => {
+            server_result[group_data.InstanceId] = err;
+            done(err);
+          });
+        },
+      ],
+      (err) => {
+        const body = {
+          err,
+          server_result,
+          launch_template_version: new_version,
+        };
+        if (err) {
+          res.status(500).send(body);
+        } else {
+          body._msg =
+            'Successful updating all servers, restarting this server.';
+          res.send(body);
+          g_config.restart_function();
+        }
+      }
+    );
+  } else {
+    res.status(400).send('hash is required');
+  }
+}
+function _updateInstance(hash, instance, done) {
+  async.series(
+    [
+      (done) => {
+        const proto = g_config.http_proto;
+        const ip = instance.PrivateIpAddress;
+        const port = g_config.service_port;
+        const prefix = g_config.route_prefix;
+        const url = `${proto}://${ip}:${port}${prefix}/update_server`;
+        const opts = {
+          strictSSL: false,
+          url,
+          method: 'GET',
+          headers: {
+            'x-sc-secret': g_config.secret,
+          },
+          json: {
+            hash,
+            secret: g_config.secret,
+          },
+        };
+        webRequest(opts, done);
+      },
+      (done) => _waitForServer({ instance, hash }, done),
+    ],
+    done
+  );
+}
+function _waitForServer(params, done) {
+  const { instance, hash } = params;
+  let count = 0;
+
+  async.forever(
+    (done) => {
+      count++;
+      _getServerData(instance, (err, body) => {
+        if (!err && body && body.git_commit_hash === hash) {
+          done('stop');
+        } else if (count > MAX_WAIT_COUNT) {
+          done('too_many_tries');
+        } else {
+          setTimeout(done, SERVER_WAIT_MS);
+        }
+      });
+    },
+    (err) => {
+      if (err === 'stop') {
+        err = null;
+      }
+      done(err);
+    }
+  );
+}
+
+function _getLatest(done) {
+  const url = g_config.remote_repo_prefix + '/LATEST';
+  fetchFileContents(url, (err, body) => {
+    done(err, body && body.trim());
+  });
+}
+function getGitCommitHash(done) {
+  if (g_gitCommitHash) {
+    done && done(null, g_gitCommitHash);
+  } else {
+    const file = pathJoin(g_config.repo_dir, '.git_commit_hash');
+    fs.readFile(file, 'utf8', (err, result) => {
+      if (!err && !result) {
+        err = 'no_result';
+      }
+      if (err) {
+        _errorLog('getGitCommitHash: err:', err, 'file:', file);
+      } else {
+        g_gitCommitHash = result.trim();
+      }
+      done && done(err, g_gitCommitHash);
+    });
+  }
+}
+function _getAwsRegion() {
+  if (!g_config.region) {
+    const meta = _getMetadataService();
+    meta.request(
+      '/latest/dynamic/instance-identity/document',
+      (err, results) => {
+        if (err) {
+          _errorLog('_getAwsRegion: metadata err:', err);
+        } else {
+          try {
+            const json = JSON.parse(results);
+            if (json && json.region) {
+              g_config.region = json.region;
+            }
+          } catch (e) {
+            _errorLog('_getAwsRegion: threw:', e);
+          }
+        }
+      }
+    );
+  }
+}
+function _getMetadataService() {
+  const opts = g_config.metadata_opts || {};
+  return new AWS.MetadataService(opts);
+}
+function _getAutoscaling() {
+  return new AWS.AutoScaling({ region: g_config.region });
+}
+function _getEC2() {
+  return new AWS.EC2({ region: g_config.region });
+}
+function _errorLog(...args) {
+  g_config.error_log(...args);
+}
+function _defaultRestartFunction() {
+  g_config.console_log(
+    'server-control: updated to: ',
+    g_updateHash,
+    'restarting...'
+  );
+  setTimeout(function () {
+    process.exit(0);
+  }, 100);
+}

package/src/request.js

@@ -0,0 +1,40 @@
+const AWS = require('aws-sdk');
+const request = require('request');
+
+exports.webRequest = webRequest;
+exports.headUrl = headUrl;
+exports.fetchFileContents = fetchFileContents;
+
+function webRequest(opts, done) {
+  request(opts, (err, response, body) => {
+    const statusCode = response && response.statusCode;
+    if (!err && (statusCode < 200 || statusCode > 299)) {
+      err = statusCode;
+    }
+    done(err, body);
+  });
+}
+function headUrl(url, done) {
+  if (url.indexOf('http') === 0) {
+    webRequest({ url, method: 'HEAD' }, done);
+  } else {
+    const parts = url.match(/s3:\/\/([^/]*)\/(.*)/);
+    const Bucket = parts && parts[1];
+    const Key = parts && parts[2];
+    const s3 = new AWS.S3();
+    s3.headObject({ Bucket, Key }, done);
+  }
+}
+function fetchFileContents(url, done) {
+  if (url.indexOf('http') === 0) {
+    webRequest({ url }, done);
+  } else {
+    const parts = url.match(/s3:\/\/([^/]*)\/(.*)/);
+    const Bucket = parts && parts[1];
+    const Key = parts && parts[2];
+    const s3 = new AWS.S3();
+    s3.getObject({ Bucket, Key }, (err, data) => {
+      done(err, data && data.Body && data.Body.toString('utf8'));
+    });
+  }
+}