chef 0.10.8 → 0.10.10.beta.1

data/lib/chef/application.rb

@@ -1,5 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@opscode.com>)
+# Author:: Mark Mzyk (mmzyk@opscode.com)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -19,8 +20,10 @@ require 'socket'
 require 'chef/config'
 require 'chef/exceptions'
 require 'chef/log'
+require 'chef/platform'
 require 'mixlib/cli'
 require 'tmpdir'
+require 'rbconfig'
 
 class Chef::Application
   include Mixlib::CLI
@@ -39,7 +42,7 @@ class Chef::Application
       Chef::Application.fatal!("SIGINT received, stopping", 2)
     end
 
-    unless RUBY_PLATFORM =~ /mswin|mingw32|windows/
+    unless Chef::Platform.windows?
       trap("QUIT") do
         Chef::Log.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
       end
@@ -78,15 +81,18 @@ class Chef::Application
       else
         ::File::open(config[:config_file]) { |f| apply_config(f.path) }
       end
-    rescue SocketError => error
-      Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}", 2)
-    rescue Exception => error
+    rescue Errno::ENOENT => error
       Chef::Log.warn("*****************************************")
-      Chef::Log.warn("Can not find config file: #{config[:config_file]}, using defaults.")
-      Chef::Log.warn("#{error.message}")
+      Chef::Log.warn("Did not find config file: #{config[:config_file]}, using command line options.")
       Chef::Log.warn("*****************************************")
 
       Chef::Config.merge!(config)
+    rescue SocketError => error
+      Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}", 2)
+    rescue Chef::Exceptions::ConfigurationError => error
+      Chef::Application.fatal!("Error processing config file #{Chef::Config[:config_file]} with error #{error.message}", 2)
+    rescue Exception => error
+      Chef::Application.fatal!("Unknown error processing config file #{Chef::Config[:config_file]} with error #{error.message}", 2)
     end
 
   end

data/lib/chef/application/client.rb

@@ -1,6 +1,7 @@
 #
 # Author:: AJ Christensen (<aj@opscode.com)
 # Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Mark Mzyk (mmzyk@opscode.com)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -33,7 +34,7 @@ class Chef::Application::Client < Chef::Application
   option :config_file,
     :short => "-c CONFIG",
     :long  => "--config CONFIG",
-    :default => "/etc/chef/client.rb",
+    :default => Chef::Config.platform_specific_path("/etc/chef/client.rb"),
     :description => "The configuration file to use"
 
   option :log_level,
@@ -209,7 +210,7 @@ class Chef::Application::Client < Chef::Application
 
   # Run the chef client, optionally daemonizing or looping at intervals.
   def run_application
-    unless RUBY_PLATFORM =~ /mswin|mingw32|windows/
+    unless Chef::Platform.windows?
       SELF_PIPE.replace IO.pipe
 
       trap("USR1") do
@@ -276,7 +277,7 @@ class Chef::Application::Client < Chef::Application
     end
   end
 
-  private 
+  private
 
   def client_sleep(sec)
     IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return

data/lib/chef/application/knife.rb

@@ -41,16 +41,10 @@ class Chef::Application::Knife < Chef::Application
     :default => 0
 
   option :color,
-    :long         => '--color',
+    :long         => '--[no-]color',
     :boolean      => true,
     :default      => true,
-    :description  => "Use colored output"
-
-  option :no_color,
-    :long         => '--no-color',
-    :boolean      => true,
-    :default      => false,
-    :description  => "Don't use colors in the output"
+    :description  => "Use colored output, defaults to enabled"
 
   option :environment,
     :short        => "-E ENVIRONMENT",
@@ -63,11 +57,12 @@ class Chef::Application::Knife < Chef::Application
     :description  => "Set the editor to use for interactive commands",
     :default      => ENV['EDITOR']
 
-  option :no_editor,
-    :short        => "-n",
-    :long         => "--no-editor",
+  option :disable_editing,
+    :short        => "-d",
+    :long         => "--disable-editing",
     :description  => "Do not open EDITOR, just accept the data as is",
-    :boolean      => true
+    :boolean      => true,
+    :defaut       => false
 
   option :help,
     :short        => "-h",

data/lib/chef/application/solo.rb

@@ -1,5 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@opscode.com>)
+# Author:: Mark Mzyk (mmzyk@opscode.com)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -30,7 +31,7 @@ class Chef::Application::Solo < Chef::Application
   option :config_file,
     :short => "-c CONFIG",
     :long  => "--config CONFIG",
-    :default => "/etc/chef/solo.rb",
+    :default => Chef::Config.platform_specfic_path('/etc/chef/solo.rb'),
     :description => "The configuration file to use"
 
   option :log_level,

data/lib/chef/application/windows_service.rb

@@ -0,0 +1,224 @@
+#
+# Author:: Christopher Maier (<maier@lambda.local>)
+# Copyright:: Copyright (c) 2011 Opscode, 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/application'
+require 'chef/client'
+require 'chef/config'
+require 'chef/handler/error_report'
+require 'chef/log'
+require 'chef/rest'
+require 'mixlib/cli'
+require 'socket'
+require 'win32/daemon'
+
+class Chef
+  class Application
+    class WindowsService < ::Win32::Daemon
+      include Mixlib::CLI
+
+      option :config_file,
+        :short => "-c CONFIG",
+        :long => "--config CONFIG",
+        :default => "#{ENV['SYSTEMDRIVE']}/chef/client.rb",
+        :description => ""
+
+      option :log_location,
+        :short        => "-L LOGLOCATION",
+        :long         => "--logfile LOGLOCATION",
+        :description  => "Set the log file location",
+        :default => "#{ENV['SYSTEMDRIVE']}/chef/client.log"
+
+      option :splay,
+        :short        => "-s SECONDS",
+        :long         => "--splay SECONDS",
+        :description  => "The splay time for running at intervals, in seconds",
+        :proc         => lambda { |s| s.to_i }
+
+      option :interval,
+        :short        => "-i SECONDS",
+        :long         => "--interval SECONDS",
+        :description  => "Set the number of seconds to wait between chef-client runs",
+        :proc         => lambda { |s| s.to_i }
+
+      def service_init
+        reconfigure
+        Chef::Log.info("Chef Client Service initialized")
+      end
+
+      def service_main(*startup_parameters)
+
+        while running?
+          if state == RUNNING
+            begin
+              # Reconfigure each time through to pick up any changes in the client file
+              Chef::Log.info("Reconfiguring with startup parameters")
+              reconfigure(startup_parameters)
+
+              splay = rand Chef::Config[:splay]
+              Chef::Log.debug("Splay sleep #{splay} seconds")
+              sleep splay
+
+              # If we've stopped, then bail out now, instead of going on to run Chef
+              next if state != RUNNING
+
+              @chef_client = Chef::Client.new(@chef_client_json)
+              @chef_client_json = nil
+
+              @chef_client.run
+              @chef_client = nil
+
+              Chef::Log.debug("Sleeping for #{Chef::Config[:interval]} seconds")
+              client_sleep Chef::Config[:interval]
+            rescue Chef::Application::Wakeup => e
+              Chef::Log.debug("Received Wakeup signal.  Starting run.")
+              next
+            rescue SystemExit => e
+              raise
+            rescue Exception => e
+              Chef::Log.error("#{e.class}: #{e}")
+              Chef::Application.debug_stacktrace(e)
+              Chef::Log.error("Sleeping for #{Chef::Config[:interval]} seconds before trying again")
+              client_sleep Chef::Config[:interval]
+              retry
+            ensure
+              GC.start
+            end
+          else # PAUSED or IDLE
+            sleep 5
+          end
+        end
+      end
+
+      ################################################################################
+      # Control Signal Callback Methods
+      ################################################################################
+
+      def service_stop
+        Chef::Log.info("SERVICE_CONTROL_STOP received, stopping")
+      end
+
+      def service_pause
+        Chef::Log.info("SERVICE_CONTROL_PAUSE received, pausing")
+      end
+
+      def service_resume
+        Chef::Log.info("SERVICE_CONTROL_CONTINUE received, resuming")
+      end
+
+      def service_shutdown
+        Chef::Log.info("SERVICE_CONTROL_SHUTDOWN received, shutting down")
+      end
+
+      ################################################################################
+      # Internal Methods
+      ################################################################################
+
+      private
+
+      def apply_config(config_file_path)
+        Chef::Config.from_file(config_file_path)
+        Chef::Config.merge!(config)
+      end
+
+      # Lifted from Chef::Application, with addition of optional startup parameters
+      # for playing nicely with Windows Services
+      def reconfigure(startup_parameters=[])
+        configure_chef startup_parameters
+        configure_logging
+
+        Chef::Config[:chef_server_url] = config[:chef_server_url] if config.has_key? :chef_server_url
+        unless Chef::Config[:exception_handlers].any? {|h| Chef::Handler::ErrorReport === h}
+          Chef::Config[:exception_handlers] << Chef::Handler::ErrorReport.new
+        end
+
+        Chef::Config[:interval] ||= 1800
+      end
+
+      # Lifted from Chef::Application and Chef::Application::Client
+      # MUST BE RUN AFTER configuration has been parsed!
+      def configure_logging
+        # Implementation from Chef::Application
+        Chef::Log.init(Chef::Config[:log_location])
+        Chef::Log.level = Chef::Config[:log_level]
+
+        # Implementation from Chef::Application::Client
+        Mixlib::Authentication::Log.use_log_devices( Chef::Log )
+        Ohai::Log.use_log_devices( Chef::Log )
+      end
+
+      def configure_chef(startup_parameters)
+        # Bit of a hack ahead:
+        # It is possible to specify a service's binary_path_name with arguments, like "foo.exe -x argX".
+        # It is also possible to specify startup parameters separately, either via the the Services manager
+        # or by using the registry (I think).
+
+        # In order to accommodate all possible sources of parameterization, we first parse any command line
+        # arguments.  We then parse any startup parameters.  This works, because Mixlib::CLI reuses its internal
+        # 'config' hash; thus, anything in startup parameters will override any command line parameters that
+        # might be set via the service's binary_path_name
+        #
+        # All these parameters then get layered on top of those from Chef::Config
+
+        parse_options # Operates on ARGV by default
+        parse_options startup_parameters
+
+        begin
+          case config[:config_file]
+          when /^(http|https):\/\//
+            Chef::REST.new("", nil, nil).fetch(config[:config_file]) { |f| apply_config(f.path) }
+          else
+            ::File::open(config[:config_file]) { |f| apply_config(f.path) }
+          end
+        rescue Errno::ENOENT => error
+          Chef::Log.warn("*****************************************")
+          Chef::Log.warn("Did not find config file: #{config[:config_file]}, using command line options.")
+          Chef::Log.warn("*****************************************")
+
+          Chef::Config.merge!(config)
+        rescue SocketError => error
+          Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}", 2)
+        rescue Chef::Exceptions::ConfigurationError => error
+          Chef::Application.fatal!("Error processing config file #{Chef::Config[:config_file]} with error #{error.message}", 2)
+        rescue Exception => error
+          Chef::Application.fatal!("Unknown error processing config file #{Chef::Config[:config_file]} with error #{error.message}", 2)
+        end
+      end
+
+      # Since we need to be able to respond to signals between Chef runs, we need to periodically
+      # wake up to see if we're still in the running state.  The method returns when it has slept
+      # for +sec+ seconds (but at least +10+ seconds), or when the service
+      # is no client_sleep in the +RUNNING+ state, whichever comes first.
+      def client_sleep(sec)
+        chunk_length = 10
+        chunks = sec / chunk_length
+        chunks = 1 if chunks < 1
+        (1..chunks).each do
+          return unless state == RUNNING
+          sleep chunk_length
+        end
+      end
+
+    end
+  end
+end
+
+# To run this file as a service, it must be called as a script from within
+# the Windows Service framework.  In that case, kick off the main loop!
+if __FILE__ == $0
+    Chef::Application::WindowsService.mainloop
+end

data/lib/chef/checksum_cache.rb

@@ -44,6 +44,7 @@ class Chef
 
       begin
         require "moneta/#{convert_to_snake_case(backend, 'Moneta')}"
+        require 'chef/monkey_patches/moneta'
       rescue LoadError => e
         Chef::Log.fatal("Could not load Moneta back end #{backend.inspect}")
         raise e

data/lib/chef/client.rb

@@ -20,6 +20,7 @@
 
 require 'chef/config'
 require 'chef/mixin/params_validate'
+require 'chef/mixin/path_sanity'
 require 'chef/log'
 require 'chef/rest'
 require 'chef/api_client'
@@ -36,14 +37,14 @@ require 'chef/cookbook/file_system_file_vendor'
 require 'chef/cookbook/remote_file_vendor'
 require 'chef/version'
 require 'ohai'
+require 'rbconfig'
 
 class Chef
   # == Chef::Client
   # The main object in a Chef run. Preps a Chef::Node and Chef::RunContext,
   # syncs cookbooks if necessary, and triggers convergence.
   class Client
-
-    SANE_PATHS = %w[/usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin]
+    include Chef::Mixin::PathSanity
 
     # Clears all notifications for client run status events.
     # Primarily for testing purposes.
@@ -313,20 +314,6 @@ class Chef
       true
     end
 
-    def enforce_path_sanity(env=ENV)
-      if Chef::Config[:enforce_path_sanity] && RUBY_PLATFORM !~ /mswin|mingw32|windows/
-        existing_paths = env["PATH"].split(':')
-        SANE_PATHS.each do |sane_path|
-          unless existing_paths.include?(sane_path)
-            env_path = env["PATH"].dup
-            env_path << ':' unless env["PATH"].empty?
-            env_path << sane_path
-            env["PATH"] = env_path
-          end
-        end
-      end
-    end
-
     private
 
     def directory_not_empty?(path)

data/lib/chef/config.rb

@@ -2,6 +2,7 @@
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Christopher Brown (<cb@opscode.com>)
 # Author:: AJ Christensen (<aj@opscode.com>)
+# Author:: Mark Mzyk (mmzyk@opscode.com)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -46,6 +47,16 @@ class Chef
       configuration.inspect
     end
 
+    def self.platform_specific_path(path)
+      if RUBY_PLATFORM =~ /mswin|mingw|windows/
+        # turns /etc/chef/client.rb into C:/chef/client.rb
+        path = File.join(ENV['SYSTEMDRIVE'], path.split('/')[2..-1])
+        # ensure all forward slashes are backslashes
+        path.gsub!(File::SEPARATOR, (File::ALT_SEPARATOR || '\\'))
+      end
+      path
+    end
+
     # Override the config dispatch to set the value of multiple server options simultaneously
     #
     # === Parameters
@@ -85,9 +96,13 @@ class Chef
         location.sync = true
         location
       elsif location.respond_to? :to_str
-        f = File.new(location.to_str, "a")
-        f.sync = true
-        f
+        begin
+          f = File.new(location.to_str, "a")
+          f.sync = true
+        rescue Errno::ENOENT => error
+          raise Chef::Exceptions::ConfigurationError("Failed to open or create log file at #{location.to_str}")
+        end
+          f
       end
     end
 
@@ -115,7 +130,8 @@ class Chef
 
     # Where the cookbooks are located. Meaning is somewhat context dependent between
     # knife, chef-client, and chef-solo.
-    cookbook_path [ "/var/chef/cookbooks", "/var/chef/site-cookbooks" ]
+    cookbook_path [ platform_specific_path("/var/chef/cookbooks"),
+                    platform_specific_path("/var/chef/site-cookbooks") ]
 
     # Where files are stored temporarily during uploads
     sandbox_path "/var/chef/sandboxes"
@@ -129,10 +145,10 @@ class Chef
     couchdb_url "http://localhost:5984"
 
     # Where chef's cache files should be stored
-    file_cache_path "/var/chef/cache"
+    file_cache_path platform_specific_path("/var/chef/cache")
 
     # Where backups of chef-managed files should go
-    file_backup_path "/var/chef/backup"
+    file_backup_path platform_specific_path("/var/chef/backup")
 
     ## Daemonization Settings ##
     # What user should Chef run as?
@@ -148,7 +164,7 @@ class Chef
     log_level :info
     log_location STDOUT
     # toggle info level log items that can create a lot of output
-    verbose_logging true 
+    verbose_logging true
     node_name nil
     node_path "/var/chef/node"
 
@@ -179,7 +195,9 @@ class Chef
 
 
     # Where should chef-solo look for role files?
-    role_path "/var/chef/roles"
+    role_path platform_specific_path("/var/chef/roles")
+
+    data_bag_path platform_specific_path("/var/chef/data_bags")
 
     # Where should chef-solo download recipes from?
     recipe_url nil
@@ -201,8 +219,8 @@ class Chef
     # (persist across rabbitmq restarts)
     amqp_consumer_id "default"
 
-    client_key "/etc/chef/client.pem"
-    validation_key "/etc/chef/validation.pem"
+    client_key platform_specific_path("/etc/chef/client.pem")
+    validation_key platform_specific_path("/etc/chef/validation.pem")
     validation_client_name "chef-validator"
     web_ui_client_name "chef-webui"
     web_ui_key "/etc/chef/webui.pem"
@@ -235,14 +253,25 @@ class Chef
     # Checksum Cache
     # Uses Moneta on the back-end
     cache_type "BasicFile"
-    cache_options({ :path => "/var/chef/cache/checksums", :skip_expires => true })
+    cache_options({ :path => platform_specific_path("/etc/chef/cache/checksums"), :skip_expires => true })
 
     # Arbitrary knife configuration data
     knife Hash.new
 
     # Those lists of regular expressions define what chef considers a
     # valid user and group name
-    user_valid_regex [ /^([-a-zA-Z0-9_.]+)$/, /^\d+$/ ]
-    group_valid_regex [ /^([-a-zA-Z0-9_.\\ ]+)$/, /^\d+$/ ]
+    if RUBY_PLATFORM =~ /mswin|mingw|windows/
+      # From http://technet.microsoft.com/en-us/library/cc776019(WS.10).aspx
+
+      principal_valid_regex_part = '[^"\/\\\\\[\]\:;|=,+*?<>]+'
+      user_valid_regex [ /^(#{principal_valid_regex_part}\\)?#{principal_valid_regex_part}$/ ]
+      group_valid_regex [ /^(#{principal_valid_regex_part}\\)?#{principal_valid_regex_part}$/ ]
+    else
+      user_valid_regex [ /^([-a-zA-Z0-9_.]+)$/, /^\d+$/ ]
+      group_valid_regex [ /^([-a-zA-Z0-9_.\\ ]+)$/, /^\d+$/ ]
+    end
+
+    # returns a platform specific path to the user home dir
+    user_home (ENV['HOME'] || ENV['SYSTEMDRIVE'] + ENV['HOMEPATH'] || ENV['USERPROFILE'])
   end
 end