chef 0.10.4 → 0.10.6.beta.1

data/lib/chef/knife/core/node_presenter.rb

@@ -53,6 +53,36 @@ class Chef
       # output formats for displaying node data
       class NodePresenter < GenericPresenter
 
+        def format(data)
+          if parse_format_option == :json
+            summarize_json(data)
+          else
+            super
+          end
+        end
+
+        def summarize_json(data)
+          if data.kind_of?(Chef::Node)
+            node = data
+            result = {}
+
+            result["name"] = node.name
+            result["chef_environment"] = node.chef_environment
+            result["run_list"] = node.run_list
+            result["normal"] = node.normal_attrs
+
+            if config[:long_output]
+              result["default"]   = node.default_attrs
+              result["override"]  = node.override_attrs
+              result["automatic"] = node.automatic_attrs
+            end
+
+            Chef::JSONCompat.to_json_pretty(result)
+          else
+            Chef::JSONCompat.to_json_pretty(data)
+          end
+        end
+
         # Converts a Chef::Node object to a string suitable for output to a
         # terminal. If config[:medium_output] or config[:long_output] are set
         # the volume of output is adjusted accordingly. Uses colors if enabled

data/lib/chef/knife/core/ui.rb

@@ -66,19 +66,24 @@ class Chef
 
       alias :info :msg
 
+      # Prints a msg to stderr. Used for warn, error, and fatal.
+      def err(message)
+        stderr.puts message
+      end
+
       # Print a warning message
       def warn(message)
-        msg("#{color('WARNING:', :yellow, :bold)} #{message}")
+        err("#{color('WARNING:', :yellow, :bold)} #{message}")
       end
 
       # Print an error message
       def error(message)
-        msg("#{color('ERROR:', :red, :bold)} #{message}")
+        err("#{color('ERROR:', :red, :bold)} #{message}")
       end
 
       # Print a message describing a fatal error.
       def fatal(message)
-        msg("#{color('FATAL:', :red, :bold)} #{message}")
+        err("#{color('FATAL:', :red, :bold)} #{message}")
       end
 
       def color(string, *colors)

data/lib/chef/knife/data_bag_create.rb

@@ -50,7 +50,7 @@ class Chef
 
       def use_encryption
         if config[:secret] && config[:secret_file]
-          stdout.puts "please specify only one of --secret, --secret-file"
+          ui.fatal("please specify only one of --secret, --secret-file")
           exit(1)
         end
         config[:secret] || config[:secret_file]
@@ -61,7 +61,7 @@ class Chef
 
         if @data_bag_name.nil?
           show_usage
-          stdout.puts("You must specify a data bag name")
+          ui.fatal("You must specify a data bag name")
           exit 1
         end
 
@@ -91,6 +91,3 @@ class Chef
     end
   end
 end
-
-
-

data/lib/chef/knife/data_bag_from_file.rb

@@ -53,7 +53,7 @@ class Chef
 
       def use_encryption
         if config[:secret] && config[:secret_file]
-          stdout.puts "please specify only one of --secret, --secret-file"
+          ui.fatal("please specify only one of --secret, --secret-file")
           exit(1)
         end
         config[:secret] || config[:secret_file]
@@ -65,7 +65,7 @@ class Chef
 
       def run
         if @name_args.size != 2
-          stdout.puts opt_parser
+          ui.msg(opt_parser)
           exit(1)
         end
         @data_bag, @item_path = @name_args[0], @name_args[1]
@@ -85,7 +85,3 @@ class Chef
     end
   end
 end
-
-
-
-

data/lib/chef/knife/node_show.rb

@@ -32,12 +32,12 @@ class Chef
 
       banner "knife node show NODE (options)"
 
-      attrs_to_show = []
+      @attrs_to_show = []
       option :attribute,
         :short => "-a [ATTR]",
         :long => "--attribute [ATTR]",
-        :proc => lambda {|val| attrs_to_show << val},
-        :description => "Show only one attribute"
+        :proc => lambda {|val| @attrs_to_show << val},
+        :description => "Show one or more attributes"
 
       option :run_list,
         :short => "-r",
@@ -61,6 +61,11 @@ class Chef
 
         node = Chef::Node.load(@node_name)
         output(format_for_display(node))
+        self.class.attrs_to_show = []
+      end
+
+      def self.attrs_to_show=(attrs)
+        @attrs_to_show = attrs
       end
     end
   end

data/lib/chef/knife/role_create.rb

@@ -30,8 +30,8 @@ class Chef
       banner "knife role create ROLE (options)"
 
       option :description,
-        :short => "-d",
-        :long => "--description",
+        :short => "-d DESC",
+        :long => "--description DESC",
         :description => "The role description"
 
       def run

data/lib/chef/knife/role_from_file.rb

@@ -28,20 +28,27 @@ class Chef
         require 'chef/json_compat'
       end
 
-      banner "knife role from file FILE (options)"
+      banner "knife role from file FILE [FILE..] (options)"
 
       def loader
         @loader ||= Knife::Core::ObjectLoader.new(Chef::Role, ui)
       end
 
+      option :all,
+        :short => "-a",
+        :long => "--all",
+        :description => "Upload all roles, rather than just a single role"
+
       def run
-        updated = loader.load_from("roles", @name_args[0])
+        @name_args.each do |arg|
+          updated = loader.load_from("roles", arg)
 
-        updated.save
+          updated.save
 
-        output(format_for_display(updated)) if config[:print_after]
+          output(format_for_display(updated)) if config[:print_after]
 
-        ui.info("Updated Role #{updated.name}!")
+          ui.info("Updated Role #{updated.name}!")
+        end
       end
 
     end

data/lib/chef/knife/search.rb

@@ -51,7 +51,7 @@ class Chef
         :short => "-R INT",
         :long => "--rows INT",
         :description => "The number of rows to return",
-        :default => 20,
+        :default => 1000,
         :proc => lambda { |i| i.to_i }
 
       option :attribute,

data/lib/chef/knife/ssh.rb

@@ -83,6 +83,7 @@ class Chef
         :default => false
 
       def session
+        config[:on_error] ||= :skip
         ssh_error_handler = Proc.new do |server|
           if config[:manual]
             node_name = server.host
@@ -91,8 +92,14 @@ class Chef
               node_name = n if format_for_display(n)[config[:attribute]] == server.host
             end
           end
-          ui.warn "Failed to connect to #{node_name} -- #{$!.class.name}: #{$!.message}"
-          $!.backtrace.each { |l| Chef::Log.debug(l) }
+          case config[:on_error]
+          when :skip
+            ui.warn "Failed to connect to #{node_name} -- #{$!.class.name}: #{$!.message}"
+            $!.backtrace.each { |l| Chef::Log.debug(l) }
+          when :raise
+            #Net::SSH::Multi magic to force exception to be re-raised.
+            throw :go, :raise
+          end
         end
 
         @session ||= Net::SSH::Multi.start(:concurrent_connections => config[:concurrency], :on_error => ssh_error_handler)
@@ -265,7 +272,7 @@ class Chef
           end.join(" \\; ")
         end
 
-        tmux_name = "'knife ssh #{@name_args[0]}'"
+        tmux_name = "'knife ssh #{@name_args[0].gsub(/:/,'=')}'"
         begin
           server = session.servers_for.first
           cmd = ["tmux new-session -d -s #{tmux_name}",
@@ -307,6 +314,14 @@ class Chef
                               "fqdn").strip
       end
 
+      def csshx
+        csshx_cmd = "csshX"
+        session.servers_for.each do |server|
+          csshx_cmd << " #{server.user ? "#{server.user}@#{server.host}" : server.host}"
+        end
+        exec(csshx_cmd)
+      end
+
       def configure_user
         config[:ssh_user] = (config[:ssh_user] ||
                              Chef::Config[:knife][:ssh_user])
@@ -337,6 +352,8 @@ class Chef
           tmux
         when "macterm"
           macterm
+        when "csshx"
+          csshx
         else
           ssh_command(@name_args[1..-1].join(" "))
         end

data/lib/chef/mixin/command/windows.rb

@@ -35,7 +35,7 @@ class Chef
 
           #XXX :user, :group, :environment support?
 
-          Open4.popen4(cmd) do |stdin,stdout,stderr,cid|
+          Open3.popen3(cmd) do |stdin,stdout,stderr,cid|
             if b
               if args[:waitlast]
                 b[cid, stdin, stdout, stderr]

data/lib/chef/platform.rb

@@ -182,6 +182,30 @@ class Chef
             }
           },
           :solaris  => {},
+          :openindiana => {
+            :default => {
+              :service => Chef::Provider::Service::Solaris,
+              :package => Chef::Provider::Package::Solaris,
+              :cron => Chef::Provider::Cron::Solaris,
+              :group => Chef::Provider::Group::Usermod
+            }
+          },
+          :opensolaris => {
+            :default => {
+              :service => Chef::Provider::Service::Solaris,
+              :package => Chef::Provider::Package::Solaris,
+              :cron => Chef::Provider::Cron::Solaris,
+              :group => Chef::Provider::Group::Usermod
+            }
+          },
+          :nexentacore => {
+            :default => {
+              :service => Chef::Provider::Service::Solaris,
+              :package => Chef::Provider::Package::Solaris,
+              :cron => Chef::Provider::Cron::Solaris,
+              :group => Chef::Provider::Group::Usermod
+            }
+          },
           :solaris2 => {
             :default => {
               :service => Chef::Provider::Service::Solaris,

data/lib/chef/provider/deploy.rb

@@ -28,7 +28,7 @@ class Chef
       include Chef::Mixin::FromFile
       include Chef::Mixin::Command
 
-      attr_reader :scm_provider, :release_path
+      attr_reader :scm_provider, :release_path, :previous_release_path
 
       def initialize(new_resource, run_context)
         super(new_resource, run_context)
@@ -59,23 +59,35 @@ class Chef
       end
 
       def action_deploy
-        if all_releases.include?(release_path)
-          if all_releases[-1] == release_path
+        save_release_state
+
+        if deployed?(release_path)
+          if current_release?(release_path) 
             Chef::Log.debug("#{@new_resource} is the latest version")
           else
             action_rollback
           end
         else
-          deploy
-          @new_resource.updated_by_last_action(true)
+
+          with_rollback_on_error do
+            deploy
+            @new_resource.updated_by_last_action(true)
+          end
         end
       end
 
       def action_force_deploy
-        if all_releases.include?(release_path)
+        if deployed?(release_path)
+          Chef::Log.info("Already deployed app at #{release_path}, forcing.")
           FileUtils.rm_rf(release_path)
           Chef::Log.info("#{@new_resource} forcing deploy of already deployed app at #{release_path}")
         end
+
+        # Alternatives:
+        # * Move release_path directory before deploy and move it back when error occurs
+        # * Rollback to previous commit
+        # * Do nothing - because deploy is force, it will be retried in short time
+        # Because last is simpliest, keep it
         deploy
         @new_resource.updated_by_last_action(true)
       end
@@ -92,10 +104,8 @@ class Chef
           releases_to_nuke = [ all_releases.last ]
         end
 
-        Chef::Log.info "#{@new_resource} rolling back to previous release #{release_path}"
-        symlink
-        Chef::Log.info "#{@new_resource} restarting with previous release"
-        restart
+        rollback
+
         releases_to_nuke.each do |i|
           Chef::Log.info "#{@new_resource} removing release: #{i}"
           FileUtils.rm_rf i
@@ -106,6 +116,7 @@ class Chef
 
       def deploy
         enforce_ownership
+        verify_directories_exist
         update_cached_repo
         copy_cached_repo
         install_gems
@@ -121,6 +132,13 @@ class Chef
         Chef::Log.info "#{@new_resource} deployed to #{@new_resource.deploy_to}"
       end
 
+      def rollback
+        Chef::Log.info "#{@new_resource} rolling back to previous release #{release_path}"
+        symlink
+        Chef::Log.info "#{@new_resource} restarting with previous release"
+        restart
+      end
+
       def callback(what, callback_code=nil)
         @collection = Chef::ResourceCollection.new
         case callback_code
@@ -218,6 +236,11 @@ class Chef
         Chef::Log.info("#{@new_resource} set group to #{@new_resource.group}") if @new_resource.group
       end
 
+      def verify_directories_exist
+        create_dir_unless_exists(@new_resource.deploy_to)
+        create_dir_unless_exists(@new_resource.shared_path)
+      end
+
       def link_current_release_to_production
         FileUtils.rm_f(@new_resource.current_path)
         begin
@@ -244,20 +267,17 @@ class Chef
       def link_tempfiles_to_current_release
         dirs_info = @new_resource.create_dirs_before_symlink.join(",")
         @new_resource.create_dirs_before_symlink.each do |dir| 
-          begin
-            FileUtils.mkdir_p(release_path + "/#{dir}")
-          rescue => e
-            raise Chef::Exceptions::FileNotFound.new("Cannot create directory #{dir}: #{e.message}")
-          end
+          create_dir_unless_exists(release_path + "/#{dir}")
         end
         Chef::Log.info("#{@new_resource} created directories before symlinking #{dirs_info}")
 
         links_info = @new_resource.symlinks.map { |src, dst| "#{src} => #{dst}" }.join(", ")
         @new_resource.symlinks.each do |src, dest|
+          create_dir_unless_exists(::File.join(@new_resource.shared_path, src))
           begin
-            FileUtils.ln_sf(@new_resource.shared_path + "/#{src}",  release_path + "/#{dest}")
+            FileUtils.ln_sf(::File.join(@new_resource.shared_path, src), ::File.join(release_path, dest))
           rescue => e
-            raise Chef::Exceptions::FileNotFound.new("Cannot symlink shared data #{@new_resource.shared_path}/#{src} to #{release_path}/#{dest}: #{e.message}")
+            raise Chef::Exceptions::FileNotFound.new("Cannot symlink shared data #{::File.join(@new_resource.shared_path, src)} to #{::File.join(release_path, dest)}: #{e.message}")
           end
         end
         Chef::Log.info("#{@new_resource} linked shared paths into current release: #{links_info}")
@@ -338,6 +358,62 @@ class Chef
         end
       end
 
+      def create_dir_unless_exists(dir)
+        if ::File.directory?(dir)
+          Chef::Log.debug "#{@new_resource} not creating #{dir} because it already exists"
+          return false
+        end
+
+        begin
+          FileUtils.mkdir_p(dir)
+          Chef::Log.debug "#{@new_resource} created directory #{dir}"
+          if @new_resource.user
+            FileUtils.chown(@new_resource.user, nil, dir)
+            Chef::Log.debug("#{@new_resource} set user to #{@new_resource.user} for #{dir}")
+          end
+          if @new_resource.group
+            FileUtils.chown(nil, @new_resource.group, dir)
+            Chef::Log.debug("#{@new_resource} set group to #{@new_resource.group} for #{dir}")
+          end
+        rescue => e
+          raise Chef::Exceptions::FileNotFound.new("Cannot create directory #{dir}: #{e.message}")
+        end
+      end
+
+      def with_rollback_on_error
+        yield
+      rescue ::Exception => e
+        if @new_resource.rollback_on_error
+          Chef::Log.warn "Error on deploying #{release_path}: #{e.message}" 
+          failed_release = release_path
+        
+          if previous_release_path
+            @release_path = previous_release_path
+            rollback
+          end
+
+          Chef::Log.info "Removing failed deploy #{failed_release}"
+          FileUtils.rm_rf failed_release
+          release_deleted(failed_release)
+        end
+        
+        raise
+      end
+
+      def save_release_state
+        if ::File.exists?(@new_resource.current_path)
+          release = ::File.readlink(@new_resource.current_path)
+          @previous_release_path = release if ::File.exists?(release)
+        end
+      end
+
+      def deployed?(release)
+        all_releases.include?(release)
+      end
+
+      def current_release?(release)
+        @previous_release_path == release
+      end
     end
   end
 end