chef 10.28.2-x86-mingw32

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

@@ -0,0 +1,130 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# 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/json_compat'
+require 'chef/node'
+
+class Chef
+  class Knife
+    class NodeEditor
+
+      attr_reader :node
+      attr_reader :ui
+      attr_reader :config
+
+      def initialize(node, ui, config)
+        @node, @ui, @config = node, ui, config
+      end
+
+      def edit_node
+        abort "You specified the --disable_editing option, nothing to edit" if config[:disable_editing]
+        assert_editor_set!
+
+        updated_node_data = edit_data(view)
+        apply_updates(updated_node_data)
+        @updated_node
+      end
+
+      def view
+        result = {}
+        result["name"] = node.name
+        result["chef_environment"] = node.chef_environment
+        result["normal"] = node.normal_attrs
+        result["run_list"] = node.run_list
+
+        if config[:all_attributes]
+          result["default"]   = node.default_attrs
+          result["override"]  = node.override_attrs
+          result["automatic"] = node.automatic_attrs
+        end
+        Chef::JSONCompat.to_json_pretty(result)
+      end
+
+      def edit_data(text)
+        edited_data = tempfile_for(text) {|filename| system("#{config[:editor]} #{filename}")}
+        Chef::JSONCompat.from_json(edited_data)
+      end
+
+      def apply_updates(updated_data)
+        if node.name and node.name != updated_data["name"]
+          ui.warn "Changing the name of a node results in a new node being created, #{node.name} will not be modified or removed."
+          confirm = ui.confirm "Proceed with creation of new node"
+        end
+
+        @updated_node = Node.new.tap do |n|
+          n.name( updated_data["name"] )
+          n.chef_environment( updated_data["chef_environment"] )
+          n.run_list( updated_data["run_list"])
+          n.normal_attrs = updated_data["normal"]
+
+          if config[:all_attributes]
+            n.default_attrs   = updated_data["default"]
+            n.override_attrs  = updated_data["override"]
+            n.automatic_attrs = updated_data["automatic"]
+          else
+            n.default_attrs   = node.default_attrs
+            n.override_attrs  = node.override_attrs
+            n.automatic_attrs = node.automatic_attrs
+          end
+        end
+      end
+
+      def updated?
+        pristine_copy = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(node), :create_additions => false)
+        updated_copy  = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@updated_node), :create_additions => false)
+        unless pristine_copy == updated_copy
+          updated_properties = %w{name normal chef_environment run_list default override automatic}.reject do |key|
+             pristine_copy[key] == updated_copy[key]
+          end
+        end
+        ( pristine_copy != updated_copy ) && updated_properties
+      end
+
+      private
+
+      def abort(message)
+        ui.error(message)
+        exit 1
+      end
+
+      def assert_editor_set!
+        unless config[:editor]
+          abort "You must set your EDITOR environment variable or configure your editor via knife.rb"
+        end
+      end
+
+      def tempfile_for(data)
+        # TODO: include useful info like the node name in the temp file
+        # name
+        basename = "knife-edit-" << rand(1_000_000_000_000_000).to_s.rjust(15, '0') << '.js'
+        filename = File.join(Dir.tmpdir, basename)
+        File.open(filename, "w+") do |f|
+          f.sync = true
+          f.puts data
+        end
+
+        yield filename
+
+        IO.read(filename)
+      ensure
+        File.unlink(filename)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,137 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# 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/knife/core/text_formatter'
+require 'chef/knife/core/generic_presenter'
+
+class Chef
+  class Knife
+    module Core
+
+      # This module may be included into a knife subcommand class to automatically
+      # add configuration options used by the NodePresenter
+      module NodeFormattingOptions
+        # :nodoc:
+        # Would prefer to do this in a rational way, but can't be done b/c of
+        # Mixlib::CLI's design :(
+        def self.included(includer)
+          includer.class_eval do
+            option :medium_output,
+              :short   => '-m',
+              :long    => '--medium',
+              :boolean => true,
+              :default => false,
+              :description => 'Include normal attributes in the output'
+
+            option :long_output,
+              :short   => '-l',
+              :long    => '--long',
+              :boolean => true,
+              :default => false,
+              :description => 'Include all attributes in the output'
+          end
+        end
+      end
+
+      #==Chef::Knife::Core::NodePresenter
+      # A customized presenter for Chef::Node objects. Supports variable-length
+      # 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
+        # in the ui object.
+        def summarize(data)
+          if data.kind_of?(Chef::Node)
+            node = data
+            # special case ec2 with their split horizon whatsis.
+            ip = (node[:ec2] && node[:ec2][:public_ipv4]) || node[:ipaddress]
+
+            summarized=<<-SUMMARY
+#{ui.color('Node Name:', :bold)}   #{ui.color(node.name, :bold)}
+#{key('Environment:')} #{node.chef_environment}
+#{key('FQDN:')}        #{node[:fqdn]}
+#{key('IP:')}          #{ip}
+#{key('Run List:')}    #{node.run_list}
+#{key('Roles:')}       #{Array(node[:roles]).join(', ')}
+#{key('Recipes:')}     #{Array(node[:recipes]).join(', ')}
+#{key('Platform:')}    #{node[:platform]} #{node[:platform_version]}
+#{key('Tags:')}        #{Array(node[:tags]).join(', ')}
+SUMMARY
+            if config[:medium_output] || config[:long_output]
+              summarized +=<<-MORE
+#{key('Attributes:')}
+#{text_format(node.normal_attrs)}
+MORE
+            end
+            if config[:long_output]
+              summarized +=<<-MOST
+#{key('Default Attributes:')}
+#{text_format(node.default_attrs)}
+#{key('Override Attributes:')}
+#{text_format(node.override_attrs)}
+#{key('Automatic Attributes (Ohai Data):')}
+#{text_format(node.automatic_attrs)}
+MOST
+            end
+            summarized
+          else
+            super
+          end
+        end
+
+        def key(key_text)
+          ui.color(key_text, :cyan)
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,112 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# 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.
+#
+
+class Chef
+  class Knife
+    module Core
+      class ObjectLoader
+
+        attr_reader :ui
+        attr_reader :klass
+
+        class ObjectType
+          FILE = 1
+          FOLDER = 2
+        end
+
+        def initialize(klass, ui)
+          @klass = klass
+          @ui = ui
+        end
+
+        def load_from(repo_location, *components)
+          unless object_file = find_file(repo_location, *components)
+            ui.error "Could not find or open file '#{components.last}' in current directory or in '#{repo_location}/#{components.join('/')}'"
+            exit 1
+          end
+          object_from_file(object_file)
+        end
+
+        # When someone makes this awesome, please update the above error message.
+        def find_file(repo_location, *components)
+          if file_exists_and_is_readable?(File.expand_path( components.last ))
+            File.expand_path( components.last )
+          else
+            relative_path = File.join(Dir.pwd, repo_location, *components)
+            if file_exists_and_is_readable?(relative_path)
+              relative_path
+            else
+              nil
+            end
+          end
+        end
+
+        # Find all objects in the given location
+        # If the object type is File it will look for all *.{json,rb}
+        # files, otherwise it will lookup for folders only (useful for
+        # data_bags)
+        #
+        # @param [String] path - base look up location
+        #
+        # @return [Array<String>] basenames of the found objects
+        #
+        # @api public
+        def find_all_objects(path)
+          path = File.join(path, '*')
+          path << '.{json,rb}'
+          objects = Dir.glob(File.expand_path(path))
+          objects.map { |o| File.basename(o) }
+        end
+
+        def find_all_object_dirs(path)
+          path = File.join(path, '*')
+          objects = Dir.glob(File.expand_path(path))
+          objects.delete_if { |o| !File.directory?(o) }
+          objects.map { |o| File.basename(o) }
+        end
+
+        def object_from_file(filename)
+          case filename
+          when /\.(js|json)$/
+            r = Yajl::Parser.parse(IO.read(filename))
+
+            # Chef::DataBagItem doesn't work well with the json_create method
+            if @klass == Chef::DataBagItem
+              r
+            else
+              @klass.json_create(r)
+            end
+          when /\.rb$/
+            r = klass.new
+            r.from_file(filename)
+            r
+          else
+            ui.fatal("File must end in .js, .json, or .rb")
+            exit 30
+          end
+        end
+
+        def file_exists_and_is_readable?(file)
+          File.exists?(file) && File.readable?(file)
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,112 @@
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009, 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/version'
+class Chef
+  class Knife
+    class SubcommandLoader
+
+      CHEF_FILE_IN_GEM = /chef-[\d]+\.[\d]+\.[\d]+/
+      CURRENT_CHEF_GEM = /chef-#{Regexp.escape(Chef::VERSION)}/
+
+      attr_reader :chef_config_dir
+      attr_reader :env
+
+      def initialize(chef_config_dir, env=ENV)
+        @chef_config_dir, @env = chef_config_dir, env
+        @forced_activate = {}
+      end
+
+      # Load all the sub-commands
+      def load_commands
+        subcommand_files.each { |subcommand| Kernel.load subcommand }
+        true
+      end
+
+      # Returns an Array of paths to knife commands located in chef_config_dir/plugins/knife/
+      # and ~/.chef/plugins/knife/
+      def site_subcommands
+        user_specific_files = []
+
+        if chef_config_dir
+          user_specific_files.concat Dir.glob(File.expand_path("plugins/knife/*.rb", chef_config_dir))
+        end
+
+        # finally search ~/.chef/plugins/knife/*.rb
+        user_specific_files.concat Dir.glob(File.join(env['HOME'], '.chef', 'plugins', 'knife', '*.rb')) if env['HOME']
+
+        user_specific_files
+      end
+
+      # Returns a Hash of paths to knife commands built-in to chef, or installed via gem.
+      # If rubygems is not installed, falls back to globbing the knife directory.
+      # The Hash is of the form {"relative/path" => "/absolute/path"}
+      #--
+      # Note: the "right" way to load the plugins is to require the relative path, i.e.,
+      #   require 'chef/knife/command'
+      # but we're getting frustrated by bugs at every turn, and it's slow besides. So
+      # subcommand loader has been modified to load the plugins by using Kernel.load
+      # with the absolute path.
+      def gem_and_builtin_subcommands
+        # search all gems for chef/knife/*.rb
+        require 'rubygems'
+        find_subcommands_via_rubygems
+      rescue LoadError
+        find_subcommands_via_dirglob
+      end
+
+      def subcommand_files
+        @subcommand_files ||= (gem_and_builtin_subcommands.values + site_subcommands).flatten.uniq
+      end
+
+      def find_subcommands_via_dirglob
+        # The "require paths" of the core knife subcommands bundled with chef
+        files = Dir[File.expand_path('../../../knife/*.rb', __FILE__)]
+        subcommand_files = {}
+        files.each do |knife_file|
+          rel_path = knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1]
+          subcommand_files[rel_path] = knife_file
+        end
+        subcommand_files
+      end
+
+      def find_subcommands_via_rubygems
+        files = Gem.find_files 'chef/knife/*.rb'
+        files.reject! {|f| from_old_gem?(f) }
+        subcommand_files = {}
+        files.each do |file|
+          rel_path = file[/(#{Regexp.escape File.join('chef', 'knife', '')}.*)\.rb/, 1]
+          subcommand_files[rel_path] = file
+        end
+
+        subcommand_files.merge(find_subcommands_via_dirglob)
+      end
+
+      private
+
+      # wow, this is a sad hack :(
+      # Gem.find_files finds files in all versions of a gem, which
+      # means that if chef 0.10 and 0.9.x are installed, we'll try to
+      # require, e.g., chef/knife/ec2_server_create, which will cause
+      # a gem activation error. So remove files from older chef gems.
+      def from_old_gem?(path)
+        path =~ CHEF_FILE_IN_GEM && path !~ CURRENT_CHEF_GEM
+      end
+    end
+  end
+end