stacks-on-stacks 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 47fd4b4169a979a44c61abfe3250b825a8bed55d
+  data.tar.gz: ccff3d88abd9a52f52c0dd1178d6d323e513b57c
+SHA512:
+  metadata.gz: 3bfdf61ffb1c26134184e1d578dba0fe72407a6840e2c6af92f68d84ab9ffe23f0ee5433cd8bf0945203e948e97e312e337dd912b608ec88e0606bd276105383
+  data.tar.gz: 7ff3b298f9a60ccf105a3691ff1a5d225a4ab9455f09ee9c08d6f8f3d7d30cd337e7fbabb5c15fee662c5543dd7e49fdd2873dca6b420ba64111ab8327c9b5b1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stacks-on-stacks.gemspec
+gemspec
+
+gem 'aws-sdk'
+gem 'inifile'

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Geoff Hayes
+
+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.

data/README.md

@@ -0,0 +1,36 @@
+
+stacks-on-stacks
+================
+
+Stack management for AWS OpsWorks
+
+# Stacks::On::Stacks
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'stacks-on-stacks'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stacks-on-stacks
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/stack

@@ -0,0 +1,415 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'json'
+require 'open3'
+require 'pp'
+require 'securerandom'
+require 'aws-sdk'
+require 'inifile'
+
+class Stack
+  module Helpers
+    
+    def self.load_config!(opts={})
+      @@config = if File.exists?('.stack') # runs in `pwd`
+        JSON(File.read('.stack'))
+      else
+        {}
+      end.merge(opts)
+    end
+
+    def self.config_hash
+      @@config
+    end
+
+    # We'll try to pull from ENV or our config
+    def self.config(var, default=nil)
+      ENV[var.to_s.upcase] || @@config[var.to_s] || default
+    end
+
+    def self.error(message)
+      raise "Error: #{message}"
+      exit 1
+    end
+
+    # TODO: Should we use a cache here or pull this live?
+    # We're probably going to want to persist settings into where this is being called
+    def self.describe
+      # File.read("#{File.dirname(__FILE__)}/.server-cache") || `aws ec2 describe-instances`
+      cmd = "aws ec2 describe-instances"
+      if !config(:profile).nil?
+        cmd << " --profile #{config(:profile)}"
+      end
+
+      `#{cmd}`
+    end
+
+    # Takes an <serverish> and returns an instance
+    def self.get_serverish(name)
+
+      # We're going to take a few options here
+      case
+      when matchData = /(?<env>[\w-]+):(?<name>[\w-]+)/.match(name)
+        env, name = matchData[:env], matchData[:name]
+        inst = get_instance(env, name)
+        "Unable to find server: #{env}:#{name}" if inst.nil?
+        return env, get_internal_address(inst)
+      when matchData = /(?<env>[\w-]+)::(?<type>[\w.-]+)/.match(name) # Looks like a name
+        inst = get_instances_by_type(matchData[:env], matchData[:type],)[0]
+        pp [ 'Getting Default Instance', matchData[:env], matchData[:type] ]
+        return matchData[:env], get_internal_address(inst)
+      when matchData = /(?<env>[\w-]+):(?<name>[\w.-]+)/.match(name) # Looks like a name
+        return matchData[:env], matchData[:name]
+      else # Default env server
+        env = name
+        inst = get_instances_by_type(env,'worker')[0]
+        pp [ 'Getting Default Instance', inst ]
+        return env, get_internal_address(inst)
+      end
+
+    end
+
+    def self.get_instances(env=nil)
+      servers = JSON(describe)
+      reservations = servers['Reservations']
+      instances = reservations.map { |reservation| reservation['Instances'].first }
+      return instances if env.nil?
+      instances.select { |instance| tag = instance['Tags'].select { |t| t['Key'] == "opsworks:stack" }.first rescue nil; tag && tag['Value'] == env }
+    end
+
+    def self.get_instance(env, name)
+      pp ['Getting instance', env, name]
+      inst = get_instances.select { |instance| instance['State']['Name'] != "terminated" && instance['Tags'].select { |t| t['Key'] == "Name" }[0]['Value'] == "#{env} - #{name}" rescue false }.first
+      error("Unable to find instance #{env}, #{name}") if inst.nil?
+      inst
+    end
+
+    def self.get_instances_by_type(env, type)
+      pp ['Getting instances',env,type]
+      get_instances.select do |instance|
+        instance['Tags'].select { |t| t['Key'] == "opsworks:stack" }.first['Value'] == "#{env}" &&
+          instance['Tags'].select { |t| t['Key'] == "opsworks:layer:#{type}" }.count > 0 &&
+          instance['State']['Name'] != "terminated" rescue false
+      end
+    end
+
+    def self.get_address(instance)
+      instance['PublicDnsName'] || instance['PublicIpAddress']
+    end
+
+    def self.get_ssh(env, address, cmd=nil)
+      bastion = bastion(env)
+
+      if config(:ssh_user)
+        bastion = "#{config(:ssh_user)}@#{bastion}"
+      end
+
+      base = ['ssh', '-t', bastion]
+      
+      if config(:identity)
+        base.concat ['-i', config(:identity)]
+      end
+
+      base << "'" + ['ssh', '-t', address, cmd ? "\"#{cmd}\"" : nil].join(' ') + "'"
+      
+      base.join(' ')
+    end
+
+    def self.get_internal_address(instance)
+      instance['PrivateIpAddress'] || instance['PrivateDnsName']
+    end
+
+    def self.bastion(env)
+      get_address(get_instance(env, config(:bastion,'bastion')))
+    end
+
+    def self.run_with_output(env, address, cmd)
+      cmd = get_ssh(env, address, cmd)
+      puts "Running #{get_ssh(env, address, cmd)}"
+
+      Net::SSH.start(address) do |ssh|
+        ssh.exec!("sudo #{cmd}") do |channel, stream, data|
+          STDOUT << data if stream == :stdout
+        end
+      end
+    end
+
+    def self.open3(cmd, tag=nil)
+      stdin, @stdin = IO.pipe
+      @stdout, stdout = IO.pipe
+      @stderr, stderr = IO.pipe
+
+      puts "Running #{cmd}"
+      puts "\033];#{tag}\007" if tag
+      Open3.pipeline cmd
+      puts "Stacks on Stacks Finished"
+    end
+
+    def self.parse_opts(args)
+      opts = {}
+      res = []
+
+      while args.length > 0
+        arg = args.shift
+
+        case
+        when arg =~ /^[-]{2,2}([\w_-]+)=([^ ]*)$/i
+          key, val = $1, $2
+        when arg =~ /^[-]{2,2}([\w_-]+)+$/i
+          key = $1
+          val = args.shift
+        else
+          res.push arg # add arg
+          next
+        end
+
+        key = key.gsub('-','_') # valid symbol names
+
+        opts[key] = val
+      end
+
+      return res, opts
+    end
+
+    def self.wait_on_aws_deployment(deployment)
+      deployment_id = deployment.data[:deployment_id]
+      deployment_desc = nil
+
+      while true
+        deployment_desc = AWS.ops_works.client.describe_deployments(deployment_ids: [deployment_id])
+        
+        status = deployment_desc.data[:deployments].first[:status]
+
+        case status
+        when 'running'
+          sleep 10
+        when 'successful'
+          return true
+        else
+          raise "Failed to run deployment: #{deployment_id} - #{status}"
+        end
+      end
+
+      return true if deployment_desc.data[:status] == 'successful'
+    end
+
+    def self.doc(opts)
+      @@docs ||= {}
+      @@docs.merge!(opts)
+    end
+
+    def self.docs(method)
+      (@@docs || {})[method.to_sym]
+    end
+  end
+
+  module Commands
+    def self.configure(*args)
+      args, opts = Stack::Helpers.parse_opts(args)
+      if args.length > 0
+        raise "Configure doesn't take any args, got: #{args}"
+      end
+
+      opts = Stack::Helpers.config_hash.merge(opts)
+
+      opts.delete_if { |key,val| val.nil? || val == "" } # remove blank keys
+        
+      pp ['Setting Config', opts]
+
+      json = JSON.pretty_generate(opts)
+      File.open(".stack", 'w') { |file| file.write(json) }
+    end
+
+    def self.run(serverish, *cmds)
+      env, address = Stack::Helpers.get_serverish(serverish)
+
+      cmd = "sudo #{cmds.join(' ')}"
+
+      ssh = Stack::Helpers.get_ssh(env, address, cmd)
+
+      Stack::Helpers.open3(ssh, "#{serverish} [run `#{cmd}`]")
+    end
+
+    def self.nohup(serverish, *cmds)
+      env, address = Stack::Helpers.get_serverish(serverish)
+      
+      log_file = "/tmp/nohup-#{SecureRandom.uuid}.out"
+      cmd = "touch #{log_file} && nohup sudo #{cmds.join(' ')} > #{log_file} 2>&1& sudo tail -f #{log_file}"
+
+      ssh = Stack::Helpers.get_ssh(env, address, cmd)
+
+      Stack::Helpers.open3(ssh, "#{serverish} [run `#{cmd}`]")
+    end
+
+    def self.tail(serverish, log_file=nil, lines=150)
+      env, address = Stack::Helpers.get_serverish(serverish)
+      app_env = Stack::Helpers.config(:env) || env
+
+      log_file ||= "/srv/www/#{Stack::Helpers.config(:app)}/shared/log/#{app_env}.log"
+
+      unless log_file.include?('/')
+        log_file = "/srv/www/#{Stack::Helpers.config(:app)}/shared/log/#{log_file}"
+      end
+
+      cmd = "sudo tail -n #{lines.to_i} -f #{log_file}"
+
+      ssh = Stack::Helpers.get_ssh(env, address, cmd)
+      
+      Stack::Helpers.open3(ssh, "#{serverish} [tail]")
+    end
+
+    def self.list(env)
+      
+      Stack::Helpers.get_instances(env).each do |instance|
+        puts "Server - #{instance['PublicDnsName'] || instance['PublicIp']}"
+        instance['Tags'].each do |tag|
+          puts "\t#{tag['Key']}: #{tag['Value']}"
+        end
+      end
+
+    end
+
+    def self.ssh(serverish)
+      env, address = Stack::Helpers.get_serverish(serverish)
+      ssh = Stack::Helpers.get_ssh(env, address)
+
+      Stack::Helpers.open3(ssh, "#{serverish} [ssh]")
+    end
+
+    def self.console(serverish)
+      env, address = Stack::Helpers.get_serverish(serverish)
+      app_env = Stack::Helpers.config(:env) || env
+      app = Stack::Helpers.config(:app)
+
+      cmd = "sudo su deploy -c \\\"cd /srv/www/#{app}/current && RAILS_ENV=#{app_env} bundle exec rails console\\\""
+
+      ssh = Stack::Helpers.get_ssh(env, address, cmd)
+
+      Stack::Helpers.open3(ssh, "#{serverish} [console]")
+    end
+
+    def self.db(serverish)
+      env, address = Stack::Helpers.get_serverish(serverish)
+      app_env = Stack::Helpers.config(:env) || env
+      app = Stack::Helpers.config(:app)
+
+      cmd = "sudo su deploy -c \\\"cd /srv/www/#{app}/current && RAILS_ENV=#{app_env} bundle exec rails db -p\\\""
+
+      ssh = Stack::Helpers.get_ssh(env, address, cmd)
+
+      Stack::Helpers.open3(ssh, "#{serverish} [db-console]")
+    end
+
+    def self.rake(serverish, rake_task, *args)
+      env, address = Stack::Helpers.get_serverish(serverish)
+      app_env = Stack::Helpers.config(:env) || env
+      app = Stack::Helpers.config(:app)
+      # accepts either type of args, e.g. task:run[1,2,3] or task:run 1 2 3
+      # should fail if both given
+      arg_string = args.count > 0 ? "[#{args.join(',')}]" : ""
+
+      cmd = "sudo su deploy -c \\\"cd /srv/www/#{app}/current && RAILS_ENV=#{app_env} bundle exec rake #{rake_task}#{arg_string}\\\""
+
+      ssh = Stack::Helpers.get_ssh(env, address, cmd)
+
+      Stack::Helpers.open3(ssh, "#{serverish} [rake] (rake #{rake_task} [#{args.join(',')}])")
+    end
+
+    Stack::Helpers.doc deploy: {
+      arguments: [
+        { name: :stack_id, desc: "Id of stack" },
+        { name: :app_id, desc: "Id of app" },
+        { name: :wait, desc: "Wait for deployment to complete?", default: true }
+        # { name: :branch, desc: "Branch for deploy" }
+      ]
+    }
+    def self.deploy(stack_id, app_id, wait="true")
+      # First, try to pull these from the environment
+      iam_key = Stack::Helpers.config(:iam_key)
+      iam_secret = Stack::Helpers.config(:iam_secret)
+      # region = Stack::Helpers.config(:region) -- region is messing this all up
+
+      # Otherwise, we'll pull them from config
+      if ( iam_key.nil? || iam_secret.nil? || region.nil? ) && Stack::Helpers.config(:aws_config_file)
+        aws_config = IniFile.load(Stack::Helpers.config(:aws_config_file))
+        profile = Stack::Helpers.config(:profile) ? "profile #{Stack::Helpers.config(:profile)}" : "default"
+
+        pp ['Stack', 'Using aws config', Stack::Helpers.config(:aws_config_file), profile]
+
+        conf = aws_config[profile]
+
+        iam_key = conf['aws_access_key_id']
+        iam_secret = conf['aws_secret_access_key']
+      end
+
+      raise ArgumentError, "Must set IAM_KEY environment variable" if iam_key.nil? || iam_key.length == 0
+      raise ArgumentError, "Must set IAM_SECRET environment variable" if iam_secret.nil? || iam_secret.length == 0
+      
+      AWS.config({
+        access_key_id: iam_key,
+        secret_access_key: iam_secret
+      })
+
+      deployment = AWS.ops_works.client.create_deployment(stack_id: stack_id, app_id: app_id, command: {name: 'deploy'})
+      
+      if wait && wait[0] == "t"
+        Stack::Helpers.wait_on_aws_deployment(deployment)
+      end
+
+      # TODO: Wait on deploy?
+      # TODO: Revision management
+      # revision = `git fetch && git rev-parse origin/#{stack[:branch]}` rescue nil
+    end
+  end
+end
+
+# Main Routine
+puts "\033];Stack\007"
+puts "Welcome to Stacks on Stacks"
+
+if ARGV[0].nil? || ARGV[0] == ""
+  puts ""
+  puts "usage: stack {run,tail,list,ssh,console}"
+  puts "\t <serverish>: {env, env:name, env::type, env:ip-address}"
+  puts "\t e.g."
+  puts "\t stack list <env>"
+  puts "\t stack tail <serverish> [something.log] (default: /srv/www/<app>/shared/log/<env>.log, if no '/' found in log, defaults to directory /srv/www/<app>/shared/log/)"
+  puts "\t stack run <serverish> cat /srv/www/app/shared/log/production.log"
+  puts "\t stack ssh <serverish>"
+  puts "\t stack console <serverish>"
+  puts "\t stack db <serverish>"
+  puts "\t stack rake <serverish> <namespace>:<rake_task>"
+  puts "\t stack configure --key=val --key2=val2"
+  puts "\t stack deploy <stack_id> <app_id>"
+  puts "\t"
+  puts "\t config variables: { app: '<app name> for /srv/www/<app>/current directory', profile: 'aws profile in ~/.aws/config', identity: 'e.g. ~/.ssh/id_rsa', ssh_user: 'geoff for ssh geoff@<host>', bastion: 'layer type as a bastion server' }"
+  exit
+end
+
+
+# TODO: Check method signature and print disparties
+args = ARGV
+args, opts = Stack::Helpers.parse_opts(args)
+Stack::Helpers.load_config!(opts)
+# pp ['Stack',args,opts]
+
+if Stack::Commands.respond_to?(args[0])
+  method = args.shift
+
+  begin
+    Stack::Commands.send(method, *args)
+  rescue ArgumentError => e
+    if Stack::Helpers.docs(method)
+      puts "Usage: stack #{method} #{Stack::Helpers.docs(method).inspect}"
+    else
+      raise e
+    end
+  end
+
+  puts "Ending Stacks on Stacks Session"
+else
+  raise "Unknown command: #{args[0]}"
+end
+
+puts "\033];bash\007"

data/lib/stacks/on/stacks.rb

@@ -0,0 +1,9 @@
+require "stacks/on/stacks/version"
+
+module Stacks
+  module On
+    module Stacks
+      # Your code goes here...
+    end
+  end
+end

data/lib/stacks/on/stacks/version.rb

@@ -0,0 +1,7 @@
+module Stacks
+  module On
+    module Stacks
+      VERSION = "0.0.1"
+    end
+  end
+end

data/stacks-on-stacks.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stacks/on/stacks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stacks-on-stacks"
+  spec.version       = Stacks::On::Stacks::VERSION
+  spec.authors       = ["Geoff Hayes"]
+  spec.email         = ["hayesgm@gmail.com"]
+  spec.description   = %q{Stacks on Stacks is a management CLI for common tasks on AWS OpsWorks.  You'll be able to SSH to your servers (via a bastion) and send off deploys.}
+  spec.summary       = %q{Stacks on Stack is a CLI for managing an OpsWorks stack}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: stacks-on-stacks
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Geoff Hayes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Stacks on Stacks is a management CLI for common tasks on AWS OpsWorks.  You'll
+  be able to SSH to your servers (via a bastion) and send off deploys.
+email:
+- hayesgm@gmail.com
+executables:
+- stack
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/stack
+- lib/stacks/on/stacks.rb
+- lib/stacks/on/stacks/version.rb
+- stacks-on-stacks.gemspec
+homepage: ''
+licenses:
+- MIT
+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.1.11
+signing_key: 
+specification_version: 4
+summary: Stacks on Stack is a CLI for managing an OpsWorks stack
+test_files: []