skewer 0.1.0

data/features/support/puppetcode/manifests/classes/foobar.pp

@@ -0,0 +1,4 @@
+class foobar {
+  include puppet::munge
+  include foo::bar
+}

data/features/support/puppetcode/manifests/classes/foobroken.pp

@@ -0,0 +1,4 @@
+class foobroken {
+  include puppet::munge
+  include foo::broken
+}

data/features/support/puppetcode/manifests/classes/role.pp

@@ -0,0 +1,3 @@
+class my_role_class {
+  notice('this is a dirty great role class that actually does nothing')
+}

data/features/support/puppetcode/manifests/site.pp

@@ -0,0 +1,2 @@
+import "nodes.pp"
+import "classes/*.pp"

data/features/support/puppetcode/modules/foo/manifests/bar.pp

@@ -0,0 +1,3 @@
+class foo::bar { 
+  notice "foo to the bar to the baz"
+}

data/features/support/puppetcode/modules/foo/manifests/broken.pp

@@ -0,0 +1,8 @@
+class foo::broken {
+  file {
+    "broken file":
+      path => "/this/path/should/not/exist",
+      mode => "0999";:w
+
+  }
+}

data/features/support/puppetcode/modules/puppet/manifests/munge.pp

@@ -0,0 +1,5 @@
+class puppet::munge {
+  group {
+    'puppet': ensure => present
+  }
+}

data/features/update.feature

@@ -0,0 +1,29 @@
+Feature: updating a node
+  In order to run my puppet code again
+  As a someone who wants to update config on the machine
+  I want to run the update command
+
+Scenario: run the command without args
+  When I run `./bin/skewer update`
+  Then the exit status should not be 0
+
+@announce-stdout @announce-stderr
+Scenario: pass in a hostname user and role on passing puppet code
+  Given I have access to the internet
+  And I have puppet code in "/tmp/skewer_test_code"
+  When I run `./bin/skewer update --host default --user vagrant --role foobar --puppetcode /tmp/skewer_test_code/`
+  Then the exit status should be 0
+  And the stdout should contain "Using Puppet Code from /tmp/skewer_test_code/"
+  And the stdout should contain "Puppet run succeeded"
+
+
+@announce-stdout @announce-stderr
+Scenario: pass in a hostname user and role on broken puppet code
+  Given I have access to the internet
+  And I have puppet code in "/tmp/skewer_test_code"
+  When I run `./bin/skewer update --host default --user vagrant --role foobroken --puppetcode /tmp/skewer_test_code/`
+  Then the exit status should be 0
+  And the stdout should contain "Using Puppet Code from /tmp/skewer_test_code/"
+  And the stdout should contain "Puppet failed"
+
+

data/lib/aws/node.rb

@@ -0,0 +1,52 @@
+require 'skewer'
+require 'aws/service'
+
+module Skewer
+  module AWS
+    # Build out an AWS node using Fog.
+    class Node
+      attr_reader :node
+
+      def initialize(aws_id, group_names, options = {})
+        if options[:aws_node]
+          @node = options[:aws_node]
+        else
+          @service = self.class.find_service(options)
+          node_options = {
+              :image_id => aws_id,
+              :flavor_id => SkewerConfig.get('flavor_id'),
+              :username => SkewerConfig.get('aws_username'),
+              :groups => group_names
+          }
+
+          if options[:key_name]
+            node_options[:key_name] = options[:key_name]
+          end
+
+          if SkewerConfig.instance.get('key_name')
+            node_options[:key_name] = SkewerConfig.get('key_name')
+          end
+
+          @node = @service.servers.bootstrap(node_options)
+        end
+      end
+
+      def self.find_service(options)
+        options[:service] ? options[:service] : AWS::Service.new.service
+      end
+
+      def destroy
+        @node.destroy
+      end
+
+      def self.find_by_name(dns_name, service = self.find_service({}))
+        node = service.servers.select { |server| server.dns_name == dns_name }[0]
+        if node
+          return self.new(nil, nil, {:aws_node => node})
+        else
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/aws/security_group.rb

@@ -0,0 +1,37 @@
+module Skewer
+  module AWS
+    # Security group permissions for our AWS service.
+    class SecurityGroup
+      attr_reader :service, :group
+
+      def initialize(name, desc, ports)
+        @service ||= SkewerConfig.get 'aws_service'
+        groups = @service.security_groups
+        group = groups.select { |group| group.name == name }[0]
+
+        if group.nil? == true
+          group = @service.create_security_group(name, desc)
+          group = groups.get(name)
+        end
+        @group = group
+
+        if ports.length >= 1
+          ensure_port_ranges(group, ports)
+        end
+      end
+
+
+      def ensure_port_ranges(group, ports)
+        ports.each do |port|
+
+          description = port[:description]
+          range = port[:range]
+
+          group.revoke_port_range(range)
+          group.authorize_port_range(range, {:name => description})
+          # TODO: get the port range options in there
+        end
+      end
+    end
+  end
+end

data/lib/aws/service.rb

@@ -0,0 +1,21 @@
+module Skewer
+  module AWS
+    # The AWS service which is used to interface through to the AWS
+    # cloud using Fog.
+    class Service
+      attr_reader :service
+
+      def initialize
+        region = SkewerConfig.get('region')
+        @service = Fog::Compute.new({
+          :provider => 'AWS',
+          :region => region})
+        SkewerConfig.set 'aws_service', @service
+      end
+
+      def self.service
+        self.new.service
+      end
+    end
+  end
+end

data/lib/bootstrapper.rb

@@ -0,0 +1,112 @@
+require 'config'
+require 'util'
+require 'skewer'
+
+module Skewer
+  # puts all of puppet's dependencies on
+  class Bootstrapper
+    MAX_CACHE = 3600
+    attr_writer :mock
+
+    def initialize(node,options)
+      @node = node
+      @options = options
+      @util = Util.new
+      @mock = false
+    end
+
+    def add_ssh_hostkey
+      location = @util.get_location(@node)
+      system "ssh -o 'StrictHostKeyChecking no' -o 'PasswordAuthentication no' no_such_user@#{location} >/dev/null 2>&1"
+    end
+
+    def execute(file_name)
+      file = File.join(File.dirname(__FILE__), '..', 'assets', file_name)
+      raise "#{file} does not exist" unless File.exists? file
+      @node.scp file, '/var/tmp/.'
+      result = @node.ssh "sudo bash /var/tmp/#{file_name}"
+      puts result.inspect
+      result
+    end
+
+    def install_gems
+      Skewer.logger.debug "Installing Gems"
+      assets = File.join(File.dirname(__FILE__), '..', 'assets')
+      @node.scp File.join(File.expand_path(assets), 'Gemfile'), 'infrastructure'
+      command = ". /etc/profile.d/rubygems.sh && cd infrastructure && bundle install"
+      result = @node.ssh(command)
+    end
+
+    def add_key_to_agent(executor = Kernel, homedir = ENV['HOME'])
+      config = SkewerConfig.instance
+      key_name = config.get('key_name')
+      key_path = File.join(homedir, '.ssh', "#{key_name}.pem")
+      Skewer.logger.debug "****Looking for #{key_path}"
+      if File.exists?(key_path)
+        executor.system("ssh-add #{key_path}")
+      end
+    end
+
+    def sync_source()
+      require 'source'
+      require 'puppet_node'
+      config = SkewerConfig.instance
+      source_dir = config.get(:puppet_repo)
+      Skewer.logger.debug "Using Puppet Code from #{source_dir}"
+      role = @options[:role]
+      if role
+        PuppetNode.new({:default => role.to_sym}).render
+      end
+      # TODO: if there's no role, it should look it up from an external source
+      if @mock
+        Skewer.logger.debug "Mock: would normally rsync now"
+      else
+        Source.new(source_dir).rsync(@node)
+      end
+
+    end
+
+    def lock_file
+      File.join('/tmp', 'skewer-' + Util.new.get_location(@node))
+    end
+
+    def lock_file_expired?(lock_file)
+      now = Time.now
+      lock_file_time = File.stat(lock_file).mtime
+      age = now - lock_file_time
+      age > MAX_CACHE
+    end
+
+    def destroy_lock_file()
+      FileUtils.rm_f(self.lock_file)
+    end
+
+    def should_i_run?
+      lock_file = lock_file()
+      if File.exists?(lock_file)
+        if lock_file_expired?(lock_file)
+          destroy_lock_file
+          return true
+        else
+          return false
+        end
+      else
+        FileUtils.touch(lock_file)
+        true
+      end
+    end
+
+    def prepare_node
+      add_ssh_hostkey
+      execute('rubygems.sh')
+      add_key_to_agent
+    end
+
+    def go
+      i_should_run = should_i_run?
+      prepare_node() if i_should_run
+      sync_source
+      install_gems if i_should_run
+    end
+  end
+end

data/lib/cli.rb

@@ -0,0 +1,96 @@
+require 'rubygems'
+require 'fog'
+
+require 'skewer'
+require 'bootstrapper'
+require 'util'
+require 'hooks'
+
+module Skewer
+  # this is responsible for composing all the other components. or should be.
+  class CLI
+    attr_reader :bootstrapper, :node
+
+    def initialize(options)
+      @options = options
+      @config = SkewerConfig.instance
+      @config.slurp_options(options)
+      @util = Util.new
+      @config.set(:logger, Skewer.logger)
+    end
+
+    def select_node(kind)
+      Skewer.logger.debug "Evaluating cloud #{kind}"
+      image = @options[:image]
+      case kind
+        when :ec2
+          require 'aws/security_group'
+          require 'aws/node'
+          require 'aws/service'
+          Skewer.logger.debug 'Launching an EC2 node'
+          aws_group = @options[:group]
+          group = aws_group ? aws_group : 'default'
+          node = AWS::Node.new(image, [group]).node
+        when :rackspace
+          require 'rackspace/node'
+          Skewer.logger.debug 'Launching a Rackspace node'
+          node = Rackspace::Node.new(@options[:flavor_id], image, 'default').node
+        when :linode
+          raise "not implemented"
+        when :eucalyptus
+          Skewer.logger.debug 'Using the EC2 API'
+          require 'eucalyptus'
+          node = Eucalyptus.new
+        when :vagrant
+          Skewer.logger.debug 'Launching a local vagrant node'
+          require 'ersatz/ersatz_node.rb'
+          node = ErsatzNode.new('default', 'vagrant')
+        when :stub
+          Skewer.logger.debug "Launching stubbed node for testing"
+          require 'stub_node'
+          node = StubNode.new
+        when :ersatz
+          require 'ersatz/ersatz_node.rb'
+          node = ErsatzNode.new(@config.get('host'), @config.get('user'))
+        else
+          raise "I don't know that cloud"
+      end
+      node
+    end
+
+    def destroy
+      @node.destroy unless @options[:keep]
+    end
+
+    def bootstrap
+      node = select_node(@options[:kind])
+      @node = node
+      @bootstrapper = Bootstrapper.new(node, @options)
+    end
+
+    def go
+      require 'puppet'
+      require 'cuke'
+      begin
+        node = @node
+        node.wait_for { ready? }
+        @bootstrapper.go
+        Puppet.run(node, @options)
+        location = @util.get_location(node)
+        Hooks.new(location).run
+        Skewer.logger.debug "Node ready\n open http://#{location} or \n ssh -l #{node.username} #{location}"
+        Cuke.new(@config.get(:cuke_dir)).run if @config.get(:cuke_dir)
+      rescue Exception => exception
+        Skewer.logger.debug exception
+      ensure
+        destroy
+      end
+    end
+
+    def self.bootstrap_and_go(options)
+      skewer = self.new(options)
+      skewer.bootstrap
+      skewer.go
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,67 @@
+require 'singleton'
+
+module Skewer
+  # responsible for all configuration, once I move all the options in
+  class SkewerConfig
+    include Singleton
+    attr_accessor :aws_service, :puppet_repo, :region, :flavor_id, :aws_username, :flavor_id
+
+    def initialize
+      reset
+      read_config_files
+    end
+
+    def reset
+      @puppet_repo = '../infrastructure'
+      @region = 'us-east-1'
+      @flavor_id = 'm1.large'
+      @aws_username = 'ubuntu'
+    end
+
+    def read_config_file(config_file)
+      if File.exists?(config_file)
+        Skewer.logger.debug "reading #{config_file}"
+        config = File.read(config_file)
+        parse(config)
+        Skewer.logger.debug self.inspect
+      end
+    end
+
+    def read_config_files
+      read_config_file(File.join(ENV['HOME'], '.skewer.json'))
+      read_config_file('.skewer.json')
+    end
+
+    def parse(config)
+      require 'json'
+      configz = JSON.parse(config)
+      configz.each { |key,value| set(key,value) }
+    end
+
+    def set(attribute, value)
+      self.instance_variable_set "@#{attribute}", value
+    end
+
+    def self.set(key,value)
+      instance = self.instance
+      instance.set(key,value)
+    end
+
+    def get(attribute)
+      if attribute.class == Symbol
+        attribute = attribute.to_s
+      end
+      self.instance_variable_get "@" + attribute
+    end
+
+    def self.get(key)
+      self.instance.get(key)
+    end
+
+    def slurp_options(options)
+      options.each_pair do |key, value|
+        self.set(key, value)
+      end
+    end
+  end
+end