giraffesoft-chef 0.7.15

data/lib/chef/role.rb

@@ -0,0 +1,231 @@
+#
+# 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/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/couchdb'
+require 'extlib'
+require 'json'
+
+class Chef
+  class Role 
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    
+    DESIGN_DOCUMENT = {
+      "version" => 3,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "role") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "role") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        },
+      },
+    }
+
+    attr_accessor :couchdb_rev
+    
+    # Create a new Chef::Role object.
+    def initialize()
+      @name = '' 
+      @description = '' 
+      @default_attributes = Mash.new
+      @override_attributes = Mash.new
+      @recipes = Array.new 
+      @couchdb_rev = nil
+      @couchdb = Chef::CouchDB.new
+    end
+
+    def name(arg=nil) 
+      set_or_return(
+        :name,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def description(arg=nil) 
+      set_or_return(
+        :description,
+        arg,
+        :kind_of => String
+      )
+    end
+
+    def recipes(*arg) 
+      arg.flatten!
+      if arg.length == 0
+        @recipes
+      else
+        arg.each do |entry|
+          raise ArgumentError, 'Recipes must be strings!' unless entry.kind_of?(String)
+        end
+        @recipes = arg
+      end
+    end
+
+    def default_attributes(arg=nil)
+      set_or_return(
+        :default_attributes,
+        arg,
+        :kind_of => Hash
+      )
+    end
+
+    def override_attributes(arg=nil)
+      set_or_return(
+        :override_attributes,
+        arg,
+        :kind_of => Hash
+      )
+    end
+
+    def to_hash
+      result = {
+        "name" => @name,
+        "description" => @description,
+        'json_class' => self.class.name,
+        "default_attributes" => @default_attributes,
+        "override_attributes" => @override_attributes,
+        "chef_type" => "role",
+        "recipes" => @recipes,
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # Serialize this object as a hash 
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+    
+    # Create a Chef::Role from JSON
+    def self.json_create(o)
+      role = new
+      role.name(o["name"])
+      role.description(o["description"])
+      role.default_attributes(o["default_attributes"])
+      role.override_attributes(o["override_attributes"])
+      role.recipes(o["recipes"])
+      role.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      role 
+    end
+    
+    # List all the Chef::Role objects in the CouchDB.  If inflate is set to true, you will get
+    # the full list of all Roles, fully inflated.
+    def self.list(inflate=false)
+      rs = Chef::CouchDB.new.list("roles", inflate)
+      if inflate
+        rs["rows"].collect { |r| r["value"] }
+      else
+        rs["rows"].collect { |r| r["key"] }
+      end
+    end
+    
+    # Load a role by name from CouchDB
+    def self.load(name)
+      Chef::CouchDB.new.load("role", name)
+    end
+    
+    # Remove this role from the CouchDB
+    def destroy
+      @couchdb.delete("role", @name, @couchdb_rev)
+
+      if Chef::Config[:couchdb_version] == 0.9
+        rs = @couchdb.get_view("nodes", "by_run_list", :startkey => "role[#{@name}]", :endkey => "role[#{@name}]", :include_docs => true)
+        rs["rows"].each do |row| 
+          node = row["doc"]
+          node.run_list.remove("role[#{@name}]")
+          node.save
+        end
+      else
+       Chef::Node.list.each do |node|
+         n = Chef::Node.load(node)
+         n.run_list.remove("role[#{@name}]")
+         n.save
+       end
+      end
+    end
+    
+    # Save this role to the CouchDB
+    def save
+      results = @couchdb.store("role", @name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document
+      Chef::CouchDB.new.create_design_document("roles", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "role[#{@name}]"
+    end
+
+    # Load a role from disk - prefers to load the JSON, but will happily load
+    # the raw rb files as well.
+    def self.from_disk(name, force=nil)
+      js_file = File.join(Chef::Config[:role_path], "#{name}.json")
+      rb_file = File.join(Chef::Config[:role_path], "#{name}.rb")
+
+      if File.exists?(js_file) || force == "json"
+        JSON.parse(IO.read(js_file))
+      elsif File.exists?(rb_file) || force == "ruby"
+        role = Chef::Role.new
+        role.name(name)
+        role.from_file(rb_file)
+        role
+      end
+    end
+
+    # Sync all the json roles with couchdb from disk
+    def self.sync_from_disk_to_couchdb
+      Dir[File.join(Chef::Config[:role_path], "*.json")].each do |role_file|
+        short_name = File.basename(role_file, ".json") 
+        Chef::Log.warn("Loading #{short_name}")
+        r = Chef::Role.from_disk(short_name, "json")
+        begin
+          couch_role = Chef::Role.load(short_name)
+          r.couchdb_rev = couch_role.couchdb_rev
+          Chef::Log.debug("Replacing role #{short_name} with data from #{role_file}")
+        rescue Net::HTTPServerException
+          Chef::Log.debug("Creating role #{short_name} with data from #{role_file}")
+        end
+        r.save
+      end
+    end
+
+  end
+end

data/lib/chef/run_list.rb

@@ -0,0 +1,156 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008, 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/mixin/deep_merge'
+
+class Chef
+  class RunList
+    include Enumerable
+
+    attr_reader :recipes, :roles, :run_list
+
+    def initialize
+      @run_list = Array.new
+      @recipes = Array.new
+      @roles = Array.new
+    end
+
+    def <<(item)
+      type, entry, fentry = parse_entry(item)
+      case type
+      when 'recipe'
+        @recipes << entry unless @recipes.include?(entry)
+      when 'role'
+        @roles << entry unless @roles.include?(entry)
+      end
+      @run_list << fentry unless @run_list.include?(fentry)
+      self
+    end
+
+    def ==(*isequal)
+      check_array = nil
+      if isequal[0].kind_of?(Chef::RunList)
+        check_array = isequal[0].run_list
+      else
+        check_array = isequal.flatten
+      end
+      
+      return false if check_array.length != @run_list.length
+
+      check_array.each_index do |i|
+        to_check = check_array[i]
+        type, name, fname = parse_entry(to_check)
+        return false if @run_list[i] != fname
+      end
+
+      true
+    end
+
+    def empty?
+      @run_list.length == 0 ? true : false
+    end
+
+    def [](pos)
+      @run_list[pos]
+    end
+
+    def []=(pos, item)
+      type, entry, fentry = parse_entry(item)
+      @run_list[pos] = fentry 
+    end
+
+    def each(&block)
+      @run_list.each { |i| block.call(i) }
+    end
+
+    def each_index(&block)
+      @run_list.each_index { |i| block.call(i) }
+    end
+
+    def include?(item)
+      type, entry, fentry = parse_entry(item)
+      @run_list.include?(fentry)
+    end
+
+    def reset(*args)
+      @run_list = Array.new
+      @recipes = Array.new
+      @roles = Array.new
+      args.flatten.each do |item|
+        if item.kind_of?(Chef::RunList)
+          item.each { |r| self << r }
+        else
+          self << item
+        end
+      end
+      self
+    end
+
+    def remove(item)
+      type, entry, fentry = parse_entry(item)
+      @run_list.delete_if { |i| i == fentry }
+      if type == "recipe"
+        @recipes.delete_if { |i| i == entry }
+      elsif type == "role"
+        @roles.delete_if { |i| i == entry }
+      end
+      self
+    end
+
+    def expand(from='server')
+      recipes = Array.new
+      default_attrs = Mash.new
+      override_attrs = Mash.new
+      
+      @run_list.each do |entry|
+        type, name, fname = parse_entry(entry)
+        case type
+        when 'recipe'
+          recipes << name unless recipes.include?(name)
+        when 'role'
+          role = nil
+          if from == 'disk' || Chef::Config[:solo]
+            # Load the role from disk
+            role = Chef::Role.from_disk("#{name}")
+          elsif from == 'server'
+            # Load the role from the server
+            r = Chef::REST.new(Chef::Config[:role_url])
+            role = r.get_rest("roles/#{name}")
+          elsif from == 'couchdb'
+            # Load the role from couchdb
+            role = Chef::Role.load(name)
+          end
+          role.recipes.each { |r| recipes <<  r unless recipes.include?(r) }
+          default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, role.default_attributes)
+          override_attrs = Chef::Mixin::DeepMerge.merge(override_attrs, role.override_attributes)
+        end
+      end
+      return recipes, default_attrs, override_attrs
+    end
+
+    def parse_entry(entry)
+      case entry 
+      when /^(.+)\[(.+)\]$/
+        [ $1, $2, entry ]
+      else
+        [ 'recipe', entry, "recipe[#{entry}]" ]
+      end
+    end
+
+  end
+end
+

data/lib/chef/runner.rb

@@ -0,0 +1,130 @@
+#
+# 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/node'
+require 'chef/resource_collection'
+require 'chef/platform'
+
+class Chef
+  class Runner
+    
+    include Chef::Mixin::ParamsValidate
+    
+    def initialize(node, collection, definitions={}, cookbook_loader=nil)
+      validate(
+        {
+          :node => node,
+          :collection => collection,
+        },
+        {
+          :node => {
+            :kind_of => Chef::Node,
+          },
+          :collection => {
+            :kind_of => Chef::ResourceCollection,
+          },
+        }
+      )
+      @node = node
+      @collection = collection
+      @definitions = definitions
+      @cookbook_loader = cookbook_loader
+    end
+    
+    def build_provider(resource)
+      provider_klass = resource.provider
+      provider_klass ||= Chef::Platform.find_provider_for_node(@node, resource)
+      Chef::Log.debug("#{resource} using #{provider_klass.to_s}")
+      provider = provider_klass.new(@node, resource, @collection, @definitions, @cookbook_loader)
+      provider.load_current_resource
+      provider
+    end
+
+    def run_action(resource, ra)
+      provider = build_provider(resource)
+      provider.send("action_#{ra}")
+
+      if resource.updated
+        resource.actions.each_key do |action|
+          if resource.actions[action].has_key?(:immediate)
+            resource.actions[action][:immediate].each do |r|
+              Chef::Log.info("#{resource} sending #{action} action to #{r} (immediate)")
+              run_action(r, action)
+            end
+          end
+          if resource.actions[action].has_key?(:delayed)
+            resource.actions[action][:delayed].each do |r|
+              @delayed_actions[r] = Hash.new unless @delayed_actions.has_key?(r)
+              @delayed_actions[r][action] = Array.new unless @delayed_actions[r].has_key?(action)
+              @delayed_actions[r][action] << lambda {
+                Chef::Log.info("#{resource} sending #{action} action to #{r} (delayed)")
+              } 
+            end
+          end
+        end
+      end
+    end
+
+    def converge
+
+      @delayed_actions = Hash.new
+      
+      @collection.execute_each_resource do |resource|
+        begin
+          Chef::Log.debug("Processing #{resource}")
+          
+          # Check if this resource has an only_if block - if it does, skip it.
+          if resource.only_if
+            unless Chef::Mixin::Command.only_if(resource.only_if)
+              Chef::Log.debug("Skipping #{resource} due to only_if")
+              next
+            end
+          end
+          
+          # Check if this resource has a not_if block - if it does, skip it.
+          if resource.not_if
+            unless Chef::Mixin::Command.not_if(resource.not_if)
+              Chef::Log.debug("Skipping #{resource} due to not_if")
+              next
+            end
+          end
+          
+          # Walk the actions for this resource, building the provider and running each.
+          action_list = resource.action.kind_of?(Array) ? resource.action : [ resource.action ]
+          action_list.each do |ra|
+            run_action(resource, ra)
+          end
+        rescue => e
+          Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace}")
+          raise e unless resource.ignore_failure
+        end
+      end
+      
+      # Run all our :delayed actions
+      @delayed_actions.each do |resource, action_hash| 
+        action_hash.each do |action, log_array|
+          log_array.each { |l| l.call } # Call each log message
+          run_action(resource, action)
+        end
+      end
+
+      true
+    end
+  end
+end