cucumber-chef 1.0.3 → 2.0.0.pre

data/lib/cucumber/chef/test_lab.rb

@@ -1,86 +1,342 @@
+################################################################################
+#
+#      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
 module Cucumber
   module Chef
-    class TestLabError < Error ; end
+
+    class TestLabError < Error; end
 
     class TestLab
-      def initialize(config)
-        @config = config
-        @connection =
-          Fog::Compute.new(:provider => 'AWS',
-                           :aws_access_key_id => @config[:knife][:aws_access_key_id],
-                           :aws_secret_access_key => @config[:knife][:aws_secret_access_key],
-                           :region => @config[:knife][:region])
+      attr_reader :connection, :server
+      attr_accessor :stdout, :stderr, :stdin
+
+      INVALID_STATES = %w( terminated pending )
+      RUNNING_STATES =  %w( running starting-up )
+      SHUTDOWN_STATES = %w( shutdown stopping stopped shutting-down )
+      VALID_STATES = RUNNING_STATES+SHUTDOWN_STATES
+
+################################################################################
+
+      def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN)
+        @stdout, @stderr, @stdin = stdout, stderr, stdin
+        @stdout.sync = true if @stdout.respond_to?(:sync=)
+
+        @connection = Fog::Compute.new(
+          :provider => 'AWS',
+          :aws_access_key_id => Cucumber::Chef::Config[:aws][:aws_access_key_id],
+          :aws_secret_access_key => Cucumber::Chef::Config[:aws][:aws_secret_access_key],
+          :region => Cucumber::Chef::Config[:aws][:region]
+        )
+        ensure_security_group
       end
 
-      def build(output)
-        if exists?
-          raise TestLabError.new("A test lab already exists using the AWS credentials you supplied")
+################################################################################
+
+      def create
+        if (lab_exists? && (@server = labs_running.first))
+          @stdout.puts("A test lab already exists using the AWS credentials you have supplied; attempting to reprovision it.")
+        else
+          server_definition = {
+            :image_id => Cucumber::Chef::Config.aws_image_id,
+            :groups => Cucumber::Chef::Config[:aws][:aws_security_group],
+            :flavor_id => Cucumber::Chef::Config[:aws][:aws_instance_type],
+            :key_name => Cucumber::Chef::Config[:aws][:aws_ssh_key_id],
+            :availability_zone => Cucumber::Chef::Config[:aws][:availability_zone],
+            :tags => { "purpose" => "cucumber-chef", "cucumber-chef-mode" => Cucumber::Chef::Config[:mode] },
+            :identity_file => Cucumber::Chef::Config[:aws][:identity_file]
+          }
+          if (@server = @connection.servers.create(server_definition))
+            @stdout.puts("Provisioning cucumber-chef test lab platform.")
+
+            @stdout.print("Waiting for instance...")
+            Cucumber::Chef.spinner do
+              @server.wait_for { ready? }
+            end
+            @stdout.puts("done.\n")
+
+            tag_server
+
+            @stdout.print("Waiting for 20 seconds...")
+            Cucumber::Chef.spinner do
+              sleep(20)
+            end
+            @stdout.print("done.\n")
+          end
+        end
+
+        if @server
+          @stdout.print("Waiting for SSHD...")
+          Cucumber::Chef.spinner do
+            Cucumber::Chef::TCPSocket.new(@server.public_ip_address, 22).wait
+          end
+          @stdout.puts("done.\n")
         end
-        server_definition = {
-          :image_id => @config[:knife][:aws_image_id],
-          :groups => "default",
-          :flavor_id => "m1.small",
-          :key_name => @config[:knife][:aws_ssh_key_id],
-          :availability_zone => @config[:knife][:availability_zone],
-          :tags => {"purpose" => "cucumber-chef"},
-          :identity_file => @config[:knife][:identity_file]
-        }
-        @server = @connection.servers.create(server_definition)
-        output.puts "Provisioning cucumber-chef test lab platform."
-        output.print "Waiting for server"
-        @server.wait_for { output.print "."; ready? }
-        output.puts("\n")
-        tag_server
-        output.puts "Instance ID: #{@server.id} ; IP Address #{@server.public_ip_address}"
-        output.puts "Platform provisioned.  Run cucumber-chef project to get started."
+
         @server
+
+      rescue Exception => e
+        $logger.fatal { e.message }
+        $logger.fatal { "Backtrace:\n#{e.backtrace.join("\n")}" }
+        raise TestLabError, e.message
       end
 
+################################################################################
+
       def destroy
-        running_labs.each do |server|
-          puts "Destroying Server: #{server.public_ip_address}"
-          server.destroy
+        if ((l = labs).count > 0)
+          @stdout.puts("Destroying Servers:")
+          l.each do |server|
+            @stdout.puts("  * #{server.public_ip_address}")
+            server.destroy
+          end
+        else
+          @stdout.puts("There are no cucumber-chef test labs to destroy!")
         end
-        nodes.each do |node|
-          puts "Destroying Node: #{node[:cloud][:public_ipv4]}"
-          node.destroy
+
+      rescue Exception => e
+        $logger.fatal { e.message }
+        $logger.fatal { e.backtrace.join("\n") }
+        raise TestLabError, e.message
+      end
+
+################################################################################
+
+      def start
+        if (lab_exists? && (@server = labs_shutdown.first))
+          if @server.start
+
+            @stdout.print("Waiting for instance...")
+            Cucumber::Chef.spinner do
+              @server.wait_for { ready? }
+            end
+            @stdout.puts("done.\n")
+
+            @stdout.print("Waiting for SSHD...")
+            Cucumber::Chef.spinner do
+              Cucumber::Chef::TCPSocket.new(@server.public_ip_address, 22).wait
+            end
+            @stdout.puts("done.\n")
+
+            @stdout.puts("Successfully started up cucumber-chef test lab!")
+
+            info
+          else
+            @stdout.puts("Failed to start up cucumber-chef test lab!")
+          end
+        else
+          @stdout.puts("There are no available cucumber-chef test labs to start up!")
         end
+
+      rescue Exception => e
+        $logger.fatal { e.message }
+        $logger.fatal { e.backtrace.join("\n") }
+        raise TestLabError, e.message
       end
 
-      def exists?
-        running_labs.size > 0
+
+      def stop
+        if (lab_exists? && (@server = labs_running.first))
+          if @server.stop
+            @stdout.puts("Successfully shutdown cucumber-chef test lab!")
+          else
+            @stdout.puts("Failed to shutdown cucumber-chef test lab!")
+          end
+        else
+          @stdout.puts("There are no available cucumber-chef test labs top shutdown!")
+        end
+
+      rescue Exception => e
+        $logger.fatal { e.message }
+        $logger.fatal { e.backtrace.join("\n") }
+        raise TestLabError, e.message
       end
 
+################################################################################
+
       def info
-        (exists? && running_labs.first.public_ip_address) || ""
+        if lab_exists?
+          labs.each do |lab|
+            @stdout.puts("Instance ID: #{lab.id}")
+            @stdout.puts("State: #{lab.state}")
+            @stdout.puts("Username: #{lab.username}") if lab.username
+            if (lab.public_ip_address || lab.private_ip_address)
+              @stdout.puts
+              @stdout.puts("IP Address:")
+              @stdout.puts("  Public...: #{lab.public_ip_address}") if lab.public_ip_address
+              @stdout.puts("  Private..: #{lab.private_ip_address}") if lab.private_ip_address
+            end
+            if (lab.dns_name || lab.private_dns_name)
+              @stdout.puts
+              @stdout.puts("DNS:")
+              @stdout.puts("  Public...: #{lab.dns_name}") if lab.dns_name
+              @stdout.puts("  Private..: #{lab.private_dns_name}") if lab.private_dns_name
+            end
+            if (lab.tags.count > 0)
+              @stdout.puts
+              @stdout.puts("Tags:")
+              lab.tags.to_hash.each do |k,v|
+                @stdout.puts("  #{k}: #{v}")
+              end
+            end
+            if lab.public_ip_address
+              @stdout.puts
+              @stdout.puts("Chef-Server WebUI:")
+              @stdout.puts("  http://#{lab.public_ip_address}:4040/")
+            end
+            @stdout.puts
+            if (labs_running.include?(lab) && (n = nodes))
+              @stdout.puts
+              @stdout.puts("Nodes:")
+              n.each do |node|
+                @stdout.puts("  * #{node.name} (#{node.cloud.public_ipv4})")
+              end
+            end
+            if (labs_running.include?(lab) && (c = clients))
+              @stdout.puts
+              @stdout.puts("Clients:")
+              c.each do |client|
+                @stdout.puts("  * #{client.name}")
+              end
+            end
+          end
+        else
+          @stdout.puts("There are no cucumber-chef test labs to display information for!")
+        end
+
+      rescue Exception => e
+        $logger.fatal { e.message }
+        $logger.fatal { e.backtrace.join("\n") }
+        raise TestLabError, e.message
       end
 
-      def public_hostname
-        nodes.first.cloud.public_hostname
+################################################################################
+
+      def lab_exists?
+        (labs.size > 0)
+      end
+
+################################################################################
+
+      def labs
+        results = @connection.servers.select do |server|
+          $logger.debug("candidate") { "ID=#{server.id}, state='#{server.state}'" }
+          ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config[:mode].to_s &&
+            server.tags['cucumber-chef-user'] == Cucumber::Chef::Config[:user].to_s &&
+            VALID_STATES.any?{ |state| state == server.state } )
+        end
+        results.each do |server|
+          $logger.debug("results") { "ID=#{server.id}, state='#{server.state}'" }
+        end
+        results
       end
 
+################################################################################
+
+      def labs_running
+        results = @connection.servers.select do |server|
+          $logger.debug("candidate") { "ID=#{server.id}, state='#{server.state}'" }
+          ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config[:mode].to_s &&
+            server.tags['cucumber-chef-user'] == Cucumber::Chef::Config[:user].to_s &&
+            RUNNING_STATES.any?{ |state| state == server.state } )
+        end
+        results.each do |server|
+          $logger.debug("results") { "ID=#{server.id}, state='#{server.state}'" }
+        end
+        results
+      end
+
+################################################################################
+
+      def labs_shutdown
+        results = @connection.servers.select do |server|
+          $logger.debug("candidate") { "ID=#{server.id}, state='#{server.state}'" }
+          ( server.tags['cucumber-chef-mode'] == Cucumber::Chef::Config[:mode].to_s &&
+            server.tags['cucumber-chef-user'] == Cucumber::Chef::Config[:user].to_s &&
+            SHUTDOWN_STATES.any?{ |state| state == server.state } )
+        end
+        results.each do |server|
+          $logger.debug("results") { "ID=#{server.id}, state='#{server.state}'" }
+        end
+        results
+      end
+
+################################################################################
+
       def nodes
-        search = ::Chef::Search::Query.new
-        mode = @config[:mode]
-        query = "roles:test_lab_test AND tags:#{mode}"
-        nodes, offset, total = search.search("node", URI.escape(query))
+        Cucumber::Chef.load_knife_config
+        query = "tags:#{Cucumber::Chef::Config[:mode]} AND tags:#{Cucumber::Chef::Config[:user]}"
+        $logger.debug { "query(#{query})" }
+        nodes, offset, total = ::Chef::Search::Query.new.search("node", URI.escape(query))
         nodes.compact
       end
 
-      def running_labs
-        @connection.servers.select do |s|
-          s.tags['cucumber-chef'] == @config[:mode] && s.state == 'running'
-        end
+      def clients
+        Cucumber::Chef.load_knife_config
+        query = "tags:#{Cucumber::Chef::Config[:mode]} AND tags:#{Cucumber::Chef::Config[:user]}"
+        $logger.debug { "query(#{query})" }
+        clients, offset, total = ::Chef::Search::Query.new.search("client", URI.escape(query))
+        clients.compact
       end
 
+
+################################################################################
     private
+################################################################################
+
       def tag_server
-        tag = @connection.tags.new
-        tag.resource_id = @server.id
-        tag.key = "cucumber-chef"
-        tag.value = @config[:mode]
-        tag.save
+        {
+          "cucumber-chef-mode" => Cucumber::Chef::Config[:mode],
+          "cucumber-chef-user" => Cucumber::Chef::Config[:user],
+          "purpose" => "cucumber-chef"
+        }.each do |k, v|
+          tag = @connection.tags.new
+          tag.resource_id = @server.id
+          tag.key, tag.value = k, v
+          tag.save
+        end
+      end
+
+################################################################################
+
+      def ensure_security_group
+        security_group_name = Cucumber::Chef::Config[:aws][:aws_security_group]
+        if (security_group = @connection.security_groups.get(security_group_name))
+          port_ranges = security_group.ip_permissions.collect{ |entry| entry["fromPort"]..entry["toPort"] }
+          security_group.authorize_port_range(22..22) if port_ranges.none?{ |port_range| port_range === 22 }
+          security_group.authorize_port_range(4000..4000) if port_ranges.none?{ |port_range| port_range === 4000 }
+          security_group.authorize_port_range(4040..4040) if port_ranges.none?{ |port_range| port_range === 4040 }
+        elsif (security_group = @connection.security_groups.new(:name => security_group_name, :description => "cucumber-chef test lab")).save
+          security_group.authorize_port_range(22..22)
+          security_group.authorize_port_range(4000..4000)
+          security_group.authorize_port_range(4040..4040)
+        else
+          raise TestLabError, "Could not find an existing or create a new AWS security group."
+        end
       end
+
+################################################################################
+
     end
+
   end
 end
+
+################################################################################

data/lib/cucumber/chef/test_runner.rb

@@ -1,32 +1,103 @@
+################################################################################
+#
+#      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
 module Cucumber
   module Chef
-    class TestRunnerError < Error ; end
+
+    class TestRunnerError < Error; end
 
     class TestRunner
 
-      require 'cucumber/chef/test_lab'
+################################################################################
+
+      def initialize(features_path, stdout=STDOUT, stderr=STDERR, stdin=STDIN)
+        @features_path = features_path
+        @stdout, @stderr, @stdin = stdout, stderr, stdin
+        @stdout.sync = true if @stdout.respond_to?(:sync=)
+
+        @test_lab = Cucumber::Chef::TestLab.new(@stdout, @stderr, @stdin)
+
+        @ssh = Cucumber::Chef::SSH.new(@stdout, @stderr, @stdin)
+        @ssh.config[:host] = @test_lab.labs_running.first.public_ip_address
+        @ssh.config[:ssh_user] = "ubuntu"
+        @ssh.config[:identity_file] = Cucumber::Chef.locate(:file, ".cucumber-chef", "id_rsa-#{@ssh.config[:ssh_user]}")
 
-      def initialize(project_dir, config)
-        @project_dir = project_dir
-        @config = config
+        @stdout.puts("Cucumber-Chef Test Runner Initalized!")
       end
 
-      def run
+################################################################################
+
+      def run(destroy, *args)
+        reset_project
         upload_project
-        @project_path = File.join('/home/ubuntu', File.basename(@project_dir), 'features')
-        connection = Net::SSH.start(@hostname, 'ubuntu', :keys => @key) do |ssh|
-          @output = ssh.exec!("sudo cucumber #{@project_path}")
+
+        @stdout.puts("Executing Cucumber-Chef Test Runner")
+        remote_path = File.join("/", "home", "ubuntu", "features")
+        cucumber_options = args.flatten.compact.uniq.join(" ")
+        env = ( destroy ? "DESTROY=1" : nil )
+        command = [ "cd #{remote_path}", "&&", "sudo", env, "cucumber", cucumber_options, "--exclude support/roles", "--exclude support/data_bags", "--exclude support/keys", "." ].flatten.compact.join(" ")
+
+        @ssh.exec(command)
+      end
+
+
+################################################################################
+    private
+################################################################################
+
+      def reset_project
+        @stdout.print("Cleaning up any previous test runs...")
+        Cucumber::Chef.spinner do
+          remote_path = File.join("/", "home", "ubuntu", "features")
+
+          command = "rm -rf #{remote_path}"
+          @ssh.exec(command, :silence => true)
         end
-        puts @output
+        @stdout.print("done.\n")
       end
 
+################################################################################
+
       def upload_project
-        lab = Cucumber::Chef::TestLab.new(@config)
-        @hostname = lab.public_hostname
-        @key = File.expand_path(@config[:knife][:identity_file])
-        %x[scp -r -i #{@key} #{@project_dir} ubuntu@#{@hostname}: 2>/dev/null]
-        puts "Cucumber-chef project: #{File.basename(@project_dir)} sucessfully uploaded to the test lab."
+        @stdout.print("Uploading files required for this test run...")
+        Cucumber::Chef.spinner do
+          local_path = File.join(@features_path)
+          remote_path = File.join("/", "home", "ubuntu", "features")
+          @ssh.upload(local_path, remote_path)
+
+          root_path = Cucumber::Chef.locate_parent(".chef")
+          cucumber_config_file = File.expand_path(File.join(root_path, "cucumber.yml"))
+          if File.exists?(cucumber_config_file)
+            remote_file = File.join(remote_path, File.basename(cucumber_config_file))
+            @ssh.upload(cucumber_config_file, remote_file)
+          end
+        end
+        @stdout.print("done.\n")
       end
+
+################################################################################
+
     end
+
   end
 end
+
+################################################################################

data/lib/cucumber/chef/utility.rb

@@ -0,0 +1,128 @@
+################################################################################
+#
+#      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
+module Cucumber
+  module Chef
+
+    class UtilityError < Error; end
+
+    module Utility
+
+################################################################################
+
+      def is_rc?
+        ((Cucumber::Chef::VERSION =~ /rc/) || (Cucumber::Chef::VERSION =~ /pre/))
+      end
+
+################################################################################
+
+      def load_knife_config
+        $logger.debug { "attempting to load cucumber-chef test lab 'knife.rb'" }
+
+        knife_rb = Cucumber::Chef.locate(:file, ".cucumber-chef", "knife.rb")
+        ::Chef::Config.from_file(knife_rb)
+
+        $logger.debug { "load_knife_config(#{knife_rb})" }
+      end
+
+################################################################################
+
+      def locate(type, *args)
+        pwd = Dir.pwd.split(File::SEPARATOR)
+        $logger.debug { "pwd='#{Dir.pwd}'" } if $logger
+        (pwd.length - 1).downto(0) do |i|
+          candidate = File.join(pwd[0..i], args)
+          $logger.debug { "candidate='#{candidate}'" } if $logger
+          case type
+          when :file
+            if (File.exists?(candidate) && !File.directory?(candidate))
+              result = File.expand_path(candidate)
+              $logger.debug { "result='#{result}'" } if $logger
+              return result
+            end
+          when :directory
+            if (File.exists?(candidate) && File.directory?(candidate))
+              result = File.expand_path(candidate)
+              $logger.debug { "result='#{result}'" } if $logger
+              return result
+            end
+          when :any
+            if File.exists?(candidate)
+              result = File.expand_path(candidate)
+              $logger.debug { "result='#{result}'" } if $logger
+              return result
+            end
+          end
+        end
+
+        message = "Could not locate #{type} '#{File.join(args)}'."
+        $logger.fatal { message } if $logger
+        raise UtilityError, message
+      end
+
+################################################################################
+
+      def locate_parent(child)
+        parent = (locate(:any, child).split(File::SEPARATOR) rescue nil)
+        raise UtilityError, "Could not locate parent of '#{child}'." unless parent
+        File.expand_path(File.join(parent[0..(parent.length - 2)]))
+      end
+
+################################################################################
+
+      def spinner(stdout=STDOUT, stderr=STDERR, stdin=STDIN)
+        spinning_chars = %w[| / - \\]
+        count = 0
+        spinner = Thread.new do
+          while count do
+            stdout.print spinning_chars[(count+=1) % spinning_chars.length]
+            stdout.flush if stdout.respond_to?(:flush)
+            sleep(0.25)
+            stdout.print "\b"
+            stdout.flush if stdout.respond_to?(:flush)
+          end
+        end
+        yield.tap do
+          count = false
+          spinner.join
+        end
+      end
+
+################################################################################
+
+      def generate_do_not_edit_warning(message=nil)
+        warning = []
+        warning << "#"
+        warning << "# WARNING: Automatically generated file; DO NOT EDIT!"
+        warning << [ "# Cucumber-Chef v#{Cucumber::Chef::VERSION}", message ].compact.join(" ")
+        warning << "# Generated on #{Time.now.utc.to_s}"
+        warning << "#"
+        warning.join("\n")
+      end
+
+################################################################################
+
+    end
+
+  end
+end
+
+################################################################################

data/lib/cucumber/chef/version.rb

@@ -1,5 +1,34 @@
+################################################################################
+#
+#      Author: Stephen Nelson-Smith <stephen@atalanta-systems.com>
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) 2011-2012 Atalanta Systems Ltd
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
 module Cucumber
   module Chef
-    VERSION = '0.0.2'
+
+################################################################################
+
+    VERSION = "2.0.0.pre" unless const_defined?(:VERSION)
+
+################################################################################
+
   end
 end
+
+################################################################################