chef-dk 0.3.5 → 0.4.0

data/lib/chef-dk/command/update.rb

@@ -0,0 +1,106 @@
+#
+# Copyright:: Copyright (c) 2014 Chef Software Inc.
+# 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.
+#
+
+require 'chef-dk/command/base'
+require 'chef-dk/ui'
+require 'chef-dk/policyfile_services/install'
+
+module ChefDK
+  module Command
+
+    class Update < Base
+
+      banner(<<-BANNER)
+Usage: chef update [ POLICY_FILE ] [options]
+
+`chef update` reads your `Policyfile.rb`, applies any changes, re-solves the
+dependencies and emits an updated `Policyfile.lock.json`. The new locked policy
+will reflect any changes to the `run_list` and pull in any cookbook updates
+that are compatible with the version constraints stated in your `Policyfile.rb`.
+
+NOTE: `chef update` does not yet support granular updates (e.g., just updating
+the `run_list` or a specific cookbook version). Support will be added in a
+future version.
+
+The Policyfile feature is incomplete and beta quality. See our detailed README
+for more information.
+
+https://github.com/opscode/chef-dk/blob/master/POLICYFILE_README.md
+
+Options:
+
+BANNER
+
+      option :debug,
+        short:       "-D",
+        long:        "--debug",
+        description: "Enable stacktraces and other debug output",
+        default:     false
+
+      attr_reader :policyfile_relative_path
+
+      attr_accessor :ui
+
+      def initialize(*args)
+        super
+        @ui = UI.new
+
+        @policyfile_relative_path = nil
+        @installer = nil
+      end
+
+      def run(params = [])
+        apply_params!(params)
+        installer.run
+        0
+      rescue PolicyfileServiceError => e
+        handle_error(e)
+        1
+      end
+
+      def installer
+        @installer ||= PolicyfileServices::Install.new(policyfile: policyfile_relative_path, ui: ui, root_dir: Dir.pwd, overwrite: true)
+      end
+
+      def debug?
+        !!config[:debug]
+      end
+
+      def handle_error(error)
+        ui.err("Error: #{error.message}")
+        if error.respond_to?(:reason)
+          ui.err("Reason: #{error.reason}")
+          ui.err("")
+          ui.err(error.extended_error_info) if debug?
+          ui.err(error.cause.backtrace.join("\n")) if debug?
+        end
+      end
+
+      def apply_params!(params)
+        remaining_args = parse_options(params)
+        if remaining_args.size > 1
+          ui.err(banner)
+          return 1
+        else
+          @policyfile_relative_path = remaining_args.first
+        end
+      end
+
+    end
+  end
+end
+

data/lib/chef-dk/command/verify.rb

@@ -143,6 +143,78 @@ require 'spec_helper'
         end
       end
 
+      add_component "rubocop" do |c|
+        c.gem_base_dir = "rubocop"
+        c.smoke_test do
+          tmpdir do |cwd|
+            with_file(File.join(cwd, 'foo.rb')) do |f|
+              f.write <<-EOF
+def foo
+  puts 'foo'
+end
+              EOF
+            end
+            sh("rubocop foo.rb -l", cwd: cwd)
+          end
+        end
+      end
+
+      add_component "fauxhai" do |c|
+        c.gem_base_dir = "fauxhai"
+        c.smoke_test { sh("gem list fauxhai") }
+      end
+
+      add_component "knife-spork" do |c|
+        c.gem_base_dir = "knife-spork"
+        c.smoke_test { sh('knife spork info')}
+      end
+
+      add_component "kitchen-vagrant" do |c|
+        c.gem_base_dir = "kitchen-vagrant"
+        # The build is not passing in travis, so no tests
+        c.smoke_test { sh("gem list kitchen-vagrant") }
+      end
+
+      add_component "package installation" do |c|
+
+        c.base_dir = "chef-dk"
+
+        c.smoke_test do
+
+          if File.directory?("/usr/bin")
+            sh!("/usr/bin/berks -v")
+
+            sh!("/usr/bin/chef -v")
+
+            sh!("/usr/bin/chef-client -v")
+            sh!("/usr/bin/chef-solo -v")
+
+            # In `knife`, `knife -v` follows a different code path that skips
+            # command/plugin loading; `knife -h` loads commands and plugins, but
+            # it exits with code 1, which is the same as a load error. Running
+            # `knife exec` forces command loading to happen and this command
+            # exits 0, which runs most of the code.
+            #
+            # See also: https://github.com/opscode/chef-dk/issues/227
+            sh!("/usr/bin/knife exec -E true")
+
+            tmpdir do |dir|
+              # Kitchen tries to create a .kitchen dir even when just running
+              # `kitchen -v`:
+              sh!("/usr/bin/kitchen -v", cwd: dir)
+            end
+
+            sh!("/usr/bin/ohai -v")
+
+            sh!("/usr/bin/foodcritic -V")
+          end
+
+          # Test blocks are expected to return a Mixlib::ShellOut compatible
+          # object:
+          ComponentTest::NullTestResult.new
+        end
+      end
+
       attr_reader :verification_threads
       attr_reader :verification_results
       attr_reader :verification_status

data/lib/chef-dk/component_test.rb

@@ -88,6 +88,17 @@ module ChefDK
       system_command(command, combined_opts)
     end
 
+    # Just like #sh but raises an error if the the command returns an
+    # unexpected exit code.
+    #
+    # Most verification steps just run a single command, then
+    # ChefDK::Command::Verify#invoke_tests handles the results by inspecting
+    # the return value of the test block. For tests that run a lot of commands,
+    # this is inconvenient so you can use #sh! instead.
+    def sh!(*args)
+      sh(*args).tap { |result| result.error! }
+    end
+
     def run_in_tmpdir(command, options={})
       tmpdir do |dir|
         options[:cwd] = dir
@@ -103,7 +114,7 @@ module ChefDK
 
     def assert_present!
       unless File.exists?( component_path )
-        raise MissingComponentError.new(name)
+        raise MissingComponentError.new(name, component_path)
       end
     end
 

data/lib/chef-dk/configurable.rb

@@ -0,0 +1,52 @@
+#
+# Copyright:: Copyright (c) 2014 Chef Software Inc.
+# 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.
+#
+
+require 'chef/config'
+require 'chef/workstation_config_loader'
+
+# Define a config context for ChefDK
+class Chef::Config
+
+  default(:policy_document_native_api, false)
+
+  config_context(:chefdk) do
+
+    default(:generator_cookbook, File.expand_path("../skeletons/code_generator", __FILE__))
+
+  end
+end
+
+module ChefDK
+  module Configurable
+
+    def chef_config
+      return @chef_config if @chef_config
+      config_loader.load
+      @chef_config = Chef::Config
+    end
+
+    def chefdk_config
+      chef_config.chefdk
+    end
+
+    def config_loader
+      @config_loader ||= Chef::WorkstationConfigLoader.new(config[:config_file])
+    end
+
+  end
+end
+

data/lib/chef-dk/cookbook_metadata.rb

@@ -15,6 +15,7 @@
 # limitations under the License.
 #
 
+require 'chef-dk/exceptions'
 require 'chef/cookbook/metadata'
 
 module ChefDK
@@ -24,8 +25,16 @@ module ChefDK
   class CookbookMetadata < Chef::Cookbook::Metadata
 
     def self.from_path(path)
+      metadata_json_path = File.join(path, "metadata.json")
       metadata_rb_path = File.join(path, "metadata.rb")
-      new.tap { |m| m.from_file(metadata_rb_path) }
+
+      if File.exist?(metadata_json_path)
+        new.tap { |m| m.from_json(File.read(metadata_json_path)) }
+      elsif File.exist?(metadata_rb_path)
+        new.tap { |m| m.from_file(metadata_rb_path) }
+      else
+        raise MalformedCookbook, "Cookbook at #{path} has neither metadata.json or metadata.rb"
+      end
     end
 
     def cookbook_name

data/lib/chef-dk/cookbook_profiler/git.rb

@@ -74,7 +74,7 @@ module ChefDK
       end
 
       def have_remote?
-        !remote_name.empty?
+        !remote_name.empty? && remote_name != '.'
       end
 
       def current_branch

data/lib/chef-dk/exceptions.rb

@@ -39,8 +39,8 @@ module ChefDK
   end
 
   class MissingComponentError < RuntimeError
-    def initialize(component_name)
-      super("Component #{component_name} is missing.")
+    def initialize(component_name, path_checked)
+      super("Component #{component_name} is missing. \nReason: Could not find #{path_checked}.")
     end
   end
 
@@ -65,4 +65,19 @@ module ChefDK
   class InvalidPolicyfileFilename < StandardError
   end
 
+  class ChefRunnerError < StandardError
+
+    attr_reader :cause
+
+    def initialize(message, cause)
+      super(message)
+      @cause = cause
+    end
+
+  end
+
+  class CookbookNotFound < ChefRunnerError; end
+
+  class ChefConvergeError < ChefRunnerError; end
+
 end

data/lib/chef-dk/helpers.rb

@@ -96,9 +96,9 @@ module ChefDK
           user_bin_dir = File.expand_path(File.join(Gem.user_dir, 'bin'))
           {
             'PATH' => [ omnibus_bin_dir, user_bin_dir, omnibus_embedded_bin_dir, ENV['PATH'] ].join(File::PATH_SEPARATOR),
-            'GEM_ROOT' => Gem.default_dir.inspect,
+            'GEM_ROOT' => Gem.default_dir,
             'GEM_HOME' => Gem.user_dir,
-            'GEM_PATH' => Gem.path.join(':'),
+            'GEM_PATH' => Gem.path.join(File::PATH_SEPARATOR),
           }
         end
     end

data/lib/chef-dk/policyfile/community_cookbook_source.rb

@@ -31,7 +31,7 @@ module ChefDK
       attr_reader :uri
 
       def initialize(uri = nil)
-        @uri = uri || "https://supermarket.getchef.com"
+        @uri = uri || "https://supermarket.chef.io"
         @http_connections = {}
       end
 

data/lib/chef-dk/policyfile/dsl.rb

@@ -32,12 +32,15 @@ module ChefDK
       attr_reader :default_source
       attr_reader :cookbook_location_specs
 
+      attr_reader :named_run_lists
+
       attr_reader :storage_config
 
       def initialize(storage_config)
         @name = nil
         @errors = []
         @run_list = []
+        @named_run_lists = {}
         @default_source = NullCookbookSource.new
         @cookbook_location_specs = {}
         @storage_config = storage_config
@@ -56,6 +59,10 @@ module ChefDK
         @run_list
       end
 
+      def named_run_list(name, *run_list_items)
+        @named_run_lists[name] = run_list_items.flatten
+      end
+
       def default_source(source_type = nil, source_uri = nil)
         return @default_source if source_type.nil?
         case source_type

data/lib/chef-dk/policyfile/uploader.rb

@@ -34,21 +34,38 @@ module ChefDK
       attr_reader :http_client
       attr_reader :ui
 
-      def initialize(policyfile_lock, policy_group, ui: nil, http_client: nil)
+      def initialize(policyfile_lock, policy_group, ui: nil, http_client: nil, policy_document_native_api: false)
         @policyfile_lock = policyfile_lock
         @policy_group = policy_group
         @http_client = http_client
         @ui = ui || UI.null
+        @policy_document_native_api = policy_document_native_api
 
         @cookbook_versions_for_policy = nil
       end
 
+      def policy_name
+        policyfile_lock.name
+      end
+
       def upload
         ui.msg("WARN: Uploading policy to policy group #{policy_group} in compatibility mode")
 
         upload_cookbooks
-        data_bag_create
-        data_bag_item_create
+        upload_policy
+      end
+
+      def upload_policy
+        if using_policy_document_native_api?
+          upload_policy_native
+        else
+          data_bag_create
+          data_bag_item_create
+        end
+      end
+
+      def upload_policy_native
+        http_client.put("/policies/#{policy_group}/#{policy_name}", policyfile_lock.to_lock)
       end
 
       def data_bag_create
@@ -58,7 +75,7 @@ module ChefDK
       end
 
       def data_bag_item_create
-        policy_id = "#{policyfile_lock.name}-#{policy_group}"
+        policy_id = "#{policy_name}-#{policy_group}"
         lock_data = policyfile_lock.to_lock.dup
 
         lock_data["id"] = policy_id
@@ -114,6 +131,10 @@ module ChefDK
         end
       end
 
+      def using_policy_document_native_api?
+        @policy_document_native_api
+      end
+
       private
 
       def upload_cookbooks

data/lib/chef-dk/policyfile_compiler.rb

@@ -44,6 +44,8 @@ module ChefDK
 
     def_delegator :@dsl, :name
     def_delegator :@dsl, :run_list
+    def_delegator :@dsl, :named_run_list
+    def_delegator :@dsl, :named_run_lists
     def_delegator :@dsl, :errors
     def_delegator :@dsl, :default_source
     def_delegator :@dsl, :cookbook_location_specs
@@ -81,6 +83,20 @@ module ChefDK
       expanded_run_list.map { |i| normalize_recipe(i) }
     end
 
+    def expanded_named_run_lists
+      named_run_lists.inject({}) do |expanded, (name, run_list_items)|
+        expanded[name] = Chef::RunList.new(*run_list_items)
+        expanded
+      end
+    end
+
+    def normalized_named_run_lists
+      expanded_named_run_lists.inject({}) do |normalized,(name, run_list)|
+        normalized[name] = run_list.map { |i| normalize_recipe(i) }
+        normalized
+      end
+    end
+
     def lock
       @policyfile_lock ||= PolicyfileLock.build_from_compiler(self, storage_config)
     end
@@ -205,7 +221,11 @@ module ChefDK
     end
 
     def cookbooks_in_run_list
-      recipes = expanded_run_list.map {|recipe| recipe.name }
+      combined_run_lists = expanded_named_run_lists.values.inject(expanded_run_list.to_a) do |accum_run_lists, run_list|
+        accum_run_lists |= run_list.to_a
+      end
+
+      recipes = combined_run_lists.map {|recipe| recipe.name }
       recipes.map { |r| r[/^([^:]+)/, 1] }
     end