mbailey-chef 0.9.12.1

data/lib/chef/openid_registration.rb

@@ -0,0 +1,187 @@
+#
+# 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/couchdb'
+require 'chef/index_queue'
+require 'digest/sha1'
+require 'json'
+
+class Chef
+  class OpenIDRegistration
+    
+    attr_accessor :name, :salt, :validated, :password, :couchdb_rev, :admin
+    
+    include Chef::Mixin::ParamsValidate
+    include Chef::IndexQueue::Indexable
+    
+    DESIGN_DOCUMENT = {
+      "version" => 3,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+            function(doc) {
+              if (doc.chef_type == "openid_registration") {
+                emit(doc.name, doc);
+              }
+            }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "openid_registration") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        },
+        "validated" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "openid_registration") {
+              if (doc.validated == true) {
+                emit(doc.name, doc);
+              }
+            }
+          }
+          EOJS
+        },
+        "unvalidated" => {
+          "map" => <<-EOJS
+          function(doc) {
+            if (doc.chef_type == "openid_registration") {
+              if (doc.validated == false) {
+                emit(doc.name, doc);
+              }
+            }
+          }
+          EOJS
+        },
+      },
+    }
+    
+    # Create a new Chef::OpenIDRegistration object.
+    def initialize()
+      @name = nil
+      @salt = nil
+      @password = nil
+      @validated = false
+      @admin = false
+      @couchdb_rev = nil
+      @couchdb = Chef::CouchDB.new
+    end
+    
+    def name=(n)
+      @name = n.gsub(/\./, '_')
+    end
+    
+    # Set the password for this object.
+    def set_password(password) 
+      @salt = generate_salt
+      @password = encrypt_password(@salt, password)      
+    end
+    
+    # Serialize this object as a hash 
+    def to_json(*a)
+      attributes = Hash.new
+      recipes = Array.new
+      result = {
+        'name' => @name,
+        'json_class' => self.class.name,
+        'salt' => @salt,
+        'password' => @password,
+        'validated' => @validated,
+        'admin' => @admin,
+        'chef_type' => 'openid_registration',
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result.to_json(*a)
+    end
+    
+    # Create a Chef::Node from JSON
+    def self.json_create(o)
+      me = new
+      me.name = o["name"]
+      me.salt = o["salt"]
+      me.password = o["password"]
+      me.validated = o["validated"]
+      me.admin = o["admin"]
+      me.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      me
+    end
+    
+    # List all the Chef::OpenIDRegistration objects in the CouchDB.  If inflate is set to true, you will get
+    # the full list of all registration objects.  Otherwise, you'll just get the IDs
+    def self.list(inflate=false)
+      rs = Chef::CouchDB.new.list("registrations", inflate)
+      if inflate
+        rs["rows"].collect { |r| r["value"] }
+      else
+        rs["rows"].collect { |r| r["key"] }
+      end
+    end
+    
+    def self.cdb_list(*args)
+      list(*args)
+    end
+    
+    # Load an OpenIDRegistration by name from CouchDB
+    def self.load(name)
+      Chef::CouchDB.new.load("openid_registration", name)
+    end
+    
+    # Whether or not there is an OpenID Registration with this key.
+    def self.has_key?(name)
+      Chef::CouchDB.new.has_key?("openid_registration", name)
+    end
+    
+    # Remove this OpenIDRegistration from the CouchDB
+    def destroy
+      @couchdb.delete("openid_registration", @name, @couchdb_rev)
+    end
+    
+    # Save this OpenIDRegistration to the CouchDB
+    def save
+      results = @couchdb.store("openid_registration", @name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document(couchdb=nil)
+      couchdb ||= Chef::CouchDB.new
+      couchdb.create_design_document("registrations", DESIGN_DOCUMENT)
+    end
+    
+    protected
+    
+      def generate_salt
+        salt = Time.now.to_s
+        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+        1.upto(30) { |i| salt << chars[rand(chars.size-1)] }
+        salt
+      end
+    
+      def encrypt_password(salt, password)
+        Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+      end
+    
+  end
+end

data/lib/chef/platform.rb

@@ -0,0 +1,371 @@
+#
+# 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/log'
+require 'chef/mixin/params_validate'
+
+# Actually, this file depends on nearly every provider in chef, but actually
+# requiring them causes circular requires resulting in uninitialized constant
+# errors.
+require 'chef/provider'
+require 'chef/provider/log'
+require 'chef/provider/user'
+require 'chef/provider/group'
+require 'chef/provider/mount'
+require 'chef/provider/service'
+require 'chef/provider/package'
+
+
+class Chef
+  class Platform
+
+    class << self
+      attr_writer :platforms
+
+      def platforms
+        @platforms ||= {
+          :mac_os_x => {
+            :default => {
+              :package => Chef::Provider::Package::Macports,
+              :user => Chef::Provider::User::Dscl,
+              :group => Chef::Provider::Group::Dscl
+            }
+          },
+          :freebsd => {
+            :default => {
+              :group   => Chef::Provider::Group::Pw,
+              :package => Chef::Provider::Package::Freebsd,
+              :service => Chef::Provider::Service::Freebsd,
+              :user    => Chef::Provider::User::Pw,
+              :cron    => Chef::Provider::Cron
+            }
+          },
+          :ubuntu   => {
+            :default => {
+              :package => Chef::Provider::Package::Apt,
+              :service => Chef::Provider::Service::Debian,
+              :cron => Chef::Provider::Cron,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :debian => {
+            :default => {
+              :package => Chef::Provider::Package::Apt,
+              :service => Chef::Provider::Service::Debian,
+              :cron => Chef::Provider::Cron,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :centos   => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Yum,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :amazon   => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Yum,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :scientific => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Yum,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :fedora   => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Yum,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :suse     => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Zypper
+            }
+          },
+          :redhat   => {
+            :default => {
+              :service => Chef::Provider::Service::Redhat,
+              :cron => Chef::Provider::Cron,
+              :package => Chef::Provider::Package::Yum,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :gentoo   => {
+            :default => {
+              :package => Chef::Provider::Package::Portage,
+              :service => Chef::Provider::Service::Gentoo,
+              :cron => Chef::Provider::Cron,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :arch   => {
+            :default => {
+              :package => Chef::Provider::Package::Pacman,
+              :service => Chef::Provider::Service::Arch,
+              :cron => Chef::Provider::Cron,
+              :mdadm => Chef::Provider::Mdadm
+            }
+          },
+          :mswin => {
+            :default => {
+              :env =>  Chef::Provider::Env::Windows,
+              :service => Chef::Provider::Service::Windows,
+              :user => Chef::Provider::User::Windows,
+              :group => Chef::Provider::Group::Windows,
+              :mount => Chef::Provider::Mount::Windows
+            }
+          },
+          :mingw32 => {
+            :default => {
+              :env =>  Chef::Provider::Env::Windows,
+              :service => Chef::Provider::Service::Windows,
+              :user => Chef::Provider::User::Windows,
+              :group => Chef::Provider::Group::Windows,
+              :mount => Chef::Provider::Mount::Windows
+            }
+          },
+          :windows => {
+            :default => {
+              :env =>  Chef::Provider::Env::Windows,
+              :service => Chef::Provider::Service::Windows,
+              :user => Chef::Provider::User::Windows,
+              :group => Chef::Provider::Group::Windows,
+              :mount => Chef::Provider::Mount::Windows
+            }
+          },
+          :solaris  => {},
+          :solaris2 => {
+            :default => {
+              :service => Chef::Provider::Service::Solaris,
+              :package => Chef::Provider::Package::Solaris,
+              :cron => Chef::Provider::Cron::Solaris,
+              :group => Chef::Provider::Group::Usermod
+            }
+          },
+          :default  => {
+            :file => Chef::Provider::File,
+            :directory => Chef::Provider::Directory,
+            :link => Chef::Provider::Link,
+            :template => Chef::Provider::Template,
+            :remote_directory => Chef::Provider::RemoteDirectory,
+            :execute => Chef::Provider::Execute,
+            :mount => Chef::Provider::Mount::Mount,
+            :script => Chef::Provider::Script,
+            :service => Chef::Provider::Service::Init,
+            :perl => Chef::Provider::Script,
+            :python => Chef::Provider::Script,
+            :ruby => Chef::Provider::Script,
+            :bash => Chef::Provider::Script,
+            :csh => Chef::Provider::Script,
+            :user => Chef::Provider::User::Useradd,
+            :group => Chef::Provider::Group::Gpasswd,
+            :http_request => Chef::Provider::HttpRequest,
+            :route => Chef::Provider::Route,
+            :ifconfig => Chef::Provider::Ifconfig,
+            :ruby_block => Chef::Provider::RubyBlock,
+            :erl_call => Chef::Provider::ErlCall,
+            :log => Chef::Provider::Log::ChefLog
+          }
+        }
+      end
+
+      include Chef::Mixin::ParamsValidate
+
+      def find(name, version)
+        provider_map = platforms[:default].clone
+
+        name_sym = name
+        if name.kind_of?(String)
+          name.downcase!
+          name.gsub!(/\s/, "_")
+          name_sym = name.to_sym
+        end
+
+        if platforms.has_key?(name_sym)
+          if platforms[name_sym].has_key?(version)
+            Chef::Log.debug("Platform #{name.to_s} version #{version} found")
+            if platforms[name_sym].has_key?(:default)
+              provider_map.merge!(platforms[name_sym][:default])
+            end
+            provider_map.merge!(platforms[name_sym][version])
+          elsif platforms[name_sym].has_key?(:default)
+            provider_map.merge!(platforms[name_sym][:default])
+          end
+        else
+          Chef::Log.debug("Platform #{name} not found, using all defaults. (Unsupported platform?)")
+        end
+        provider_map
+      end
+
+      def find_platform_and_version(node)
+        platform = nil
+        version = nil
+
+        if node[:platform]
+          platform = node[:platform]
+        elsif node.attribute?("os")
+          platform = node[:os]
+        end
+
+        raise ArgumentError, "Cannot find a platform for #{node}" unless platform
+
+        if node[:platform_version]
+          version = node[:platform_version]
+        elsif node[:os_version]
+          version = node[:os_version]
+        elsif node[:os_release]
+          version = node[:os_release]
+        end
+
+        raise ArgumentError, "Cannot find a version for #{node}" unless version
+
+        return platform, version
+      end
+
+      def provider_for_resource(resource)
+        node = resource.run_context && resource.run_context.node
+        raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
+        find_provider_for_node(node, resource).new(resource, resource.run_context)
+      end
+
+      def provider_for_node(node, resource_type)
+        raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"
+        find_provider_for_node(node, resource_type).new(node, resource_type)
+      end
+
+      def find_provider_for_node(node, resource_type)
+        platform, version = find_platform_and_version(node)
+        provider = find_provider(platform, version, resource_type)
+      end
+
+      def set(args)
+        validate(
+          args,
+          {
+            :platform => {
+              :kind_of => Symbol,
+              :required => false,
+            },
+            :version => {
+              :kind_of => String,
+              :required => false,
+            },
+            :resource => {
+              :kind_of => Symbol,
+            },
+            :provider => {
+              :kind_of => [ String, Symbol, Class ],
+            }
+          }
+        )
+        if args.has_key?(:platform)
+          if args.has_key?(:version)
+            if platforms.has_key?(args[:platform])
+              if platforms[args[:platform]].has_key?(args[:version])
+                platforms[args[:platform]][args[:version]][args[:resource].to_sym] = args[:provider]
+              else
+                platforms[args[:platform]][args[:version]] = {
+                  args[:resource].to_sym => args[:provider]
+                }
+              end
+            else
+              platforms[args[:platform]] = {
+                args[:version] => {
+                  args[:resource].to_sym => args[:provider]
+                }
+              }
+            end
+          else
+            if platforms.has_key?(args[:platform])
+              if platforms[args[:platform]].has_key?(:default)
+                platforms[args[:platform]][:default][args[:resource].to_sym] = args[:provider]
+              else
+                platforms[args[:platform]] = { :default => { args[:resource].to_sym => args[:provider] } }
+              end
+            else
+              platforms[args[:platform]] = {
+                :default => {
+                  args[:resource].to_sym => args[:provider]
+                }
+              }
+            end
+          end
+        else
+          if platforms.has_key?(:default)
+            platforms[:default][args[:resource].to_sym] = args[:provider]
+          else
+            platforms[:default] = {
+              args[:resource].to_sym => args[:provider]
+            }
+          end
+        end
+      end
+
+      def find_provider(platform, version, resource_type)
+        pmap = Chef::Platform.find(platform, version)
+        provider_klass = explicit_provider(platform, version, resource_type) ||
+                         platform_provider(platform, version, resource_type) ||
+                         resource_matching_provider(platform, version, resource_type)
+
+        raise ArgumentError, "Cannot find a provider for #{resource_type} on #{platform} version #{version}" if provider_klass.nil?
+
+        provider_klass
+      end
+
+      private
+
+        def explicit_provider(platform, version, resource_type)
+          resource_type.kind_of?(Chef::Resource) ? resource_type.provider : nil
+        end
+
+        def platform_provider(platform, version, resource_type)
+          pmap = Chef::Platform.find(platform, version)
+          rtkey = resource_type.kind_of?(Chef::Resource) ? resource_type.resource_name.to_sym : resource_type
+          pmap.has_key?(rtkey) ? pmap[rtkey] : nil
+        end
+
+        def resource_matching_provider(platform, version, resource_type)
+          if resource_type.kind_of?(Chef::Resource)
+            begin
+              Chef::Provider.const_get(resource_type.class.to_s.split('::').last)
+            rescue NameError
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+    end
+
+  end
+end