chef 12.0.3 → 12.1.0.rc.0

data/lib/chef/application/knife.rb

@@ -20,7 +20,6 @@ require 'chef/application'
 require 'mixlib/log'
 require 'ohai/config'
 require 'chef/monkey_patches/net_http.rb'
-require 'chef/monkey_patches/uri.rb'
 
 class Chef::Application::Knife < Chef::Application
 
@@ -64,7 +63,7 @@ class Chef::Application::Knife < Chef::Application
     :long         => "--disable-editing",
     :description  => "Do not open EDITOR, just accept the data as is",
     :boolean      => true,
-    :defaut       => false
+    :default       => false
 
   option :help,
     :short        => "-h",

data/lib/chef/application/solo.rb

@@ -99,6 +99,11 @@ class Chef::Application::Solo < Chef::Application
       :proc => lambda { |p| true }
   end
 
+  option :lockfile,
+    :long         => "--lockfile LOCKFILE",
+    :description  => "Set the lockfile location. Prevents multiple processes from converging at the same time",
+    :proc         => nil
+
   option :interval,
     :short => "-i SECONDS",
     :long => "--interval SECONDS",
@@ -160,6 +165,11 @@ class Chef::Application::Solo < Chef::Application
     :description  => 'Enable whyrun mode',
     :boolean      => true
 
+  option :ez,
+    :long         => '--ez',
+    :description  => 'A memorial for Ezra Zygmuntowicz',
+    :boolean      => true
+
   option :environment,
     :short        => '-E ENVIRONMENT',
     :long         => '--environment ENVIRONMENT',
@@ -179,6 +189,8 @@ class Chef::Application::Solo < Chef::Application
   def reconfigure
     super
 
+    set_specific_recipes
+
     Chef::Config[:solo] = true
 
     if Chef::Config[:daemonize]
@@ -191,6 +203,8 @@ class Chef::Application::Solo < Chef::Application
       cookbooks_path = Array(Chef::Config[:cookbook_path]).detect{|e| e =~ /\/cookbooks\/*$/ }
       recipes_path = File.expand_path(File.join(cookbooks_path, '..'))
 
+      Chef::Log.debug "Cleanup path #{recipes_path} before extract recipes into it"
+      FileUtils.rm_rf(recipes_path, :secure => true)
       Chef::Log.debug "Creating path #{recipes_path} to extract recipes into"
       FileUtils.mkdir_p(recipes_path)
       tarball_path = File.join(recipes_path, 'recipes.tgz')
@@ -204,6 +218,9 @@ class Chef::Application::Solo < Chef::Application
       config_fetcher = Chef::ConfigFetcher.new(Chef::Config[:json_attribs])
       @chef_client_json = config_fetcher.fetch_json
     end
+
+    # Disable auditing for solo
+    Chef::Config[:audit_mode] = :disabled
   end
 
   def setup_application
@@ -211,6 +228,7 @@ class Chef::Application::Solo < Chef::Application
   end
 
   def run_application
+    for_ezra if Chef::Config[:ez]
     if !Chef::Config[:client_fork] || Chef::Config[:once]
       # Run immediately without interval sleep or splay
       begin
@@ -225,7 +243,19 @@ class Chef::Application::Solo < Chef::Application
     end
   end
 
+
   private
+
+  def for_ezra
+    puts <<-EOH
+For Ezra Zygmuntowicz:
+  The man who brought you Chef Solo
+  Early contributor to Chef
+  Kind hearted open source advocate
+  Rest in peace, Ezra.
+EOH
+  end
+
   def interval_run_chef_client
     if Chef::Config[:daemonize]
       Chef::Daemon.daemonize("chef-client")

data/lib/chef/application/windows_service.rb

@@ -26,6 +26,7 @@ require 'chef/log'
 require 'chef/rest'
 require 'mixlib/cli'
 require 'socket'
+require 'uri'
 require 'win32/daemon'
 require 'chef/mixin/shell_out'
 

data/lib/chef/application/windows_service_manager.rb

@@ -16,7 +16,9 @@
 # limitations under the License.
 #
 
-require 'win32/service'
+if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+  require 'win32/service'
+end
 require 'chef/config'
 require 'mixlib/cli'
 
@@ -88,6 +90,8 @@ class Chef
         @service_display_name = service_options[:service_display_name]
         @service_description = service_options[:service_description]
         @service_file_path = service_options[:service_file_path]
+        @service_start_name = service_options[:run_as_user]
+        @password = service_options[:run_as_password]
       end
 
       def run(params = ARGV)
@@ -116,7 +120,9 @@ class Chef
                                  # and we don't want that, so we need to override the service type.
                                  :service_type     => ::Win32::Service::SERVICE_WIN32_OWN_PROCESS,
                                  :start_type       => ::Win32::Service::SERVICE_AUTO_START,
-                                 :binary_path_name => cmd
+                                 :binary_path_name => cmd,
+                                 :service_start_name => @service_start_name,
+                                 :password => @password,
                                  )
             puts "Service '#{@service_name}' has successfully been installed."
           end

data/lib/chef/applications.rb

@@ -1,4 +1,3 @@
-require 'chef/application/agent'
 require 'chef/application/client'
 require 'chef/application/knife'
 require 'chef/application/solo'

data/lib/chef/audit/audit_event_proxy.rb

@@ -0,0 +1,93 @@
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# 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.
+#
+
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+
+class Chef
+  class Audit
+    class AuditEventProxy < ::RSpec::Core::Formatters::BaseFormatter
+      ::RSpec::Core::Formatters.register self, :stop, :example_group_started
+
+      # TODO I don't like this, but I don't see another way to pass this in
+      # see rspec files configuration.rb#L671 and formatters.rb#L129
+      def self.events=(events)
+        @@events = events
+      end
+
+      def events
+        @@events
+      end
+
+      def example_group_started(notification)
+        if notification.group.parent_groups.size == 1
+          # top level `control_group` block
+          desc = notification.group.description
+          Chef::Log.debug("Entered `control_group` block named #{desc}")
+          events.control_group_started(desc)
+        end
+      end
+
+      def stop(notification)
+        Chef::Log.info("Successfully executed all `control_group` blocks and contained examples")
+        notification.examples.each do |example|
+          control_group_name, control_data = build_control_from(example)
+          e = example.exception
+          if e
+            events.control_example_failure(control_group_name, control_data, e)
+          else
+            events.control_example_success(control_group_name, control_data)
+          end
+        end
+      end
+
+      private
+
+      def build_control_from(example)
+        described_class = example.metadata[:described_class]
+        if described_class
+          resource_type = described_class.class.name.split(':')[-1]
+          resource_name = described_class.name
+        end
+
+        # The following code builds up the context - the list of wrapping `describe` or `control` blocks
+        describe_groups = []
+        group = example.metadata[:example_group]
+        # If the innermost block has a resource instead of a string, don't include it in context
+        describe_groups.unshift(group[:description]) if described_class.nil?
+        group = group[:parent_example_group]
+        while !group.nil?
+          describe_groups.unshift(group[:description])
+          group = group[:parent_example_group]
+        end
+
+        # We know all of our examples each live in a top-level `control_group` block - get this name now
+        outermost_group_desc = describe_groups.shift
+
+        return outermost_group_desc, {
+            :name => example.description,
+            :desc => example.full_description,
+            :resource_type => resource_type,
+            :resource_name => resource_name,
+            :context => describe_groups,
+            :line_number => example.metadata[:line_number]
+        }
+      end
+
+    end
+  end
+end

data/lib/chef/audit/audit_reporter.rb

@@ -0,0 +1,169 @@
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# 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/event_dispatch/base'
+require 'chef/audit/control_group_data'
+require 'time'
+
+class Chef
+  class Audit
+    class AuditReporter < EventDispatch::Base
+
+      attr_reader :rest_client, :audit_data, :ordered_control_groups, :run_status
+      private :rest_client, :audit_data, :ordered_control_groups, :run_status
+
+      PROTOCOL_VERSION = '0.1.1'
+
+      def initialize(rest_client)
+        @rest_client = rest_client
+        # Ruby 1.9.3 and above "enumerate their values in the order that the corresponding keys were inserted."
+        @ordered_control_groups = Hash.new
+      end
+
+      def run_context
+        run_status.run_context
+      end
+
+      def audit_phase_start(run_status)
+        Chef::Log.debug("Audit Reporter starting")
+        @audit_data = AuditData.new(run_status.node.name, run_status.run_id)
+        @run_status = run_status
+      end
+
+      def audit_phase_complete
+        Chef::Log.debug("Audit Reporter completed successfully without errors.")
+        ordered_control_groups.each do |name, control_group|
+          audit_data.add_control_group(control_group)
+        end
+      end
+
+      # If the audit phase failed, its because there was some kind of error in the framework
+      # that runs tests - normal errors are interpreted as EXAMPLE failures and captured.
+      # We still want to send available audit information to the server so we process the
+      # known control groups.
+      def audit_phase_failed(error)
+        # The stacktrace information has already been logged elsewhere
+        Chef::Log.debug("Audit Reporter failed.")
+        ordered_control_groups.each do |name, control_group|
+          audit_data.add_control_group(control_group)
+        end
+      end
+
+      def run_completed(node)
+        post_auditing_data
+      end
+
+      def run_failed(error)
+        post_auditing_data(error)
+      end
+
+      def control_group_started(name)
+        if ordered_control_groups.has_key?(name)
+          raise Chef::Exceptions::AuditControlGroupDuplicate.new(name)
+        end
+        metadata = run_context.audits[name].metadata
+        ordered_control_groups.store(name, ControlGroupData.new(name, metadata))
+      end
+
+      def control_example_success(control_group_name, example_data)
+        control_group = ordered_control_groups[control_group_name]
+        control_group.example_success(example_data)
+      end
+
+      def control_example_failure(control_group_name, example_data, error)
+        control_group = ordered_control_groups[control_group_name]
+        control_group.example_failure(example_data, error.message)
+      end
+
+      # If @audit_enabled is nil or true, we want to run audits
+      def auditing_enabled?
+        Chef::Config[:audit_mode] != :disabled
+      end
+
+      private
+
+      def post_auditing_data(error = nil)
+        unless auditing_enabled?
+          Chef::Log.debug("Audit Reports are disabled. Skipping sending reports.")
+          return
+        end
+
+        unless run_status
+          Chef::Log.debug("Run failed before audits were initialized, not sending audit report to server")
+          return
+        end
+
+        audit_data.start_time = iso8601ify(run_status.start_time)
+        audit_data.end_time = iso8601ify(run_status.end_time)
+
+        audit_history_url = "controls"
+        Chef::Log.debug("Sending audit report (run-id: #{audit_data.run_id})")
+        run_data = audit_data.to_hash
+
+        if error
+          run_data[:error] = "#{error.class.to_s}: #{error.message}\n#{error.backtrace.join("\n")}"
+        end
+
+        Chef::Log.debug "Audit Report:\n#{Chef::JSONCompat.to_json_pretty(run_data)}"
+        # Since we're posting compressed data we can not directly call post_rest which expects JSON
+        begin
+          audit_url = rest_client.create_url(audit_history_url)
+          rest_client.post(audit_url, run_data, headers)
+        rescue StandardError => e
+          if e.respond_to? :response
+            # 404 error code is OK. This means the version of server we're running against doesn't support
+            # audit reporting. Don't alarm failure in this case.
+            if e.response.code == "404"
+              Chef::Log.debug("Server doesn't support audit reporting. Skipping report.")
+              return
+            else
+              # Save the audit report to local disk
+              error_file = "failed-audit-data.json"
+              Chef::FileCache.store(error_file, Chef::JSONCompat.to_json_pretty(run_data), 0640)
+              Chef::Log.error("Failed to post audit report to server. Saving report to #{Chef::FileCache.load(error_file, false)}")
+            end
+          else
+            Chef::Log.error("Failed to post audit report to server (#{e})")
+          end
+
+          if Chef::Config[:enable_reporting_url_fatals]
+            Chef::Log.error("Reporting fatals enabled. Aborting run.")
+            raise
+          end
+        end
+      end
+
+      def headers(additional_headers = {})
+        options = {'X-Ops-Audit-Report-Protocol-Version' => PROTOCOL_VERSION}
+        options.merge(additional_headers)
+      end
+
+      def encode_gzip(data)
+        "".tap do |out|
+          Zlib::GzipWriter.wrap(StringIO.new(out)){|gz| gz << data }
+        end
+      end
+
+      def iso8601ify(time)
+        time.utc.iso8601.to_s
+      end
+
+    end
+  end
+end

data/lib/chef/audit/control_group_data.rb

@@ -0,0 +1,140 @@
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# 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 'securerandom'
+
+class Chef
+  class Audit
+    class AuditData
+      attr_reader :node_name, :run_id, :control_groups
+      attr_accessor :start_time, :end_time
+
+      def initialize(node_name, run_id)
+        @node_name = node_name
+        @run_id = run_id
+        @control_groups = []
+      end
+
+      def add_control_group(control_group)
+        control_groups << control_group
+      end
+
+      def to_hash
+        {
+            :node_name => node_name,
+            :run_id => run_id,
+            :start_time => start_time,
+            :end_time => end_time,
+            :control_groups => control_groups.collect { |c| c.to_hash }
+        }
+      end
+    end
+
+    class ControlGroupData
+      attr_reader :name, :status, :number_succeeded, :number_failed, :controls, :metadata
+
+      def initialize(name, metadata={})
+        @status = "success"
+        @controls = []
+        @number_succeeded = 0
+        @number_failed = 0
+        @name = name
+        @metadata = metadata
+      end
+
+
+      def example_success(control_data)
+        @number_succeeded += 1
+        control = create_control(control_data)
+        control.status = "success"
+        controls << control
+        control
+      end
+
+      def example_failure(control_data, details)
+        @number_failed += 1
+        @status = "failure"
+        control = create_control(control_data)
+        control.details = details if details
+        control.status = "failure"
+        controls << control
+        control
+      end
+
+      def to_hash
+        # We sort it so the examples appear in the output in the same order
+        # they appeared in the recipe
+        controls.sort! {|x,y| x.line_number <=> y.line_number}
+        h = {
+              :name => name,
+              :status => status,
+              :number_succeeded => number_succeeded,
+              :number_failed => number_failed,
+              :controls => controls.collect { |c| c.to_hash }
+        }
+        # If there is a duplicate key, metadata will overwrite it
+        add_display_only_data(h).merge(metadata)
+      end
+
+      private
+
+      def create_control(control_data)
+        ControlData.new(control_data)
+      end
+
+      # The id and control sequence number are ephemeral data - they are not needed
+      # to be persisted and can be regenerated at will.  They are only needed
+      # for display purposes.
+      def add_display_only_data(group)
+        group[:id] = SecureRandom.uuid
+        group[:controls].collect!.with_index do |c, i|
+          # i is zero-indexed, and we want the display one-indexed
+          c[:sequence_number] = i+1
+          c
+        end
+        group
+      end
+
+    end
+
+    class ControlData
+      attr_reader :name, :resource_type, :resource_name, :context, :line_number
+      attr_accessor :status, :details
+
+      def initialize(control_data={})
+        control_data.each do |k, v|
+          self.instance_variable_set("@#{k}", v)
+        end
+      end
+
+      def to_hash
+        h = {
+            :name => name,
+            :status => status,
+            :details => details,
+            :resource_type => resource_type,
+            :resource_name => resource_name
+        }
+        h[:context] = context || []
+        h
+      end
+    end
+
+  end
+end