chef-sugar-ng 4.2.2

data/lib/chef/sugar/version.rb

@@ -0,0 +1,21 @@
+#
+# Copyright 2013-2015, Seth Vargo <sethvargo@gmail.com>
+#
+# 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.
+#
+
+class Chef
+  module Sugar
+    VERSION = '4.2.2'
+  end
+end

data/lib/chef/sugar/virtualization.rb

@@ -0,0 +1,151 @@
+#
+# Copyright 2014, Joseph J. Nuspl Jr. <nuspl@nvwls.com>
+#
+# 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.
+#
+
+class Chef
+  module Sugar
+    module Virtualization
+      extend self
+
+      #
+      # Determine if the current node is running under KVM.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running under KVM, false
+      #   otherwise
+      #
+      def kvm?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'kvm'
+      end
+
+      #
+      # Determine if the current node is running in a linux container.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running in a container, false
+      #   otherwise
+      #
+      def lxc?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'lxc'
+      end
+
+      #
+      # Determine if the current node is running under Parallels Desktop.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running under Parallels Desktop, false
+      #   otherwise
+      #
+      def parallels?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'Parallels'
+      end
+
+      #
+      # Determine if the current node is running under VirtualBox.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running under VirtualBox, false
+      #   otherwise
+      #
+      def virtualbox?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'vbox'
+      end
+
+      #
+      # Determine if the current node is running under VMware.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running under VMware, false
+      #   otherwise
+      #
+      def vmware?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'vmware'
+      end
+
+      #
+      # Determine if the current node is running under openvz.
+      #
+      # @param [Chef::Node] node
+      #
+      # @return [Boolean]
+      #   true if the machine is currently running under openvz, false
+      #   otherwise
+      #
+      def openvz?(node)
+        node.key?('virtualization') && node['virtualization']['system'] == 'openvz'
+      end
+
+      def virtual?(node)
+        openvz?(node) || vmware?(node) || virtualbox?(node) || parallels?(node) || lxc?(node) || kvm?(node)
+      end
+
+      def physical?(node)
+        !virtual?(node)
+      end
+    end
+
+    module DSL
+      # @see Chef::Sugar::Virtualization#kvm?
+      def kvm?
+        Chef::Sugar::Virtualization.kvm?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#lxc?
+      def lxc?
+        Chef::Sugar::Virtualization.lxc?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#parallels?
+      def parallels?
+        Chef::Sugar::Virtualization.parallels?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#virtualbox?
+      def virtualbox?
+        Chef::Sugar::Virtualization.virtualbox?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#vmware?
+      def vmware?
+        Chef::Sugar::Virtualization.vmware?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#openvz?
+      def openvz?
+        Chef::Sugar::Virtualization.openvz?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#virtual?
+      def virtual?
+        Chef::Sugar::Virtualization.virtual?(node)
+      end
+
+      # @see Chef::Sugar::Virtualization#physical?
+      def physical?
+        Chef::Sugar::Virtualization.physical?(node)
+      end
+    end
+  end
+end

data/libraries/chef-sugar.rb

@@ -0,0 +1 @@
+require "chef/sugar"

data/metadata.rb

@@ -0,0 +1,24 @@
+name             'chef-sugar'
+maintainer       'Seth Vargo'
+maintainer_email 'sethvargo@gmail.com'
+license          'Apache-2.0'
+description      'Installs chef-sugar. Please see the chef-sugar ' \
+                 'Ruby gem for more information.'
+long_description <<-EOH
+Chef Sugar is a Gem & Chef Recipe that includes series of helpful syntactic
+sugars on top of the Chef core and other resources to make a cleaner, more lean
+recipe DSL, enforce DRY principles, and make writing Chef recipes an awesome and
+fun experience!
+
+For the most up-to-date information and documentation, please visit the [Chef
+Sugar project page on GitHub](https://github.com/sethvargo/chef-sugar).
+EOH
+
+require          File.expand_path('../lib/chef/sugar/version', __FILE__)
+version          Chef::Sugar::VERSION
+
+supports     'any'
+issues_url   'https://github.com/sethvargo/chef-sugar/issues'
+source_url   'https://github.com/sethvargo/chef-sugar'
+chef_version '>= 12.10.48' if respond_to?(:chef_version)
+gem          'chef-sugar-ng'

data/recipes/default.rb

@@ -0,0 +1,20 @@
+#
+# Cookbook Name:: chef-sugar
+# Recipe:: default
+#
+# Copyright 2013-2015, Seth Vargo <sethvargo@gmail.com>
+#
+# 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.
+#
+
+Chef::Log.warn('chef-sugar::default no longer needs to be included in your runlist. Instead simply depend on the chef-sugar cookbook and the gem will be intalled and loaded automatically.')

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rspec'
+require 'chefspec'
+require 'chef/sugar'
+
+require_relative 'support/shared_examples'
+
+RSpec.configure do |config|
+  # Prohibit using the should syntax
+  config.expect_with :rspec do |spec|
+    spec.syntax = :expect
+  end
+
+  # Focus groups
+  config.filter_run(focus: true)
+  config.run_all_when_everything_filtered = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  # ChefSpec configuration
+  config.log_level = :fatal
+end

data/spec/support/shared_examples.rb

@@ -0,0 +1,20 @@
+module RSpec
+  shared_examples 'a chef sugar' do
+    it 'acts as a singleton' do
+      described_class.module_eval("def foo; 'result'; end")
+      klass = Class.new.tap { |k| k.send(:include, described_class) }
+      expect(described_class.foo).to eq(klass.new.foo)
+    end
+
+    described_class.instance_methods.each do |name|
+      it "defines a `#{name}` DSL method" do
+        expect(Chef::Sugar::DSL).to be_method_defined(name)
+      end
+
+      it 'has n-1 arity from the parent method' do
+        method = Chef::Sugar::DSL.instance_method(name)
+        expect(method.arity).to eq(described_class.method(name).arity - 1)
+      end
+    end
+  end
+end

data/spec/unit/chef/sugar/architecture_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Architecture do
+  it_behaves_like 'a chef sugar'
+
+  _64_bit_machines = %w(amd64 x86_64 ppc64 ppc64le s390x ia64 sparc64 aarch64 arch64 arm64 sun4u sun4v)
+  _intel_machines = %w(i86pc i386 x86_64 amd64 i686)
+
+  describe '#_64_bit?' do
+    _64_bit_machines.each do |arch|
+      it "returns true when the system is #{arch}" do
+        node = { 'kernel' => { 'machine' => arch } }
+        expect(described_class._64_bit?(node)).to be true
+      end
+    end
+
+    it 'returns true when ohai provides the bittiness' do
+      node = { 'kernel' => { 'bits' => '64' } }
+      expect(described_class._64_bit?(node)).to be true
+    end
+
+    it 'returns false when ohai provides the bittiness' do
+      node = { 'kernel' => { 'bits' => '32' } }
+      expect(described_class._64_bit?(node)).to be false
+    end
+
+    it 'returns false when the system is not 64 bit' do
+      node = { 'kernel' => { 'machine' => 'i386' } }
+      expect(described_class._64_bit?(node)).to be false
+    end
+  end
+
+  describe '#_32_bit?' do
+    it 'returns true when the system is 32 bit' do
+      node = { 'kernel' => { 'machine' => 'i386' } }
+      expect(described_class._32_bit?(node)).to be true
+    end
+
+    _64_bit_machines.each do |arch|
+      it "returns false when the system is #{arch}" do
+        node = { 'kernel' => { 'machine' => arch } }
+        expect(described_class._32_bit?(node)).to be false
+      end
+    end
+  end
+
+  describe '#i386?' do
+    it 'returns true when the system is 32 bit' do
+      node = { 'kernel' => { 'machine' => 'i386' } }
+      expect(described_class.i386?(node)).to be true
+    end
+
+    _64_bit_machines.each do |arch|
+      it "returns false when the system is #{arch}" do
+        node = { 'kernel' => { 'machine' => arch } }
+        expect(described_class.i386?(node)).to be false
+      end
+    end
+  end
+
+  describe '#intel?' do
+    _intel_machines.each do |arch|
+      it "returns true when the system is #{arch}" do
+        node = { 'kernel' => { 'machine' => arch } }
+        expect(described_class.intel?(node)).to be true
+      end
+
+      it 'returns false when the system is non Intel' do
+        node = { 'kernel' => { 'machine' => 'sun4u' } }
+        expect(described_class.intel?(node)).to be false
+      end
+    end
+  end
+
+  describe '#powerpc?' do
+    it 'returns true when the system is IBM POWER or powerpc' do
+      node = { 'kernel' => { 'machine' => 'powerpc' } }
+    end
+  end
+
+  describe '#armhf?' do
+    it 'returns true when the system is ARM' do
+      node = { 'kernel' => { 'machine' => 'armv7l' } }
+      expect(described_class.intel?(node)).to be false
+      expect(described_class.armhf?(node)).to be true
+    end
+  end
+
+  describe '#aarch64?' do
+    it 'returns true when the system is AArch64' do
+      node = { 'kernel' => { 'machine' => 'aarch64' } }
+      expect(described_class.intel?(node)).to be false
+      expect(described_class.aarch64?(node)).to be true
+    end
+  end
+
+  describe '#sparc?' do
+    it 'returns true when the system is SPARC sun4u' do
+      node = { 'kernel' => { 'machine' => 'sun4u' } }
+      expect(described_class.sparc?(node)).to be true
+    end
+
+    it 'returns true when the system is SPARC sun4v' do
+      node = { 'kernel' => { 'machine' => 'sun4v' } }
+      expect(described_class.sparc?(node)).to be true
+    end
+  end
+
+  describe '#ppc64?' do
+    it 'returns true when the system is PowerPC64 Big Endian' do
+      node = { 'kernel' => { 'machine' => 'ppc64' } }
+      expect(described_class.ppc64?(node)).to be true
+    end
+  end
+
+  describe '#ppc64le?' do
+    it 'returns true when the system is PowerPC64 Little Endian' do
+      node = { 'kernel' => { 'machine' => 'ppc64le' } }
+      expect(described_class.ppc64le?(node)).to be true
+    end
+  end
+
+  describe '#s390x?' do
+    it 'returns true when the system is s390x' do
+      node = { 'kernel' => { 'machine' => 's390x' } }
+      expect(described_class.s390x?(node)).to be true
+    end
+  end
+end

data/spec/unit/chef/sugar/cloud_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Chef::Sugar::Cloud do
+  it_behaves_like 'a chef sugar'
+
+  describe '#cloud?' do
+    it 'is true when the node is on cloud' do
+      node = { 'cloud' => nil }
+      expect(described_class.cloud?(node)).to be true
+    end
+
+    it 'is false when the node is not on cloud' do
+      node = {}
+      expect(described_class.cloud?(node)).to be false
+    end
+  end
+
+  describe '#ec2?' do
+    it 'is true when the node is on ec2' do
+      node = { 'ec2' => nil }
+      expect(described_class.ec2?(node)).to be true
+    end
+
+    it 'is false when the node is not on ec2' do
+      node = {}
+      expect(described_class.ec2?(node)).to be false
+    end
+  end
+
+  describe '#gce?' do
+    it 'is true when the node is on gce' do
+      node = { 'gce' => nil }
+      expect(described_class.gce?(node)).to be true
+    end
+
+    it 'is false when the node is not on gce' do
+      node = {}
+      expect(described_class.gce?(node)).to be false
+    end
+  end
+
+  describe '#rackspace?' do
+    it 'is true when the node is on rackspace' do
+      node = { 'rackspace' => nil }
+      expect(described_class.rackspace?(node)).to be true
+    end
+
+    it 'is false when the node is not on rackspace' do
+      node = {}
+      expect(described_class.rackspace?(node)).to be false
+    end
+  end
+
+  describe '#eucalyptus?' do
+    it 'is true when the node is on eucalyptus' do
+      node = { 'eucalyptus' => nil }
+      expect(described_class.eucalyptus?(node)).to be true
+    end
+
+    it 'is false when the node is not on eucalyptus' do
+      node = {}
+      expect(described_class.eucalyptus?(node)).to be false
+    end
+  end
+
+  describe '#euca?' do
+    it 'is true when the node is on eucalyptus' do
+      node = { 'eucalyptus' => nil }
+      expect(described_class.euca?(node)).to be true
+    end
+
+    it 'is false when the node is not on eucalyptus' do
+      node = {}
+      expect(described_class.euca?(node)).to be false
+    end
+  end
+
+  describe '#linode?' do
+    it 'is true when the node is on linode' do
+      node = { 'linode' => nil }
+      expect(described_class.linode?(node)).to be true
+    end
+
+    it 'is false when the node is not on linode' do
+      node = {}
+      expect(described_class.linode?(node)).to be false
+    end
+  end
+
+  describe '#openstack?' do
+    it 'is true when the node is on openstack' do
+      node = { 'openstack' => nil }
+      expect(described_class.openstack?(node)).to be true
+    end
+
+    it 'is false when the node is not on openstack' do
+      node = {}
+      expect(described_class.openstack?(node)).to be false
+    end
+  end
+
+  describe '#cloudstack?' do
+    it 'is true when the node is on cloudstack' do
+      node = { 'cloudstack' => nil }
+      expect(described_class.cloudstack?(node)).to be true
+    end
+
+    it 'is false when the node is not on cloudstack' do
+      node = {}
+      expect(described_class.cloudstack?(node)).to be false
+    end
+  end
+
+  describe '#azure?' do
+    it 'is true when the node is on azure' do
+      node = { 'azure' => nil }
+      expect(described_class.azure?(node)).to be true
+    end
+
+    it 'is false when the node is not on azure' do
+      node = {}
+      expect(described_class.azure?(node)).to be false
+    end
+  end
+
+  describe '#digitalocean?' do
+    it 'is true when the node is on digitalocean' do
+      node = { 'digital_ocean' => nil }
+      expect(described_class.digitalocean?(node)).to be true
+    end
+
+    it 'is false when the node is not on digitalocean' do
+      node = {}
+      expect(described_class.digitalocean?(node)).to be false
+    end
+  end
+
+  describe '#softlayer?' do
+    it 'is true when the node is on softlayer' do
+      node = { 'softlayer' => nil }
+      expect(described_class.softlayer?(node)).to be true
+    end
+
+    it 'is false when the node is not on softlayer' do
+      node = {}
+      expect(described_class.softlayer?(node)).to be false
+    end
+  end
+end