skewer 0.1.0

data/lib/cuke.rb

@@ -0,0 +1,26 @@
+module Skewer
+  # Runs the Cucumber features for a given directory.
+  #
+  # Specifically, the tests related to infrastructure that skewer
+  # will map against to check if the node has been successfully
+  # built.
+  class Cuke
+    class CukeError < RuntimeError; end
+
+    def initialize(dir = nil)
+      raise "you must provide a valid directory for features to be executed within" if dir.nil? or dir.class != String or  !directory_exists?(dir)
+      @dir = dir
+    end
+
+    def directory_exists?(dir)
+      File.directory?(dir)
+    end
+
+    def run
+      result = `cucumber #{@dir}`
+      parsed = result.match(/failed/)[0] rescue false
+      raise CukeError, "One of the cuke features failed!\n\n#{result}" if parsed
+      result
+    end
+  end
+end

data/lib/ersatz/ersatz_node.rb

@@ -0,0 +1,31 @@
+require 'ersatz/ssh_result.rb'
+
+module Skewer
+  # fakes a fog node
+  class ErsatzNode
+    attr_accessor :username, :dns_name
+
+    def initialize(hostname, user)
+      @dns_name = hostname
+      @username = user
+    end
+
+    def ssh(command)
+      full_ssh_command = "ssh -l #{@username} #{@dns_name} '#{command}'"
+      Skewer.logger.debug full_ssh_command
+      stdout = `#{full_ssh_command}`
+      result = ErsatzSSHResult.new(command, stdout, $?.exitstatus)
+      [result]
+    end
+
+    def scp(file, dest)
+      `scp #{file} #{@username}@#{@dns_name}:#{dest}`
+    end
+
+    def destroy
+    end
+
+    def wait_for
+    end
+  end
+end

data/lib/ersatz/ssh_result.rb

@@ -0,0 +1,15 @@
+require 'skewer'
+
+module Skewer
+  # fakes a fog SSH result
+  class ErsatzSSHResult
+    attr_accessor :command, :stdout, :status
+
+    def initialize(command, stdout, status)
+      @command = command
+      @stdout = stdout
+      @status = status
+      Skewer.logger.debug self.stdout
+    end
+  end
+end

data/lib/eucalyptus.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'fog'
+
+module Skewer
+  # instantiates a eucalyptus endpoint
+  class Eucalyptus
+    def initialize
+      compute = Fog::Compute.new({
+        :provider => 'AWS',
+        :endpoint => 'http://localhost:4567'
+      })
+      @node = compute.servers.bootstrap()
+    end
+  end
+end

data/lib/hooks.rb

@@ -0,0 +1,22 @@
+module Skewer
+  require 'config'
+
+  class Hooks
+    attr_writer :command
+
+    def initialize(host_name)
+      @command = SkewerConfig.instance.get('hook')
+      @host_name = host_name
+    end
+
+    def run
+      return_code = false
+      unless @command.nil?
+        Skewer.logger.debug "Running hooks ..."
+        `#{@command}  #{@host_name}`
+        return_code = $? == 0 ? true : false
+      end
+      return_code
+    end
+  end
+end

data/lib/node.erb

@@ -0,0 +1,5 @@
+<% @nodes.each_pair do |k,v|%>
+node <%= k %> {
+  include <%= v %>
+}
+<% end %>

data/lib/node.rb

@@ -0,0 +1,43 @@
+module Skewer
+  # responsible for talking to remote machines
+  class Node
+    attr_reader :username
+
+    def initialize
+      @address = nil
+      @username = nil
+      @password = nil
+      @pubkey = nil
+      @ssh = Fog::SSH::Real.new(
+        @address,
+        @username,
+        {:password => @password}
+      )
+      install_pubkey(@ssh, @pubkey)
+    end
+
+    def install_pubkey(ssh, key)
+      key_file = File.read(key).gsub("\n",'')
+      ssh(['mkdir -p .ssh', 'chmod 0700 .ssh',"echo #{key_file} > .ssh/authorized_keys"])
+    end
+
+    def dns_name
+      @address
+    end
+
+    def wait_for(*blk)
+    end
+
+    def destroy
+    end
+
+    def ssh(commands)
+      results = @ssh.run(commands)
+      if results.is_a?(Array)
+        results.each {|result| Skewer.logger.debug result.stdout }
+      else
+        Skewer.logger.debug results.stdout
+      end
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,92 @@
+require 'fog'
+require 'cli'
+require 'aws/node'
+require "rackspace/node"
+
+module Skewer
+  class CLI
+    # Parses the CLI input and makes sure that it's clean.
+    class Parser
+      def initialize(type = nil, options = {})
+        # base case tests that we have input that we accept.
+        Fog.mock! if options[:mock]
+        validate_options(options, type)
+
+        if type == 'delete'
+          case options[:kind]
+            when :ec2
+              node = AWS::Node.find_by_name(options[:host])
+            when :rackspace
+              node = Rackspace::Node.find_by_ip(options[:host])
+            else
+              raise("#{options[:kind]} not found")
+          end
+          destroy_node(node, options)
+        else
+          Skewer::CLI.bootstrap_and_go(options)
+        end
+      end
+
+      def destroy_node(node, options)
+        if node
+          node.destroy
+          Skewer.logger.info("#{options[:host]} deleted.")
+        else
+          abort("#{options[:host]} not found.")
+        end
+      end
+
+      def validate_options(options, type)
+        abort(usage) if type.nil? and options.empty?
+        abort(usage) unless ['provision', 'update', 'delete'].include? type
+        abort("A key (--key KEY) must be provided if using EC2") if options[:kind] == :ec2 && !options[:key_name]
+        if type == 'provision'
+          unless options[:kind] && options[:image] && options[:role] && !options[:help]
+            abort(provision_usage)
+          end
+        elsif type == 'update'
+          unless options[:host] && options[:user] && !options[:help]
+            abort(update_usage)
+          end
+        elsif type == 'delete'
+          unless options[:kind] && options[:host] && !options[:help]
+            abort(delete_usage)
+          end
+        end
+      end
+
+      def usage
+        out = <<EOF
+Usage: skewer COMMAND [options]
+
+The available skewer commands are:
+   provision  spawn a new VM via a cloud system and provision it with puppet code
+   update     update the puppet code on a machine that you've already provisioned
+   delete     deletes the given host from the provided cloud provider
+EOF
+        out.strip
+      end
+
+      def provision_usage
+        out = <<EOF
+Usage: skewer provision --cloud <which cloud>  --image <AWS image> --role <puppet role class>
+EOF
+        out.strip
+      end
+
+      def update_usage
+        out = <<EOF
+Usage: skewer update --host <host> --user <user with sudo rights> --role <puppet role class>
+EOF
+        out.strip
+      end
+
+      def delete_usage
+        out = <<EOF
+Usage: skewer delete --cloud <which cloud> --host <host>
+EOF
+        out.strip
+      end
+    end
+  end
+end

data/lib/puppet.rb

@@ -0,0 +1,53 @@
+require 'skewer'
+
+module Skewer
+  require 'puppet_runtime_error'
+  # responsible for executing puppet
+  class Puppet
+    def arguments
+      [
+       "--modulepath modules",
+       "--vardir /var/lib/puppet"
+      ].join(' ')
+    end
+
+    def bundle
+      "/var/lib/gems/1.8/bin/bundle"
+    end
+
+    def command_string(username, options)
+      @command_line = "cd infrastructure"
+      if username == 'root'
+        @command_line << " &&"
+      else
+        @command_line <<  " && sudo"
+      end
+      @command_line << " #{self.bundle} exec"
+      @command_line << " puppet apply"
+      @command_line << " manifests/site.pp"
+      @command_line << " --color false"
+      @command_line << " #{arguments}"
+      if options[:noop]
+        @command_line << " --noop"
+      end
+      @command_line
+    end
+
+    def run(node, options)
+      command = command_string(node.username, options)
+      result = node.ssh(command)[0]
+      if result.status != 0
+        Skewer.logger.debug result.stdout
+        raise PuppetRuntimeError, "Puppet failed"
+      else
+        Skewer.logger.debug "Puppet run succeeded"
+      end
+      result
+    end
+
+    def self.run(node, options)
+      this = self.new
+      this.run(node, options)
+    end
+  end
+end

data/lib/puppet_node.rb

@@ -0,0 +1,26 @@
+module Skewer
+  # responsible for creating a node definition
+  class PuppetNode
+    attr_accessor :nodes, :puppet_repo
+
+    def initialize(nodes = { :default =>:noop})
+      @nodes = nodes
+      config = SkewerConfig.instance
+      @puppet_repo = config.get(:puppet_repo)
+    end
+
+    def to_s
+      require 'erb'
+      lib_dir = File.dirname(__FILE__)
+      template = ERB.new(File.read(File.join(lib_dir, 'node.erb')))
+      template.result(binding)
+    end
+
+    def render
+      node_file_path = File.join(@puppet_repo, 'manifests','nodes.pp')
+      file = File.new(node_file_path, 'w+')
+      file << self.to_s
+      file.close
+    end
+  end
+end

data/lib/puppet_runtime_error.rb

@@ -0,0 +1,6 @@
+module Skewer
+  class PuppetRuntimeError < Exception
+
+  end
+
+end

data/lib/rackspace/images.rb

@@ -0,0 +1,25 @@
+module Skewer
+  module Rackspace
+    class Images
+      attr_reader :supported
+
+      def initialize
+        @supported = {
+          'ubuntu1004' => { :id => 112, :name => "Ubuntu 10.04 LTS"},
+          'ubuntu1104' => { :id => 115, :name => "Ubuntu 11.04"},
+          'ubuntu1110' => { :id => 119, :name => "Ubuntu 11.10"},
+        }
+      end
+
+      # If provided a name for an image, give back the ID.
+      def get_id(name)
+        return @supported['ubuntu1004'][:id] if name.nil?
+        name = Integer(name) rescue name
+        return name if name.class == Fixnum
+        return @supported['ubuntu1004'][:id] if name.class != String
+        raise "An image with the name '#{name}' doesn't exist" if !@supported.has_key?(name)
+        @supported[name][:id]
+      end
+    end
+  end
+end

data/lib/rackspace/node.rb

@@ -0,0 +1,60 @@
+require 'fog'
+require 'rackspace/images'
+
+module Skewer
+  module Rackspace
+    # Build out a Rackspace node using Fog.
+    class Node
+      attr_reader :node
+
+      # By default, boot an Ubuntu 10.04 LTS (lucid) server.
+      def initialize(flavor = 1, image = 112, name = 'my_server', instance = nil)
+        connection = self.class.find_service
+
+        # Get our SSH key to attach it to the server.
+        if instance
+          @node = instance
+        else
+          @node = build(connection, flavor, image, name)
+        end
+      end
+
+      def self.find_service
+        Fog::Compute.new(
+          :provider => 'Rackspace',
+          :rackspace_api_key => Fog.credentials[:rackspace_api_key],
+          :rackspace_username => Fog.credentials[:rackspace_username],
+          :rackspace_auth_url => "lon.auth.api.rackspacecloud.com")
+      end
+
+      def build(connection, flavor, image, name)
+        path = File.expand_path '~/.ssh/id_rsa.pub'
+        path = File.expand_path '~/.ssh/id_dsa.pub' if not File.exist? path
+        raise "Couldn't find a public key" if not File.exist? path
+        key = File.open(path, 'rb').read
+
+        images = Rackspace::Images.new
+        options = {
+          :flavor_id  => flavor,
+          :image_id   => images.get_id(image),
+          :name       => name,
+          :public_key => key
+        }
+        connection.servers.bootstrap(options)
+      end
+
+      def destroy
+        @node.destroy if !@node.nil?
+      end
+
+      def self.find_by_ip(ip_address, service = self.find_service())
+        node = service.servers.select { |server| server.public_ip_address == ip_address }
+        if node.size > 0
+          return self.new(nil, nil, nil, node[0])
+        else
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/skewer.rb

@@ -0,0 +1,13 @@
+module Skewer
+  require 'logger'
+
+  class << self
+    def logger
+      @log = @log ? @log : Logger.new(STDOUT)
+    end
+
+    def logger=(logger)
+      @log = logger
+    end
+  end
+end