controlrepo 1.0.0

data/lib/controlrepo/beaker.rb

@@ -0,0 +1,185 @@
+class Controlrepo
+  class Beaker
+    def self.facts_to_vagrant_box(facts)
+      # Gets the most similar vagrant box to the facts set provided, will accept a single fact
+      # se or an array
+
+      if facts.is_a?(Array)
+        returnval = []
+        facts.each do |fact|
+          returnval << self.facts_to_vagrant_box(fact)
+        end
+        return returnval
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Ubuntu'
+          os = 'ubuntu'
+          version = facts['os']['distro']['release']['major']
+        end
+      rescue
+        # Do nothing, this is the easiest way to handle the hash bing in different formats
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Debian'
+          os = 'Debian'
+          version = facts['os']['distro']['release']['major']
+        end
+      rescue
+        # Do nothing
+      end
+
+      begin
+        if facts['os']['family'] == "RedHat"
+          os = 'centos'
+          version = "#{facts['os']['release']['major']}.#{facts['os']['release']['minor']}"
+        end
+      rescue
+        # Do nothing
+      end
+
+      return "UNKNOWN" unless os.is_a?(String)
+
+      if facts['os']['architecture'] =~ /64/
+        arch = '64'
+      else
+        arch = '32'
+      end
+
+      "puppetlabs/#{os}-#{version}-#{arch}-puppet"
+    end
+
+    # This will take a fact set and return the beaker platform of that machine
+    # This is necissary as beaker needs the platform set up correctly to know which
+    # commands to run when we do stuff. Personally I would prefer beaker to detect the
+    # platform as it would not be that hard, especially once puppet is installed, oh well.
+    def self.facts_to_platform(facts)
+      if facts.is_a?(Array)
+        returnval = []
+        facts.each do |fact|
+          returnval << self.facts_to_platform(fact)
+        end
+        return returnval
+      end
+
+      begin
+        if facts['os']['family'] == 'RedHat'
+          platform = 'el'
+          version = facts['os']['release']['major']
+        end
+      rescue
+        # Do nothing, this is the easiest way to handle the hash bing in different formats
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Ubuntu'
+          platform = 'ubuntu'
+          version = facts['os']['distro']['release']['major']
+        end
+      rescue
+        # Do nothing, this is the easiest way to handle the hash bing in different formats
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Debian'
+          platform = 'Debian'
+          version = facts['os']['distro']['release']['major']
+        end
+      rescue
+        # Do nothing
+      end
+
+      if facts['os']['architecture'] =~ /64/
+        arch = '64'
+      else
+        arch = '32'
+      end
+
+      "#{platform}-#{version}-#{arch}"
+    end
+
+    # This little method will deploy a Controlrepo object to a host, just using r10k deploy
+    def self.deploy_controlrepo_on(host, repo = Controlrepo.new())
+      require 'beaker-rspec'
+      require 'controlrepo'
+
+      if host.is_a?(Array)
+        hosts.each do |single_host|
+          deploy_controlrepo_on(single_host)
+        end
+      end
+
+      # Use a beaker helper to do the install (*nix only)
+      install_r10k_on(host)
+
+      # Use beaker to install git
+      host.install_package('git')
+
+      # copy the file over to the host (Maybe I should be changing the directory here??)
+      scp_to(host,repo.r10k_config_file,'/tmp/r10k.yaml')
+
+      # Do an r10k deploy
+      r10k_deploy(host,{
+        :puppetfile => true,
+        :configfile => '/tmp/r10k.yaml',
+        })
+    end
+
+    # This actually provisions a node and checks that puppet will be able to run and
+    # be idempotent. It hacks the beaker NetworkManager object to do this. The reason
+    # is that beaker is designed to run in the following order:
+    #   1. Spin up nodes
+    #   2. Run all tests
+    #   3. Kill all nodes
+    #
+    # This is not helpful for us. We want to be able to test all of our classes on
+    # all of our nodes, this could be a lot of vms and having them all running at once
+    # would be a real kick in the dick for whatever system was running it.
+    def self.provision_and_test(host,puppet_class,opts = {},repo = Controlrepo.new)
+      opts = {:runs_before_idempotency => 1}.merge(opts)
+      opts = {:check_idempotency => true}.merge(opts)
+      opts = {:deploy_controlrepo => true}.merge(opts)
+
+
+      raise "Hosts must be a single host object, not an array" if host.is_a?(Array)
+      raise "Class must be a single Class [String], not an array" unless puppet_class.is_a?(String)
+
+      # Create our own NWM object that we are going to interact with
+      # Note here that 'options', 'logger' and are exposed within the rspec tests
+      # if this is run outside of that context it will fail
+      network_manager = ::Beaker::NetworkManager.new(options,logger)
+
+      # Hack the network manager to smash our host in there without provisioning
+      network_manager.instance_variable_set(:@hosts,host)
+
+      # Now that we have a working network manager object, we can provision, but only if
+      # we need to, ahhh smart...
+      unless host.up?
+        network_manager.provision
+        network_manager.proxy_package_manager
+        network_manager.validate
+        network_manager.configure
+      end
+
+      if opts[:deploy_controlrepo]
+        # Get the code onto the host
+        Controlrepo::Beaker.deploy_controlrepo_on(host,repo)
+      end
+
+      # Actually run the tests
+      manifest = "include #{puppet_class}"
+
+      opts[:runs_before_idempotency].times do
+        apply_manifest_on(host,manifest,{:catch_failures => true})
+      end
+
+      if opts[:check_idempotency]
+        apply_manifest_on(host,manifest,{:catch_changes => true})
+      end
+
+      network_manager.cleanup
+    end
+
+  end
+end

data/lib/controlrepo/class.rb

@@ -0,0 +1,28 @@
+class Controlrepo
+  class Class
+    @@all = []
+
+    attr_accessor :name
+    def initialize(name)
+      @name = name
+      @@all << self
+    end
+
+    def self.find(class_name)
+      @@all.each do |cls|
+        if class_name.is_a?(Controlrepo::Class)
+          if cls = class_name
+            return cls
+          end
+        elsif cls.name == class_name
+          return cls
+        end
+      end
+      nil
+    end
+
+    def self.all
+      @@all
+    end
+  end
+end

data/lib/controlrepo/group.rb

@@ -0,0 +1,61 @@
+require 'controlrepo/class'
+require 'controlrepo/node'
+
+class Controlrepo
+  class Group
+    @@all = []
+
+    # Work out how to do class veriables so that I can keep track of all the groups easily
+    attr_accessor :name
+    attr_accessor :members
+
+    # You need to pass in an array of strings for members, not objects, it will find the objects
+    # by itself, and yes it will reference them, not just create additional ones, woo!
+    def initialize(name = nil, members = [])
+      @name = name
+      @members = []
+
+      if members.any?
+        member_objects = []
+        members.each do |member|
+          # Try to find the type for each member
+          if Controlrepo::Class.find(member)
+            member_objects << Controlrepo::Class.find(member)
+          elsif Controlrepo::Node.find(member)
+            member_objects << Controlrepo::Node.find(member)
+          else
+            raise "#{member} was not found in the list of nodes or classes!"
+          end
+        end
+
+        # Check that they are all the same type
+        if member_objects.all? { |item| item.is_a?(Controlrepo::Class) }
+          type = Controlrepo::Class
+        elsif member_objects.all? { |item| item.is_a?(Controlrepo::Node) }
+          type = Controlrepo::Node
+        else
+          raise 'Groups must contain either all nodes or all classes. Either there was a mix, or something was spelled wrong'
+        end
+
+        # Smash it into the instance variable
+        @members = member_objects
+      end
+
+      # Finally add it to the list of all grops
+      @@all << self
+    end
+
+    def self.find(group_name)
+      @@all.each do |group|
+        if group.name == group_name
+          return group
+        end
+      end
+      nil
+    end
+
+    def self.all
+      @@all
+    end
+  end
+end

data/lib/controlrepo/node.rb

@@ -0,0 +1,43 @@
+require 'controlrepo'
+
+class Controlrepo
+  class Node
+    @@all = []
+
+
+    attr_accessor :name
+    attr_accessor :beaker_node
+    attr_accessor :fact_set
+
+    def initialize(name)
+      @name = name
+      @beaker_node = nil
+
+      # If we can't find the factset it will fail, so just catch that error and ignore it
+      begin
+        @fact_set = Controlrepo.facts[(Controlrepo.facts_files.index{|facts_file| File.basename(facts_file,'.json') == name})]
+      rescue TypeError
+        @fact_set = nil
+      end
+      @@all << self
+
+    end
+
+    def self.find(node_name)
+      @@all.each do |node|
+        if node_name.is_a?(Controlrepo::Node)
+          if node = node_name
+            return node
+          end
+        elsif node.name == node_name
+          return node
+        end
+      end
+      nil
+    end
+
+    def self.all
+      @@all
+    end
+  end
+end

data/lib/controlrepo/rake_tasks.rb

@@ -0,0 +1,150 @@
+require 'controlrepo'
+require 'pathname'
+
+@repo = nil
+@config = nil
+
+task :generate_fixtures do
+  repo = Controlrepo.new
+  raise ".fixtures.yml already exits, we won't overwrite because we are scared" if File.exists?(File.expand_path('./.fixtures.yml',repo.root))
+  File.write(File.expand_path('./.fixtures.yml',repo.root),repo.fixtures)
+end
+
+task :hiera_setup do
+  repo = Controlrepo.new
+  current_config = repo.hiera_config
+  current_config.each do |key, value|
+    if value.is_a?(Hash)
+      if value.has_key?(:datadir)
+        current_config[key][:datadir] = Pathname.new(repo.hiera_data).relative_path_from(Pathname.new(File.expand_path('..',repo.hiera_config_file))).to_s
+      end
+    end
+  end
+  puts "Changing hiera config from \n#{repo.hiera_config}\nto\n#{current_config}"
+  repo.hiera_config = current_config
+end
+
+task :generate_nodesets do
+  require 'controlrepo/beaker'
+  require 'net/http'
+  require 'json'
+
+  repo = Controlrepo.new
+
+  begin
+    Dir.mkdir("#{repo.root}/spec/acceptance")
+    puts "Created #{repo.root}/spec/acceptance"
+  rescue Errno::EEXIST
+    # Do nothing, this is okay
+  end
+
+  begin
+    Dir.mkdir("#{repo.root}/spec/acceptance/nodesets")
+    puts "Created #{repo.root}/spec/acceptance/nodesets"
+  rescue Errno::EEXIST
+    # Do nothing, this is okay
+  end
+
+  facts = repo.facts
+  facts.each do |fact_set|
+    boxname = Controlrepo_beaker.facts_to_vagrant_box(fact_set)
+    platform = Controlrepo_beaker.facts_to_platform(fact_set)
+    response = Net::HTTP.get(URI.parse("https://atlas.hashicorp.com/api/v1/box/#{boxname}"))
+    url = 'URL goes here'
+
+    unless response =~ /404 Not Found/
+      box_info = JSON.parse(response)
+      box_info['current_version']['providers'].each do |provider|
+        if provider['name'] == 'virtualbox'
+          url = provider['original_url']
+        end
+      end
+    end
+
+    # Use an ERB template to write the files
+    template_dir = File.expand_path('../../templates',File.dirname(__FILE__))
+    fixtures_template = File.read(File.expand_path('./nodeset.yaml.erb',template_dir))
+    output_file = File.expand_path("spec/acceptance/nodesets/#{fact_set['fqdn']}.yml",repo.root)
+    if File.exists?(output_file) == false
+      File.write(output_file,ERB.new(fixtures_template, nil, '-').result(binding))
+      puts "Created #{output_file}"
+    else
+      puts "#{output_file} already exists, not going to overwrite because scared"
+    end
+  end
+end
+
+task :controlrepo_autotest_prep do
+  require 'controlrepo/testconfig'
+  @repo = Controlrepo.new
+  @config = Controlrepo::TestConfig.new("#{@repo.spec_dir}/controlrepo.yaml")
+
+  # Deploy r10k to a temp dir
+  @config.r10k_deploy_local(@repo)
+
+  # Create the other directories we need
+  FileUtils.mkdir_p("#{@repo.tempdir}/spec/classes")
+  FileUtils.mkdir_p("#{@repo.tempdir}/spec/acceptance/nodesets")
+
+  # Copy our nodesets over
+  FileUtils.cp_r("#{@repo.spec_dir}/acceptance/nodesets","#{@repo.tempdir}/spec/acceptance")
+
+  # Create the Rakefile so that we can take advantage of the existing tasks
+  @config.write_rakefile(@repo.tempdir, "spec/classes/**/*_spec.rb")
+
+  # Create spec_helper.rb
+  @config.write_spec_helper("#{@repo.tempdir}/spec",@repo)
+
+  # Create spec_helper_accpetance.rb
+  @config.write_spec_helper_acceptance("#{@repo.tempdir}/spec",@repo)
+
+  # Create Gemfile
+  @config.write_gemfile(@repo.tempdir)
+
+  # Deduplicate and write the tests (Spec and Acceptance)
+  Controlrepo::Test.deduplicate(@config.tests).each do |test|
+    @config.write_spec_test("#{@repo.tempdir}/spec/classes",test)
+    @config.write_acceptance_test("#{@repo.tempdir}/spec/acceptance",test)
+  end
+
+  # Parse the current hiera config, modify, and write it to the temp dir
+  hiera_config = @repo.hiera_config
+  hiera_config.each do |setting,value|
+    if value.is_a?(Hash)
+      if value.has_key?(:datadir)
+        hiera_config[setting][:datadir] = "#{@repo.temp_environmentpath}/#{@config.environment}/#{value[:datadir]}"
+      end
+    end
+  end
+  File.write("#{@repo.temp_environmentpath}/#{@config.environment}/hiera.yaml",hiera_config.to_yaml)
+
+  @config.create_fixtures_symlinks(@repo)
+end
+
+task :controlrepo_autotest_spec do
+  Dir.chdir(@repo.tempdir) do
+    #`bundle install --binstubs`
+    #`bin/rake spec_standalone`
+    exec("bundle install --binstubs; bundle exec rake spec_standalone")
+  end
+  # TODO: Look at how this outputs and see if it needs to be improved
+end
+
+task :controlrepo_spec => [
+  :controlrepo_autotest_prep,
+  :controlrepo_autotest_spec
+  ]
+
+task :r10k_deploy_local do
+  require 'controlrepo/testconfig'
+  @repo = Controlrepo.new
+  @config = Controlrepo::TestConfig.new("#{repo.spec_dir}/controlrepo.yaml")
+
+  # Deploy r10k to a temp dir
+  config.r10k_deploy_local(repo)
+end
+
+# TODO: We could use rspec's tagging abilities to choose which if the acceptance tests to run.
+
+
+