TrueCar-chef 0.10.0.beta.3

data/lib/chef/knife/status.rb

@@ -0,0 +1,90 @@
+#
+# Author:: Ian Meyer (<ianmmeyer@gmail.com>)
+# Copyright:: Copyright (c) 2010 Ian Meyer
+# 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'
+
+class Chef
+  class Knife
+    class Status < Knife
+
+      deps do
+        require 'highline'
+        require 'chef/search/query'
+      end
+
+      banner "knife status QUERY (options)"
+
+      option :run_list,
+        :short => "-r",
+        :long => "--run-list",
+        :description => "Show the run list"
+
+      def highline
+        @h ||= HighLine.new
+      end
+
+      def run
+        all_nodes = []
+        q = Chef::Search::Query.new
+        query = @name_args[0] || "*:*"
+        q.search(:node, query) do |node|
+          all_nodes << node
+        end
+        all_nodes.sort { |n1, n2| (n1["ohai_time"] or 0) <=> (n2["ohai_time"] or 0) }.each do |node|
+          if node.has_key?("ec2")
+            fqdn = node['ec2']['public_hostname']
+            ipaddress = node['ec2']['public_ipv4']
+          else
+            fqdn = node['fqdn']
+            ipaddress = node['ipaddress']
+          end
+          hours, minutes, seconds = time_difference_in_hms(node["ohai_time"])
+          hours_text   = "#{hours} hour#{hours == 1 ? ' ' : 's'}"
+          minutes_text = "#{minutes} minute#{minutes == 1 ? ' ' : 's'}"
+          run_list = ", #{node.run_list}." if config[:run_list]
+          if hours > 24
+            color = "RED"
+            text = hours_text
+          elsif hours >= 1
+            color = "YELLOW"
+            text = hours_text
+          else
+            color = "GREEN"
+            text = minutes_text
+          end
+
+          highline.say("<%= color('#{text}', #{color}) %> ago, #{node.name}, #{node['platform']} #{node['platform_version']}, #{fqdn}, #{ipaddress}#{run_list}")
+        end
+
+      end
+
+      # :nodoc:
+      # TODO: this is duplicated from StatusHelper in the Webui. dedup.
+      def time_difference_in_hms(unix_time)
+        now = Time.now.to_i
+        difference = now - unix_time.to_i
+        hours = (difference / 3600).to_i
+        difference = difference % 3600
+        minutes = (difference / 60).to_i
+        seconds = (difference % 60)
+        return [hours, minutes, seconds]
+      end
+
+    end
+  end
+end

data/lib/chef/knife/subcommand_loader.rb

@@ -0,0 +1,101 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# 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
+      end
+
+      # Load all the sub-commands
+      def load_commands
+        subcommand_files.each { |subcommand| require 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'))
+
+        user_specific_files.map! { |path| path[/(.+).rb/, 1] }
+        user_specific_files
+      end
+
+      # Returns an Array 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.
+      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 + 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__)]
+        files.map! { |knife_file| knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/,1] }
+        files
+      end
+
+      def find_subcommands_via_rubygems
+        files = Gem.find_files 'chef/knife/*.rb'
+        files.reject! {|f| from_old_gem?(f) }
+        files.map! do |file|
+          file[/(#{Regexp.escape File.join('chef', 'knife', '')}.*)\.rb/, 1]
+        end.uniq!
+        files
+      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

data/lib/chef/knife/tag_create.rb

@@ -0,0 +1,31 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class TagCreate < Knife
+
+      deps do
+        require 'chef/node'
+      end
+
+      banner "knife tag create NODE TAG ..."
+
+      def run
+        name = @name_args[0]
+        tags = @name_args[1..-1].join(",").split(/\s*,\s*/)
+
+        unless name or tags.empty?
+          show_usage
+          # TODO: blah blah
+          ui.fatal("You must specify a node name")
+          exit 1
+        end
+
+        node = Chef::Node.load name
+        tags.each do |tag|
+          node.tags << tag
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/tag_delete.rb

@@ -0,0 +1,31 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class TagDelete < Knife
+
+      deps do
+        require 'chef/node'
+      end
+
+      banner "knife tag delete NODE TAG ..."
+
+      def run
+        name = @name_args[0]
+        tags = @name_args[1..-1].join(",").split(/\s*,\s*/)
+
+        unless name or tags.empty?
+          show_usage
+          # TODO: blah blah
+          ui.fatal("You must specify a node name")
+          exit 1
+        end
+
+        node = Chef::Node.load name
+        tags.each do |tag|
+          node.tags.delete tag
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/tag_list.rb

@@ -0,0 +1,29 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class TagList < Knife
+
+      deps do
+        require 'chef/node'
+      end
+
+      banner "knife tag list NODE"
+
+      def run
+        name = @name_args[0]
+        tags = @name_args[1..-1].join(",").split(/\s*,\s*/)
+
+        unless name or tags.empty?
+          show_usage
+          # TODO: blah blah
+          ui.fatal("You must specify a node name")
+          exit 1
+        end
+
+        node = Chef::Node.load name
+        output node.tags
+      end
+    end
+  end
+end

data/lib/chef/knife/ui.rb

@@ -0,0 +1,227 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# 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.
+#
+
+
+class Chef
+  class Knife
+    class UI
+
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :stdin
+      attr_reader :config
+
+      def initialize(stdout, stderr, stdin, config)
+        @stdout, @stderr, @stdin, @config = stdout, stderr, stdin, config
+      end
+
+      def highline
+        @highline ||= begin
+          require 'highline'
+          HighLine.new
+        end
+      end
+
+      def msg(message)
+        stdout.puts message
+      end
+
+      alias :info :msg
+
+      def warn(message)
+        msg("WARNING: #{message}")
+      end
+
+      def error(message)
+        msg("ERROR: #{message}")
+      end
+
+      def fatal(message)
+        msg("FATAL: #{message}")
+      end
+
+      def color(*args)
+        highline.color(*args)
+      end
+
+      def ask(*args, &block)
+        highline.ask(*args, &block)
+      end
+
+      def list(*args)
+        highline.list(*args)
+      end
+
+      def ask_question(question, opts={})
+        question = question + "[#{opts[:default]}] " if opts[:default]
+
+        if opts[:default] and config[:defaults]
+          opts[:default]
+        else
+          stdout.print question
+          a = stdin.readline.strip
+
+          if opts[:default]
+            a.empty? ? opts[:default] : a
+          else
+            a
+          end
+        end
+      end
+
+      def pretty_print(data)
+        stdout.puts data
+      end
+
+      def output(data)
+        case config[:format]
+        when "json", nil
+          stdout.puts Chef::JSONCompat.to_json_pretty(data)
+        when "yaml"
+          require 'yaml'
+          stdout.puts YAML::dump(data)
+        when "text"
+          # 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]
+            stdout.puts data.values[0]
+          else
+            PP.pp(data, stdout)
+          end
+        else
+          raise ArgumentError, "Unknown output format #{config[:format]}"
+        end
+      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]
+          config[:attribute].split(".").each do |attr|
+            if data.respond_to?(:[])
+              data = data[attr]
+            elsif data.nil?
+              nil # don't get no method error on nil
+            else data.respond_to?(attr.to_sym)
+              data = data.send(attr.to_sym)
+            end
+          end
+          { config[:attribute] => data.respond_to?(:to_hash) ? data.to_hash : data }
+        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 format_cookbook_list_for_display(item)
+        if config[:with_uri]
+          item
+        else
+          item.inject({}){|result, (k,v)|
+            result[k] = v["versions"].inject([]){|res, ver| res.push(ver["version"]); res}
+            result
+          }
+        end
+      end
+
+      def edit_data(data, parse_output=true)
+        output = Chef::JSONCompat.to_json_pretty(data)
+
+        if (!config[:no_editor])
+          filename = "knife-edit-"
+          0.upto(20) { filename += rand(9).to_s }
+          filename << ".js"
+          filename = File.join(Dir.tmpdir, filename)
+          tf = File.open(filename, "w")
+          tf.sync = true
+          tf.puts output
+          tf.close
+          raise "Please set EDITOR environment variable" unless system("#{config[:editor]} #{tf.path}")
+          tf = File.open(filename, "r")
+          output = tf.gets(nil)
+          tf.close
+          File.unlink(filename)
+        end
+
+        parse_output ? Chef::JSONCompat.from_json(output) : output
+      end
+
+      def edit_object(klass, name)
+        object = klass.load(name)
+
+        output = edit_data(object)
+
+        # Only make the save if the user changed the object.
+        #
+        # Output JSON for the original (object) and edited (output), then parse
+        # them without reconstituting the objects into real classes
+        # (create_additions=false). Then, compare the resulting simple objects,
+        # which will be Array/Hash/String/etc.
+        #
+        # We wouldn't have to do these shenanigans if all the editable objects
+        # implemented to_hash, or if to_json against a hash returned a string
+        # with stable key order.
+        object_parsed_again = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(object), :create_additions => false)
+        output_parsed_again = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(output), :create_additions => false)
+        if object_parsed_again != output_parsed_again
+          output.save
+          self.msg("Saved #{output}")
+        else
+          self.msg("Object unchanged, not saving")
+        end
+        output(format_for_display(object)) if config[:print_after]
+      end
+
+      def confirm(question, append_instructions=true)
+        return true if config[:yes]
+
+        stdout.print question
+        stdout.print "? (Y/N) " if append_instructions
+        answer = stdin.readline
+        answer.chomp!
+        case answer
+        when "Y", "y"
+          true
+        when "N", "n"
+          self.msg("You said no, so I'm done here.")
+          exit 3
+        else
+          self.msg("I have no idea what to do with #{answer}")
+          self.msg("Just say Y or N, please.")
+          confirm(question)
+        end
+      end
+
+    end
+  end
+end