boxci 0.0.30

data/lib/boxci/tester.rb

@@ -0,0 +1,287 @@
+require "yaml"
+require "net/ssh"
+require "net/scp"
+
+module Boxci
+  class Tester
+    include Thor::Base
+    include Thor::Actions
+
+    def self.exit_on_failure?
+      true
+    end
+
+    source_root(File.dirname(__FILE__))
+
+    def test(options)
+      File.open('/tmp/boxci.log', 'w') do |f|
+        f.write('')
+      end
+
+      # NOTE: The Signal.trap('SIGTERM') is required for Bamboo's "Stop
+      # Build" functionality because Bamboo basically sends a SIGTERM to
+      # Boxci and then immediately closes its stdout and stderr pipes
+      # before Boxci has had a chance to cleanup. Therefore, it causes
+      # Errno::EPIPE exceptions to be raised. It does seem that in general
+      # the use of SIGTERM is correct however one would hope that stdout and
+      # stderr pipes would stay open until Boxci exits, but sadly they
+      # do not.
+      Signal.trap('SIGTERM') do
+        File.open('/tmp/boxci.log', 'a+') { |f| f.write("Got SIGTERM, going to cleanup...\n") }
+
+        begin
+          cleanup
+        rescue Errno::EPIPE => e
+          File.open('/tmp/boxci.log', 'a+') { |f| f.write("SIGTERM handler swallowed Errno::EPIPE exception\n") }
+        rescue => e
+          File.open('/tmp/boxci.log', 'a+') do |f|
+            f.write("SIGTERM handler caught exception")
+            f.write("#{e.class}\n")
+            f.write("#{e.message}\n")
+            f.write("#{e.backtrace.join("\n")}\n")
+          end
+          raise e
+        end
+
+        File.open('/tmp/boxci.log', 'a+') { |f| f.write("Finished cleanup process from SIGTERM\n") }
+        exit 255
+      end
+
+      Signal.trap('SIGINT') do
+        cleanup
+        exit 255
+      end
+
+      # TODO: I don't believe this is necessary as I think Ruby's default
+      # handler for SIGPIPE is to ignore it. I need to test this though to
+      # verify.
+      Signal.trap('SIGPIPE', 'SIG_IGN')
+
+      @tester_exit_code = 0
+      # depencency_checker = Boxci::DependencyChecker.new
+      # depencency_checker.verify_all
+      initial_config(options)
+
+      create_project_folder
+      create_project_archive
+      write_vagrant_file
+      write_test_runner
+      if @provider_object.requires_plugin?
+        install_vagrant_plugin
+        add_provider_box
+      end
+      spin_up_box
+      setup_ssh_config
+      install_puppet_on_box
+      provision_box
+      create_artifact_directory
+      upload_test_runner
+      run_tests
+      download_artifacts
+      say "Finished!", :green
+    rescue Errno::EPIPE => e
+      File.open('/tmp/boxci.log', 'a+') do |f|
+        f.write("test() method swallowed Errno::EPIPE exception\n")
+      end
+    rescue => e
+      File.open('/tmp/boxci.log', 'a+') do |f|
+        f.write("test() method caught exception")
+        f.write("#{e.class}\n")
+        f.write("#{e.message}\n")
+        f.write("#{e.backtrace.join("\n")}\n")
+      end
+      raise e
+    ensure
+      cleanup
+      exit @tester_exit_code
+    end
+
+    def initial_config(options)
+      @gem_path = File.expand_path(File.dirname(__FILE__) + "/../..")
+      @puppet_path = File.join(Boxci.project_path, "puppet")
+      @project_uid = "#{rand(1000..9000)}-#{rand(1000..9000)}-#{rand(1000..9000)}-#{rand(1000..9000)}"
+      @project_workspace_folder = File.join(File.expand_path(ENV['HOME']), '.boxci', @project_uid)
+      @options = options
+      @provider_config = Boxci.provider_config(provider)
+      @project_config = Boxci.project_config
+      @provider_object = Boxci::ProviderFactory.build(provider)
+    end
+
+    def provider
+      @options["provider"]
+    end
+
+    def verbose?
+      @options["verbose"] == true
+    end
+
+    def create_project_folder
+      empty_directory @project_workspace_folder, :verbose => verbose?
+    end
+
+    def create_project_archive
+      inside Boxci.project_path do
+        run "git checkout #{@options["revision"]}", :verbose => verbose?
+        run "git submodule update --init", :verbose => verbose?
+        run "tar cf #{File.join(@project_workspace_folder, "project.tar")} --exclude .git --exclude \"*.log\" --exclude node_modules .", :verbose => verbose?
+      end
+    end
+
+    def write_vagrant_file
+      erb_template = File.join("templates", "providers", provider, "Vagrantfile.erb")
+      destination = File.join(@project_workspace_folder, "Vagrantfile")
+
+      template erb_template, destination, :verbose => verbose?
+    end
+
+    def write_test_runner
+      destination = File.join(@project_workspace_folder, "test_runner.sh")
+      test_runner = Boxci::TestRunner.new(Boxci::LanguageFactory.build(Boxci.project_config.language))
+      File.open(destination, 'w+') do |f|
+        f.write(test_runner.generate_script)
+      end
+    end
+
+    def install_vagrant_plugin
+      inside @project_workspace_folder do
+        plugin = @provider_object.plugin
+        # check for vagrant plugin
+        if !system("vagrant plugin list | grep -q #{plugin}")
+          # if vagrant plugin is missing
+          say "You are missing the Vagrant plugin for #{provider}", :yellow
+          # ask user if it's ok to install for them
+          if yes?("Would you like to install it now?")
+            run "vagrant plugin install #{plugin}", :verbose => verbose?
+          end
+        else # if vagrant plugin is found
+          say "Provider plugin #{plugin} found", :green
+        end
+      end
+    end
+
+    def add_provider_box
+      dummy_box_url = @provider_object.dummy_box_url
+      if dummy_box_url
+        if run "curl --output /dev/null --silent --head --fail #{dummy_box_url}"
+          say "Using specified VM Box URL", :green
+        else
+          say "Could not resolve the Box URL: #{dummy_box_url}", :red
+        end
+      else
+        inside @project_workspace_folder do
+          # check for box
+          if !system("vagrant box list | grep dummy | grep -q \"(#{provider})\"")
+            # if box is missing
+            say "No box found for #{provider}, installing now...", :blue
+            run "vagrant box add dummy #{dummy_box_url}", :verbose => verbose?
+          else # if vagrant plugin is found
+            say "Provider box found", :green
+          end
+        end
+      end
+    end
+
+    def spin_up_box
+      inside @project_workspace_folder do
+        run "vagrant up --no-provision --provider #{provider}", :verbose => verbose?
+      end
+    end
+
+    def setup_ssh_config
+      inside @project_workspace_folder do
+        run "vagrant ssh-config > ssh-config.local", :verbose => verbose?
+      end
+    end
+
+    def install_puppet_on_box
+      say "Opening SSH tunnel into the box...", :blue if verbose?
+      Net::SSH.start("default", nil, {:config => File.join(@project_workspace_folder, "ssh-config.local")}) do |ssh|
+        puppet = ssh.exec! "which puppet"
+        unless puppet
+          say "Running: sudo apt-get --yes update", :blue if verbose?
+          ssh.exec! "sudo apt-get --yes update"
+          say "Running: sudo apt-get --yes install puppet", :blue if verbose?
+          ssh.exec! "sudo apt-get --yes install puppet"
+        end
+      end
+    end
+
+    def provision_box
+      say "Provisioning the box with puppet...", :blue if verbose?
+      inside @project_workspace_folder do
+        run "vagrant provision", :verbose => verbose?
+      end
+    end
+
+    def create_artifact_directory
+      say "Creating the artifact directory on the box...", :blue if verbose?
+      Net::SSH.start("default", nil, {:config => File.join(@project_workspace_folder, "ssh-config.local")}) do |ssh|
+        ssh.exec!  "mkdir -p #{@project_config.artifact_path}"
+      end
+    end
+
+    def upload_test_runner
+      Net::SSH.start("default", nil, {:config => File.join(@project_workspace_folder, "ssh-config.local")}) do |ssh|
+        say "Uploading test_runner.sh to the box...", :blue if verbose?
+        ssh.scp.upload! File.join(@project_workspace_folder, "test_runner.sh"), "/vagrant/test_runner.sh"
+        say "Running: chmod a+x /vagrant/test_runner.sh", :blue if verbose?
+        puts ssh.exec! "chmod a+x /vagrant/test_runner.sh"
+      end
+    end
+
+    def run_tests
+      exit_code = nil
+      exit_signal = nil
+      Net::SSH.start("default", nil, {:config => File.join(@project_workspace_folder, "ssh-config.local")}) do |session|
+        say "Running the test steps on the box...", :blue if verbose?
+        session.open_channel do |channel|
+          channel.on_data do |ch, data|
+            $stdout.write(data)
+          end
+
+          channel.on_extended_data do |ch, type, data|
+            $stderr.write(data)
+          end
+
+          channel.on_request("exit-status") do |ch, data|
+            exit_code = data.read_long
+            @tester_exit_code = exit_code
+          end
+
+          channel.exec "/vagrant/test_runner.sh"
+        end
+        session.loop
+      end
+    end
+
+    def download_artifacts
+      Net::SSH.start("default", nil, {:config => File.join(@project_workspace_folder, "ssh-config.local")}) do |ssh|
+        say "Downloading the reports...", :blue if verbose?
+        puts ssh.exec! "cd #{@project_config.artifact_path} && tar cf /tmp/boxci_artifacts.tar ."
+        ssh.scp.download! "/tmp/boxci_artifacts.tar", '.'
+      end
+    end
+
+    def cleanup
+      if @project_workspace_folder && File.directory?(@project_workspace_folder)
+        # NOTE: The begin rescue for Errno::EPIPE and the &>>
+        # /tmp/boxci.log in the backtick execution ARE required for
+        # Bamboo's "Stop Build" functionality because Bamboo basically sends
+        # a SIGTERM to Boxci and then immediately closes its stdout and
+        # stderr pipes before Boxci has had a chance to cleanup. Therefore,
+        # it causes Errno::EPIPE exceptions to be raised.
+        begin
+          say "Cleaning up...", :blue
+        rescue Errno::EPIPE => e
+          File.open('/tmp/boxci.log', 'a+') { |f| f.write("Cleaning up...\n") }
+        end
+        inside @project_workspace_folder do
+          `vagrant destroy -f >> /tmp/boxci.log 2>&1`
+          # run "vagrant destroy -f", :verbose => verbose?, :capture => true
+        end
+        `rm -rf #{@project_workspace_folder} >> /tmp/boxci.log 2>&1`
+        # remove_dir @project_workspace_folder, :verbose => verbose?, :capture => true
+      end
+    end
+  end
+end

data/lib/boxci/version.rb

@@ -0,0 +1,3 @@
+module Boxci
+  VERSION = "0.0.30"
+end

data/lib/boxci.rb

@@ -0,0 +1,71 @@
+require 'boxci/version'
+require 'boxci/project_config'
+require 'boxci/global_config'
+require 'boxci/provider_config'
+require 'boxci/initializer'
+require 'boxci/builder'
+require 'boxci/dependency_checker'
+require 'boxci/tester'
+require 'boxci/language_factory'
+require 'boxci/language'
+require 'boxci/languages/ruby'
+require 'boxci/provider_factory'
+require 'boxci/provider'
+require 'boxci/providers/virtualbox'
+require 'boxci/providers/aws'
+require 'boxci/providers/openstack'
+require 'boxci/config_permutation'
+require 'boxci/config_permutation_component'
+require 'boxci/config_permutation_component_factory'
+require 'boxci/config_permutation_components/rbenv'
+require 'boxci/test_runner'
+
+module Boxci
+  class MissingDependency < StandardError; end
+  class PureVirtualMethod < StandardError; end
+
+  def self.project_config
+    if @project_config
+      return @project_config
+    else
+      @project_config = Boxci::ProjectConfig.new
+      @project_config.load
+      return @project_config
+    end
+  end
+
+  def self.global_config
+    if @global_config
+      return @global_config
+    else
+      @global_config = Boxci::GlobalConfig.new
+      @global_config.load
+      return @global_config
+    end
+  end
+
+  def self.provider_config(provider)
+    if @provider_config
+      return @provider_config
+    else
+      @provider_config = Boxci::ProviderConfig.new(provider)
+      @provider_config.load
+      return @provider_config
+    end
+  end
+
+  def self.default_provider
+    if global_config.default_provider
+      return global_config.default_provider
+    else
+      return ::Boxci::CLI::DEFAULT_PROVIDER
+    end
+  end
+
+  def self.project_path
+    @project_path ||= File.expand_path(%x(pwd)).strip
+  end
+end
+
+# TODO: Restructure to prevent this from needing to be here.
+require 'boxci/cli'

data/spec/lib/boxci/builder_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe Boxci::Builder do
+  describe "#build" do
+    it "generates project Vagrantfile" do
+      allow(subject).to receive(:generate_starter_puppet_manifest)
+      expect(subject).to receive(:generate_project_vagrantfile)
+      subject.build
+    end
+
+    it "generates starter Puppet manifiest" do
+      allow(subject).to receive(:generate_project_vagrantfile)
+      expect(subject).to receive(:generate_starter_puppet_manifest)
+      subject.build
+    end
+  end
+
+  describe "#generate_project_vagrantfile" do
+    let(:project_path) { "/some/path" }
+    let(:dependency_checker) { double(Boxci::DependencyChecker, :verify_boxci_config => nil) }
+
+    it "verifies the boxci config file is present" do
+      allow(subject).to receive(:template)
+      allow(Boxci).to receive(:project_config)
+      allow(Boxci::DependencyChecker).to receive(:new).and_return(dependency_checker)
+      expect(dependency_checker).to receive(:verify_boxci_config)
+      subject.generate_project_vagrantfile
+    end
+
+    it "gets boxci project config hash" do
+      allow(subject).to receive(:template)
+      allow(Boxci::DependencyChecker).to receive(:new).and_return(dependency_checker)
+      expect(Boxci).to receive(:project_config)
+      subject.generate_project_vagrantfile
+    end
+
+    it "assigns the boxci project config to instance variable" do
+      allow(subject).to receive(:template)
+      allow(Boxci::DependencyChecker).to receive(:new).and_return(dependency_checker)
+      project_config_double = double
+      allow(Boxci).to receive(:project_config).and_return(project_config_double)
+      subject.generate_project_vagrantfile
+      expect(subject.instance_variable_get(:@project_config)).to eq(project_config_double)
+    end
+
+    it "copies the Vagrantfile template for the specified language to the user's home directory" do
+      allow(Boxci).to receive(:project_config)
+      allow(Boxci::DependencyChecker).to receive(:new).and_return(dependency_checker)
+      expect(subject).to receive(:template).with("templates/Vagrantfile", File.join(Boxci.project_path, "Vagrantfile"))
+      subject.generate_project_vagrantfile
+    end
+  end
+
+  describe "#generate_starter_puppet_manifiest" do
+    let(:project_path) { "/some/path" }
+
+    before do
+      allow(Boxci).to receive(:project_path).and_return(project_path)
+      allow(Boxci).to receive(:project_config).and_return(double(:language => 'ruby'))
+    end
+
+    it "copies the template to the repo" do
+      language_factory_double = double(:generate_starter_puppet_manifest => nil)
+      allow(Boxci::LanguageFactory).to receive(:build).and_return(language_factory_double)
+      expect(subject).to receive(:directory).with("templates/puppet", File.join(Boxci.project_path, "puppet"))
+      subject.generate_starter_puppet_manifest
+    end
+
+    it "builds a boxci language object" do
+      allow(subject).to receive(:directory)
+      language_double = double
+      project_config_double = double(:language => language_double)
+      allow(Boxci).to receive(:project_config).and_return(project_config_double)
+      expect(Boxci::LanguageFactory).to receive(:build).with(language_double).and_return(double.as_null_object)
+      subject.generate_starter_puppet_manifest
+    end
+
+    it "generates the language specific starter puppet manifest" do
+      allow(subject).to receive(:directory)
+      language_obj_double = double
+      allow(Boxci::LanguageFactory).to receive(:build).and_return(language_obj_double)
+      expect(language_obj_double).to receive(:generate_starter_puppet_manifest)
+      subject.generate_starter_puppet_manifest
+    end
+  end
+end

data/spec/lib/boxci/config_permutation_component_factory_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Boxci::ConfigPermutationComponentFactory do
+  describe ".build" do
+    it "gets the constant for the config permutation component class" do
+      expect(Boxci::ConfigPermutationComponents).to receive(:const_get).with('Rbenv').and_return(double.as_null_object)
+      subject.build('rbenv', 'foo')
+    end
+
+    it "constructs a new instance of the config permutation component const it previously grabbed" do
+      comp = double
+      allow(Boxci::ConfigPermutationComponents).to receive(:const_get).with('Rbenv').and_return(comp)
+      expect(comp).to receive(:new)
+      subject.build('rbenv', 'foo')
+    end
+  end
+end

data/spec/lib/boxci/config_permutation_component_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Boxci::ConfigPermutationComponent do
+  subject { Boxci::ConfigPermutationComponent }
+
+  describe '#initialize' do
+    it 'assigns the given value to an instance variable' do
+      config_permutation_component = subject.new('foeue')
+      expect(config_permutation_component.instance_variable_get(:@val)).to eq('foeue')
+    end
+  end
+
+  describe '#switch_to_script' do
+    it 'raises exception stating it is pure virtual method' do
+      config_permutation_component = subject.new('foeue')
+      expect { config_permutation_component.switch_to_script }.to raise_error(Boxci::PureVirtualMethod)
+    end
+  end
+end

data/spec/lib/boxci/config_permutation_components/rbenv_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Boxci::ConfigPermutationComponents::Rbenv do
+  subject { Boxci::ConfigPermutationComponents::Rbenv }
+  
+  describe '#switch_to_script' do
+    it 'generates bash script to switch ruby verisons with rbenv' do
+      comp = subject.new('2.1.0')
+      expect(comp.switch_to_script).to eq("echo \"Switching to ruby 2.1.0\"\nrbenv local 2.1.0\necho \"Swithed to ruby `ruby --version`\"\n")
+    end
+  end
+end

data/spec/lib/boxci/config_permutation_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Boxci::ConfigPermutation do
+  describe "#initialize" do
+    it "constructs an instance of a Boxci::ConfigPermutation given an array of config permutation components" do
+      config_permutation_components = [double, double, double]
+      config_permutation = Boxci::ConfigPermutation.new(config_permutation_components)
+    end
+
+    it "assigns the given components array to an instance variable" do
+      config_permutation_components = [double, double, double]
+      config_permutation = Boxci::ConfigPermutation.new(config_permutation_components)
+      expect(config_permutation.instance_variable_get(:@components)).to eq(config_permutation_components)
+    end
+  end
+
+  describe "#switch_to_script" do
+    it "grabs the switch to scripts of each of the components and joins them together with newlines" do
+      comp1 = double(:switch_to_script => 'a')
+      comp2 = double(:switch_to_script => 'b')
+      comp3 = double(:switch_to_script => 'c')
+      config_permutation_components = [comp1, comp2, comp3]
+      config_permutation = Boxci::ConfigPermutation.new(config_permutation_components)
+      expect(config_permutation.switch_to_script).to eq("a\nb\nc")
+    end
+  end
+end