runa-chef 0.8.0.1

data/lib/chef/exceptions.rb

@@ -0,0 +1,39 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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 Exceptions
+    class Application < RuntimeError; end
+    class Cron < RuntimeError; end
+    class Exec < RuntimeError; end
+    class FileNotFound < RuntimeError; end  
+    class Package < RuntimeError; end
+    class Service < RuntimeError; end
+    class Route < RuntimeError; end
+    class SearchIndex < RuntimeError; end  
+    class Override < RuntimeError; end
+    class UnsupportedAction < RuntimeError; end
+    class MissingLibrary < RuntimeError; end
+    class User < RuntimeError; end
+    class Group < RuntimeError; end
+    class Link < RuntimeError; end
+    class Mount < RuntimeError; end
+    class CouchDBNotFound < RuntimeError; end
+    class PrivateKeyMissing < RuntimeError; end
+    class CannotWritePrivateKey < RuntimeError; end
+  end
+end

data/lib/chef/file_cache.rb

@@ -0,0 +1,205 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/params_validate'
+require 'chef/mixin/create_path'
+require 'chef/exceptions'
+require 'json'
+require 'fileutils'
+
+class Chef
+  class FileCache
+    class << self
+      include Chef::Mixin::ParamsValidate
+      include Chef::Mixin::CreatePath
+      
+      # Write a file to the File Cache.
+      #
+      # === Parameters
+      # path<String>:: The path to the file you want to put in the cache - should
+      #   be relative to Chef::Config[:file_cache_path]
+      # contents<String>:: A string with the contents you want written to the file
+      #
+      # === Returns
+      # true
+      def store(path, contents)
+        validate(
+          {
+            :path => path,
+            :contents => contents
+          },
+          {
+            :path => { :kind_of => String },
+            :contents => { :kind_of => String },
+          }
+        )
+      
+        file_path_array = File.split(path)
+        file_name = file_path_array.pop
+        cache_path = create_cache_path(File.join(file_path_array))
+        io = File.open(File.join(cache_path, file_name), "w")
+        io.print(contents)
+        io.close
+        true
+      end
+      
+      # Move a file in to the cache.  Useful with the REST raw file output.
+      #
+      # === Parameteres
+      # file<String>:: The path to the file you want in the cache
+      # path<String>:: The relative name you want the new file to use
+      def move_to(file, path)
+        validate(
+          {
+            :file => file,
+            :path => path
+          },
+          {
+            :file => { :kind_of => String },
+            :path => { :kind_of => String },
+          }
+        )
+        
+        file_path_array = File.split(path)
+        file_name = file_path_array.pop
+        if File.exists?(file) && File.writable?(file)
+          FileUtils.mv(
+            file, 
+            File.join(create_cache_path(File.join(file_path_array), true), file_name)
+          )
+        else
+          raise RuntimeError, "Cannot move #{file} to #{path}!"
+        end
+      end
+    
+      # Read a file from the File Cache
+      #
+      # === Parameters
+      # path<String>:: The path to the file you want to load - should
+      #   be relative to Chef::Config[:file_cache_path]
+      # read<True/False>:: Whether to return the file contents, or the path.
+      #   Defaults to true.
+      #
+      # === Returns
+      # String:: A string with the file contents, or the path to the file.
+      #
+      # === Raises
+      # Chef::Exceptions::FileNotFound:: If it cannot find the file in the cache
+      def load(path, read=true)
+        validate(
+          {
+            :path => path
+          },
+          {
+            :path => { :kind_of => String }
+          }
+        )
+        cache_path = create_cache_path(path, false)
+        raise Chef::Exceptions::FileNotFound, "Cannot find #{cache_path} for #{path}!" unless File.exists?(cache_path)
+        if read
+          File.read(cache_path)
+        else
+          cache_path
+        end
+      end
+      
+      # Delete a file from the File Cache
+      #
+      # === Parameters
+      # path<String>:: The path to the file you want to delete - should
+      #   be relative to Chef::Config[:file_cache_path]
+      #
+      # === Returns
+      # true
+      def delete(path)
+        validate(
+          {
+            :path => path
+          },
+          {
+            :path => { :kind_of => String },
+          }
+        )
+        cache_path = create_cache_path(path, false)
+        if File.exists?(cache_path)
+          File.unlink(cache_path)
+        end
+        true
+      end
+      
+      # List all the files in the Cache
+      #
+      # === Returns
+      # Array:: An array of files in the cache, suitable for use with load, delete and store
+      def list()
+        keys = Array.new
+        Dir[File.join(Chef::Config[:file_cache_path], '**', '*')].each do |f|
+          if File.file?(f)
+            path = f.match("^#{Chef::Config[:file_cache_path]}\/(.+)")[1]
+            keys << path
+          end
+        end
+        keys
+      end
+      
+      # Whether or not this file exists in the Cache
+      #
+      # === Parameters
+      # path:: The path to the file you want to check - is relative 
+      #   to Chef::Config[:file_cache_path]
+      # 
+      # === Returns
+      # True:: If the file exists
+      # False:: If it does not
+      def has_key?(path)
+        validate(
+          {
+            :path => path
+          },
+          {
+            :path => { :kind_of => String },
+          }
+        )
+        full_path = create_cache_path(path, false)
+        if File.exists?(full_path)
+          true
+        else
+          false
+        end
+      end
+      
+      # Create a full path to a given file in the cache. By default,
+      # also creates the path if it does not exist.
+      #
+      # === Parameters
+      # path:: The path to create, relative to Chef::Config[:file_cache_path]
+      # create_if_missing:: True by default - whether to create the path if it does not exist
+      # 
+      # === Returns
+      # String:: The fully expanded path
+      def create_cache_path(path, create_if_missing=true)
+        cache_dir = File.expand_path(File.join(Chef::Config[:file_cache_path], path))
+        if create_if_missing
+          create_path(cache_dir) 
+        else
+          cache_dir
+        end
+      end
+  
+    end
+  end
+end

data/lib/chef/knife.rb

@@ -0,0 +1,300 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2009 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 'mixlib/cli'
+require 'chef/mixin/convert_to_class_name'
+
+class Chef
+  class Knife
+    include Mixlib::CLI
+    extend Chef::Mixin::ConvertToClassName
+
+    attr_accessor :name_args
+
+    # Load all the sub-commands
+    def self.load_commands
+      @sub_classes = Hash.new
+      Dir[
+        File.expand_path(File.join(File.dirname(__FILE__), 'knife', '*.rb'))
+      ].each do |knife_file|
+        require knife_file
+        snake_case_file_name = File.basename(knife_file).sub(/\.rb$/, '')
+        @sub_classes[snake_case_file_name] = convert_to_class_name(snake_case_file_name)
+      end
+      @sub_classes
+    end
+
+    def self.list_commands
+      load_commands
+      @sub_classes.keys.sort.each do |snake_case|
+        klass_instance = build_sub_class(snake_case) 
+        klass_instance.parse_options
+        puts klass_instance.opt_parser
+        puts
+      end
+    end
+
+    def self.build_sub_class(snake_case, merge_opts=nil)
+      klass = Chef::Knife.const_get(@sub_classes[snake_case])
+      klass.options.merge!(merge_opts) if merge_opts 
+      klass.new
+    end
+
+    def self.find_command(args=ARGV, merge_opts={})
+      load_commands
+
+      non_dash_args = Array.new
+      args.each do |arg|
+        non_dash_args << arg if arg =~ /^([[:alnum:]]|_)+$/
+      end
+
+      to_try = non_dash_args.length 
+      klass_instance = nil
+      cli_bits = nil 
+
+      while(to_try >= 0)
+        cli_bits = non_dash_args[0..to_try]
+        snake_case_class_name = cli_bits.join("_")
+
+        if @sub_classes.has_key?(snake_case_class_name)
+          klass_instance = build_sub_class(snake_case_class_name, merge_opts)
+          break
+        end
+
+        to_try = to_try - 1
+      end
+
+      unless klass_instance
+        Chef::Log.fatal("Cannot find sub command for: #{args.join(' ')}")
+        Chef::Knife.list_commands
+        exit 10
+      end
+
+      extra = klass_instance.parse_options(args)
+      if klass_instance.config[:help]
+        puts klass_instance.opt_parser
+        exit 1
+      end
+      klass_instance.name_args = (extra - cli_bits) || []
+      klass_instance.configure_chef
+      klass_instance
+    end
+
+    def ask_question(q)
+      print q 
+      a = STDIN.readline
+      a.chomp!
+      a
+    end
+
+    def configure_chef
+      if !config[:config_file].nil? && File.exists?(config[:config_file]) && File.readable?(config[:config_file])
+        Chef::Config.from_file(config[:config_file]) 
+      end
+
+      Chef::Config[:log_level] = config[:log_level] if config[:log_level]
+      Chef::Config[:log_location] = config[:log_location] if config[:log_location]
+      Chef::Config[:node_name] = config[:node_name] if config[:node_name]
+      Chef::Config[:client_key] = config[:client_key] if config[:client_key]
+      Chef::Config[:chef_server_url] = config[:chef_server_url] if config[:chef_server_url]
+      Chef::Log::Formatter.show_time = false
+      Chef::Log.init(Chef::Config[:log_location])
+      Chef::Log.level(Chef::Config[:log_level])
+    end
+
+    def pretty_print(data)
+      puts data
+    end
+
+    def json_pretty_print(data)
+      puts JSON.pretty_generate(data)
+    end
+
+    def format_list_for_display(list)
+      config[:with_uri] ? list : list.keys.sort { |a,b| a <=> b } 
+    end
+
+    def format_for_display(item)
+      data = item.kind_of?(Chef::DataBagItem) ? item.raw_data : item
+
+      if config[:attribute]
+        config[:attribute].split(".").each do |attr|
+          if data.respond_to?(:[])
+            data = data[attr]
+          else
+            data = data.send(attr.to_sym)
+          end
+        end
+        { config[:attribute] => data.kind_of?(Chef::Node::Attribute) ? data.to_hash: data }
+      elsif config[:run_list]
+        data = data.run_list.run_list
+        { "run_list" => data }
+      elsif config[:id_only]
+        data.respond_to?(:name) ? data.name : data["id"]
+      else
+        data
+      end
+    end
+
+    def edit_data(data, parse_output=true)
+      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 JSON.pretty_generate(data)
+      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)
+
+      parse_output ? JSON.parse(output) : output
+    end
+
+    def confirm(question)
+      return true if config[:yes]
+
+      print "#{question}? (Y/N) "
+      answer = STDIN.readline
+      answer.chomp!
+      case answer
+      when "Y", "y"
+        true
+      when "N", "n"
+        Chef::Log.info("You said no, so I'm done here.")
+        exit 3 
+      else
+        Chef::Log.error("I have no idea what to do with #{answer}")
+        Chef::Log.error("Just say Y or N, please.")
+        confirm(question)
+      end
+    end
+
+    def load_from_file(klass, from_file) 
+      from_file = @name_args[0]
+      relative_file = File.expand_path(File.join(Dir.pwd, 'roles', from_file))
+      filename = nil
+
+      if file_exists_and_is_readable?(from_file)
+        filename = from_file
+      elsif file_exists_and_is_readable?(relative_file) 
+        filename = relative_file 
+      else
+        Chef::Log.fatal("Cannot find file #{from_file}")
+        exit 30
+      end
+
+      case from_file
+      when /\.(js|json)$/
+        JSON.parse(IO.read(filename))
+      when /\.rb$/
+        r = klass.new
+        r.from_file(filename)
+        r
+      else
+        Chef::Log.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
+
+    def edit_object(klass, name)
+      object = klass.load(name)
+
+      output = edit_data(object)
+      
+      output.save
+
+      Chef::Log.info("Saved #{output}")
+
+      json_pretty_print(format_for_display(object)) if config[:print_after]
+    end
+
+    def create_object(object, pretty_name=nil, &block)
+      output = edit_data(object)
+
+      if Kernel.block_given?
+        output = block.call(output)
+      else
+        output.save
+      end
+
+      pretty_name ||= output
+
+      Chef::Log.info("Created (or updated) #{pretty_name}")
+      
+      json_pretty_print(output) if config[:print_after]
+    end
+
+    def delete_object(klass, name, delete_name=nil, &block)
+      confirm("Do you really want to delete #{name}")
+
+      if Kernel.block_given?
+        object = block.call
+      else
+        object = klass.load(name)
+        object.destroy
+      end
+
+      json_pretty_print(format_for_display(object)) if config[:print_after]
+
+      obj_name = delete_name ? "#{delete_name}[#{name}]" : object
+      Chef::Log.warn("Deleted #{obj_name}!")
+    end
+
+    def bulk_delete(klass, fancy_name, delete_name=nil, list=nil, &block)
+      object_list = list ? list : klass.list(true)
+
+      if config[:regex]
+        to_delete = Hash.new
+        object_list.each_key do |object|
+          next if config[:regex] && object !~ /#{config[:regex]}/
+          to_delete[object] = object_list[object]
+        end
+      else
+        to_delete = object_list
+      end
+
+      json_pretty_print(format_list_for_display(to_delete))
+
+      confirm("Do you really want to delete the above items")
+
+      to_delete.each do |name, object|
+        if Kernel.block_given?
+          block.call(name, object)
+        else
+          object.destroy
+        end
+        json_pretty_print(format_for_display(object)) if config[:print_after]
+        Chef::Log.warn("Deleted #{fancy_name} #{name}")
+      end
+    end
+
+    def rest
+      @rest ||= Chef::REST.new(Chef::Config[:chef_server_url])
+    end
+
+  end
+end
+