rmm-chef 0.10.0.rc.0

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

@@ -0,0 +1,184 @@
+#--
+# 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'
+
+class Chef
+  class Knife
+    module Core
+
+      #==Chef::Knife::Core::GenericPresenter
+      # The base presenter class for displaying structured data in knife commands.
+      # This is not an abstract base class, and it is suitable for displaying
+      # most kinds of objects that knife needs to display.
+      class GenericPresenter
+
+        attr_reader :ui
+        attr_reader :config
+
+        # Instaniates a new GenericPresenter. This is generally handled by the
+        # Chef::Knife::UI object, though you need to match the signature of this
+        # method if you intend to use your own presenter instead.
+        def initialize(ui, config)
+          @ui, @config = ui, config
+        end
+
+        # Is the selected output format a data interchange format?
+        # Returns true if the selected output format is json or yaml, false
+        # otherwise. Knife search uses this to adjust its data output so as not
+        # to produce invalid JSON output.
+        def interchange?
+          case parse_format_option
+          when :json, :yaml
+            true
+          else
+            false
+          end
+        end
+
+        # Returns a String representation of +data+ that is suitable for output
+        # to a terminal or perhaps for data interchange with another program.
+        # The representation of the +data+ depends on the value of the
+        # `config[:format]` setting.
+        def format(data)
+          case parse_format_option
+          when :summary
+            summarize(data)
+          when :text
+            text_format(data)
+          when :json
+            Chef::JSONCompat.to_json_pretty(data)
+          when :yaml
+            require 'yaml'
+            YAML::dump(data)
+          when :pp
+            # If you were looking for some attribute and there is only one match
+            # just dump the attribute value
+            if data.length == 1 and config[:attribute]
+              data.values[0]
+            else
+              out = StringIO.new
+              PP.pp(data, out)
+              out.string
+            end
+          end
+        end
+
+        # Converts the user-supplied value of `config[:format]` to a Symbol
+        # representing the desired output format.
+        # ===Returns
+        # returns one of :summary, :text, :json, :yaml, or :pp
+        # ===Raises
+        # Raises an ArgumentError if the desired output format could not be
+        # determined from the value of `config[:format]`
+        def parse_format_option
+          case config[:format]
+          when "summary", /^s/, nil
+            :summary
+          when "text", /^t/
+            :text
+          when "json", /^j/
+            :json
+          when "yaml", /^y/
+            :yaml
+          when "pp", /^p/
+            :pp
+          else
+            raise ArgumentError, "Unknown output format #{config[:format]}"
+          end
+        end
+
+        # Summarize the data. Defaults to text format output,
+        # which may not be very summary-like
+        def summarize(data)
+          text_format(data)
+        end
+
+        # Converts the +data+ to a String in the text format. Uses
+        # Chef::Knife::Core::TextFormatter
+        def text_format(data)
+          TextFormatter.new(data, ui).formatted_data
+        end
+
+        def format_list_for_display(list)
+          config[:with_uri] ? list : list.keys.sort { |a,b| a <=> b }
+        end
+
+        def format_for_display(data)
+          if config[:attribute]
+            result = {}
+            Array(config[:attribute]).each do |nested_value_spec|
+              nested_value = extract_nested_value(data, nested_value_spec)
+              result[nested_value_spec] = nested_value
+            end
+            result
+          elsif config[:run_list]
+            data = data.run_list.run_list
+            { "run_list" => data }
+          elsif config[:environment]
+            if data.respond_to?(:chef_environment)
+              {"chef_environment" => data.chef_environment}
+            else
+              # this is a place holder for now. Feel free to modify (i.e. add other cases). [nuo]
+              data
+            end
+          elsif config[:id_only]
+            data.respond_to?(:name) ? data.name : data["id"]
+          else
+            data
+          end
+        end
+
+        def extract_nested_value(data, nested_value_spec)
+          nested_value_spec.split(".").each do |attr|
+            if data.nil?
+              nil # don't get no method error on nil
+            elsif data.respond_to?(attr.to_sym)
+              data = data.send(attr.to_sym)
+            elsif data.respond_to?(:[])
+              data = data[attr]
+            else
+              data = begin
+                data.send(attr.to_sym)
+              rescue NoMethodError
+                nil
+              end
+            end
+          end
+          ( !data.kind_of?(Array) && data.respond_to?(:to_hash) ) ? data.to_hash : data
+        end
+
+        def format_cookbook_list_for_display(item)
+          if config[:with_uri]
+            item
+          else
+            versions_by_cookbook = item.inject({}) do |collected, ( cookbook, versions )|
+              collected[cookbook] = versions["versions"].map {|v| v['version']}
+              collected
+            end
+            key_length = versions_by_cookbook.empty? ? 0 : versions_by_cookbook.keys.map {|name| name.size }.max + 2
+            versions_by_cookbook.sort.map do |cookbook, versions|
+              "#{cookbook.ljust(key_length)} #{versions.join('  ')}"
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+#
+# 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 --no-editor option, nothing to edit" if config[:no_editor]
+        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)
+        # TODO: should warn/error/ask for confirmation when changing the
+        # name, since this results in a new node, not an edited node.
+        @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,103 @@
+#
+# 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
+
+        # 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 the ui object.
+        def summarize(data)
+          if data.kind_of?(Chef::Node)
+            node = data
+            summarized=<<-SUMMARY
+#{ui.color('Node Name:', :bold)}   #{ui.color(node.name, :bold)}
+#{key('Environment:')} #{node.chef_environment}
+#{key('FQDN:')}        #{node[:fqdn]}
+#{key('IP:')}          #{node[:ipaddress]}
+#{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]}
+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,75 @@
+#
+# 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
+
+        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 for #{components.join(' ')}"
+            exit 1
+          end
+          object_from_file(object_file)
+        end
+
+        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
+
+        def object_from_file(filename)
+          case filename
+          when /\.(js|json)$/
+            Chef::JSONCompat.from_json(IO.read(filename))
+          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
+