skewer 0.1.0

data/lib/skewer/version.rb

@@ -0,0 +1,3 @@
+module Skewer
+  VERSION = "0.1.0"
+end

data/lib/source.rb

@@ -0,0 +1,54 @@
+require 'util'
+
+module Skewer
+  # responsible for moving source to remote nodes
+  class Source
+    def initialize(path = nil)
+      @util = Util.new
+      raise "I can't see the path #{path}" unless File.exists?(path)
+      @path = path.sub(/\/$/, '')
+    end
+
+    def excludes
+      '--exclude Gemfile --exclude Gemfile.lock --exclude ' + ['.git'].join(' ')
+    end
+
+    def create_destination(node)
+      begin
+        node.ssh('mkdir -p infrastructure')
+      rescue
+        location = @util.get_location(node)
+        raise "Couldn't SSH to #{location} with #{node.username}"
+      end
+    end
+
+    def rsync_command(node)
+      location = @util.get_location(node)
+      "rsync #{self.excludes} --delete -arpze ssh #{@path}/. #{node.username}@#{location}:infrastructure/."
+    end
+
+    def mock_rsync(command)
+      Skewer.logger.debug "MOCK: #{command}"
+    end
+
+    def real_rsync(node, command)
+      location = @util.get_location(node)
+      raise "Failed to rsync to #{location} with #{node.username}" unless system(command)
+    end
+
+    def rsync(node)
+      Skewer.logger.debug rsync_command(node)
+      location = @util.get_location(node)
+      Skewer.logger.debug "Copying code to #{location} ..."
+      create_destination(node)
+      command = self.rsync_command(node)
+
+      if node.class.to_s =~ /StubNode/
+        mock_rsync(command)
+      else
+        real_rsync(node, command)
+      end
+      Skewer.logger.debug " Done."
+    end
+  end
+end

data/lib/stub_node.rb

@@ -0,0 +1,25 @@
+module Skewer
+  # test stub for pretending to be a real node
+  class StubNode
+    attr_reader :dns_name, :username, :public_ip_address
+
+    def initialize
+      @dns_name = 'com.doodoo'
+      @public_ip_address = '192.168.0.1'
+      @username = 'imabirdbrain'
+      @debug = false
+    end
+
+    def announce(return_type)
+      Skewer.logger.debug "#{self.class} will return #{return_type}" if @debug
+      return_type
+    end
+
+    def method_missing(name, *args)
+      require 'ersatz/ssh_result.rb'
+      Skewer.logger.debug "#{self.class}.#{name} called with #{args.join(',')}" if @debug
+      return announce([ErsatzSSHResult.new('foo', 'success', 0)]) if name == :ssh
+      announce true
+    end
+  end
+end

data/lib/util.rb

@@ -0,0 +1,17 @@
+module Skewer
+  # A utility class to handle common cloud operations that we'll
+  # encounter amongst different providers.
+  class Util
+    # Get the location (dns name, or IP) for a given Fog server. Cloud
+    # provider agnostic.
+    def get_location(server = nil)
+      # Negative case.
+      return nil if server.nil?
+      return nil if not server.respond_to?(:dns_name) and not server.respond_to?(:public_ip_address)
+
+      # Positive case.
+      return server.dns_name if server.respond_to? :dns_name
+      server.public_ip_address if server.respond_to? :public_ip_address
+    end
+  end
+end

data/skewer.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "skewer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "skewer"
+  s.version     = Skewer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Julian Simpson", "Kushal Pisavadia"]
+  s.email       = ["julian@build-doctor.com"]
+  s.homepage    = "http://www.build-doctor.com/skewer"
+  s.summary     = "skewer-#{s.version}"
+  s.description = "Runs masterless puppet code on cloud machines"
+
+  s.rubyforge_project = "skewer"
+
+  s.add_runtime_dependency 'fog', '~> 1.1.2'
+
+  s.add_development_dependency 'aruba'
+  s.add_development_dependency 'jeweler'
+  s.add_development_dependency 'metric_fu'
+  s.add_development_dependency 'rcov', '~> 1.0.0'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'vagrant', '~> 0.9.0'
+
+  s.files         = `git ls-files`.split("\n").reject {|path| path =~ /\.gitignore$/ }
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/aws/node_spec.rb

@@ -0,0 +1,70 @@
+require 'rspec'
+require 'fog'
+require 'aws/node'
+require 'config'
+
+describe Skewer::AWS::Node do
+  it "should have an optional SSH key" do
+    lambda {
+      Fog.mock!
+      Skewer::AWS::Node.new('ami-123456', ['default']).node
+    }.should raise_exception Fog::Errors::MockNotImplemented
+
+    begin
+      Skewer::AWS::Node.new('ami-123456', ['default'], {:key_name => 'FOO_BAR_KEY'})
+    rescue Fog::Compute::AWS::NotFound => e
+      e.message.should == "The key pair 'FOO_BAR_KEY' does not exist"
+    end
+  end
+
+  it "should get the SSH key via config" do
+    Skewer::SkewerConfig.set('key_name', 'FRONT_DOOR')
+    begin
+      Skewer::AWS::Node.new('ami-123456', ['default']).inspect
+    rescue Fog::Compute::AWS::NotFound => e
+      e.message.should == "The key pair 'FRONT_DOOR' does not exist"
+    end
+  end
+
+  it "should be able to find the node by name" do
+    options = {}
+    service = stub('aws_service')
+    servers = stub('aws_servers')
+    service.should_receive(:servers).and_return(servers)
+    servers.should_receive(:select).and_return([])
+    Skewer::AWS::Node.find_by_name('foobar', service)
+  end
+
+  it "should be able in inject the AWS service" do
+    options = {}
+    service = stub('aws_service')
+    servers = stub('aws_servers')
+
+    service.should_receive(:servers).and_return(servers)
+    servers.should_receive(:bootstrap)
+
+    options[:service] = service
+    Skewer::AWS::Node.new('ami-goo', ['default'], options)
+  end
+
+  it "should have a delete method" do
+    options = {}
+    service = stub('aws_service')
+    servers = stub('aws_servers')
+    node = stub('aws_node')
+
+    service.should_receive(:servers).and_return(servers)
+    servers.should_receive(:bootstrap).and_return(node)
+    node.should_receive(:delete).and_return(true)
+
+    options[:service] = service
+    Skewer::AWS::Node.new('ami-goo', ['default'], options).node.delete.should == true
+  end
+
+  it "should have a static find_service method" do
+    options = {}
+    service = stub('aws_service')
+    options[:service] = service
+    Skewer::AWS::Node.find_service(options).should == service
+  end
+end

data/spec/aws/security_group_spec.rb

@@ -0,0 +1,20 @@
+require 'aws/security_group'
+require 'fog'
+
+describe Skewer::AWS::SecurityGroup do
+  Fog.mock!
+  it "should use an existing AWS service if it exists" do
+    service = Skewer::AWS::Service.service
+    group = Skewer::AWS::SecurityGroup.new('foo','bar', {})
+    group.service.should == service
+  end
+
+  it "should not open any extra ports if we don't ask" do 
+    Skewer::AWS::SecurityGroup.new('foo1','bar1', {}).group.ip_permissions.should == []
+  end
+
+  it "should open SSH by default" do
+    default_group = Skewer::AWS::Service.service.security_groups.select {|group| group.name == 'default'}[0]
+    default_group.ip_permissions.select {|dg| dg['fromPort'] == 22 && dg['toPort'] == 22 }.length.should == 1
+  end
+end

data/spec/aws/service_spec.rb

@@ -0,0 +1,31 @@
+require 'config'
+require 'aws/service'
+require 'fog'
+
+describe Skewer::AWS::Service do
+  it "should return an AWS instance" do
+    Fog.mock!
+    Skewer::AWS::Service.service.class.should == Fog::Compute::AWS::Mock
+  end
+
+  it "should register itself for reuse" do
+    service = Skewer::AWS::Service.service
+    Skewer::SkewerConfig.get('aws_service').should == service
+  end
+
+  it "should take zone param from SkewerConfig, and raise exception if not supported" do
+    Skewer::SkewerConfig.set 'region', 'unknown region'
+
+    lambda {
+      service = Skewer::AWS::Service.service
+    }.should raise_exception(ArgumentError, 'Unknown region: "unknown region"')
+  end
+
+  it "should take zone param from SkewerConfig" do
+    Fog.mock!
+    Skewer::SkewerConfig.set 'region', 'eu-west-1'
+    service = Skewer::AWS::Service.service
+    service.nil?.should == false
+    service.class.should == Fog::Compute::AWS::Mock
+  end
+end

data/spec/bootstrapper_spec.rb

@@ -0,0 +1,116 @@
+require 'bootstrapper'
+require 'source'
+require 'config'
+
+describe Skewer::Bootstrapper do
+  it "should barf if the file doesn't exist" do
+    lambda {
+      Skewer::Bootstrapper.new(nil, {}).execute('oberon.sh')
+    }.should raise_exception RuntimeError
+  end
+
+  it "should copy the rubygems profile.d script over" do
+    node = mock('node')
+    node.should_receive(:scp)
+    node.should_receive(:ssh).with('sudo bash /var/tmp/rubygems.sh')
+    Skewer::Bootstrapper.new(node, {}).execute('rubygems.sh')
+  end
+
+  it "should install rubygems on the remote machine" do 
+    node = mock('node')
+    node.should_receive(:scp).with(File.expand_path("./lib/../assets/Gemfile"), "infrastructure")
+    node.should_receive(:ssh).with('. /etc/profile.d/rubygems.sh && cd infrastructure && bundle install')
+    Skewer::Bootstrapper.new(node, {}).install_gems
+  end
+
+  it "should make a node file if it can't find one" do
+    FileUtils.mkdir_p('target/manifests')
+    s = Skewer::Source.new('target')
+    node  = stub('node')
+    node.should_receive(:username).at_least(1).times
+    node.should_receive(:dns_name).at_least(1).times
+    node.should_receive(:ssh).at_least(1).times
+    Skewer::SkewerConfig.instance.set(:puppet_repo, 'target')
+    lambda {
+      Skewer::Bootstrapper.new(node, {:role => 'foo'}).sync_source
+    }.should raise_exception RuntimeError
+    Skewer::SkewerConfig.instance.set(:puppet_repo, '../infrastructure')
+    File.exist?('target/manifests/nodes.pp').should == true
+    FileUtils
+  end
+
+  it "should make an attempt to load the key so that we can rsync the code over" do
+    kernel = stub('kernel')
+    node = stub('node')
+    kernel.should_receive(:system).and_return(true)
+    faux_homedir = 'tmp/foo/.ssh'
+
+    config = Skewer::SkewerConfig.instance
+
+    config.set(:key_name, 'my_great_test_key' )
+    FileUtils.mkdir_p(faux_homedir)
+    FileUtils.touch("#{faux_homedir}/my_great_test_key.pem")
+
+    bootstrapper = Skewer::Bootstrapper.new(node, {})
+    bootstrapper.add_key_to_agent(kernel, 'tmp/foo')
+    Skewer::SkewerConfig.set(:key_name, nil)
+
+
+  end
+
+  it "should always run if there is no lock file" do
+    node  = stub('node')
+    node.should_receive(:dns_name).at_least(1).times.and_return('foo.bar.com')
+
+    bootstrapper = Skewer::Bootstrapper.new(node, {:role => 'foo'})
+    bootstrapper.destroy_lock_file
+
+    bootstrapper.should_i_run?.should == true
+    File.unlink(bootstrapper.lock_file)
+    bootstrapper.should_i_run?.should == true
+
+  end
+
+  it "should let me know if it has just run" do
+    node  = stub('node')
+    node.should_receive(:dns_name).at_least(1).times.and_return('foo.bar.com')
+
+    bootstrapper = Skewer::Bootstrapper.new(node, {:role => 'foo'})
+    bootstrapper.destroy_lock_file
+
+    bootstrapper.should_i_run?.should == true
+    bootstrapper.should_i_run?.should == false
+    bootstrapper.should_i_run?.should == false
+  end
+
+  it "should not bother bootstrapping again if it has bootstrapped recently" do
+    node  = stub('node')
+    node.should_receive(:scp).at_least(1).times
+    node.should_receive(:ssh).at_least(1).times
+    node.should_receive(:dns_name).at_least(1).times.and_return('foo.bar.com')
+    bootstrapper = Skewer::Bootstrapper.new(node, {:role => 'foo'})
+    bootstrapper.destroy_lock_file
+    bootstrapper.mock = true
+    bootstrapper.go
+    sleep 1
+    bootstrapper.go
+  end
+
+  it "should allow mocking out of the source step" do
+    node  = stub('node')
+    node.should_not_receive(:username)
+    bootstrapper = Skewer::Bootstrapper.new(node, {:role => 'foo'})
+    bootstrapper.mock = true
+    bootstrapper.sync_source
+  end
+
+  it "should actually run the source step" do
+    node  = stub('node')
+    node.should_receive(:username).at_least(3).times
+    node.should_receive(:ssh)
+    bootstrapper = Skewer::Bootstrapper.new(node, {:role => 'foo'})
+    lambda {
+      bootstrapper.sync_source
+    }.should  raise_exception RuntimeError
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,71 @@
+require 'cli'
+
+describe Skewer::CLI do
+  before(:each) do
+    config = Skewer::SkewerConfig.instance
+    config.reset
+  end
+
+  Fog.mock!
+  it "shouldn't barf if you instantiate it wthout options" do
+    lambda {
+      Skewer::CLI.new({:kind => :nil})
+    }.should_not raise_exception
+  end
+
+  it "should blow up if you ask for Linode as it's not done" do
+    lambda {
+      Skewer::CLI.new({:kind => :nil}).select_node(:linode)
+    }.should raise_exception RuntimeError
+  end
+
+  it "should return a node of type eucalytus if you ask for one" do
+    lambda {
+      Skewer::CLI.new({:kind => :nil}).select_node(:eucalyptus)
+    }.should raise_exception Fog::Errors::MockNotImplemented
+  end
+
+  it "should return a node of type local if you ask for vagrant" do
+    Skewer::CLI.new({:kind => :nil}).select_node(:vagrant).class.should == Skewer::ErsatzNode
+  end
+
+  it "should return a node of type AWS if you ask for one" do
+    lambda {
+      Skewer::CLI.new({:kind => :nil}).select_node(:ec2)
+    }.should raise_exception Fog::Errors::MockNotImplemented
+  end
+
+  it "should be able to parse the options as they're given" do
+    config = Skewer::SkewerConfig.instance
+    config.get(:region).should == 'us-east-1'
+    cli = Skewer::CLI.new({:kind => :nil, :region => 'eu-west-1'})
+    config.get(:region).should == 'eu-west-1'
+  end
+
+  it "should be able to pass the region through to the AWS service" do
+    config = Skewer::SkewerConfig.instance
+    config.get(:region).should == 'us-east-1'
+    cli = Skewer::CLI.new({:kind => :nil, :region => 'eu-west-1'})
+    config.get(:region).should == 'eu-west-1'
+    lambda {
+      cli.select_node(:ec2)
+    }.should raise_exception Fog::Errors::MockNotImplemented
+  end
+
+  it "should be able to pass the flavor_id through to the AWS service" do
+    config = Skewer::SkewerConfig.instance
+    config.get(:flavor_id).should == 'm1.large'
+    cli = Skewer::CLI.new({:kind => :nil, :flavor_id => 'm1.small'})
+    config.get(:flavor_id).should == 'm1.small'
+    lambda {
+      cli.select_node(:ec2)
+    }.should raise_exception Fog::Errors::MockNotImplemented
+  end
+
+  it "should be able to provide a cuke directory" do
+    config = Skewer::SkewerConfig.instance
+    config.get(:cuke_dir).should == nil
+    cli = Skewer::CLI.new({:kind => :nil, :cuke_dir => 'spec'})
+    config.get(:cuke_dir).should == 'spec'
+  end
+end