roark 0.0.1

data/lib/roark/cli/create.rb

@@ -0,0 +1,76 @@
+module Roark
+  module CLI
+    class Create
+
+      include Shared
+
+      def initialize
+        @options = { :parameters => {}, :region => 'us-east-1' }
+        @logger  = Roark.logger
+      end
+
+      def create
+        option_parser.parse!
+
+        validate_required_options [:name, :template]
+
+        unless File.exists? @options[:template]
+          @logger.error "Template #{@options[:template]} does not exist."
+          exit 1
+        end
+
+        template = File.read @options[:template]
+
+        ami = Roark::Ami.new :aws => aws, :name => @options[:name]
+
+        ami_create_workflow = Roark::AmiCreateWorkflow.new :ami      => ami,
+                                                           :template   => template,
+                                                           :parameters => @options[:parameters]
+        response = ami_create_workflow.execute
+
+        unless response.success?
+          @logger.error response.message
+          exit 1
+        end
+
+        @logger.info response.message
+      end
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: roark create [options]"
+
+          opts.on("-n", "--name [NAME]", "Name of AMI") do |o|
+            @options[:name] = o
+          end
+
+          opts.on("-p", "--parameters [PARAMETERS]", "Parameter name and it's value separated by '=' to pass to Cloud Formation. Can be specified multiple times.") do |o|
+            data = o.split('=')
+            @options[:parameters].merge!({ data.first => data[1] })
+          end
+
+          opts.on("-r", "--region [REGION]", "Region to build AMI") do |o|
+            @options[:region] = o
+          end
+
+          opts.on("-t", "--template [TEMPLATE]", "Path to Cloud Formation template") do |o|
+            @options[:template] = o
+          end
+
+          opts.on("--aws-access-key [KEY]", "AWS Access Key") do |o|
+            @options[:aws_access_key] = o
+          end
+
+          opts.on("--aws-secret-key [KEY]", "AWS Secret Key") do |o|
+            @options[:aws_secret_key] = o
+          end
+        end
+      end
+
+      def command_summary
+        'Creates an AMI'
+      end
+
+    end
+  end
+end

data/lib/roark/cli/destroy.rb

@@ -0,0 +1,53 @@
+module Roark
+  module CLI
+    class Destroy
+
+      include Shared
+
+      def initialize
+        @options = { :region => 'us-east-1' }
+      end
+
+      def destroy
+        option_parser.parse!
+
+        validate_required_options [:ami_id]
+
+        ami = Roark::Ami.new :aws => aws, :ami_id => @options[:ami_id]
+
+        response = ami.destroy
+        unless response.success?
+          Roark.logger.error response.message
+          exit 1
+        end
+      end
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: roark destroy [options]"
+
+          opts.on("-i", "--ami-id [AMI_ID]", "ID of AMI to destroy") do |o|
+            @options[:ami_id] = o
+          end
+
+          opts.on("-r", "--region [REGION]", "Region to build AMI") do |o|
+            @options[:region] = o
+          end
+
+          opts.on("--aws-access-key [KEY]", "AWS Access Key") do |o|
+            @options[:aws_access_key] = o
+          end
+
+          opts.on("--aws-secret-key [KEY]", "AWS Secret Key") do |o|
+            @options[:aws_secret_key] = o
+          end
+        end
+      end
+
+      def command_summary
+        'Destroys an AMI'
+      end
+
+    end
+  end
+end

data/lib/roark/cli/shared.rb

@@ -0,0 +1,28 @@
+module Roark
+  module CLI
+    module Shared
+      def validate_required_options(options)
+        options.each do |o|
+          unless @options[o]
+            @logger.error "Option '#{o.to_s}' required."
+            exit 1
+          end
+        end
+      end
+
+      def command_name
+        self.class.name.split('::').last.downcase
+      end
+
+      def help
+        puts option_parser.help
+      end
+
+      def aws
+        Roark::Aws::Connection.new :access_key_id  => @options[:access_key_id],
+                                   :aws_secret_key => @options[:secret_access_key],
+                                   :region         => @options[:region]
+      end
+    end
+  end
+end

data/lib/roark/cli.rb

@@ -0,0 +1,66 @@
+require 'optparse'
+
+require 'roark/cli/shared'
+
+require 'roark/cli/create'
+require 'roark/cli/destroy'
+
+module Roark
+  module CLI
+
+    def self.start
+      cmd = ARGV.shift
+
+      case cmd
+      when 'create'
+        begin
+          CLI::Create.new.create
+        rescue OptionParser::MissingArgument => e
+          puts e.message
+          exit 1
+        end
+      when 'destroy'
+        begin
+          CLI::Destroy.new.destroy
+        rescue OptionParser::MissingArgument => e
+          puts e.message
+          exit 1
+        end
+      when '-h'
+        usage
+      when '-v'
+        puts Roark::VERSION
+      else
+        puts "Unknown command: '#{cmd}'."
+        puts ''
+        usage
+        exit 1
+      end
+    end
+
+    def self.usage
+      puts 'Usage: roark command'
+      puts ''
+      puts 'Append -h for help on specific subcommand.'
+      puts ''
+
+      puts 'Commands:'
+      commands.each do |cmd|
+        $stdout.printf "    %-#{length_of_longest_command}s      %s\n",
+                       cmd.command_name,
+                       cmd.command_summary
+      end
+    end
+
+    def self.commands
+      return @commands if @commands
+      klasses   = Roark::CLI.constants.reject {|c| [:Shared].include? c}
+      @commands = klasses.map { |klass| Roark::CLI.const_get(klass).new }
+    end
+
+    def self.length_of_longest_command
+      commands.map { |c| c.command_name.length }.max
+    end
+
+  end
+end

data/lib/roark/instance.rb

@@ -0,0 +1,56 @@
+module Roark
+  class Instance
+
+    require "forwardable"
+
+    extend Forwardable
+
+    def_delegators :stack, :destroy, :exists?, :in_progress?, :instance_id, :success?
+
+    def initialize(args)
+      @aws    = args[:aws]
+      @name   = args[:name]
+      @logger = Roark.logger
+    end
+
+    def create(args)
+      parameters = args[:parameters]
+      template   = args[:template]
+
+      stack.create :name       => @name,
+                   :parameters => parameters,
+                   :template   => template
+    end
+
+    def create_ami_from_instance
+      create_ami.create :name        => @name,
+                        :instance_id => instance_id
+    end
+
+    def stop
+      stop_instance.stop instance_id
+    end
+
+    def status
+      instance_status.status instance_id
+    end
+
+    private
+
+    def stack
+      @stack ||= Stack.new :aws  => @aws, :name => @name
+    end
+
+    def create_ami
+      @create_ami ||= Roark::Aws::Ec2::CreateAmi.new @aws
+    end
+
+    def stop_instance
+      @stop_instance ||= Roark::Aws::Ec2::StopInstance.new @aws
+    end
+
+    def instance_status
+      @instance_status ||= Roark::Aws::Ec2::InstanceStatus.new @aws
+    end
+  end
+end

data/lib/roark/response.rb

@@ -0,0 +1,15 @@
+module Roark
+  class Response
+    attr_accessor :code, :message
+
+    def initialize(args={})
+      @code    = args.fetch :code, 1
+      @message = args.fetch :message, ''
+    end
+
+    def success?
+      @code == 0
+    end
+
+  end
+end

data/lib/roark/stack.rb

@@ -0,0 +1,63 @@
+class Stack
+
+  def initialize(args)
+    @aws    = args[:aws]
+    @name   = args[:name]
+    @region = @aws.region
+    @logger = Roark.logger
+  end
+
+  def create(args)
+    @logger.info "Creating Cloud Formation stack '#{@name}' in '#{@region}'."
+    create_stack.create :name       => @name,
+                        :parameters => args[:parameters],
+                        :template   => args[:template]
+  end
+
+  def destroy
+    @logger.info "Destroying Cloud Formation stack '#{@name}'."
+    destroy_stack.destroy @name
+  end
+
+  def exists?
+    stack_status.exists? @name
+  end
+
+  def in_progress?
+    status =~ /^CREATE_IN_PROGRESS$/
+  end
+
+  def success?
+    status =~ /^CREATE_COMPLETE$/
+  end
+
+  def instance_id
+    outputs.find {|o| o.key == 'InstanceId'}.value
+  end
+
+  private
+
+  def status
+    stack_status.status @name
+  end
+
+  def outputs
+    stack_outputs.outputs @name
+  end
+
+  def create_stack
+    @create_stack ||= Roark::Aws::CloudFormation::CreateStack.new @aws
+  end
+
+  def destroy_stack
+    @destroy_stack ||= Roark::Aws::CloudFormation::DestroyStack.new @aws
+  end
+
+  def stack_outputs
+    @stack_outputs ||= Roark::Aws::CloudFormation::StackOutputs.new @aws
+  end
+
+  def stack_status
+    @stack_status ||= Roark::Aws::CloudFormation::StackStatus.new @aws
+  end
+end

data/lib/roark/version.rb

@@ -0,0 +1,3 @@
+module Roark
+  VERSION = "0.0.1"
+end

data/lib/roark.rb

@@ -0,0 +1,17 @@
+require "roark/aws"
+require "roark/ami"
+require "roark/ami_create_workflow"
+require "roark/instance"
+require "roark/response"
+require "roark/stack"
+require "roark/version"
+
+require "logger"
+
+module Roark
+  module_function
+
+  def logger(logger=nil)
+    @logger ||= logger ? logger : Logger.new(STDOUT)
+  end
+end

data/roark.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'roark/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "roark"
+  spec.version       = Roark::VERSION
+  spec.authors       = ["Brett Weaver"]
+  spec.email         = ["brett@weav.net"]
+  spec.description   = %q{Library and CLI to build AMIs from Instances created via Cloud Formation.}
+  spec.summary       = %q{Howard Roark, master architect and builder of AMIs.}
+  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"
+  spec.add_development_dependency "rspec"
+
+  spec.add_runtime_dependency "aws-sdk", "1.11.2"
+end

data/spec/ami_create_workflow_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Roark::AmiCreateWorkflow do
+  before do
+    logger_stub = stub 'logger'
+    @response_stub = mock 'response'
+    Roark.logger logger_stub
+    Roark.logger.stub :info => true
+    @ami_mock            = mock 'ami mock'
+    @ami_create_workflow = Roark::AmiCreateWorkflow.new :ami        => @ami_mock,
+                                                        :parameters => { 'key' => 'val' },
+                                                        :template   => 'template'
+  end
+
+  it "should create and execute a new workflow" do
+    @response_stub.stub :success? => true
+    @ami_mock.should_receive(:create_instance).with(:parameters => { 'key' => 'val' },
+                                                    :template   => 'template').and_return @response_stub
+    @ami_mock.should_receive(:wait_for_instance).and_return @response_stub
+    @ami_mock.should_receive(:stop_instance).and_return @response_stub
+    @ami_mock.should_receive(:wait_for_instance_to_stop).and_return @response_stub
+    @ami_mock.should_receive(:create_ami).and_return @response_stub
+    @ami_mock.should_receive(:wait_for_ami).and_return @response_stub
+    @ami_mock.should_receive(:destroy_instance).and_return @response_stub
+    expect(@ami_create_workflow.execute.success?).to be_true
+  end
+
+  it "should raise AmiCreateWorkflowError exception" do
+    @response_stub.stub :success? => false, :message => 'error'
+    @ami_mock.should_receive(:create_instance).with(:parameters => { 'key' => 'val' },
+                                                    :template   => 'template').and_return @response_stub
+    expect(@ami_create_workflow.execute.success?).to be_false
+  end
+end

data/spec/ami_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe Roark::Ami do
+  before do
+    logger_stub = stub 'logger stub'
+    Roark.logger.stub :info => true
+
+    @aws_mock = mock "aws connection mock"
+    @aws_mock.stub :region => 'us-west-1'
+    init_args = { :aws    => @aws_mock,
+                  :name   => 'test-ami' }
+
+    @ami = Roark::Ami.new init_args
+  end
+
+  context "testing instance methods" do
+    before do
+      @instance_mock = mock 'instance mock'
+      Roark::Instance.should_receive(:new).
+                      with(:aws  => @aws_mock,
+                           :name => 'test-ami').
+                      and_return @instance_mock
+      @instance_mock.stub :instance_id => 'i-1234abcd'
+    end
+
+    describe "#create_instance" do
+      it "should create on instance" do
+        args = { :parameters => 'parameters',
+                 :template   => 'template' }
+        @instance_mock.should_receive(:create).with args
+        expect(@ami.create_instance(args).success?).to be_true
+      end
+
+      it "should return unsuccesful if an AWS exception is raised" do
+        args = { :parameters => 'parameters',
+                 :template   => 'template' }
+        @instance_mock.should_receive(:create).and_raise AWS::Errors::Base.new "error"
+        expect(@ami.create_instance(args).success?).to be_false
+      end
+    end
+
+    describe "#create_ami" do
+      it "should call create_ami_from_instance on instance and return ami" do
+        ami_mock = mock 'ami'
+        @instance_mock.stub :create_ami_from_instance => ami_mock
+        ami_mock.stub :id => 'ami-12345678'
+        expect(@ami.create_ami.success?).to be_true
+        expect(@ami.ami_id).to eq('ami-12345678')
+      end
+
+      it "should return unsuccesful if an AWS exception is raised" do
+        ami_mock = mock 'ami'
+        @instance_mock.should_receive(:create_ami_from_instance).
+                       and_raise AWS::Errors::Base.new "error"
+        expect(@ami.create_ami.success?).to be_false
+      end
+    end
+
+    describe "#stop_instance" do
+      it "should call stop on instance" do
+        @instance_mock.should_receive(:stop)
+        expect(@ami.stop_instance.success?).to be_true
+      end
+
+      it "should return unsuccesful if an AWS exception is raised" do
+        @instance_mock.should_receive(:stop).
+                       and_raise AWS::Errors::Base.new "error"
+        expect(@ami.stop_instance.success?).to be_false
+      end
+    end
+
+    describe "#destroy_instance" do
+      it "should call destroy on instance" do
+        @instance_mock.should_receive(:destroy)
+        expect(@ami.destroy_instance.success?).to be_true
+      end
+
+      it "should return unsuccesful if an AWS exception is raised" do
+        @instance_mock.should_receive(:destroy).
+                       and_raise AWS::Errors::Base.new "error"
+        expect(@ami.destroy_instance.success?).to be_false
+      end
+    end
+
+    describe "#wait_for_instance_to_stop" do
+      it "should sleep until instance is stopped" do
+        @instance_mock.stub(:status).and_return(:available, :stopped)
+        @ami.should_receive(:sleep).with(15)
+        expect(@ami.wait_for_instance_to_stop.success?).to be_true
+      end
+    end
+
+    describe "#wait_for_instance" do
+      it "should sleep until the instance is not in state in_progress" do
+        @instance_mock.stub(:in_progress?).and_return(true, false)
+        @instance_mock.stub :exists? => true
+        @ami.should_receive(:sleep).with(60)
+        @instance_mock.stub :success? => true
+        expect(@ami.wait_for_instance.success?).to be_true
+      end
+    end
+
+    describe "#wait_for_instance" do
+      it "should sleep until the instance exists" do
+        @instance_mock.stub :in_progress? => false
+        @instance_mock.stub(:exists?).and_return(false, true)
+        @ami.should_receive(:sleep).with(60)
+        @instance_mock.stub :success? => true
+        expect(@ami.wait_for_instance.success?).to be_true
+      end
+    end
+
+    describe "#wait_for_instance" do
+      it "should return false if instance create was not succesful" do
+        @instance_mock.stub :in_progress? => false
+        @instance_mock.stub :exists? => true
+        @instance_mock.stub :success? => false
+        expect(@ami.wait_for_instance.success?).to be_false
+      end
+    end
+
+    describe "#instance_id" do
+      it "should call instance_id on instance" do
+        @instance_mock.stub :instance_id => 'i-12345678'
+        expect(@ami.instance_id).to eq('i-12345678')
+      end
+    end
+  end
+
+  context "testing state methods" do
+    before do
+      @ec2_ami_state_mock = mock 'ec2 ami state'
+      Roark::Aws::Ec2::AmiState.should_receive(:new).
+                                with(@aws_mock).
+                                and_return @ec2_ami_state_mock
+    end
+
+    describe "#available?" do
+      it "should return true if the ami is in state available" do
+        @ec2_ami_state_mock.stub :state => :available
+        expect(@ami.available?).to be_true
+      end
+
+      it "should return false if the ami is not in state available" do
+        @ec2_ami_state_mock.stub :state => :pending
+        expect(@ami.available?).to be_false
+      end
+    end
+
+    describe "#pending?" do
+      it "should return true if the ami is in state pending" do
+        @ec2_ami_state_mock.stub :state => :pending
+        expect(@ami.pending?).to be_true
+      end
+
+      it "should return false if the ami is not in state pending" do
+        @ec2_ami_state_mock.stub :state => :stopped
+        expect(@ami.pending?).to be_false
+      end
+    end
+
+    describe "#exists?" do
+      it "should return true if the ami exists" do
+        @ec2_ami_state_mock.stub :exists? => true
+        expect(@ami.exists?).to be_true
+      end
+
+      it "should return false if the ami does not exist" do
+        @ec2_ami_state_mock.stub :exists? => false
+        expect(@ami.exists?).to be_false
+      end
+    end
+
+    describe "#state" do
+      it "should call Ec2::AmiState for ami state" do
+        @ec2_ami_state_mock.stub :state => :available
+        expect(@ami.state).to eq(:available)
+      end
+    end
+
+    describe "#wait_for_ami" do
+      it "should wait for the ami to not be in state pending" do
+        @ec2_ami_state_mock.stub(:state).and_return(:pending, :available)
+        @ec2_ami_state_mock.stub :exists? => true
+        @ami.should_receive(:sleep).with(15)
+        expect(@ami.wait_for_ami.success?).to be_true
+      end
+
+      it "should wait for the ami if it does not yet exists" do
+        @ec2_ami_state_mock.stub(:exists?).and_return(false, true)
+        @ec2_ami_state_mock.stub :state => :available
+        @ami.should_receive(:sleep).with(15)
+        expect(@ami.wait_for_ami.success?).to be_true
+      end
+
+      it "should return false if the ami is not in state available" do
+        @ec2_ami_state_mock.stub :state => :failed, :exists? => true
+        expect(@ami.wait_for_ami.success?).to be_false
+      end
+    end
+  end
+
+  context "testing ami methods" do
+    describe "#destroy" do
+      it "should call destroy on Ec2::DestroyAmi" do
+        @ami.ami_id = 'ami-12345678'
+        ec2_destroy_ami_mock = mock 'aws_destroy_ami'
+        Roark::Aws::Ec2::DestroyAmi.should_receive(:new).
+                                    with(@aws_mock).
+                                    and_return ec2_destroy_ami_mock
+        ec2_destroy_ami_mock.should_receive(:destroy).with('ami-12345678')
+        expect(@ami.destroy.success?).to be_true
+      end
+    end
+  end
+
+end

data/spec/aws/cloud_formation/create_stack_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Roark::Aws::CloudFormation::CreateStack do
+  describe "#create" do
+    it "should create the requestd stack" do
+      stacks_mock     = mock 'stacks'
+      cf_stub         = stub 'cf', :stacks => stacks_mock
+      connection_stub = stub 'connection', :cf => cf_stub
+      create_stack = Roark::Aws::CloudFormation::CreateStack.new connection_stub
+      stacks_mock.should_receive(:create).
+                  with("test123", "{\"some\":\"json\"}",
+                       { :capabilities => ["CAPABILITY_IAM"],
+                         :parameters   => [{ :parameter_key   => "key",
+                                             :parameter_value => "val"}]})
+      create_stack.create :name       => 'test123',
+                          :parameters => { 'key' => 'val' },
+                          :template   => "{\"some\":\"json\"}"
+    end
+  end
+end