inf 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 575f2c3299b818ecc71262fcc870d0c37c650ff1
+  data.tar.gz: ee6999576321334813dfa5a7d50395b3e25ac64a
+SHA512:
+  metadata.gz: c0d28adc8da0b26881ead0ddc7041def45d54e01ab61d51ca73ccf515ae13bb296c33a5f913866d53fa8cd7730cce22ab79a4ab9b4dfb973d91f8b47dc58a8b5
+  data.tar.gz: 6aeaa6eaf7ec2f03fb9198ebb22fb40603416b4c934a704aa6d56f79bd7f55ca5616a2e5d3555419a9df6ee911314c3e812269c85d516e11a6afb98b8b39cec8

data/bin/inf

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'aws-sdk'
+require 'time'
+require 'pry'
+require 'awesome_print'
+require 'base64'
+require 'colored'
+require 'dotenv'
+
+require_relative '../lib/inf.rb'
+
+Dotenv.load('inf.env')
+
+def require_env_vars(vars)
+  vars.each do |v|
+    raise ArgumentError.new("Missing env var #{v}") unless ENV[v]
+  end
+end
+
+require_env_vars %w(
+  STATE_BUCKET
+  APP_NAME
+  AWS_REGION
+  SPOT_PRICE
+  TARGET_CAPACITY
+  AMI
+  FLEET_ROLE
+  INSTANCE_PROFILE_NAME
+  SG
+  ELB_SG
+  SUBNET_IDS
+  KEY_NAME
+  CERT_ARN
+  JENKINS_PUBLIC_KEY
+)
+
+ENV['TERMINATE_INSTANCES'] ||= "true"
+ENV['INSTANCE_TYPES'] = 'm1.small,m1.medium'
+ENV['DNS_TTL'] ||= "30"
+
+SSH_CMD='ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
+
+class CLI < Thor
+  register Inf::Fleet, :fleet, 'fleet', 'operate on the fleet'
+  register Inf::LoadBalancer, :lb, 'lb', 'operate on load balancer'
+  register Inf::Env, :env, 'env', "operate on app environment"
+  # register Inf::Domains, :domains, 'domains', 'operate on domains'
+
+  def method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  desc 'release [TARBALL_PATH]', 'create release from slug (default: ./slug.tgz)'
+  def release(tarball_path='./slug.tgz')
+    release_id = latest_release + 1
+
+    tarball_path = File.expand_path tarball_path
+
+    puts "Uploading slug to s3 (could take a moment)...".yellow
+    put_state("apps/#{app_name}/releases/v#{release_id}.tgz", File.read(tarball_path))
+    put_state("apps/#{app_name}/latest_release_id", release_id)
+  end
+
+  desc 'migrate', 'migrate state'
+  def migrate
+    Inf::Migrations.maybe_migrate!
+  end
+
+  desc 'deploy [RELEASE_ID]', 'deploy release_id (default: currently deployed release)'
+  def deploy(release_id=nil)
+    release_id ||= current_release || latest_release
+
+    unless release_id
+      puts "No current or latest release; please specify a release"
+      return
+    end
+
+
+    # set the current release
+    # app servers will pull this and use
+    # it to deploy
+    put_state("apps/#{app_name}/current_release_id", release_id)
+
+    # loop over app servers and tell them
+    # they should deploy
+    Inf::Fleet.each_fleet do |name|
+      puts "Deploying release v#{release_id} to fleet #{name}...".blue
+
+      Inf::Fleet.ips(name).each do |ip|
+        puts "Deploying to #{ip}...".gray
+        `#{SSH_CMD} -t ubuntu@#{ip} fork-and-deploy-app`
+        $?.success? or exit 1
+      end
+    end
+  end
+
+  desc 'deploy_latest', 'deploy newest release to app'
+  def deploy_latest
+    deploy latest_release
+  end
+
+  desc 'latest_release', 'show version number of latest release'
+  def latest_release
+    get_state("apps/#{app_name}/latest_release_id").tap do |id|
+      puts "The latest release is v#{id} (it may not be deployed at the moment)".blue
+    end.to_i
+  end
+
+  desc 'current_release', 'show version number of current release'
+  def current_release
+    get_state("apps/#{app_name}/current_release_id").tap do |id|
+      puts "The current release is v#{id}".blue
+    end.to_i
+  end
+
+  desc 'releases', 'list releases'
+  def releases
+    list_state "apps/#{app_name}/releases" do |key|
+      ap key
+    end
+  end
+
+  desc 'restart', 'restart servers'
+  def restart
+    Inf::Fleet.each_fleet do |name|
+      puts "Restarting fleet #{name}...".blue
+
+      Inf::Fleet.ips(name).each do |ip|
+        puts "Restarting #{ip}...".gray
+        `#{SSH_CMD} -t ubuntu@#{ip} fork-and-restart-app`
+        $?.success? or exit 1
+      end
+    end
+  end
+
+  desc 'clear_state', 'resets the s3 state'
+  def clear_state
+    delete_spec = s3.list_objects_v2(
+      bucket: state_bucket
+    ).contents.map { |object| {key: object.key} }
+
+    if delete_spec.empty?
+      puts "Had no state".yellow
+    else
+      s3.delete_objects(
+        bucket: state_bucket,
+        delete: {
+          objects: delete_spec
+        }
+      )
+
+      puts "State cleared".blue
+    end
+  end
+
+  desc 'open [BROWSER]', 'opens app in browser'
+  def open(browser='google-chrome')
+    url = get_state("apps/#{app_name}/lb-dns")
+    puts "Opening #{url} in #{browser}".blue
+    `#{browser} #{url}`
+  end
+end
+
+CLI.start(ARGV)

data/bootstrap-scripts/default-app.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+
+. ./bootstrap-env
+
+INSTANCE_ID=$(curl http://169.254.169.254/latest/meta-data/instance-id)
+LB_NAME=$(aws s3 cp s3://$STATE_BUCKET/apps/$APP_NAME/lb-name -)
+
+cat <<EOF | logger -t bootstrap
+  beginning instance bootstrap for $INSTANCE_ID
+    app: $APP_NAME
+    state_bucket: $STATE_BUCKET
+    lb_name: $LB_NAME
+    fleet_name: $FLEET_NAME
+EOF
+
+if [ $FLEET_NAME == "web" ]; then
+  echo "Registering with load balancer $LB_NAME" | logger -t bootstrap
+
+  aws elb register-instances-with-load-balancer \
+    --load-balancer-name $LB_NAME \
+    --instances $INSTANCE_ID \
+    --region $AWS_REGION
+fi
+
+mkdir -p /var/app
+
+cat > /var/app/env <<EOF
+APP_NAME=$APP_NAME
+STATE_BUCKET=$STATE_BUCKET
+FLEET_NAME=$FLEET_NAME
+EOF
+
+echo "Wrote /var/app/env" | logger -t bootstrap
+
+chown -R ubuntu:ubuntu /var/app
+
+mkdir -p /home/ubuntu/.ssh
+echo "$JENKINS_PUBLIC_KEY" >> /home/ubuntu/.ssh/authorized_keys
+chown -R ubuntu:ubuntu /home/ubuntu/.ssh
+
+echo "Wrote jenkins public key" | logger -t bootstrap
+
+cat > /usr/local/bin/deploy-app <<EOF
+#!/bin/bash
+
+cd /var/app
+. ./env
+
+DEPLOYED_VERSION=`cat /var/app/release_id`
+VERSION=\$1
+
+if [ -z \$VERSION ]; then
+  VERSION=\$(aws s3 cp s3://\$STATE_BUCKET/apps/\$APP_NAME/current_release_id -)
+fi
+
+if [ "\$VERSION" == "\$DEPLOYED_VERSION" ]; then
+  echo "The desired version (\$VERSION) is currently deployed; exiting"
+  exit 0
+elif [ -z \$DEPLOYED_VERSION ]; then
+  echo "Bootstrapping instance with version \$VERSION"
+else
+  echo "Had version \$DEPLOYED_VERSION; deploying \$VERSION"
+fi
+
+aws s3 cp s3://\$STATE_BUCKET/apps/\$APP_NAME/releases/v\$VERSION.tgz /tmp/slug.tgz
+
+rm -rf staging || true
+mkdir staging
+cd staging
+tar -xzf /tmp/slug.tgz
+
+. bin/pre-deploy
+
+cd /var/app
+
+rm -rf live
+mv staging live
+
+cd live
+
+. bin/restart
+
+echo \$VERSION > /var/app/release_id
+EOF
+
+cat > /usr/local/bin/restart-app <<EOF
+#!/bin/bash
+
+cd /var/app
+. ./env
+
+cd live
+
+. bin/restart
+EOF
+
+
+cat > /usr/local/bin/fork-and-deploy-app <<EOF
+#!/bin/bash -l
+
+( setsid deploy-app 2>&1 | setsid logger -t deploy ) & disown
+
+sleep 1
+echo "Forked... bye"
+EOF
+
+cat > /usr/local/bin/fork-and-restart-app <<EOF
+#!/bin/bash -l
+
+( setsid restart-app 2>&1 | setsid logger -t deploy ) & disown
+
+sleep 1
+echo "Forked... bye"
+EOF
+
+
+chmod +x /usr/local/bin/deploy-app
+chmod +x /usr/local/bin/fork-and-deploy-app
+chmod +x /usr/local/bin/restart-app
+chmod +x /usr/local/bin/fork-and-restart-app
+
+echo "Wrote deploy scripts" | logger -t bootstrap
+
+echo "Running initial deploy as user 'ubuntu'..."
+nohup sudo -u ubuntu fork-and-deploy-app & disown
+
+echo "That's it for bootstrap!"

data/lib/aws.rb

@@ -0,0 +1,131 @@
+module Inf::AWS
+  def self.method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.ec2
+    @ec2 ||= Aws::EC2::Client.new
+  end
+
+  def self.elb
+    @elb ||= Aws::ElasticLoadBalancing::Client.new
+  end
+
+  def self.s3
+    @s3 ||= Aws::S3::Client.new
+  end
+
+  def self.route53
+    @route53 ||= Aws::Route53::Client.new
+  end
+
+  def self.bootstrap_script(app_name, state_bucket, fleet_name)
+    <<BOOTSTRAP_SCRIPT
+#!/bin/bash
+
+cd /tmp
+
+cat > bootstrap-env <<EOF
+export APP_NAME=#{app_name}
+export STATE_BUCKET=#{state_bucket}
+export FLEET_NAME=#{fleet_name}
+export AWS_REGION=#{ENV['AWS_REGION']}
+export JENKINS_PUBLIC_KEY="#{ENV['JENKINS_PUBLIC_KEY']}"
+EOF
+
+. ./bootstrap-env
+
+aws s3 cp s3://$STATE_BUCKET/apps/$APP_NAME/bootstrap-instance.sh ./bootstrap.sh
+chmod +x bootstrap.sh
+
+( setsid ./bootstrap.sh 2>&1 | setsid logger -t bootstrap ) & disown
+
+BOOTSTRAP_SCRIPT
+  end
+
+  def self.launch_load_balancer
+    lb_name = "app-lb-#{app_name}"
+    lb_dns = elb.create_load_balancer(
+      load_balancer_name: lb_name,
+      subnets: ENV['SUBNET_IDS'].split(','),
+      security_groups: [ENV['ELB_SG']],
+      scheme: "internet-facing",
+      listeners: [{
+        instance_port: 5000,
+        instance_protocol: 'HTTP',
+        load_balancer_port: 80,
+        protocol: 'HTTP'
+      }, {
+        instance_port: 5000,
+        instance_protocol: "HTTP",
+        load_balancer_port: 443,
+        protocol: "HTTPS",
+        ssl_certificate_id: ENV['CERT_ARN'],
+      }]
+    ).dns_name
+
+    elb.configure_health_check(
+      load_balancer_name: lb_name,
+      health_check: {
+        target: 'HTTP:80/',
+        interval: 10, # seconds
+        timeout: 5, # seconds to respond
+        unhealthy_threshold: 2, # two consecutive failures
+        healthy_threshold: 2
+      }
+    )
+
+    put_state("apps/#{app_name}/lb-name", lb_name)
+    put_state("apps/#{app_name}/lb-dns", lb_dns)
+
+    puts "Launched load balancer (or it was running)".blue
+  end
+
+  def self.request_spot_fleet(fleet_name='default')
+    launch_specifications = ENV['SUBNET_IDS'].split(',').map do |subnet_id|
+      ENV['INSTANCE_TYPES'].split(',').map do |type|
+        {
+          image_id: ENV['AMI'],
+          key_name: ENV['KEY_NAME'],
+          instance_type: type,
+          monitoring: {
+            enabled: false,
+          },
+          network_interfaces: [{
+            associate_public_ip_address: true,
+            device_index: 0,
+            groups: [ENV['SG']],
+            subnet_id: subnet_id
+          }],
+          iam_instance_profile: {
+            name: ENV['INSTANCE_PROFILE_NAME'],
+          },
+          # ebs_optimized: type == 'm1.small' ? false : false,
+          weighted_capacity: 1.0,
+          user_data: Base64.encode64(bootstrap_script(app_name, state_bucket, fleet_name))
+        }
+      end
+    end.flatten
+
+    resp = ec2.request_spot_fleet(
+      spot_fleet_request_config: {
+        spot_price: ENV['SPOT_PRICE'],
+        target_capacity: ENV['TARGET_CAPACITY'],
+        valid_from: Time.now,
+        valid_until: Time.parse('1/1/2050'),
+        terminate_instances_with_expiration: ENV['TERMINATE_INSTANCES'],
+        iam_fleet_role: ENV['FLEET_ROLE'],
+        launch_specifications: launch_specifications,
+        excess_capacity_termination_policy: "default", # accepts noTermination, default
+        allocation_strategy: "diversified", # accepts lowestPrice, diversified
+        type: "maintain", # accepts request, maintain
+        replace_unhealthy_instances: true,
+      },
+    )
+
+    resp.spot_fleet_request_id.tap do |sfr|
+      puts "Launched spot fleet #{fleet_name} (#{sfr})".blue
+      put_state("apps/#{app_name}/fleets/#{fleet_name}/sfr", sfr)
+    end
+  end
+end

data/lib/domains.rb

@@ -0,0 +1,91 @@
+class Inf::Domains < Thor
+  def method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.list
+    get_state("apps/#{app_name}/domains").lines rescue []
+  end
+
+  def self.hosted_zones
+    @hosted_zones ||= route53.list_hosted_zones_by_name.hosted_zones.reduce
+      binding.pry
+    end
+  end
+
+  def self.sync_to_route53
+    lb_dns = get_state("apps/#{app_name}/lb-dns")
+
+    hosted_zones
+
+    list.each do |domain|
+      route53.change_resource_record_sets({
+        change_batch: {
+          changes: [
+            {
+              action: "UPSERT",
+              resource_record_set: {
+                name: domain,
+                resource_records: [
+                  {
+                    value: lb_dns,
+                  },
+                ],
+                ttl: ENV['DNS_TTL'],
+                type: "CNAME",
+              },
+            },
+          ],
+          comment: "load balancer for #{app_name}",
+        },
+        hosted_zone_id: zone_id,
+      })
+    end
+  end
+
+  desc 'domains', 'list domains'
+  def list
+    Inf::Domains.list.each do |domain|
+      puts domain
+    end
+  end
+
+  desc 'sync', 'sync to route53'
+  def sync
+    Inf::Domains.sync_to_route53
+  end
+
+  desc 'add DOMAIN', 'cname DOMAIN to the load balancer'
+  def add(domain)
+    domains = Inf::Domains.list
+
+    if domains.include? domain
+      puts "Domain #{domain} is already configured".blue
+      return
+    end
+
+    domains += [domain]
+    put_state("apps/#{app_name}/domains", domains.join("\n"))
+
+    Inf::Domains.sync_to_route53
+  end
+
+  desc 'remove DOMAIN', 'un-cname DOMAIN'
+  def remove(domain)
+    domains = Inf::Domains.list
+
+    unless domains.include? domain
+      puts "Domain #{domain} is not configured".red
+      return
+    end
+
+    domains = domains.reject { |d| d == domain }
+    put_state("apps/#{app_name}/domains", domains.join("\n"))
+
+    Inf::Domains.sync_to_route53
+  end
+end

data/lib/env.rb

@@ -0,0 +1,27 @@
+class Inf::Env < Thor
+  def method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  desc 'push [FILE]', 'sets the .env file for the app (default: ./.env; pass "-" for stdin)'
+  def push(file='.env')
+    file = File.expand_path(file)
+
+    if file == '-'
+      env = STDIN.read
+    else
+      env = File.read(file)
+    end
+
+    put_state("apps/#{app_name}/env", env)
+  end
+
+  desc 'pull', 'gets env vars'
+  def pull
+    puts get_state("apps/#{app_name}/env")
+  end
+end

data/lib/fleet.rb

@@ -0,0 +1,167 @@
+class Inf::Fleet < Thor
+  def method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  no_commands do
+    def get_sfr(fleet_name='web')
+      @sfrs ||= {}
+      @sfrs[fleet_name] ||= get_state("apps/#{app_name}/fleets/#{fleet_name}/sfr")
+    end
+  end
+
+  def self.each_fleet(&block)
+    list_state("apps/#{app_name}/fleets") do |key|
+      key.match(/fleets\/([^\/]+)/)[1]
+    end.uniq.each { |name| block.call name }
+  end
+
+  def self.ips(fleet_name='web')
+    sfr = new.get_sfr fleet_name
+
+    unless sfr
+      puts "No sfr for #{app_name}/#{fleet_name}".red
+      puts "Is a fleet launched?"
+      exit 1
+    end
+
+    instance_ids = ec2.describe_spot_fleet_instances(
+      spot_fleet_request_id: sfr
+    ).active_instances.map(&:instance_id)
+
+    if instance_ids.empty?
+      []
+    else
+      ec2.describe_instances(
+        instance_ids: instance_ids
+      ).reservations.map do |it|
+        it.instances.first.public_ip_address
+      end
+    end
+  end
+
+  desc 'launch', 'launch app fleet; check env vars in code'
+  def launch(fleet_name='web')
+    sfr = get_sfr fleet_name
+
+    if sfr
+      puts "Kill existing sfr first".red
+      exit 1
+    end
+
+    Inf::AWS.request_spot_fleet fleet_name
+
+    script = File.expand_path "../../bootstrap-scripts/default-app.sh", __FILE__
+
+    put_state "apps/#{app_name}/bootstrap-instance.sh", File.read(script)
+    puts "Don't forget to deploy something".yellow
+  end
+
+  desc 'kill', 'kill fleet'
+  def kill(fleet_name='web')
+    sfr = get_sfr fleet_name
+
+    if sfr
+      ec2.cancel_spot_fleet_requests(
+        spot_fleet_request_ids: [sfr],
+        terminate_instances: true
+      )
+      puts "Killed #{sfr}".blue
+    else
+      puts "Did not find a sfr".yellow
+    end
+
+    delete_state "apps/#{app_name}/fleets/#{fleet_name}/sfr"
+  end
+
+  desc 'rename [NAME] [NEW_NAME]', 'rename fleet'
+  def rename(name, new_name)
+    sfr = get_sfr new_name
+
+    if sfr
+      puts "Fleet #{new_name} already exists".red
+      exit 1
+    end
+
+    list_state("apps/#{app_name}/fleets/#{name}") do |key|
+      leaf = key.split('/').last
+
+      s3.copy_object(
+        bucket: state_bucket,
+        key: "apps/#{app_name}/fleets/#{new_name}/#{leaf}",
+        copy_source: "#{state_bucket}/#{key}"
+      )
+
+      delete_state key
+    end
+  end
+
+  desc 'nodes', 'list public ips of nodes in fleet'
+  def nodes(fleet_name='web')
+    ips = Inf::Fleet.ips fleet_name
+
+    if ips.any?
+      puts ips.join("\n")
+    else
+      puts "No active instances in fleet"
+    end
+  end
+
+  # TODO make tmux optional
+  desc 'ssh', 'ssh to a node in the fleet'
+  def ssh(fleet_name='web')
+    ips = Inf::Fleet.ips fleet_name
+
+    if ips.empty?
+      puts "No instances in fleet #{fleet_name}".red
+    else
+      ip = ips.first
+
+      puts "Opening ssh to #{ip} in a tmux split".blue
+      `tmux split-window "#{SSH_CMD} ubuntu@#{ips.first}"`
+    end
+  end
+
+  desc 'scale FLEET_NAME COUNT', 'scales the fleet'
+  def scale(fleet_name, count)
+    sfr = get_sfr fleet_name
+
+    ec2.modify_spot_fleet_request({
+      spot_fleet_request_id: sfr,
+      target_capacity: count.to_i,
+      excess_capacity_termination_policy: "default"
+    })
+  end
+
+  desc 'status', 'describes the fleet'
+  def status(fleet_name='web', indent='')
+    nodes = Inf::Fleet.ips fleet_name
+    sfr = get_state("apps/#{app_name}/fleets/#{fleet_name}/sfr")
+
+    sfr_status = ec2.describe_spot_fleet_requests(
+      spot_fleet_request_ids: [sfr]
+    ).spot_fleet_request_configs[0].spot_fleet_request_state
+
+    if nodes.any?
+      puts "Fleet #{fleet_name} has #{nodes.count} nodes (#{nodes.join ', '})".blue
+    elsif sfr
+      puts "Fleet #{fleet_name} (#{sfr}: #{sfr_status}) has no nodes!".red
+    else
+      puts "No fleet #{fleet_name} is launched".yelow
+    end
+  end
+
+  desc 'list', 'lists fleets'
+  def list
+    Inf::Fleet.each_fleet { |name| puts name }
+  end
+
+  desc 'status_all', 'runs `status` for all fleets'
+  def status_all
+    Inf::Fleet.each_fleet { |name| status name }
+  end
+end

data/lib/inf.rb

@@ -0,0 +1,73 @@
+require 'mini_cache'
+
+module Inf
+  def self.cache
+    @cache ||= MiniCache::Store.new
+  end
+
+  def self.state_bucket
+    ENV['STATE_BUCKET'].downcase
+  end
+
+  def self.app_name
+    ENV['APP_NAME'].downcase
+  end
+
+  def self.put_state(k, v)
+    v = v.to_s
+    s3.put_object(
+      bucket: state_bucket,
+      key: k,
+      body: v
+    )
+
+    summary = v.lines.count > 1 ? '[multiline]' : v
+    cache.unset k
+    puts "#{k} -> #{summary}".gray
+  end
+
+  def self.list_state(prefix)
+    s3.list_objects_v2(
+      bucket: state_bucket,
+      prefix: prefix,
+    ).contents.map do |it|
+      yield it.key
+    end
+  end
+
+  def self.get_state(k, opts={})
+    cache.get_or_set(k) do
+      begin
+        object = s3.get_object(bucket: state_bucket, key: k)
+
+        if opts[:raw]
+          object
+        else
+          object.body.read
+        end
+      rescue Aws::S3::Errors::NoSuchKey
+      end
+    end
+  end
+
+  def self.delete_state(k)
+    s3.delete_object(bucket: state_bucket, key: k) rescue nil
+  end
+
+  class << self
+    %i(s3 ec2 elb route53).each do |m|
+      define_method m do
+        AWS.send m
+      end
+    end
+  end
+end
+
+require 'thor'
+
+require_relative 'migrations.rb'
+require_relative 'aws.rb'
+require_relative 'fleet.rb'
+require_relative 'env.rb'
+require_relative 'load_balancer.rb'
+# require_relative 'domains.rb'

data/lib/load_balancer.rb

@@ -0,0 +1,53 @@
+class Inf::LoadBalancer < Thor
+  def method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  desc 'launch', 'launch load balancer for app'
+  def launch
+    Inf::AWS.launch_load_balancer
+  end
+
+  desc 'kill', 'kill lb for app'
+  def kill
+    lb_name  = get_state "apps/#{app_name}/lb-name"
+    delete_state "apps/#{app_name}/lb-name"
+
+    if lb_name
+      elb.delete_load_balancer(
+        load_balancer_name: lb_name
+      )
+
+      delete_state "apps/#{app_name}/lb-dns"
+      puts "Deleted lb #{lb_name}".blue
+    else
+      puts "Did not find an lb".yellow
+    end
+  end
+
+  desc 'status', 'lb status'
+  def status
+    lb_name  = get_state "apps/#{app_name}/lb-name"
+
+    unless lb_name
+      puts "Load balancer is not configured".blue
+      return
+    end
+
+    lb = elb.
+      describe_load_balancers(load_balancer_names: [lb_name]).
+      load_balancer_descriptions[0]
+
+    unless lb
+      puts "Load balancer expected but not found!".red
+      return
+    end
+
+    puts "Load balancer is at #{lb.dns_name} with ".blue +
+      "#{lb.instances.count} instances".blue
+  end
+end

data/lib/migrations.rb

@@ -0,0 +1,18 @@
+module Inf::Migrations
+  def self.method_missing(m, *args, &block)
+    Inf.send(m, *args, &block)
+  end
+
+  def self.maybe_migrate!
+    if single_sfr = get_state("apps/#{app_name}/sfr")
+      migrate_to_multi_fleets single_sfr
+    end
+  end
+
+  # before: apps/:name/sfr is the only fleet
+  # after: apps/:name/fleets/web/sfr
+  def self.migrate_to_multi_fleets(sfr)
+    Inf.put_state "apps/#{app_name}/fleets/web/sfr", sfr
+    Inf.delete_state "apps/#{app_name}/sfr"
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: inf
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- Kyle Brett <kyle@kylebrett.com>
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: mini_cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description: 
+email: kyle@kylebrett.com
+executables:
+- inf
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/inf
+- bootstrap-scripts/default-app.sh
+- lib/aws.rb
+- lib/domains.rb
+- lib/env.rb
+- lib/fleet.rb
+- lib/inf.rb
+- lib/load_balancer.rb
+- lib/migrations.rb
+homepage: http://www.kylebrett.com
+licenses:
+- Nonstandard
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: inf
+test_files: []