dop_common 0.13.0

data/lib/hiera/backend/dop_backend.rb

@@ -0,0 +1,94 @@
+#
+# DOP Plan Hiera Backend
+#
+
+class Hiera
+  module Backend
+
+    class Dop_backend
+
+      def initialize
+        Hiera.debug('Hiera DOP backend starting')
+        begin
+          require 'dop_common'
+        rescue
+          require 'rubygems'
+          require 'dop_common'
+        end
+
+        if Config[:dop].kind_of?(Hash)
+          @plan_store_dir ||= Config[:dop][:plan_store_dir]
+        end
+        @plan_store_dir ||= '/var/lib/dop/plans'
+
+        @plan_store = DopCommon::PlanStore.new(@plan_store_dir)
+        @plan_cache = DopCommon::PlanCache.new(@plan_store)
+        Hiera.debug('DOP Plan Cache Loaded')
+      end
+
+      def lookup(key, scope, order_override, resolution_type, context)
+        node_name = scope['::clientcert']
+        plan = @plan_cache.plan_by_node(node_name)
+
+        if plan.nil?
+          Hiera.debug("Node #{node_name} not found in any plan")
+          throw(:no_such_key)
+        else
+          Hiera.debug("Node #{node_name} found in plan #{plan.name}")
+          plan_lookup(plan, key, scope, order_override, resolution_type, context)
+        end
+      end
+
+      def plan_lookup(plan, key, scope, order_override, resolution_type, context)
+        answer = nil
+        found = false
+        extra_data = {}
+        context[:order_override] = order_override
+        Hiera::Backend.datasources(scope, order_override) do |source|
+          Hiera.debug("Looking for data source #{source}")
+          begin
+            data = plan.configuration.lookup(source, key, scope)
+            new_answer = Hiera::Backend.parse_answer(data, scope, extra_data, context)
+            found = true
+
+            case resolution_type.is_a?(Hash) ? :hash : resolution_type
+            when :array then answer = merge_array(answer, new_answer)
+            when :hash  then answer = merge_hash(answer, new_answer, resolution_type)
+            else
+              answer = new_answer
+              break
+            end
+
+          rescue DopCommon::ConfigurationValueNotFound
+            next
+          end
+        end
+        throw(:no_such_key) unless found
+        return answer
+      end
+
+    private
+
+      def merge_array(answer, new_answer)
+        answer ||= []
+        case new_answer
+        when Array then answer += new_answer
+        when String then answer << new_answer
+        else
+          raise "Hiera type mismatch: expected Array or String and got #{new_answer.class}"
+        end
+        return answer
+      end
+
+      def merge_hash(answer, new_answer, resolution_type)
+        answer ||= {}
+        answer = Hiera::Backend.merge_answer(new_answer, answer, resolution_type)
+        unless new_answer.kind_of?(Hash)
+          raise "Hiera type mismatch: expected Hash and got #{new_answer.class}"
+        end
+        return answer
+      end
+
+    end
+  end
+end

data/lib/hiera/dop_logger.rb

@@ -0,0 +1,20 @@
+#
+# Route Hiera Log entries to DOPi Logger
+#
+require 'dop_common'
+
+class Hiera
+  module Dop_logger
+    class << self
+
+      def warn(msg)
+        DopCommon.log.warn('Hiera: ' +msg)
+      end
+
+      def debug(msg)
+        DopCommon.log.debug('Hiera: ' + msg)
+      end
+
+    end
+  end
+end

data/spec/data/fake_hook_file_invalid

@@ -0,0 +1 @@
+# A fake hook file that is invalid, i.e. without executable permissions.

data/spec/data/fake_hook_file_valid

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+# A fake hook file that is , i.e. with executable permissions.
+
+uname -a

data/spec/data/fake_keyfile

@@ -0,0 +1 @@
+# this is a fake keyfile for tests.

data/spec/dop-puppet-autosign_spec_disable.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+#
+# This test does not run on ruby 1.8.7 because of the mixlib-shellout gem
+# and is therefor deactivated for now.
+#
+
+describe 'dop-puppet-autosign' do
+
+  before :each do
+    @tmpdir = '/tmp/dop-puppet-autosign-test'
+    @plan_store = DopCommon::PlanStore.new(@tmpdir)
+  end
+
+  after :each do
+    FileUtils.remove_entry_secure(@tmpdir)
+  end
+
+  let(:plan) { 'spec/fixtures/simple_plan.yaml' }
+
+  context 'There is no plan with the node in the plan store' do
+    command 'dop-puppet-autosign --plan_cache /tmp/dop-puppet-autosign-test linux01.example.com', :allow_error => true
+    its(:exitstatus) { is_expected.to_not eq 0 }
+  end
+  context 'The node is in one of the plans in the plan store' do
+    before do
+      @plan_store.add(plan)
+    end
+    command 'dop-puppet-autosign --plan_cache /tmp/dop-puppet-autosign-test linux01.example.com'
+    its(:exitstatus) { is_expected.to eq 0 }
+  end
+end
+

data/spec/dop_common/affinity_group_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe DopCommon::AffinityGroup do
+
+  describe '#positive' do
+    it "will return 'true' if the affinity group is positive and 'false' if it is not" do
+      affinity_group = DopCommon::AffinityGroup.new('ag', {'positive' => true, 'enforce' => true, 'cluster' => 'cl'})
+      expect(affinity_group.positive).to eq(true)
+      affinity_group = DopCommon::AffinityGroup.new('ag', {'positive' => false, 'enforce' => true, 'cluster' => 'cl'})
+      expect(affinity_group.positive).to eq(false)
+    end
+    it 'will raise an error if the flag is not specified correctly' do
+      affinity_group = DopCommon::AffinityGroup.new('ag', {})
+      expect { affinity_group.positive }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#enforce' do
+    it "will return 'true' if the affinity group should be enforced and 'false' if it shouldn't" do
+      affinity_group = DopCommon::AffinityGroup.new('ag', {'positive' => true, 'enforce' => true, 'cluster' => 'cl'})
+      expect(affinity_group.enforce).to eq(true)
+      affinity_group = DopCommon::AffinityGroup.new('ag', {'positive' => false, 'enforce' => false, 'cluster' => 'cl'})
+      expect(affinity_group.enforce).to eq(false)
+    end
+    it 'will raise an error if the flag is not specified correctly' do
+      affinity_group = DopCommon::AffinityGroup.new('ag', {})
+      expect { affinity_group.enforce }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#cluster' do
+    it 'will return the cluster name of the affinity group' do
+      affinity_group = DopCommon::AffinityGroup.new('ag', {'positive' => true, 'enforce' => true, 'cluster' => 'cl'})
+      expect(affinity_group.cluster).to eq('cl')
+    end
+    it 'will raise an error in case of invalid cluster specification' do
+      affinity_group = DopCommon::AffinityGroup.new('ag', {})
+      expect { affinity_group.cluster }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+end

data/spec/dop_common/command_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe DopCommon::Command do
+
+  describe '#plugin' do
+    it 'returns the name of the plugin' do
+      command = DopCommon::Command.new({:plugin => 'dummy'})
+      expect(command.plugin).to eq 'dummy'
+      command = DopCommon::Command.new('dummy')
+      expect(command.plugin).to eq 'dummy'
+    end
+    it 'throws an exception if the the plugin name is not correctly specified' do
+      command = DopCommon::Command.new(1)
+      expect{command.plugin}.to raise_error DopCommon::PlanParsingError
+      command = DopCommon::Command.new('')
+      expect{command.plugin}.to raise_error DopCommon::PlanParsingError
+      command = DopCommon::Command.new({})
+      expect{command.plugin}.to raise_error DopCommon::PlanParsingError
+      command = DopCommon::Command.new({:plugin => 1})
+      expect{command.plugin}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#plugin_timeout' do
+    it 'returns the plugin timeout if specified' do
+      command = DopCommon::Command.new({:plugin_timeout => 200})
+      expect(command.plugin_timeout).to eq 200
+    end
+    it 'returns the default timeout if nothing is specified' do
+      command = DopCommon::Command.new({})
+      expect(command.plugin_timeout).to eq 300
+    end
+    it 'throws an exception if the value is not correctly specified' do
+      command = DopCommon::Command.new({:plugin_timeout => 'foo'})
+      expect{command.plugin_timeout}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#verify_command' do
+    it 'returns an array of command instances if specified right' do
+      command = DopCommon::Command.new({:verify_commands => 'dummy'})
+      expect(command.verify_commands).to be_an_instance_of Array
+      expect(command.verify_commands.length).to be 1
+      expect(command.verify_commands.all?{|x| x.class == DopCommon::Command}).to be true
+      command = DopCommon::Command.new({:verify_commands => {:plugin => 'dummy'}})
+      expect(command.verify_commands).to be_an_instance_of Array
+      expect(command.verify_commands.length).to be 1
+      expect(command.verify_commands.all?{|x| x.class == DopCommon::Command}).to be true
+      command = DopCommon::Command.new({:verify_commands => ['dummy', {:plugin => 'dummy'}]})
+      expect(command.verify_commands).to be_an_instance_of Array
+      expect(command.verify_commands.length).to be 2
+      expect(command.verify_commands.all?{|x| x.class == DopCommon::Command}).to be true
+    end
+    it 'returns an empty array if nothing is specified' do
+      command = DopCommon::Command.new({})
+      expect(command.verify_commands).to be_an_instance_of Array
+      expect(command.verify_commands.length).to be 0
+    end
+     it 'throws an exception if the value is not correctly specified' do
+      command = DopCommon::Command.new({:verify_commands => 1})
+      expect{command.verify_commands}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#verify_after_run' do
+    it 'returns false if verify_after_run is not defined' do
+      command = DopCommon::Command.new({})
+      expect(command.verify_after_run).to be false
+    end
+    it 'returns the correct value if set correctly' do
+      command = DopCommon::Command.new({:verify_after_run => true})
+      expect(command.verify_after_run).to be true
+      command = DopCommon::Command.new({:verify_after_run => false})
+      expect(command.verify_after_run).to be false
+    end
+    it 'raises an exeption if the value is not valid' do
+      command = DopCommon::Command.new({:verify_after_run => 2})
+      expect{command.verify_after_run}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+end
+

data/spec/dop_common/credential_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'securerandom'
+require 'tempfile'
+
+describe DopCommon::Credential do
+
+  describe '#type' do
+    it 'returns the type if specified correctly (username_password)' do
+      credential = DopCommon::Credential.new('test', {:type => :username_password, :username => 'a', :password => 'b'})
+      expect(credential.type).to eq :username_password
+    end
+    it 'returns the type if specified correctly (kerberos)' do
+      credential = DopCommon::Credential.new('test', {:type => :kerberos, :realm => 'a',})
+      expect(credential.type).to eq :kerberos
+    end
+    it 'returns the type if specified correctly (ssh_key)' do
+      credential = DopCommon::Credential.new('test', {:type => :ssh_key, :username => 'a', :private_key => 'spec/data/fake_keyfile'})
+      expect(credential.type).to eq :ssh_key
+    end
+    it 'will raise an exception if the type is missing' do
+      credential = DopCommon::Credential.new('test', {})
+      expect{credential.type}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an exception if the type is not valid' do
+      credential = DopCommon::Credential.new('test', {:type => :non_existing_type})
+      expect{credential.type}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  [:username, :realm, :service].each do |key|
+    describe '#' + key.to_s do
+      it "returns a #{key} if one is correctly specified" do
+        credential = DopCommon::Credential.new('test', {key => 'a'})
+        expect(credential.send(key)).to eq 'a'
+      end
+      it "returns nil if #{key} is not specified" do
+        credential = DopCommon::Credential.new('test', {})
+        expect(credential.send(key)).to be nil
+      end
+      it "raises an exception if #{key} is not a string" do
+        credential = DopCommon::Credential.new('test', {key => []})
+        expect{credential.send(key)}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  [:password, :keytab, :public_key, :private_key].each do |key|
+    describe '#' + key.to_s do
+      it "returns the content if correctly specified as a string" do
+        credential = DopCommon::Credential.new('test', {key => 'my secret'})
+        expect(credential.send(key)).to eq 'my secret'
+      end
+      it 'returns the content if correctly specified as a file' do
+        key_file = Tempfile.new('secret_file', ENV['HOME'])
+        key_file.write("my secret")
+        key_file.close
+        credential = DopCommon::Credential.new('test', {key => {'file' => key_file.path}})
+        expect(credential.send(key)).to eq 'my secret'
+        key_file.delete
+      end
+      it "returns nil if #{key} is not specified" do
+        credential = DopCommon::Credential.new('test', {})
+        expect(credential.send(key)).to be nil
+      end
+      it "raises an exception if the file does not exist" do
+        credential = DopCommon::Credential.new('test', {key => {'file' => 'spec/data/nonexisting_keyfile'}})
+        expect{credential.send(key)}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+end
+

data/spec/dop_common/data_disk_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe DopCommon::DataDisk do
+  before(:all) do
+    @infrastructures = {
+      'rhev' => DopCommon::Infrastructure.new('rhev', {
+        'type' => 'rhev'
+      }),
+      'rhos' => DopCommon::Infrastructure.new('rhos', {
+        'type' => 'rhos'
+      }),
+      'baremetal' => DopCommon::Infrastructure.new('baremetal', {
+        'type' => 'baremetal'
+      }),
+      'vsphere' => DopCommon::Infrastructure.new('vsphere', {
+        'type' => 'vsphere'
+      }),
+    }
+  end
+
+  describe '#pool' do
+    %w(rhev vsphere rhos baremetal).each do |provider|
+      properties = case provider
+        when 'rhos'; { 'tenant' => 'foo' }
+        when 'baremetal'; {}
+        else { 'datacenter' => 'foo', 'cluster' => 'bar' }
+      end
+      it "will return pool's name if specified properly for provider #{provider}" do
+        data_disk = DopCommon::DataDisk.new('foo',
+          { 'pool' => 'foo' },
+          {
+            :parsed_infrastructure => @infrastructures[provider],
+            :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+              properties,
+              @infrastructures[provider]
+            )
+          }
+        )
+        expect(data_disk.pool).to eq 'foo'
+      end
+      it "will return default pool's if specified properly for provider #{provider} " do
+        data_disk = DopCommon::DataDisk.new('foo', {},
+          {
+            :parsed_infrastructure => @infrastructures[provider],
+            :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+              properties.merge('default_pool' => 'bar'),
+              @infrastructures[provider]
+            )
+          }
+        )
+        expect(data_disk.pool).to eq 'bar'
+      end
+      it %w(rhos baremetal).include?(provider) ?
+        "will return nil if unspecified because it is optional for provider #{provider}" :
+        "will raise an error if unspecified because it is required for provider #{provider}" do
+          data_disk = DopCommon::DataDisk.new('foo', {},
+            {
+              :parsed_infrastructure => @infrastructures[provider],
+              :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+                properties,
+                @infrastructures[provider]
+              )
+            }
+          )
+          %w(rhos baremetal).include?(provider) ?
+            (expect(data_disk.pool).to eq nil) :
+            (expect{data_disk.pool}.to raise_error DopCommon::PlanParsingError)
+      end
+      [[], {}, :invalid, 2].each do |pool_val|
+        it "will raise an error if not specified properly" do
+          data_disk = DopCommon::DataDisk.new('foo',
+            { 'pool' => pool_val},
+            {
+              :parsed_infrastructure => @infrastructures[provider],
+              :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+                properties,
+                @infrastructures[provider]
+              )
+            }
+          )
+          expect{data_disk.pool}.to raise_error DopCommon::PlanParsingError
+        end
+      end
+    end
+  end
+
+  describe '#size' do
+    ['1000K', '1000M', '10G', '1000KB', '1000MB', '1000GB'].each do |size|
+      it 'will return DopCommon::Utils::DataSize object if specified properly' do
+        data_disk = DopCommon::DataDisk.new('foo',
+          { 'size' => size },
+          {
+            :parsed_infrastructure => @infrastructures['baremetal'],
+            :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+              {},
+              @infrastructures['baremetal']
+            )
+          }
+        )
+        expect(data_disk.size).to be_an_instance_of(DopCommon::Utils::DataSize)
+      end
+    end
+    [nil, [], {}].each do |size|
+      it 'will raise an exception if not specified properly' do
+        data_disk = DopCommon::DataDisk.new('foo',
+          { 'size' => size },
+          {
+            :parsed_infrastructure => @infrastructures['baremetal'],
+            :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+              {},
+              @infrastructures['baremetal']
+            )
+          }
+        )
+        expect{data_disk.size}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#thin?' do
+    it 'will return true if not explicitly defined' do
+      data_disk = DopCommon::DataDisk.new('foo',
+        {},
+        {
+          :parsed_infrastructure => @infrastructures['baremetal'],
+          :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+            {},
+            @infrastructures['baremetal']
+          )
+        }
+      )
+      expect(data_disk.thin?).to be true
+    end
+    [true, false].each do |thin_val|
+      it 'will return true or false if specified properly' do
+        data_disk = DopCommon::DataDisk.new('foo',
+          { 'thin' => thin_val },
+          {
+            :parsed_infrastructure => @infrastructures['baremetal'],
+            :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+              {},
+              @infrastructures['baremetal']
+            )
+          }
+        )
+        expect(data_disk.thin?).to be thin_val
+      end
+    end
+  end
+  ['true', 'false', nil, [], {}, :true, :false].each do |thin_val|
+      it "will raise an error if isn't specified properly" do
+        data_disk = DopCommon::DataDisk.new('foo',
+          { 'thin' => thin_val },
+          {
+            :parsed_infrastructure => @infrastructures['baremetal'],
+            :parsed_infrastructure_properties => DopCommon::InfrastructureProperties.new(
+              {},
+              @infrastructures['baremetal']
+            )
+          }
+        )
+        expect{data_disk.thin?}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+end

data/spec/dop_common/dns_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe DopCommon::DNS do
+  describe '#name_servers' do
+    it "will return list of name servers' IP addresses if specified correctly" do
+      dns = DopCommon::DNS.new(nil)
+      expect(dns.name_servers).to eq([])
+      dns = DopCommon::DNS.new({'name_servers' => ['10.0.1.1', '172.16.2.1']})
+      expect(dns.name_servers).to eq(['10.0.1.1', '172.16.2.1'])
+    end
+    it 'will raise an exception of not specified properly' do
+      [nil, {}, [], 'aaa.bbb.ccc', '1.2.3.300'].each do |val|
+        dns = DopCommon::DNS.new({'name_servers' => val})
+        expect { dns.name_servers }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#search_domains' do
+    it "will return list of search domains if specified correctly" do
+      dns = DopCommon::DNS.new(nil)
+      expect(dns.search_domains).to eq([])
+      dns = DopCommon::DNS.new({'search_domains' => ['foo', 'foo.bar']})
+      expect(dns.search_domains).to eq(['foo', 'foo.bar'])
+    end
+    it 'will raise an exception of not specified properly' do
+      [nil, [], {}, '-foo.bar.baz', 'foo.b.c', 'f', 1].each do |val|
+        dns = DopCommon::DNS.new({'search_domains' => val})
+        expect { dns.search_domains }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+end