chef 0.7.16 → 0.8.2

data/lib/chef.rb

@@ -27,7 +27,7 @@ require 'chef/config'
 Dir[File.join(File.dirname(__FILE__), 'chef/mixin/**/*.rb')].sort.each { |lib| require lib }
 
 class Chef
-  VERSION = '0.7.16'
+  VERSION = '0.8.2'
 end
 
 # Adds a Dir.glob to Ruby 1.8.5, for compat

data/lib/chef/api_client.rb

@@ -0,0 +1,263 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@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/config'
+require 'chef/mixin/params_validate'
+require 'chef/couchdb'
+require 'chef/certificate'
+require 'chef/index_queue'
+require 'extlib'
+require 'json'
+
+class Chef
+  class ApiClient 
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    include Chef::IndexQueue::Indexable
+    
+    
+    DESIGN_DOCUMENT = {
+      "version" => 1,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "client") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "client") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        }
+      }
+    }
+
+    attr_accessor :couchdb_rev, :couchdb_id, :couchdb
+    
+    # Create a new Chef::ApiClient object.
+    def initialize(couchdb=nil)
+      @name = '' 
+      @public_key = nil
+      @private_key = nil
+      @couchdb_rev = nil
+      @couchdb_id = nil
+      @admin = false
+      @couchdb = (couchdb || Chef::CouchDB.new)
+    end
+
+    # Gets or sets the client name.
+    #
+    # @params [Optional String] The name must be alpha-numeric plus - and _.
+    # @return [String] The current value of the name.
+    def name(arg=nil) 
+      set_or_return(
+        :name,
+        arg,
+        :regex => /^[\-[:alnum:]_\.]+$/
+      )
+    end
+
+    # Gets or sets whether this client is an admin. 
+    #
+    # @params [Optional True/False] Should be true or false - default is false.
+    # @return [True/False] The current value
+    def admin(arg=nil)
+      set_or_return(
+        :admin,
+        arg,
+        :kind_of => [ TrueClass, FalseClass ]
+      )
+    end
+
+    # Gets or sets the public key.
+    # 
+    # @params [Optional String] The string representation of the public key. 
+    # @return [String] The current value.
+    def public_key(arg=nil) 
+      set_or_return(
+        :public_key,
+        arg,
+        :kind_of => String
+      )
+    end
+
+    # Gets or sets the private key.
+    # 
+    # @params [Optional String] The string representation of the private key.
+    # @return [String] The current value.
+    def private_key(arg=nil) 
+      set_or_return(
+        :private_key,
+        arg,
+        :kind_of => String
+      )
+    end
+
+    # Creates a new public/private key pair, and populates the public_key and
+    # private_key attributes.
+    # 
+    # @return [True]
+    def create_keys
+      results = Chef::Certificate.gen_keypair(self.name)
+      self.public_key(results[0].to_s)
+      self.private_key(results[1].to_s)
+      true
+    end
+
+    # The hash representation of the object.  Includes the name and public_key,
+    # but never the private key.
+    # 
+    # @return [Hash]
+    def to_hash
+      result = {
+        "name" => @name,
+        "public_key" => @public_key,
+        "admin" => @admin,
+        'json_class' => self.class.name,
+        "chef_type" => "client"
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # The JSON representation of the object.
+    # 
+    # @return [String] the JSON string.
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+    
+    def self.json_create(o)
+      client = Chef::ApiClient.new
+      client.name(o["name"] || o["clientname"])
+      client.public_key(o["public_key"])
+      client.admin(o["admin"])
+      client.couchdb_rev = o["_rev"]
+      client.couchdb_id = o["_id"]
+      client.index_id = client.couchdb_id
+      client
+    end
+    
+    # List all the Chef::ApiClient objects in the CouchDB.  If inflate is set
+    # to true, you will get the full list of all ApiClients, fully inflated.
+    def self.cdb_list(inflate=false, couchdb=nil)
+      rs = (couchdb || Chef::CouchDB.new).list("clients", inflate)
+      lookup = (inflate ? "value" : "key")
+      rs["rows"].collect { |r| r[lookup] }
+    end
+    
+    def self.list(inflate=false)
+      if inflate
+        response = Hash.new
+        Chef::Search::Query.new.search(:client) do |n|
+          n = self.json_create(n) if n.instance_of?(Hash)
+          response[n.name] = n
+        end
+        response
+      else
+        Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("clients")
+      end
+    end
+    
+    # Load a client by name from CouchDB
+    # 
+    # @params [String] The name of the client to load
+    # @return [Chef::ApiClient] The resulting Chef::ApiClient object
+    def self.cdb_load(name, couchdb=nil)
+      (couchdb || Chef::CouchDB.new).load("client", name)
+    end
+    
+    # Load a client by name via the API
+    def self.load(name)
+      response = Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("clients/#{name}")
+      if response.kind_of?(Chef::ApiClient)
+        response
+      else
+        client = Chef::ApiClient.new
+        client.name(response['clientname'])
+        client
+      end
+    end
+    
+    # Remove this client from the CouchDB
+    #
+    # @params [String] The name of the client to delete
+    # @return [Chef::ApiClient] The last version of the object
+    def cdb_destroy
+      @couchdb.delete("client", @name, @couchdb_rev)
+    end
+    
+    # Remove this client via the REST API
+    def destroy
+      Chef::REST.new(Chef::Config[:chef_server_url]).delete_rest("clients/#{@name}")
+    end
+    
+    # Save this client to the CouchDB
+    def cdb_save
+      @couchdb_rev = @couchdb.store("client", @name, self)["rev"]
+    end
+    
+    # Save this client via the REST API, returns a hash including the private key
+    def save(new_key=false, validation=false)
+      if validation
+        r = Chef::REST.new(Chef::Config[:chef_server_url], Chef::Config[:validation_client_name], Chef::Config[:validation_key])
+      else
+        r = Chef::REST.new(Chef::Config[:chef_server_url])
+      end
+      # First, try and create a new registration
+      begin
+        r.post_rest("clients", {:name => self.name, :admin => self.admin })
+      rescue Net::HTTPServerException => e
+        # If that fails, go ahead and try and update it
+        if e.response.code == "409"
+          r.put_rest("clients/#{name}", { :name => self.name, :admin => self.admin, :private_key => new_key }) 
+        else
+          raise e
+        end
+      end
+    end 
+    
+    # Create the client via the REST API
+    def create
+      Chef::REST.new(Chef::Config[:chef_server_url]).post_rest("clients", self)
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document(couchdb=nil)
+      (couchdb ||= Chef::CouchDB.new).create_design_document("clients", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "client[#{@name}]"
+    end
+
+  end
+end
+

data/lib/chef/application.rb

@@ -68,7 +68,7 @@ class Chef::Application
   # Initialize and configure the logger
   def configure_logging
     Chef::Log.init(Chef::Config[:log_location])
-    Chef::Log.level(Chef::Config[:log_level])
+    Chef::Log.level = Chef::Config[:log_level]
   end
   
   # Called prior to starting the application, by the run method

data/lib/chef/application/client.rb

@@ -1,5 +1,6 @@
 #
 # Author:: AJ Christensen (<aj@opscode.com)
+# Author:: Christopher Brown (<cb@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -20,8 +21,7 @@ require 'chef/client'
 require 'chef/config'
 require 'chef/daemon'
 require 'chef/log'
-require 'net/http'
-require 'open-uri'
+require 'chef/rest'
 
 
 class Chef::Application::Client < Chef::Application
@@ -44,6 +44,12 @@ class Chef::Application::Client < Chef::Application
     :description  => "Set the log file location, defaults to STDOUT - recommended for daemonizing",
     :proc         => nil
 
+  option :verbose_logging,
+    :short        => "-V",
+    :long         => "--verbose",
+    :description  => "Ensures logging goes to STDOUT as well as to other configured log location(s).",
+    :proc         => lambda { |p| true }
+
   option :help,
     :short        => "-h",
     :long         => "--help",
@@ -135,7 +141,13 @@ class Chef::Application::Client < Chef::Application
 
     if Chef::Config[:json_attribs]
       begin
-          json_io = open(Chef::Config[:json_attribs])
+        json_io = case Chef::Config[:json_attribs]
+                  when /^(http|https):\/\//
+                    @rest = Chef::REST.new(Chef::Config[:json_attribs], nil, nil)
+                    @rest.get_rest(Chef::Config[:json_attribs], true).open
+                  else
+                    open(Chef::Config[:json_attribs])
+                  end
       rescue SocketError => error
         Chef::Application.fatal!("I cannot connect to #{Chef::Config[:json_attribs]}", 2)
       rescue Errno::ENOENT => error
@@ -148,11 +160,17 @@ class Chef::Application::Client < Chef::Application
 
       begin
         @chef_client_json = JSON.parse(json_io.read)
+        json_io.close unless json_io.closed?
       rescue JSON::ParserError => error
         Chef::Application.fatal!("Could not parse the provided JSON file (#{Chef::Config[:json_attribs]})!: " + error.message, 2)
       end
     end
   end
+
+  def configure_logging
+    super
+    Mixlib::Authentication::Log.logger = Chef::Log.logger
+  end
   
   # Setup an instance of the chef client
   # Why is this so ugly? surely the client should just read out of chef::config instead of needing the values to be assigned like this..

data/lib/chef/application/knife.rb

@@ -0,0 +1,144 @@
+#
+# 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 'chef/knife'
+require 'chef/application'
+require 'chef/client'
+require 'chef/config'
+require 'chef/log'
+require 'chef/node'
+require 'chef/role'
+require 'chef/data_bag'
+require 'chef/data_bag_item'
+require 'chef/rest'
+require 'chef/search/query'
+require 'tmpdir'
+require 'uri'
+
+class Chef::Application::Knife < Chef::Application
+
+  banner "Usage: #{$0} sub-command (options)"
+
+  option :config_file, 
+    :short => "-c CONFIG",
+    :long  => "--config CONFIG",
+    :default => File.join(ENV['HOME'], '.chef', 'knife.rb'),
+    :description => "The configuration file to use"
+
+  option :log_level, 
+    :short        => "-l LEVEL",
+    :long         => "--log_level LEVEL",
+    :description  => "Set the log level (debug, info, warn, error, fatal)",
+    :proc         => lambda { |l| l.to_sym }
+
+  option :log_location,
+    :short        => "-L LOGLOCATION",
+    :long         => "--logfile LOGLOCATION",
+    :description  => "Set the log file location, defaults to STDOUT",
+    :proc         => nil
+
+  option :editor,
+    :short        => "-e EDITOR",
+    :long         => "--editor EDITOR",
+    :description  => "Set the editor to use for interactive commands",
+    :default      => ENV['EDITOR']
+  
+  option :no_editor,
+    :short        => "-n",
+    :long         => "--no-editor",
+    :description  => "Do not open EDITOR, just accept the data as is",
+    :boolean      => true
+  
+  option :help,
+    :short        => "-h",
+    :long         => "--help",
+    :description  => "Show this message",
+    :on           => :tail,
+    :boolean      => true
+    
+  option :node_name,
+    :short => "-u USER",
+    :long => "--user USER",
+    :description => "API Client Username"
+
+  option :client_key,
+    :short => "-k KEY",
+    :long => "--key KEY",
+    :description => "API Client Key"
+
+  option :chef_server_url,
+    :short => "-s URL",
+    :long => "--server-url URL",
+    :description => "Chef Server URL"
+
+  option :yes,
+    :short => "-y",
+    :long => "--yes",
+    :description => "Say yes to all prompts for confirmation"
+
+  option :print_after,
+    :short => "-p",
+    :long => "--print-after",
+    :description => "Show the data after a destructive operation"
+  
+  option :version,
+    :short        => "-v",
+    :long         => "--version",
+    :description  => "Show chef version",
+    :boolean      => true,
+    :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
+    :exit         => 0
+
+  # Run knife 
+  def run
+    validate_and_parse_options
+    knife = Chef::Knife.find_command(ARGV, self.class.options)
+    knife.run
+  end
+  
+  private
+  
+  def validate_and_parse_options
+    # Checking ARGV validity *before* parse_options because parse_options
+    # mangles ARGV in some situations
+    print_help_and_exit(2, "Sorry, you need to pass a sub-command first!") if no_subcommand_given?
+    print_help_and_exit if no_command_given?
+  end
+  
+  def no_subcommand_given?
+    ARGV[0] =~ /^-/
+  end
+  
+  def no_command_given?
+    ARGV.empty?
+  end
+  
+  def print_help_and_exit(exitcode=1, fatal_message=nil)
+    Chef::Log.fatal(fatal_message) if fatal_message
+  
+    begin
+      self.parse_options
+    rescue OptionParser::InvalidOption => e
+      puts "#{e}\n"
+    end
+    puts self.opt_parser
+    puts
+    Chef::Knife.list_commands
+    exit exitcode
+  end
+  
+end