dm-ldap-adapter 0.2.0

data/ldap-commands.txt

@@ -0,0 +1,14 @@
+# populate ldap with basic data
+ldapadd -x -w behappy -c -D "cn=admin,dc=example,dc=com" < test.ldif
+
+# search the whole domain
+ldapsearch -x -w behappy -c -D "cn=admin,dc=example,dc=com" -b 'dc=example,dc=com'
+
+# search people
+ldapsearch -x -w behappy -c -D "cn=admin,dc=example,dc=com" -b 'ou=people,dc=example,dc=com'
+
+#search groups
+ldapsearch -x -w behappy -c -D "cn=admin,dc=example,dc=com" -b 'ou=groups,dc=example,dc=com'
+
+# printout delete commands for all people
+ldapsearch -x -w behappy -c -D "cn=admin,dc=example,dc=com" -b 'ou=people,dc=example,dc=com' "uid=*" | grep ^uid: | sed -e "s/^.....//" -e 's/$/,ou=people,dc=example,dc=com"/' -e 's/^/-x -w behappy -c -D "cn=admin,dc=example,dc=com" "uid=/' | xargs -L 1 echo ldapdelete

data/lib/adapters/ldap_adapter.rb

@@ -0,0 +1,244 @@
+require 'adapters/simple_adapter'
+# load the ldap facade only if NOT loaded before
+require 'ldap/ldap_facade' unless Object.const_defined?('Ldap') and Ldap.const_defined?('LdapFacade')
+
+module Ldap
+
+  # the class provides two ways of getting a LdapFacade. either
+  # one which is put on the current Thread or a new one
+  class LdapConnection
+    
+    include ::Slf4r::Logger
+
+    def initialize(uri)
+      @ldaps = { }
+      auth =  { 
+        :method => :simple,
+        :username => uri[:bind_name],
+        :password => uri[:password]
+      } 
+      @config = { 
+        :host => uri[:host], 
+        :port => uri[:port].to_i, 
+        :auth => auth, 
+        :base => uri[:base]
+      }
+    end
+    
+    # puts a LdapFacade into the current thread and executes the
+    # given block.
+    def open
+      begin
+        Ldap::LdapFacade.open(@config) do |ldap|
+          @ldaps[Thread.current] = Ldap::LdapFacade.new(ldap)
+          yield
+        end
+      ensure
+        @ldaps[Thread.current] = nil 
+      end
+    end
+    
+    # @return [Ldap::LdapFacade]
+    #  either the one from the current Thread or a new one
+    def current
+      ldap = @ldaps[Thread.current]
+      if ldap
+        ldap
+      else
+        Ldap::LdapFacade.new(@config)
+      end
+    end
+  end
+end
+
+require "dm-core"
+module DataMapper
+  module Adapters
+    class LdapAdapter < SimpleAdapter
+
+      # @return [Ldap::LdapFacade] 
+      #   ready to use LdapFacade
+      def ldap
+        @ldap_connection.current
+      end
+
+      def open_ldap_connection(&block)
+        @ldap_connection.open(&block)
+      end
+
+      def key_properties(resource)
+        resource.send(:key_properties).first
+      end
+
+      # helper to remove datamapper specific classes from the conditions
+      # @param [Array] conditions 
+      #   array of tuples: (action, property, new value)
+      # @return [Array] 
+      #   tuples: (action, attribute name, new value)
+      def to_ldap_conditions(conditions)
+        ldap_conditions = []
+        conditions.each do |c|
+          ldap_conditions << [c[0], c[1].field, c[2]]
+        end
+        ldap_conditions
+      end
+
+      public
+
+      def initialize(name, uri_or_options)
+        super(name, uri_or_options)
+        @ldap_connection = ::Ldap::LdapConnection.new(@uri)
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   to be created
+      # @see SimpleAdapter#create_resource
+      # @return [Fixnum] 
+      #    value for the primary key or nil
+      def create_resource(resource)
+        logger.debug { resource.inspect }
+
+        props = resource.model.ldap_properties(resource)
+        key = nil
+        resource.send(:properties).each do |prop|
+          value = prop.get!(resource)
+          props[prop.field.to_sym] = value.to_s unless value.nil?
+          key = prop if prop.serial?
+        end
+        key_value = ldap.create_object(resource.model.dn_prefix(resource), 
+                                       resource.model.treebase, 
+                                       key_properties(resource).field, 
+                                       props, resource.model.multivalue_field)
+        logger.debug { "key value: #{key_value.inspect}" }
+        if key_value
+          key.set!(resource, key_value.to_i)
+          resource
+        elsif resource.model.multivalue_field
+          multivalue_prop = resource.send(:properties).detect do |prop|
+            prop.field.to_sym == resource.model.multivalue_field
+          end
+          update_resource(resource, 
+                          { multivalue_prop => 
+                            resource.send(resource.model.multivalue_field)})
+        else
+          nil
+        end
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   to be updated
+      # @param [Hash] attributes
+      #   new attributes for the resource
+      # @see SimpleAdapter#update_resource
+      def update_resource(resource, attributes)
+        actions = attributes.collect do |property, value|
+          field = property.field.to_sym #TODO sym needed or string ???
+          if resource.model.multivalue_field == property.name
+            if value.nil?
+              [:delete, field, resource.original_values[property.name].to_s]
+            else
+              [:add, field, value.to_s]
+            end
+          elsif value.nil?
+            [:delete, field, []]
+          elsif resource.original_values[property.name].nil?
+            [:add, field, value.to_s]            
+          else
+            [:replace, field, value.to_s]
+          end
+        end
+#puts "actions"
+#p actions
+#puts
+        ldap.update_object(resource.model.dn_prefix(resource), 
+                           resource.model.treebase, 
+                           actions)
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   to be deleted
+      # @see SimpleAdapter#delete_resource
+      def delete_resource(resource)
+        if resource.model.multivalue_field
+          # set the original value so update does the right thing
+          resource.send("#{resource.model.multivalue_field}=".to_sym, nil)
+          update_resource(resource, 
+                          { resource.send(:properties)[resource.model.multivalue_field] => nil })
+        else
+          ldap.delete_object(resource.model.dn_prefix(resource),
+                             resource.model.treebase)
+        end
+      end
+      
+      # @param [DataMapper::Query] query
+      #   the search criteria
+      # @return [DataMapper::Resource]
+      #   the found resource or nil
+      # @see SimpleAdapter#read_resource
+      def read_resource(query)  
+        
+        result = ldap.read_objects(query.model.treebase, 
+                                   query.model.key.collect { |k| k.field}, 
+                                   to_ldap_conditions(query.conditions))
+        if query.model.multivalue_field
+          resource = result.detect do |item|
+            # run over all values of the multivalue field
+            item[query.model.multivalue_field].any? do |value|
+              values =  query.fields.collect do |f|
+                if query.model.multivalue_field == f.field.to_sym 
+                  value
+                else 
+                  item[f.field.to_sym].first 
+                end
+              end
+              resource = query.model.load(values, query)
+              return resource if filter_resource(resource, query.conditions)
+            end
+          end
+        else
+          values = result.first
+          if values
+            query.fields.collect do |f|
+              values[f.field.to_sym].first
+            end
+          end
+        end
+      end
+        
+      # @param [DataMapper::Query] query
+      #   the search criteria
+      # @return [Array<DataMapper::Resource]
+      #   the array of found resources
+      # @see SimpleAdapter#read_resources
+      def read_resources(query)     
+        result = ldap.read_objects(query.model.treebase, 
+                                   query.model.key.collect { |k| k.field }, 
+                                   to_ldap_conditions(query.conditions))
+        if query.model.multivalue_field
+          props_result = []
+          result.each do |props|
+            # run over all values of the multivalue field
+            props[query.model.multivalue_field].each do |value|
+              values =  query.fields.collect do |f|
+                if query.model.multivalue_field == f.field.to_sym 
+                  value
+                else 
+                  props[f.field.to_sym].first 
+                end
+              end
+              resource = query.model.load(values, query)
+              props_result << resource if filter_resource(resource, query.conditions)
+            end
+          end
+          props_result
+        else # no multivalue field
+          result.collect do |props|
+            query.fields.collect do |f|
+              props[f.field.to_sym].first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adapters/memory_adapter.rb

@@ -0,0 +1,79 @@
+require "dm-core"
+require 'adapters/simple_adapter'
+
+# this and the SimpleAdapter is basically the 
+# dm-core/adapter/in_memory_adapter.rb most credits go dm-core. 
+# there are few bug fixes and enhancements.
+module DataMapper
+  module Adapters
+    class MemoryAdapter < SimpleAdapter
+
+      public
+
+      # @see SimpleAdapter
+      def initialize(name, uri_or_options)
+        super
+
+        @records = Hash.new { |hash,model| hash[model] = Array.new }
+        @ids = Hash.new { |hash,model| hash[model] = 0 }
+      end
+
+      # @see SimpleAdapter
+      def create_resource(resource)
+        uniques = resource.model.properties.select do |prop|
+          prop if prop.unique_index
+        end
+        uniques.each do |prop|
+          raise PersistentError.new "#{prop.name} = #{prop.get(resource)} already exists" unless resource.model.first( prop.name => prop.get(resource) ).nil?
+        end
+        @records[resource.model] << resource
+        resource.id = (@ids[resource.model] += 1) if resource.key.size == 1 
+        # and resource.key[0].serial?
+        resource
+      end
+
+      # @see SimpleAdapter
+      def update_resource(resource, attributes)
+        attributes.each do |property, value|
+          property.set!(resource, value)
+        end
+      end
+
+      # @see SimpleAdapter
+      def delete_resource(resource)
+        records = @records[resource.model]
+        records.delete(resource)
+      end
+
+      # @see SimpleAdapter
+      def read_resource(query)        
+        read(query, false)
+      end
+
+      # @see SimpleAdapter
+      def read_resources(query)        
+        read(query, true)
+      end
+
+      private
+
+      # helper to read either one or many resources matching the given query
+      def read(query, many)
+        model      = query.model
+        conditions = query.conditions
+        
+        match_with = many ? :select : :detect
+
+        result = @records[model].send(match_with) do |resource|
+          filter_resource(resource, conditions)
+        end
+
+        # TODO Sort
+
+        # TODO Limit
+
+        return result
+      end
+    end
+  end
+end

data/lib/adapters/simple_adapter.rb

@@ -0,0 +1,198 @@
+require "dm-core"
+require 'slf4r'
+
+module DataMapper
+  module Adapters
+    class NoopTransaction
+      
+      def close ; end
+      def begin ; end
+      def prepare ; end
+      def commit ; end
+      def rollback ; end
+      def rollback_prepared ; end
+      
+    end
+    class SimpleAdapter < AbstractAdapter
+
+      include Slf4r::Logger
+
+      # @see AbstractAdapter
+      def transaction_primitive
+        NoopTransaction.new
+      end
+
+      def initialize(name, uri_or_options)
+        super(name, uri_or_options)
+      end
+
+      protected
+      
+      # checks whether a given resource fullfils the conditions
+      # @param [DataMapper::Resource] resource
+      # @param [Array<Condition>] conditions
+      # @return [Boolean] 
+      #   true if the resource are within the conditions otherwise false
+      def filter_resource(resource, conditions)
+        #puts "condi"
+        #p conditions
+        # no conditation => no filter
+        if conditions.size == 0
+          true
+        else
+          conditions.all? do |tuple|
+            operator, property, bind_value = *tuple
+            
+            value = property.get!(resource)
+            case operator
+            when :eql, :in then equality_comparison(bind_value, value)
+            when :not      then !equality_comparison(bind_value, value)
+            when :like     then Regexp.new(bind_value.gsub(/%/, ".*")) =~ value
+            when :gt       then !value.nil? && value >  bind_value
+            when :gte      then !value.nil? && value >= bind_value
+            when :lt       then !value.nil? && value <  bind_value
+            when :lte      then !value.nil? && value <= bind_value
+            else raise "Invalid query operator: #{operator.inspect}"
+            end
+          end
+        end
+      end
+
+      # helper method to dispatch the equality test for different
+      # classes
+      def equality_comparison(bind_value, value)
+        case bind_value
+          when Array, Range then bind_value.include?(value)
+          when NilClass     then value.nil?
+          else                   bind_value == value
+        end
+      end
+
+      public
+
+      # @see AbstractAdapter
+      # @param [Array<DataMapper::Resources>] resources
+      #   aaaa
+      # @return [Fixnum] 
+      #    number of the newly created resources
+      def create(resources)
+        resources.select do |resource|
+
+          create_resource(resource)
+
+        end.size # just return the number of create resources
+      end
+
+      # @see AbstractAdapter
+      # @param [Hash] attributes
+      #   collection of attribute, i.e. the name/value pairs which 
+      #   needs to be updated
+      # @param [Query] 
+      #   on all resources which are selected by that query the 
+      #   update will be applied
+      # @return [Fixnum] 
+      #   number of the updated resources
+      def update(attributes, query)
+        read_many(query).select do |resource|
+          
+          update_resource(resource, attributes)
+
+        end.size
+      end
+
+      # @see AbstractAdapter
+      # @param [DataMapper::Query] query
+      #    which selects the resource
+      # @return [DataMapper::Resource] 
+      #    the found Resource or nil
+      def read_one(query)
+        result = read_resource(query)
+        if result.is_a? Resource
+          result
+        elsif result # assume result to be Array with the values
+          #puts "------------------"
+          #p result
+          query.model.load(result, query)
+        end
+      end
+      
+      # @see AbstractAdapter
+      # @param [DataMapper::Query] query
+      #   which selects the resources
+      # @return [DataMapper::Collection] 
+      #   collection of Resources
+      def read_many(query)
+        Collection.new(query) do |set|
+          result = read_resources(query)
+#puts "read_many"
+#p result
+          if result.size > 0 and result.first.is_a? Resource
+            set.replace(result)
+          else
+            result.each do |values|
+              set.load(values)
+            end
+          end
+        end
+      end
+
+      # @see AbstractAdapter
+      # @param [Query] query
+      #   which selects the resources to be deleted
+      # @return [Fixnum]
+      #   number of the deleted resources
+      def delete(query)
+        read_many(query).each do |resource|
+
+          delete_resource(resource)
+
+        end.size
+      end
+      
+      private
+
+      # @param [DataMapper::Resource] resource
+      #   which will be created
+      # @return [DataMapper::Resource] 
+      #   either the resource itself if the creation was successful or nil 
+      def create_resource(resource)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Query] query
+      #   which selects the resource
+      # @return [DataMapper::Resource,Array<String>] 
+      #   the resource or a set of values ordered in the same manner as query.fields attributes
+      def read_resource(query)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Query] query
+      #   which selects the resources
+      # @return [Array<DataMapper::Resource>,Array<String>]
+      #   resources or ordered values 
+      # @see #read_resource
+      def read_resources(query)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   which will be updated with the given attributes.
+      # @param [Hash] attributes 
+      #    the keys are the property names and the values are the new values of that property. 
+      # @return [DataMapper::Resource] 
+      #   resource on success otherwise nil
+      def update_resource(resource, attributes)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   which will be deleted
+      # @return [DataMapper::Resource]
+      #   either the resource if the deletion was successful or nil 
+      def delete_resource(resource)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end