tylerrick-chef 0.10.8

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

@@ -0,0 +1,148 @@
+#
+# 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/mixin/shell_out'
+
+class Chef
+  class Knife
+    class CookbookSCMRepo
+
+      DIRTY_REPO = /^[\s]+M/
+
+      include Chef::Mixin::ShellOut
+
+      attr_reader :repo_path
+      attr_reader :default_branch
+      attr_reader :ui
+
+      def initialize(repo_path, ui, opts={})
+        @repo_path = repo_path
+        @ui = ui
+        @default_branch = 'master'
+        apply_opts(opts)
+      end
+
+      def sanity_check
+        unless ::File.directory?(repo_path)
+          ui.error("The cookbook repo path #{repo_path} does not exist or is not a directory")
+          exit 1
+        end
+        unless git_repo?(repo_path)
+          ui.error "The cookbook repo #{repo_path} is not a git repository."
+          ui.info("Use `git init` to initialize a git repo")
+          exit 1
+        end
+        unless branch_exists?(default_branch)
+          ui.error "The default branch '#{default_branch}' does not exist"
+          ui.info "If this is a new git repo, make sure you have at least one commit before installing cookbooks"
+          exit 1
+        end
+        cmd = git('status --porcelain')
+        if cmd.stdout =~ DIRTY_REPO
+          ui.error "You have uncommitted changes to your cookbook repo (#{repo_path}):"
+          ui.msg cmd.stdout
+          ui.info "Commit or stash your changes before importing cookbooks"
+          exit 1
+        end
+        # TODO: any untracked files in the cookbook directory will get nuked later
+        # make this an error condition also.
+        true
+      end
+
+      def reset_to_default_state
+        ui.info("Checking out the #{default_branch} branch.")
+        git("checkout #{default_branch}")
+      end
+
+      def prepare_to_import(cookbook_name)
+        branch = "chef-vendor-#{cookbook_name}"
+        if branch_exists?(branch)
+          ui.info("Pristine copy branch (#{branch}) exists, switching to it.")
+          git("checkout #{branch}")
+        else
+          ui.info("Creating pristine copy branch #{branch}")
+          git("checkout -b #{branch}")
+        end
+      end
+
+      def finalize_updates_to(cookbook_name, version)
+        if update_count = updated?(cookbook_name)
+          ui.info "#{update_count} files updated, committing changes"
+          git("add #{cookbook_name}")
+          git("commit -m 'Import #{cookbook_name} version #{version}' -- #{cookbook_name}")
+          ui.info("Creating tag cookbook-site-imported-#{cookbook_name}-#{version}")
+          git("tag -f cookbook-site-imported-#{cookbook_name}-#{version}")
+          true
+        else
+          ui.info("No changes made to #{cookbook_name}")
+          false
+        end
+      end
+
+      def merge_updates_from(cookbook_name, version)
+        branch = "chef-vendor-#{cookbook_name}"
+        Dir.chdir(repo_path) do
+          if system("git merge #{branch}")
+            ui.info("Cookbook #{cookbook_name} version #{version} successfully installed")
+          else
+            ui.error("You have merge conflicts - please resolve manually")
+            ui.info("Merge status (cd #{repo_path}; git status):")
+            system("git status")
+            exit 3
+          end
+        end
+      end
+
+      def updated?(cookbook_name)
+        update_count = git("status --porcelain -- #{cookbook_name}").stdout.strip.lines.count
+        update_count == 0 ? nil : update_count
+      end
+
+      def branch_exists?(branch_name)
+        git("branch --no-color").stdout.lines.any? {|l| l =~ /\s#{Regexp.escape(branch_name)}(?:\s|$)/ }
+      end
+
+      private
+
+      def git_repo?(directory)
+        if File.directory?(File.join(directory, '.git'))
+          return true
+        elsif File.dirname(directory) == directory
+          return false
+        else
+          git_repo?(File.dirname(directory))
+        end
+      end
+
+      def apply_opts(opts)
+        opts.each do |option, value|
+          case option.to_s
+          when 'default_branch'
+            @default_branch = value
+          end
+        end
+      end
+
+      def git(command)
+        shell_out!("git #{command}", :cwd => repo_path)
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,191 @@
+#--
+# 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
+            require 'stringio'
+            # 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.inject({}) do |collected, (cookbook, versions)|
+              collected[cookbook] = Hash.new
+              versions['versions'].each do |ver|
+                collected[cookbook][ver['version']] = ver['url']
+              end
+              collected
+            end
+          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
+