tecnh-chef 0.9.9.vpc

data/lib/chef/node/attribute.rb

@@ -0,0 +1,450 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: AJ Christensen (<aj@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/deep_merge'
+require 'chef/log'
+
+class Chef
+  class Node
+    class Attribute
+      HIDDEN_ATTRIBUES = [:@override, :@attribute, :@default, :@normal, :@automatic]
+
+      attr_accessor :normal,
+                    :default,
+                    :override,
+                    :automatic,
+                    :state,
+                    :current_normal,
+                    :current_default,
+                    :current_override,
+                    :current_automatic,
+                    :auto_vivifiy_on_read,
+                    :set_unless_value_present,
+                    :has_been_read,
+                    :set_type
+
+      include Enumerable
+
+      def initialize(normal, default, override, automatic, state=[])
+        @normal = normal
+        @current_normal = normal
+        @default = default
+        @current_default = default
+        @override = override
+        @current_override = override
+        @automatic = automatic
+        @current_automatic = automatic
+        @state = state
+        @auto_vivifiy_on_read = false
+        @set_unless_value_present = false
+        @set_type = nil
+        @has_been_read = false
+      end
+
+      def attribute
+        normal
+      end
+
+      def attribute=(value)
+        normal = value
+      end
+
+      def set_type_hash
+        case @set_type
+        when :normal
+          @normal
+        when :override
+          @override
+        when :default
+          @default
+        when :automatic
+          @automatic
+        end
+      end
+
+      # Reset our internal state to the top of every tree
+      def reset
+        @current_normal = @normal
+        @current_default = @default
+        @current_override = @override
+        @current_automatic = @automatic
+        @has_been_read = false
+        @state = []
+      end
+
+      def [](key)
+        @state << key
+
+        # We set this to so that we can cope with ||= as a setting.
+        # See the comments in []= for more details.
+        @has_been_read = true
+
+        # If we have a set type, our destiny is to write
+        if @set_type
+          a_value = @set_type == :automatic ? value_or_descend(current_automatic, key, auto_vivifiy_on_read) : nil
+          o_value = @set_type == :override ? value_or_descend(current_override, key, auto_vivifiy_on_read) : nil
+          n_value = @set_type == :normal ? value_or_descend(current_normal, key, auto_vivifiy_on_read) : nil
+          d_value = @set_type == :default ? value_or_descend(current_default, key, auto_vivifiy_on_read) : nil
+
+          determine_value(a_value, o_value, n_value, d_value)
+        # Our destiny is only to read, so we get the full list.
+        else
+          a_value = value_or_descend(current_automatic, key)
+          o_value = value_or_descend(current_override, key)
+          n_value = value_or_descend(current_normal, key)
+          d_value = value_or_descend(current_default, key)
+
+          determine_value(a_value, o_value, n_value, d_value)
+        end
+      end
+
+      def attribute?(key)
+        return true if get_value(automatic, key)
+        return true if get_value(override, key)
+        return true if get_value(normal, key)
+        return true if get_value(default, key)
+        false
+      end
+
+      def has_key?(key)
+        attribute?(key)
+      end
+
+      alias :include? :has_key?
+      alias :key? :has_key?
+      alias :member? :has_key?
+
+      def each(&block)
+        get_keys.each do |key|
+          value = determine_value(
+            get_value(automatic, key),
+            get_value(override, key),
+            get_value(normal, key),
+            get_value(default, key)
+          )
+          block.call([key, value])
+        end
+      end
+
+      def each_pair(&block)
+        get_keys.each do |key|
+          value = determine_value(
+            get_value(automatic, key),
+            get_value(override, key),
+            get_value(normal, key),
+            get_value(default, key)
+          )
+          block.call(key, value)
+        end
+      end
+
+      def each_attribute(&block)
+        get_keys.each do |key|
+          value = determine_value(
+            get_value(automatic, key),
+            get_value(override, key),
+            get_value(normal, key),
+            get_value(default, key)
+          )
+          block.call(key, value)
+        end
+      end
+
+      def each_key(&block)
+        get_keys.each do |key|
+          block.call(key)
+        end
+      end
+
+      def each_value(&block)
+        get_keys.each do |key|
+          value = determine_value(
+            get_value(automatic, key),
+            get_value(override, key),
+            get_value(normal, key),
+            get_value(default, key)
+          )
+          block.call(value)
+        end
+      end
+
+      def empty?
+        get_keys.empty?
+      end
+
+      def fetch(key, default_value=nil, &block)
+        if get_keys.include? key
+          determine_value(
+            get_value(automatic, key),
+            get_value(override, key),
+            get_value(normal, key),
+            get_value(default, key)
+          )
+        elsif default_value
+          default_value
+        elsif block_given?
+          block.call(key)
+        else
+          raise IndexError, "Key #{key} does not exist"
+        end
+      end
+
+      # Writing this method hurts me a little bit.
+      #
+      # TODO: Refactor all this stuff so this kind of horror is no longer needed
+      #
+      # We have invented a new kind of duck-typing, we call it Madoff typing.
+      # We just lie and hope we die before you recognize our scheme. :)
+      def kind_of?(klass)
+        if klass == Hash || klass == Mash || klass == Chef::Node::Attribute
+          true
+        else
+          false
+        end
+      end
+
+      def has_value?(value)
+        self.any? do |k,v|
+          value == v
+        end
+      end
+
+      alias :value? :has_value?
+
+      def index(value)
+        index = self.find do |h|
+          value == h[1]
+        end
+        index.first if index.is_a? Array || nil
+      end
+
+      def values
+        self.collect { |h| h[1] }
+      end
+
+      def size
+        self.collect{}.length
+      end
+
+      alias :length :size
+
+      def get_keys
+        keys
+      end
+
+      def keys
+        tkeys = current_automatic ? current_automatic.keys : []
+        [ current_override, current_normal, current_default ].each do |attr_hash|
+          if attr_hash
+            attr_hash.keys.each do |key|
+              tkeys << key unless tkeys.include?(key)
+            end
+          end
+        end
+        tkeys
+      end
+
+      def get_value(data_hash, key)
+        last = nil
+
+        if state.length == 0
+          if data_hash.has_key?(key) && ! data_hash[key].nil?
+            return data_hash[key]
+          else
+            return nil
+          end
+        end
+
+        0.upto(state.length) do |i|
+          if i == 0
+            last = auto_vivifiy(data_hash, state[i])
+          elsif i == state.length
+            fk = last[state[i - 1]]
+            if fk.has_key?(key) && ! fk[key].nil?
+              return fk[key]
+            else
+              return nil
+            end
+          else
+            last = auto_vivifiy(last[state[i - 1]], state[i])
+          end
+        end
+      end
+
+      def hash_and_not_cna?(to_check)
+        (! to_check.kind_of?(Chef::Node::Attribute)) && to_check.respond_to?(:has_key?)
+      end
+
+      def determine_value(a_value, o_value, n_value, d_value)
+        if hash_and_not_cna?(a_value)
+          value = {}
+          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
+          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
+          value = Chef::Mixin::DeepMerge.merge(value, o_value) if hash_and_not_cna?(o_value)
+          value = Chef::Mixin::DeepMerge.merge(value, a_value)
+          value
+        elsif hash_and_not_cna?(o_value)
+          value = {}
+          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
+          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
+          value = Chef::Mixin::DeepMerge.merge(value, o_value)
+          value
+        elsif hash_and_not_cna?(n_value)
+          value = {}
+          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
+          value = Chef::Mixin::DeepMerge.merge(value, n_value)
+          value
+        elsif hash_and_not_cna?(d_value)
+          d_value
+        else
+          return a_value if ! a_value.nil?
+          return o_value if ! o_value.nil?
+          return n_value if ! n_value.nil?
+          return d_value if ! d_value.nil?
+          return nil
+        end
+      end
+
+      def []=(key, value)
+        # If we don't have one, then we'll pretend we're normal
+        @set_type ||= :normal
+
+        if set_unless_value_present
+          if get_value(set_type_hash, key) != nil
+            Chef::Log.debug("Not setting #{state.join("/")}/#{key} to #{value.inspect} because it has a #{@set_type} value already")
+            return false
+          end
+        end
+
+        # If we have been read, and the key we are writing is the same
+        # as our parent, we have most like been ||='ed.  So we need to
+        # just rewind a bit.
+        #
+        # In practice, these objects are single use - this is just
+        # supporting one more single-use style.
+        @state.pop if @has_been_read && @state.last == key
+
+        set_value(set_type_hash, key, value)
+        value
+      end
+
+      def set_value(data_hash, key, value)
+        last = nil
+
+        # If there is no state, just set the value
+        if state.length == 0
+          data_hash[key] = value
+          return data_hash
+        end
+
+        # Walk all the previous places we have been
+        0.upto(state.length) do |i|
+          # If we are the first, we are top level, and should vivifiy the data_hash
+          if i == 0
+            last = auto_vivifiy(data_hash, state[i])
+          # If we are one past the last state, we are adding a key to that hash with a value
+          elsif i == state.length
+            last[state[i - 1]][key] = value
+          # Otherwise, we're auto-vivifiy-ing an interim mash
+          else
+            last = auto_vivifiy(last[state[i - 1]], state[i])
+          end
+        end
+        data_hash
+      end
+
+      def auto_vivifiy(data_hash, key)
+        if data_hash.has_key?(key)
+          unless data_hash[key].respond_to?(:has_key?)
+            raise ArgumentError, "You tried to set a nested key, where the parent is not a hash-like object: #{@state.join("/")}/#{key} " unless auto_vivifiy_on_read
+          end
+        else
+          data_hash[key] = Mash.new
+        end
+        data_hash
+      end
+
+      def value_or_descend(data_hash, key, auto_vivifiy=false)
+        if auto_vivifiy
+          hash_to_vivifiy = auto_vivifiy(data_hash, key)
+          data_hash[key] = hash_to_vivifiy[key]
+        else
+          return nil if data_hash == nil
+          return nil unless data_hash.has_key?(key)
+        end
+
+        if data_hash[key].respond_to?(:has_key?)
+          cna = Chef::Node::Attribute.new(@normal, @default, @override, @automatic, @state)
+          cna.current_normal = current_normal.nil? ? Mash.new : current_normal[key]
+          cna.current_default   = current_default.nil? ? Mash.new : current_default[key]
+          cna.current_override  = current_override.nil? ? Mash.new : current_override[key]
+          cna.current_automatic  = current_automatic.nil? ? Mash.new : current_automatic[key]
+          cna.auto_vivifiy_on_read = auto_vivifiy_on_read
+          cna.set_unless_value_present = set_unless_value_present
+          cna.set_type = set_type
+          cna
+        else
+          data_hash[key]
+        end
+      end
+
+      def method_missing(symbol, *args)
+        by = symbol
+        if self.attribute?(symbol)
+          by = symbol
+        elsif self.attribute?(symbol.to_s)
+          by = symbol.to_s
+        else
+          if args.length != 0
+            by = symbol
+          else
+            raise ArgumentError, "Attribute #{symbol.to_s} is not defined!" unless auto_vivifiy_on_read
+          end
+        end
+
+        if args.length != 0
+          if by.to_s =~ /^(.+)=$/
+            by = $1
+          end
+          self[by] = args.length == 1 ? args[0] : args
+        else
+          self[by]
+        end
+      end
+
+      def inspect
+        determine_value(current_automatic, current_override, current_normal, current_default)
+
+        "#<#{self.class} " << instance_variables.map{|iv|
+          iv.to_s + '=' + (HIDDEN_ATTRIBUES.include?(iv.to_sym) ? "{...}" : instance_variable_get(iv).inspect)
+        }.join(', ') << ">"
+      end
+
+      def to_hash
+        result = determine_value(current_automatic, current_override, current_normal, current_default)
+        if result.class == Hash
+          result
+        else
+          result.to_hash
+        end
+      end
+
+    end
+  end
+end

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