management 0.9

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+cache: bundler
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org/'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,86 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    builder (3.2.2)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    excon (0.32.1)
+    fakefs (0.5.2)
+    ffi (1.9.3)
+    fog (1.21.0)
+      fog-brightbox
+      fog-core (~> 1.21, >= 1.21.1)
+      fog-json
+      nokogiri (~> 1.5, >= 1.5.11)
+    fog-brightbox (0.0.1)
+      fog-core
+      fog-json
+    fog-core (1.21.1)
+      builder
+      excon (~> 0.32)
+      formatador (~> 0.2.0)
+      mime-types
+      net-scp (~> 1.1)
+      net-ssh (>= 2.1.3)
+    fog-json (1.0.0)
+      multi_json (~> 1.0)
+    formatador (0.2.4)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-rspec (4.2.9)
+      guard (~> 2.1)
+      rspec (>= 2.14, < 4.0)
+    listen (2.7.7)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.6)
+    method_source (0.8.2)
+    mime-types (2.2)
+    mini_portile (0.5.3)
+    multi_json (1.9.2)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.8.0)
+    nokogiri (1.6.1)
+      mini_portile (~> 0.5.0)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.5.0)
+    thor (0.19.1)
+    timers (1.1.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakefs
+  fog
+  guard-rspec
+  pry
+  rake
+  rspec
+  unf

data/Guardfile

@@ -0,0 +1,7 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch('spec/main_spec.rb') { "spec" }
+  watch(%r{^lib/(.+)\.rb$})  { "spec" }
+end

data/README.md

@@ -0,0 +1,193 @@
+## Management
+
+Minimalist EC2 configuration & deployment tool.
+
+- Version: **0.9**
+
+![build status](https://travis-ci.org/sdegutis/management.svg?branch=master)
+
+#### Usage
+
+```
+$ management
+Usage:
+
+       create-server <env> <type>
+      destroy-server <server>
+        list-servers [<env>]
+          run-script <server> <script>
+          ssh-server <server>
+
+    -h, --help                       Display this screen
+    -v, --version                    Show version
+
+$ management list-servers
+
+$ management create-server staging web
+Created "staging-web-1".
+
+$ management list-servers
+Name             State       IP                    Private IP
+---------------  ----------  --------------------  --------------------
+staging-db-1     active      107.170.80.230        10.128.198.115
+
+$ management run-script staging-web-1 setup-web
+Copying resources/scripts/bootstrap_base.sh -> /home/webapp/bootstrap_base.sh
+Running /home/webapp/bootstrap_base.sh
+[...snip...]
+Copying resources/files/web.conf.erb -> /etc/init/web.conf
+Copying resources/files/nginx.conf -> /etc/init/nginx.conf
+Copying resources/scripts/start_web_server.sh -> /home/webapp/start_web_server.sh
+Running /home/webapp/start_web_server.sh
+[...snip...]
+```
+
+#### Niche
+
+The remote server only needs ssh and `tar -xzf` to be available, which
+means it'll work in pretty much any linux server, out-of-the-box.
+
+If you only need to provision and manage a handful of servers, this
+project may be right for you.
+
+#### Setup
+
+Put this in `management_config.yml':
+
+```yaml
+cloud:  # NOTE: this just gets passed to Fog::Compute.new
+  provider: AWS
+  aws_access_key_id: 123
+  aws_secret_access_key: 456
+  region: New York 1
+
+envs:
+  - staging
+  - production
+
+types:
+  web:  # NOTE: this just gets passed to compute.servers.create
+    image_id: ami-1234
+    flavor_id: m1.small
+    key_name: my-ssh-key-name
+    groups: ["web"]
+    ssh_key_path: resources/my-ssh-key
+
+scripts:
+  setup-web:
+    - copy: [resources/scripts/bootstrap_base.sh, /home/webapp/bootstrap_base.sh]
+    - run: /home/webapp/bootstrap_base.sh
+    - copy: [resources/files/web.conf.erb, /etc/init/web.conf, template: true]
+    - copy: [resources/files/nginx.conf, /etc/init/nginx.conf]
+    - copy: [resources/scripts/start_web_server.sh, /home/webapp/start_web_server.sh]
+    - run: /home/webapp/start_web_server.sh
+```
+
+Management doesn't care where any of your files are, with the exception of
+`management_config.yml`, which it expects to be in your project's
+root. Here's the relevant part of the file structure that the above
+sample config assumes:
+
+```
+./my-project
+|-- management_config.yml
+`-- resources
+    |-- files
+    |   |-- nginx.conf
+    |   `-- web.conf.erb
+    |-- keys
+    |   |-- id_rsa_digitalocean
+    |   `-- id_rsa_digitalocean.pub
+    `-- scripts
+        |-- bootstrap_base.sh
+        `-- start_web_server.sh
+```
+
+#### Details
+
+Most of how it works should be self-explanatory from the examples
+above. There's just a few things that might not be obvious:
+
+1. Management assumes it's only dealing with servers it created. So it
+   assumes that the name will be in the "{env}-{type}-{n}"
+   format. But that's really all it assumes.
+
+2. A `copy` line in the `scripts` section will copy all the files from
+   the local paths (relative to the project root) to the remote
+   *absolute* path, creating directories as needed.
+
+3. If a `copy` line has a third entry of `template: true`, then it
+   will be run through ERB. The context will have access to `server`
+   representing the Fog server, `cloud` representing the Fog::Compute
+   instance, and `configs` representing your configs (YAML). Also,
+   each Fog server has two new methods: `env` and `type`. NOTE: if you
+   only specified a directory, and it happens to contain `.erb` files,
+   they won't be templated.
+
+4. A `run` line in a script will be run on the remote server. The
+   paths represent the remote *absolute* paths. It's your
+   responsibility to make sure they're executable.
+
+5. Files specified by `run` aren't copied for you automatically; they
+   should either already be on the remote server, or you should copy
+   them with a `copy` line.
+
+6. The `envs` section is strictly there to catch typos and
+   wrongly-ordered arguments at the command line. You can only
+   create/destroy/etc servers in a valid environment.
+
+7. The `create-server` command doesn't run any scripts for you, it
+   just creates a new server based on the given type.
+
+8. The `scripts` section is admittedly poorly named, since each
+   "script" is really an ordered list of files to copy and scripts to
+   run remotely. Couldn't think of a better word for it though that
+   wasn't too far out there or knee-deep in analogies. I'd love some
+   suggestions.
+
+9. A `script` line doesn't have to be a bash scripts, although that's
+   the simplest way. It just needs to be something executable. TIP: if
+   it's a bash script, it's a good idea to add `set -e` and `set -x`
+   to the top of them.
+
+#### Example Scripts
+
+If you wanted to install Ruby 2 in your setup phase, you might add
+this to one of your scripts
+([courtesy of Brandon Hilkert](https://github.com/brandonhilkert/fucking_shell_scripts)):
+
+```bash
+sudo apt-get -y install build-essential zlib1g-dev libssl-dev libreadline6-dev libyaml-dev
+cd /tmp
+wget http://ftp.ruby-lang.org/pub/ruby/2.0/ruby-2.0.0-p247.tar.gz
+tar -xzf ruby-2.0.0-p247.tar.gz
+cd ruby-2.0.0-p247
+./configure --prefix=/usr/local
+make
+sudo make install
+rm -rf /tmp/ruby*
+```
+
+#### License
+
+> Released under MIT license.
+>
+> Copyright (c) 2013 Steven Degutis
+>
+> 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/Rakefile

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/management

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/management.rb'
+Management::Interpreter.interpret! ARGV.dup

data/lib/ext/fog.rb

@@ -0,0 +1,74 @@
+require 'fog'
+require 'fog/core/ssh'
+
+
+# Monkey-patch Fog 1.3.1 to stream SSH output
+# (in real time) to stdout.
+class Fog::SSH::Real
+  def run(commands)
+    commands = [*commands]
+    results  = []
+    begin
+      Net::SSH.start(@address, @username, @options) do |ssh|
+        commands.each do |command|
+          result = Fog::SSH::Result.new(command)
+          ssh.open_channel do |ssh_channel|
+            ssh_channel.request_pty
+            ssh_channel.exec(command) do |channel, success|
+              unless success
+                raise "Could not execute command: #{command.inspect}"
+              end
+
+              channel.on_data do |ch, data|
+                result.stdout << data
+                print data
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                next unless type == 1
+                result.stderr << data
+                print data
+              end
+
+              channel.on_request('exit-status') do |ch, data|
+                result.status = data.read_long
+              end
+
+              channel.on_request('exit-signal') do |ch, data|
+                result.status = 255
+              end
+            end
+          end
+          ssh.loop
+          results << result
+        end
+      end
+    rescue Net::SSH::HostKeyMismatch => exception
+      exception.remember_host!
+      sleep 0.2
+      retry
+    end
+    results
+  end
+end
+
+
+require 'fog/compute/models/server'
+# we're assuming the servers were created via boucher or management
+class Fog::Compute::Server
+  def env;  tags["Env"]; end
+  def type; tags["Meal"]; end
+  def name; tags["Name"]; end
+
+  def copy_file(tar_path, remote_tar_path)
+    scp(tar_path, remote_tar_path)
+  end
+
+  def extract_tar(remote_tar_path)
+    ssh("tar -xzf #{remote_tar_path} -C /")
+  end
+
+  def chown_r(remote_path, chown)
+    ssh("chown -R #{chown} #{remote_path}")
+  end
+end

data/lib/management/command.rb

@@ -0,0 +1,97 @@
+require 'fog'
+require 'yaml'
+
+module Management
+
+  class Command
+
+    class << self
+
+      def all
+        @all ||= []
+      end
+
+      def inherited(subclass)
+        all << subclass
+      end
+
+      def help_string
+        params = instance_method(:call).parameters
+
+        output = sprintf("%20s ", command_name)
+        args = []
+
+        params.each do |req, name|
+          name = "<#{name.to_s.sub('_name', '')}>"
+          if req == :opt
+            name = "[#{name}]"
+          end
+          args << name
+        end
+
+        return output + args.join(' ')
+      end
+
+      def command_name
+        self.name.split('::').last.
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("_", "-").
+          downcase
+      end
+
+    end
+
+
+    def get_env(name)
+      return nil if name.nil?
+      config[:envs].include?(name) and name or invalid_selection "Invalid environment: #{name}", config[:envs]
+    end
+
+    def get_type(name)
+      config[:types][name.to_sym] or invalid_selection "Invalid type: #{name}", config[:types].map(&:first)
+    end
+
+    def get_script(name)
+      config[:scripts][name.to_sym] or invalid_selection "Invalid script: #{name}", config[:scripts].map(&:first)
+    end
+
+    def get_server(name)
+      servers = cloud.servers
+      servers.find{|server| server.name == name} or invalid_selection "Invalid server: #{name}", servers.map(&:name)
+    end
+
+    def config
+      @config ||= symbolize_keys!(raw_yaml)
+    end
+
+    def cloud
+      @cloud ||= Fog::Compute.new(config[:cloud])
+    end
+
+
+    private
+
+    def raw_yaml
+      YAML.load(File.read("management_config.yml"))
+    end
+
+    def invalid_selection(str, selection)
+      abort "#{str}\nValid choices:" + (["\n"] + selection).join("\n - ")
+    end
+
+    def symbolize_keys! h
+      case h
+      when Hash
+        pairs = h.map { |k, v| [k.respond_to?(:to_sym) ? k.to_sym : k, symbolize_keys!(v)] }
+        return Hash[pairs]
+      when Array
+        return h.map{ |e| symbolize_keys!(e) }
+      else
+        return h
+      end
+    end
+
+  end
+
+end

data/lib/management/commands/create_server.rb

@@ -0,0 +1,50 @@
+require_relative '../command'
+
+module Management
+
+  class CreateServer < Management::Command
+
+    def call(env_name, type_name)
+      env = get_env(env_name)
+      type = get_type(type_name)
+
+      servers = cloud.servers
+      name = make_unique_server_name(env_name, type_name, servers)
+
+      puts "Creating \"#{name}\"..."
+
+      cloud.servers.create(image_id: type[:image_id],
+                           flavor_id: type[:flavor_id],
+                           groups: type[:groups],
+                           key_name: type[:key_name],
+                           tags: {
+                             "Creator" => current_user,
+                             "CreatedAt" => Time.new.strftime("%Y%m%d%H%M%S"),
+                             "Name" => name,
+                             "Env" => env_name,
+                             "Meal" => type_name,
+                           })
+
+      puts "Done."
+    end
+
+    def current_user
+      `git config user.name`.strip
+    rescue
+      "unknown"
+    end
+
+    def make_unique_server_name(env_name, type_name, servers)
+      (1..Float::INFINITY).each do |i|
+        name = "#{env_name}-#{type_name}-#{i}"
+        if servers.find{|s|s.name == name}
+          i += 1
+        else
+          return name
+        end
+      end
+    end
+
+  end
+
+end

data/lib/management/commands/destroy_server.rb

@@ -0,0 +1,23 @@
+require_relative '../command'
+
+module Management
+
+  class DestroyServer < Management::Command
+
+    def call(server_name)
+      server = get_server(server_name)
+
+      print "Are you sure you want to do this? Type 'Yes' to continue, or anything else to abort: "
+      answer = $stdin.gets.chomp
+
+      if answer == 'Yes'
+        server.destroy
+        puts "Destroyed."
+      else
+        puts "Aborted."
+      end
+    end
+
+  end
+
+end

data/lib/management/commands/list_servers.rb

@@ -0,0 +1,38 @@
+require_relative '../command'
+
+module Management
+
+  class ListServers < Management::Command
+
+    def call(env_name = nil)
+      env = get_env(env_name)
+
+      cols = [
+        {size: 20, title: "Name",       field: :name },
+        {size: 10, title: "State",      field: :state },
+        {size: 20, title: "IP",         field: :public_ip_address },
+        {size: 20, title: "Private IP", field: :private_ip_address },
+        {size: 10, title: "Size",       field: :flavor_id },
+        {size: 15, title: "Env",        field: :env },
+        {size: 15, title: "Type",       field: :type },
+        {size: 11, title: "EC2 ID",     field: :id },
+      ]
+
+      format = cols.map{|c| "%-#{c[:size]}s"}.join("  ") + "\n"
+
+      send :printf, *([format].concat(cols.map{|c|c[:title]}))
+      send :printf, *([format].concat(cols.map{|c|'-' * c[:size]}))
+
+      servers = cloud.servers.sort_by(&:name)
+
+      servers.each do |server|
+        next if env_name && server.env != env_name
+        next if server.state == 'terminated'
+
+        send :printf, *([format].concat(cols.map{|c|server.send(c[:field])}))
+      end
+    end
+
+  end
+
+end

data/lib/management/commands/run_script.rb

@@ -0,0 +1,123 @@
+require_relative '../command'
+require 'tmpdir'
+require 'fileutils'
+require 'erb'
+require 'shellwords'
+
+module Management
+
+  class RunScript < Management::Command
+
+    def call(server_name, script_name)
+      server = get_server(server_name)
+      script = get_script(script_name)
+
+      server.private_key_path = config[:types][server.type.to_sym][:ssh_key_path]
+
+      missing = missing_local_files(script)
+      abort "The following files are missing:" + (["\n"] + missing).join("\n - ") if !missing.empty?
+
+      script.each do |tuple|
+        type, data = *tuple.first
+
+        case type.to_sym
+        when :copy
+          copy_file(server, *data)
+        when :run
+          run_command(server, data)
+        end
+
+      end
+
+    end
+
+    def copy_file(server, local_path, remote_path, opts = nil)
+      should_template = opts && opts[:template]
+      custom_chown = opts && opts[:chown]
+
+      puts "Copying #{local_path} -> #{remote_path}"
+
+      Dir.mktmpdir('management-file-dir') do |file_tmpdir|
+
+        # copy to the fake "remote" path locally
+        remote_looking_path = File.join(file_tmpdir, remote_path)
+        FileUtils.mkdir_p File.dirname(remote_looking_path)
+        FileUtils.cp_r local_path, remote_looking_path, preserve: true
+
+        # overwrite the fake "remote" file with its own templated contents if necessary
+        if should_template
+          new_contents = ERB.new(File.read(remote_looking_path)).result(binding)
+          File.write(remote_looking_path, new_contents)
+        end
+
+        Dir.mktmpdir('management-tar-dir') do |tar_tmpdir|
+
+          # zip this file up, starting from its absolute path
+          local_tar_path = File.join(tar_tmpdir, "__management__.tar.gz")
+          zip_relevant_files(file_tmpdir, local_tar_path)
+
+          # copy tar file to remote and extract
+          remote_tar_path = "/tmp/__management__.tar.gz"
+          server.copy_file(local_tar_path, remote_tar_path)
+          server.extract_tar(remote_tar_path)
+          server.chown_r(remote_path, custom_chown) if custom_chown
+
+        end
+
+      end
+
+    end
+
+    def run_command(server, cmd)
+      puts "Running #{cmd}"
+
+      result = server.ssh("#{cmd}").first
+
+      if result.respond_to?(:status)
+        puts
+        puts "---------------------------"
+        if result.status == 0
+          puts "Success!"
+        else
+          puts "Failed. Exit code: #{result.status}"
+        end
+      end
+    end
+
+    def missing_local_files(script)
+      script.find_all do |tuple|
+        type, data = *tuple.first
+        if type == :copy
+          local, remote = *data
+          ! File.exists?(local)
+        end
+      end.map do |tuple|
+        type, data = *tuple.first
+        local, remote = *data
+        local
+      end
+    end
+
+    def relevant_files(at_dir)
+      abort unless at_dir.start_with? "/"
+
+      Dir[File.join(at_dir, "**/*")].select do |path|
+        File.file?(path) || (File.directory?(path) && Dir.entries(path) == [".", ".."])
+      end.map do |path|
+        path.slice! at_dir.end_with?("/") ? at_dir : "#{at_dir}/"
+        "./#{path}"
+      end
+    end
+
+    private
+
+    def zip_relevant_files(in_dir, out_file)
+      Dir.chdir(in_dir) do
+        file_list = Shellwords.join(relevant_files(in_dir))
+        system("tar -czf #{out_file} #{file_list}")
+      end
+    end
+
+  end
+
+end

data/lib/management/commands/ssh_server.rb

@@ -0,0 +1,23 @@
+require_relative '../command'
+
+module Management
+
+  class SshServer < Management::Command
+
+    def call(server_name)
+      server = get_server(server_name)
+
+      type = config[:types][server.type.to_sym]
+      ssh_key_path = type[:ssh_key_path]
+      run "chmod 0600 #{ssh_key_path}"
+      run "ssh -i #{ssh_key_path} #{config[:root_user]}@#{server.public_ip_address}"
+    end
+
+    def run(cmd)
+      puts "Running: #{cmd}"
+      system cmd
+    end
+
+  end
+
+end

data/lib/management/commands/stop_server.rb

@@ -0,0 +1,15 @@
+require_relative '../command'
+
+module Management
+
+  class StopServer < Management::Command
+
+    def call(server_name)
+      server = get_server(server_name)
+      server.stop
+      puts "Stopped #{server_name}."
+    end
+
+  end
+
+end

data/lib/management/interpreter.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+
+module Management
+
+  class Interpreter
+
+    class << self
+
+      def interpret!(input)
+        commands = Management::Command.all
+
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage:"
+          opts.separator('')
+          commands.each { |cmd| opts.separator cmd.help_string }
+          opts.separator('')
+          opts.on('-h', '--help', 'Display this screen') { puts opts; exit }
+          opts.on('-v', '--version', 'Show version') { puts Management::VERSION; exit }
+        end
+
+        abort parser.help if input.empty?
+
+        args = parser.parse(input)
+        task = args.shift
+        ARGV.clear
+
+        if chosen_command = commands.find{|c|c.command_name == task}
+          all_args = chosen_command.instance_method(:call).parameters
+          req_args = all_args.map(&:first).take_while{|p| p == :req}
+
+          case
+          when args.count < req_args.count
+            puts "Error: not enough arguments"
+            abort parser.help
+          when args.count > all_args.count
+            puts "Error: too many arguments"
+            abort parser.help
+          else
+            chosen_command.new.call(*args)
+          end
+        else
+          puts "Error: unknown task \"#{task}\""
+          abort parser.help
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/management/version.rb

@@ -0,0 +1,3 @@
+module Management
+  VERSION = "0.9"
+end

data/lib/management.rb

@@ -0,0 +1,10 @@
+require_relative 'ext/fog'
+
+require_relative 'management/version'
+require_relative 'management/interpreter'
+require_relative 'management/commands/create_server'
+require_relative 'management/commands/list_servers'
+require_relative 'management/commands/destroy_server'
+require_relative 'management/commands/run_script'
+require_relative 'management/commands/ssh_server'
+require_relative 'management/commands/stop_server'

data/management.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "management/version"
+
+Gem::Specification.new do |s|
+  s.name          = 'management'
+  s.version       = Management::VERSION
+  s.email         = 'steven@cleancoders.com'
+  s.authors       = ["Steven Degutis"]
+  s.homepage      = 'https://github.com/sdegutis/management'
+  s.license       = 'MIT'
+  s.summary       = "Minimalist EC2 management & deployment tool."
+  s.description   = "Write your deployment using just shell scripts."
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'fog'
+  s.add_dependency 'unf' # just to shut up the warnings
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'fakefs'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'guard-rspec'
+end

data/spec/main_spec.rb

@@ -0,0 +1,256 @@
+require_relative '../lib/management'
+require 'fakefs/spec_helpers'
+require 'stringio'
+require 'pry'
+require 'etc'
+
+
+SampleConfig = <<EOC
+cloud:
+  provider: AWS
+  aws_access_key_id: 123
+  aws_secret_access_key: 456
+  region: New York 1
+
+envs:
+  - staging
+  - production
+
+types:
+  web:
+    image_id: ami-1234
+    flavor_id: m1.small
+    key_name: my-ssh-key-name
+    groups: ["web"]
+    ssh_key_path: resources/my-ssh-key
+
+scripts:
+  testing:
+    - copy: [resources/testing.sh, /home/web/testing.sh]
+    - copy: [resources/web.conf.erb, /etc/init/web.conf, template: true]
+    - run: /home/web/testing.sh
+EOC
+
+
+def with_stdin(s) old = $stdin; $stdin = StringIO.new(s); yield; $stdin = old end
+def without_stdout old = $stdout; $stdout = StringIO.new; yield; $stdout = old end
+def without_stderr old = $stderr; $stderr = StringIO.new; yield; $stderr = old end
+
+describe 'management' do
+
+  before { subject.stub(:raw_yaml).and_return(YAML.load(SampleConfig)) }
+
+  describe Management::Command do
+
+    describe "safely getting config values" do
+
+      it "can get env" do
+        expect { without_stderr { subject.get_env("FAKE") } }.to raise_error SystemExit
+        expect { without_stderr { subject.get_env("staging") } }.to_not raise_error
+      end
+
+      it "can get type" do
+        expect { without_stderr { subject.get_type("FAKE") } }.to raise_error SystemExit
+        expect { without_stderr { subject.get_type("web") } }.to_not raise_error
+      end
+
+      it "can get script" do
+        expect { without_stderr { subject.get_script("FAKE") } }.to raise_error SystemExit
+        expect { without_stderr { subject.get_script("testing") } }.to_not raise_error
+      end
+
+    end
+
+
+  end
+
+  describe Management::RunScript do
+
+    include FakeFS::SpecHelpers
+
+    describe "finding relevant files to zip" do
+
+      it "finds all files in the tree" do
+        FileUtils.mkdir_p("/foo/bar/baz")
+        File.write("/foo/bar/baz/quux", "woot")
+        File.write("/foo/bar/baz/zap", "wat")
+        subject.relevant_files("/").should == ["./foo/bar/baz/quux", "./foo/bar/baz/zap"]
+      end
+
+      it "finds empty leaf directories in the tree" do
+        FileUtils.mkdir_p("/foo/bar/baz")
+        File.write("/foo/bar/baz/quux", "woot")
+        FileUtils.mkdir_p("/foo/bar/baz/zap")
+        subject.relevant_files("/").should == ["./foo/bar/baz/quux", "./foo/bar/baz/zap"]
+      end
+
+      it "returns dot files" do
+        FileUtils.mkdir_p("/foo/bar/baz")
+        File.write("/foo/bar/baz/.quux", "woot")
+        FileUtils.mkdir_p("/foo/bar/baz/.zap")
+        subject.relevant_files("/").should == ["./foo/bar/baz/.quux", "./foo/bar/baz/.zap"]
+      end
+
+      it "returns relative filenames" do
+        FileUtils.mkdir_p("/foo/bar/baz")
+        File.write("/foo/bar/baz/quux", "woot")
+        FileUtils.mkdir_p("/foo/bar/baz/zap")
+        subject.relevant_files("/foo/bar").should == ["./baz/quux", "./baz/zap"]
+      end
+
+      it "returns relative filenames, even when you add a trailing slash" do
+        FileUtils.mkdir_p("/foo/bar/baz")
+        File.write("/foo/bar/baz/quux", "woot")
+        FileUtils.mkdir_p("/foo/bar/baz/zap")
+        subject.relevant_files("/foo/bar/").should == ["./baz/quux", "./baz/zap"]
+      end
+
+      it "requires an absolute path" do
+        FileUtils.mkdir_p("/foo")
+        expect{ subject.relevant_files("foo") }.to raise_error SystemExit
+      end
+
+    end
+
+    describe "copying files over" do
+
+      let(:server) { Object.new }
+
+      before(:each) do
+
+        # just copy_r the given directory's contents into a new temp dir
+        # and put the filename of that new temp dir into out_file
+        subject.define_singleton_method(:zip_relevant_files) do |in_dir, out_file|
+          zip_dir = Dir.mktmpdir("fake-local-zip-dir")
+          FileUtils.cp_r Dir[File.join(in_dir, "*")], zip_dir
+          File.write(out_file, zip_dir)
+        end
+
+        server.define_singleton_method(:name) { "server-1" }
+        server.define_singleton_method(:env) { "staging" }
+
+        # local just contains the name of a dir containing all the files
+        server.define_singleton_method(:copy_file) do |local, remote|
+          # copying "local" zip file to "remote" zip file
+          fake_remote = File.join("/fake-remote-dir", remote)
+          FileUtils.cp local, fake_remote
+        end
+
+        # just cp_r the files under fake-zip-dir into /fake-remote-dir
+        server.define_singleton_method(:extract_tar) do |remote|
+          tar_dir = File.read(File.join("/fake-remote-dir", remote))
+          FileUtils.cp_r(File.join(tar_dir, "*"), "/fake-remote-dir")
+        end
+
+        server.define_singleton_method(:chown_r) do |remote, chowner|
+          user, group = chowner.split(":")
+          FileUtils.chown_R(user, group, File.join("/fake-remote-dir", remote))
+        end
+
+      end
+
+      it "copies file contents into their remote paths" do
+        File.write("foo", "the contents of foo")
+        without_stdout { subject.copy_file(server, "foo", "/remote/foo") }
+        File.read("/fake-remote-dir/remote/foo").should == "the contents of foo"
+      end
+
+      it "templates files correctly" do
+        File.write("foo", "the contents of <%= server.env %>")
+        without_stdout { subject.copy_file(server, "foo", "/remote/foo", template: true) }
+        File.read("/fake-remote-dir/remote/foo").should == "the contents of staging"
+      end
+
+      it "chowns files correctly when specified" do
+        user = Etc.passwd.name
+        group = Etc.group.name
+
+        File.write("foo", "hello world")
+        without_stdout { subject.copy_file(server, "foo", "/remote/foo", chown: "#{user}:#{group}") }
+
+        stats = File.stat("/fake-remote-dir/remote/foo")
+        Etc.getpwuid(stats.uid).name.should == user
+        Etc.getgrgid(stats.gid).name.should == group
+      end
+
+      it "doesn't chown anything unless specified" do
+        File.write("foo", "hello world")
+        without_stdout { subject.copy_file(server, "foo", "/remote/foo") }
+
+        stats = File.stat("/fake-remote-dir/remote/foo")
+        Etc.getpwuid(stats.uid).name.should == `id -un`.chomp
+        Etc.getgrgid(stats.gid).name.should == `id -gn`.chomp
+      end
+
+      it "fails if multiple local paths don't exist" do
+        script = subject.get_script("testing")
+        list = subject.missing_local_files(script)
+        list.should == ["resources/testing.sh", "resources/web.conf.erb"]
+      end
+
+      it "fails if a single local path doesn't exist" do
+        FileUtils.mkdir_p "resources"
+        File.write "resources/testing.sh", "hello world"
+        script = subject.get_script("testing")
+        list = subject.missing_local_files(script)
+        list.should == ["resources/web.conf.erb"]
+      end
+
+    end
+
+  end
+
+  describe Management::CreateServer do
+
+    it "uses unique names for servers" do
+      fake_server = Struct.new(:name)
+      servers = [fake_server.new('staging-web-1'),
+                 fake_server.new('production-web-1'),
+                 fake_server.new('staging-web-2')]
+
+      subject.make_unique_server_name("staging", "web", []).should == "staging-web-1"
+      subject.make_unique_server_name("staging", "web", servers).should == "staging-web-3"
+      subject.make_unique_server_name("production", "web", servers).should == "production-web-2"
+    end
+
+  end
+
+  describe Management::DestroyServer do
+
+    let(:server) { Object.new }
+    before { subject.stub(:get_server).with("server-1").and_return(server) }
+
+    it "destroys the given server if you type 'Yes' verbatim" do
+      server.should_receive(:destroy).once
+      with_stdin("Yes\n") { without_stdout { subject.call("server-1") } }
+    end
+
+    it "does not destroy the given server if you don't type 'Yes' verbatim" do
+      server.should_not_receive(:destroy)
+      without_stdout do
+        with_stdin("yes\n") { subject.call("server-1") }
+        with_stdin("Y\n") { subject.call("server-1") }
+        with_stdin("y\n") { subject.call("server-1") }
+        with_stdin("yep\n") { subject.call("server-1") }
+        with_stdin("\n") { subject.call("server-1") }
+        with_stdin("YES\n") { subject.call("server-1") }
+        with_stdin("Yes.\n") { subject.call("server-1") }
+      end
+    end
+
+  end
+
+  describe Management::StopServer do
+
+    let(:server) { Object.new }
+    before { subject.stub(:get_server).with("server-1").and_return(server) }
+
+    it "stops the given server" do
+      server.should_not_receive(:destroy)
+      server.should_receive(:stop).once
+      without_stdout { subject.call("server-1") }
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: management
+version: !ruby/object:Gem::Version
+  version: '0.9'
+  prerelease: 
+platform: ruby
+authors:
+- Steven Degutis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: unf
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Write your deployment using just shell scripts.
+email: steven@cleancoders.com
+executables:
+- management
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- Rakefile
+- bin/management
+- lib/ext/fog.rb
+- lib/management.rb
+- lib/management/command.rb
+- lib/management/commands/create_server.rb
+- lib/management/commands/destroy_server.rb
+- lib/management/commands/list_servers.rb
+- lib/management/commands/run_script.rb
+- lib/management/commands/ssh_server.rb
+- lib/management/commands/stop_server.rb
+- lib/management/interpreter.rb
+- lib/management/version.rb
+- management.gemspec
+- spec/main_spec.rb
+homepage: https://github.com/sdegutis/management
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Minimalist EC2 management & deployment tool.
+test_files:
+- spec/main_spec.rb