activeldap3 1.2.3

data/lib/active_ldap/callbacks.rb

@@ -0,0 +1,52 @@
+require 'active_record/callbacks'
+
+module ActiveLdap
+  module Callbacks
+    def self.append_features(base)
+      super
+
+      base.class_eval do
+        include ActiveRecord::Callbacks
+
+        unless respond_to?(:instantiate_with_callbacks)
+          extend ClassMethods
+          class << self
+            alias_method_chain :instantiate, :callbacks
+          end
+          alias_method_chain :initialize, :callbacks
+        end
+
+        def callback(method)
+          super
+        rescue ActiveRecord::ActiveRecordError
+          raise Error, $!.message
+        end
+      end
+    end
+
+    module ClassMethods
+      def instantiate_with_callbacks(record)
+        object = instantiate_without_callbacks(record)
+
+        if object.respond_to_without_attributes?(:after_find)
+          object.send(:callback, :after_find)
+        end
+
+        if object.respond_to_without_attributes?(:after_initialize)
+          object.send(:callback, :after_initialize)
+        end
+
+        object
+      end
+    end
+
+    def initialize_with_callbacks(attributes = nil) #:nodoc:
+      initialize_without_callbacks(attributes)
+      result = yield self if block_given?
+      if respond_to_without_attributes?(:after_initialize)
+        callback(:after_initialize)
+      end
+      result
+    end
+  end
+end

data/lib/active_ldap/command.rb

@@ -0,0 +1,49 @@
+require 'optparse'
+require 'ostruct'
+
+module ActiveLdap
+  module Command
+    include GetTextSupport
+
+    module_function
+    def parse_options(argv=nil, version=nil)
+      argv ||= ARGV.dup
+      options = OpenStruct.new
+      opts = OptionParser.new do |opts|
+        yield(opts, options)
+
+        opts.separator ""
+        opts.separator _("Common options:")
+
+        opts.on_tail("--config=CONFIG",
+                     _("Specify configuration file written as YAML")) do |file|
+          require 'yaml'
+          config = YAML.load(File.read(file)).symbolize_keys
+          config = Base.prepare_configuration(config)
+          Configuration::DEFAULT_CONFIG.update(config)
+        end
+
+        opts.on_tail("-h", "--help", _("Show this message")) do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("--version", _("Show version")) do
+          puts(version || VERSION)
+          exit
+        end
+      end
+      opts.parse!(argv)
+      [argv, opts, options]
+    end
+
+    def read_password(prompt, input=$stdin, output=$stdout)
+      output.print(prompt)
+      system("/bin/stty -echo") if input.tty?
+      input.gets.chomp
+    ensure
+      system("/bin/stty echo") if input.tty?
+      output.puts
+    end
+  end
+end

data/lib/active_ldap/compatible.rb

@@ -0,0 +1,44 @@
+module ActiveLdap
+  module Compatible
+    module_function
+    if "".respond_to?(:force_encoding)
+      def convert_to_utf8_encoded_object(object)
+        case object
+        when Array
+          object.collect {|element| convert_to_utf8_encoded_object(element)}
+        when Hash
+          encoded = {}
+          object.each do |key, value|
+            key = convert_to_utf8_encoded_object(key)
+            value = convert_to_utf8_encoded_object(value)
+            encoded[key] = value
+          end
+          encoded
+        when String
+          encoded = object.dup
+          encoded.force_encoding("utf-8")
+          encoded = object unless encoded.valid_encoding?
+          encoded
+        else
+          object
+        end
+      end
+    else
+      def convert_to_utf8_encoded_object(object)
+        object
+      end
+    end
+
+    if "".respond_to?(:lines)
+      def string_to_lines(string)
+        string.lines.to_a
+      end
+    else
+      def string_to_lines(string)
+        ary = []
+        string.each_line{|l| ary << l}
+        ary
+      end
+    end
+  end
+end

data/lib/active_ldap/configuration.rb

@@ -0,0 +1,147 @@
+require 'uri'
+begin
+  require 'uri/ldaps'
+rescue LoadError
+  module URI
+    class LDAPS < LDAP
+      DEFAULT_PORT = 636
+    end
+    @@schemes['LDAPS'] = LDAPS
+  end
+end
+
+module ActiveLdap
+  # Configuration
+  #
+  # Configuration provides the default settings required for
+  # ActiveLdap to work with your LDAP server. All of these
+  # settings can be passed in at initialization time.
+  module Configuration
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    DEFAULT_CONFIG = {}
+    DEFAULT_CONFIG[:host] = '127.0.0.1'
+    DEFAULT_CONFIG[:port] = nil
+    DEFAULT_CONFIG[:method] = :plain  # :ssl, :tls, :plain allowed
+
+    DEFAULT_CONFIG[:bind_dn] = nil
+    DEFAULT_CONFIG[:password_block] = nil
+    DEFAULT_CONFIG[:password] = nil
+    DEFAULT_CONFIG[:store_password] = true
+    DEFAULT_CONFIG[:allow_anonymous] = true
+    DEFAULT_CONFIG[:sasl_quiet] = true
+    DEFAULT_CONFIG[:try_sasl] = false
+    DEFAULT_CONFIG[:sasl_options] = nil
+    # See http://www.iana.org/assignments/sasl-mechanisms
+    DEFAULT_CONFIG[:sasl_mechanisms] = ["GSSAPI", "DIGEST-MD5",
+                                        "CRAM-MD5", "EXTERNAL"]
+
+    DEFAULT_CONFIG[:retry_limit] = 1
+    DEFAULT_CONFIG[:retry_wait] = 1
+    DEFAULT_CONFIG[:timeout] = 0 # in seconds; 0 <= Never timeout
+    # Whether or not to retry on timeouts
+    DEFAULT_CONFIG[:retry_on_timeout] = true
+
+    DEFAULT_CONFIG[:logger] = nil
+
+    module ClassMethods
+      @@defined_configurations = {}
+
+      def default_configuration
+        DEFAULT_CONFIG.dup
+      end
+
+      def ensure_configuration(config=nil)
+        if config.nil?
+          if defined?(LDAP_ENV)
+            config = LDAP_ENV
+          elsif defined?(RAILS_ENV)
+            config = RAILS_ENV
+          else
+            config = {}
+          end
+        end
+
+        if config.is_a?(Symbol) or config.is_a?(String)
+          _config = configurations[config.to_s]
+          unless _config
+            raise ConnectionError,
+                  _("%s connection is not configured") % config
+          end
+          config = _config
+        end
+
+        config
+      end
+
+      def configuration(key=nil)
+        @@defined_configurations[key || active_connection_name]
+      end
+
+      def define_configuration(key, config)
+        @@defined_configurations[key] = config
+      end
+
+      def defined_configurations
+        @@defined_configurations
+      end
+
+      def remove_configuration_by_configuration(config)
+        @@defined_configurations.delete_if {|key, value| value == config}
+      end
+
+      CONNECTION_CONFIGURATION_KEYS = [:uri, :base, :adapter]
+      def remove_connection_related_configuration(config)
+        config.reject do |key, value|
+          CONNECTION_CONFIGURATION_KEYS.include?(key)
+	end
+      end
+
+      def merge_configuration(user_configuration, target=self)
+        configuration = default_configuration
+        prepare_configuration(user_configuration).each do |key, value|
+          case key
+          when :base
+            # Scrub before inserting
+            target.base = value.gsub(/['}{#]/, '')
+          when :scope, :ldap_scope
+            if key == :ldap_scope
+              message = _(":ldap_scope configuration option is deprecated. " \
+                          "Use :scope instead.")
+              ActiveSupport::Deprecation.warn(message)
+            end
+            target.scope = value
+            configuration[:scope] = value
+          else
+            configuration[key] = value
+          end
+        end
+        configuration
+      end
+
+      def prepare_configuration(configuration)
+        configuration = configuration.symbolize_keys
+        uri = configuration.delete(:uri)
+        return configuration unless uri
+
+        begin
+          uri = URI.parse(uri)
+        rescue URI::InvalidURIError
+          raise ConfigurationError.new(_("invalid URI: %s") % uri)
+        end
+        unless uri.is_a?(URI::LDAP)
+          raise ConfigurationError.new(_("not a LDAP URI: %s") % uri.to_s)
+        end
+
+        uri_configuration = {:port => uri.port}
+        uri_configuration[:host] = uri.host if uri.host
+        uri_configuration[:bind_dn] = uri.dn if uri.dn
+        uri_configuration[:scope] = uri.scope if uri.scope
+        uri_configuration[:method] = :ssl if uri.is_a?(URI::LDAPS)
+        uri_configuration.merge(configuration)
+      end
+    end
+  end
+end

data/lib/active_ldap/connection.rb

@@ -0,0 +1,294 @@
+module ActiveLdap
+  module Connection
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      @@active_connections = {}
+      @@allow_concurrency = false
+
+      def thread_safe_active_connections
+        @@active_connections[Thread.current.object_id] ||= {}
+      end
+
+      def single_threaded_active_connections
+        @@active_connections
+      end
+
+      if @@allow_concurrency
+        alias_method :active_connections, :thread_safe_active_connections
+      else
+        alias_method :active_connections, :single_threaded_active_connections
+      end
+
+      def allow_concurrency=(threaded) #:nodoc:
+        logger.debug {"allow_concurrency=#{threaded}"} if logger
+        return if @@allow_concurrency == threaded
+        clear_all_cached_connections!
+        @@allow_concurrency = threaded
+        method_prefix = threaded ? "thread_safe" : "single_threaded"
+        sing = (class << self; self; end)
+        [:active_connections].each do |method|
+          sing.send(:alias_method, method, "#{method_prefix}_#{method}")
+        end
+      end
+
+      def active_connection_name
+        @active_connection_name ||= determine_active_connection_name
+      end
+
+      def remove_active_connections!
+        active_connections.keys.each do |key|
+          remove_connection(key)
+        end
+      end
+
+      def clear_active_connections!
+        connections = active_connections
+        connections.each do |key, connection|
+          connection.disconnect!
+        end
+        connections.clear
+      end
+
+      def clear_active_connection_name
+        @active_connection_name = nil
+        ObjectSpace.each_object(Class) do |klass|
+          if klass < self and !klass.name.blank?
+            klass.instance_variable_set("@active_connection_name", nil)
+          end
+        end
+      end
+
+      def connection
+        conn = nil
+        @active_connection_name ||= nil
+        if @active_connection_name
+          conn = active_connections[@active_connection_name]
+        end
+        unless conn
+          conn = retrieve_connection
+          active_connections[@active_connection_name] = conn
+        end
+        conn
+      end
+
+      def connection=(adapter)
+        if adapter.is_a?(Adapter::Base)
+          active_connections[active_connection_name] = adapter
+        elsif adapter.is_a?(Hash)
+          config = adapter
+          self.connection = instantiate_adapter(config)
+        elsif adapter.nil?
+          raise ConnectionNotSetup
+        else
+          setup_connection(adapter)
+        end
+      end
+
+      def instantiate_adapter(config)
+        adapter = (config[:adapter] || default_adapter)
+        normalized_adapter = adapter.downcase.gsub(/-/, "_")
+        adapter_method = "#{normalized_adapter}_connection"
+        unless Adapter::Base.respond_to?(adapter_method)
+          raise AdapterNotFound.new(adapter)
+        end
+        if config.has_key?(:ldap_scope)
+          message = _(":ldap_scope connection option is deprecated. " \
+                      "Use :scope instead.")
+          ActiveSupport::Deprecation.warn(message)
+          config[:scope] ||= config.delete(:ldap_scope)
+        end
+        config = remove_connection_related_configuration(config)
+        Adapter::Base.send(adapter_method, config)
+      end
+
+      def default_adapter
+        @@default_adapter ||= guess_available_adapter
+      end
+
+      def connected?
+        active_connections[active_connection_name] ? true : false
+      end
+
+      def retrieve_connection
+        conn = nil
+        name = active_connection_name
+        raise ConnectionNotSetup unless name
+        conn = active_connections[name]
+        if conn.nil?
+          config = configuration(name)
+          raise ConnectionNotSetup unless config
+          self.connection = config
+          conn = active_connections[name]
+        end
+        raise ConnectionNotSetup if conn.nil?
+        conn
+      end
+
+      def remove_connection(klass_or_key=self)
+        if klass_or_key.is_a?(Module)
+          key = active_connection_key(klass_or_key)
+        else
+          key = klass_or_key
+        end
+        config = configuration(key)
+        conn = active_connections[key]
+        remove_configuration_by_configuration(config)
+        active_connections.delete_if {|_key, value| value == conn}
+        conn.disconnect! if conn
+        config
+      end
+
+      def setup_connection(config=nil)
+        config = ensure_configuration(config)
+        remove_connection
+
+        clear_active_connection_name
+        key = active_connection_key
+        @active_connection_name = key
+        define_configuration(key, merge_configuration(config))
+      end
+
+      def establish_connection(config=nil)
+        message =
+          _("ActiveLdap::Connection.establish_connection has been deprecated " \
+            "since 1.1.0. " \
+            "Please use ActiveLdap::Connection.setup_connection instead.")
+        ActiveSupport::Deprecation.warn(message)
+        setup_connection(config)
+      end
+
+      # Return the schema object
+      def schema
+        connection.schema
+      end
+
+      def reset_runtime
+        active_connections.inject(0) do |result, (name, connection)|
+          result + connection.reset_runtime
+        end
+      end
+
+      private
+      def active_connection_key(k=self)
+        k.name.blank? ? k.object_id : k.name
+      end
+
+      def determine_active_connection_name
+        key = active_connection_key
+        if active_connections[key] or configuration(key)
+          key
+        elsif self == ActiveLdap::Base
+          nil
+        else
+          superclass.active_connection_name
+        end
+      end
+
+      def clear_all_cached_connections!
+        if @@allow_concurrency
+          @@active_connections.each_value do |connection_hash_for_thread|
+            connection_hash_for_thread.each_value {|conn| conn.disconnect!}
+            connection_hash_for_thread.clear
+          end
+        else
+          @@active_connections.each_value {|conn| conn.disconnect!}
+        end
+        @@active_connections.clear
+      end
+
+      def guess_available_adapter
+        if Object.respond_to?(:java)
+          "jndi"
+        else
+          ruby_ldap_available = false
+          $LOAD_PATH.each do |path|
+            if File.exist?(File.join(path, "ldap", "ldif.rb"))
+              ruby_ldap_available = true
+              break
+            end
+          end
+          if !ruby_ldap_available and Object.const_defined?(:Gem)
+            ruby_ldap_available = Gem.available?("ruby-ldap")
+          end
+          if ruby_ldap_available
+            "ldap"
+          else
+            "net-ldap"
+          end
+        end
+      end
+    end
+
+    def setup_connection(config=nil)
+      config = self.class.ensure_configuration(config)
+      config = self.class.configuration.merge(config)
+      config = self.class.merge_configuration(config, self)
+
+      remove_connection
+      self.class.define_configuration(dn, config)
+    end
+
+    def establish_connection(config=nil)
+      message =
+        _("ActiveLdap::Connection#establish_connection has been deprecated " \
+          "since 1.1.0. " \
+          "Please use ActiveLdap::Connection#setup_connection instead.")
+      ActiveSupport::Deprecation.warn(message)
+      setup_connection(config)
+    end
+
+    def remove_connection
+      self.class.remove_connection(dn)
+      @connection = nil
+    end
+
+    def connection
+      conn = @connection
+      return conn if conn
+
+      have_dn = !@dn.nil?
+      if !have_dn and attribute_name_resolvable_without_connection?
+        begin
+          have_dn = !get_attribute_before_type_cast(dn_attribute)[1].nil?
+        rescue DistinguishedNameInvalid
+        end
+      end
+      conn = self.class.active_connections[dn] || retrieve_connection if have_dn
+      conn || self.class.connection
+    end
+
+    def connected?
+      connection != self.class.connection
+    end
+
+    def connection=(adapter)
+      if adapter.nil? or adapter.is_a?(Adapter::Base)
+        @connection = adapter
+      elsif adapter.is_a?(Hash)
+        config = adapter
+        @connection = self.class.instantiate_adapter(config)
+      else
+        setup_connection(adapter)
+      end
+    end
+
+    def retrieve_connection
+      conn = self.class.active_connections[dn]
+      return conn if conn
+
+      config = self.class.configuration(dn)
+      return nil unless config
+
+      conn = self.class.instantiate_adapter(config)
+      @connection = self.class.active_connections[dn] = conn
+      conn
+    end
+
+    def schema
+      connection.schema
+    end
+  end
+end