powerhome-activeldap 3.2.3

data/TODO

@@ -0,0 +1,32 @@
+- [1.1.x] add :readonly option to :has_many.
+- Work as framework on Rails.
+- How to support dSCorePropagationData? ignore it?
+  all systemOnly == "TRUE" attribute can be ignored?
+- Add parsing position to DistinguishedNameInvalid error like
+  <NAME=VALUE,INVALID_HERE>@<REST=INPUT>.
+- Support TLS optioins (e.g. CA certification file and so on)
+- Provide FormHelper for LDAP entry's attribute to handle multiple values
+  (["foo", "bar", ...]) and option value ({"binary" => "..."},
+  {"lang-en-us" => "..."})
+- Test SASL bind.
+- Add result pagination via LDAP::Controls
+- serialize & serialized_attributes
+- schema mgmt - how does AR handle it?
+- columns() -- ?
+http://api.rubyonrails.com/classes/ActiveRecord/Base.html#M000865
+- provide full documentation for new API.
+- handle all exception raised from Ruby/LDAP and wrap as
+  ActiveLdap exception. I think we need to develop an
+  application using ActiveLdap.
+- Add locking around Timeout.alarm() to ensure a multithreaded ruby
+  app doesn't hit any race conditions
+- Add AR matching exceptions:
+* ActiveRecordError -- ActiveLdapError as base
+* AssociationTypeMismatch
+* SerializationTypeMismatch
+* ConnectionNotEstablished
+* RecordNotFound
+* LdapActionInvalid - like StatementInvalid
+* MultiparameterAssignmentErrors
+* AttributeAssignmentError
+* RecordNotSaved

data/benchmark/README.md

@@ -0,0 +1,64 @@
+# README
+
+This document describes how to run benchmarks under
+benchmark/ directory.
+
+## Configure your LDAP server
+
+You need a LDAP server to run benchmarks. This is dependes
+on your environment.
+
+In this document, we assume that you configure your LDAP
+server by the following configuration:
+
+* host: 127.0.0.1
+* base DN: dc=bench,dc=local
+* encryption: startTLS
+* bind DN: cn=admin,dc=local
+* password: secret
+
+## Configure ActiveLdap to connect to your LDAP server
+
+You need an ActiveLdap configuration in
+benchmark/config.yaml to connect to your LDAP server. There
+is a sample configuration in
+benchmark/config.yaml.sample. It's good to start from it.
+
+    % cp benchmark/config.yaml.sample benchmark/config.yaml
+    % editor benchmark/config.yaml
+
+The configuration uses the same format of ldap.yaml.
+
+## Run benchmarks
+
+You just run a bencmark script. It loads
+benchmark/config.yaml and populate benchmark data automatically.
+
+    % ruby benchmark/bench-backend.rb
+	Populating...
+
+	Rehearsal ---------------------------------------------------------------
+	  1x: AL(LDAP)                0.220000   0.000000   0.220000 (  0.234775)
+	  1x: AL(Net::LDAP)           0.280000   0.000000   0.280000 (  0.273048)
+	  1x: AL(LDAP: No Obj)        0.000000   0.000000   0.000000 (  0.009217)
+	  1x: AL(Net::LDAP: No Obj)   0.060000   0.000000   0.060000 (  0.056727)
+	  1x: LDAP                    0.000000   0.000000   0.000000 (  0.003261)
+	  1x: Net::LDAP               0.040000   0.000000   0.040000 (  0.029862)
+	------------------------------------------------------ total: 0.600000sec
+
+									  user     system      total        real
+	  1x: AL(LDAP)                0.200000   0.000000   0.200000 (  0.195660)
+	  1x: AL(Net::LDAP)           0.220000   0.000000   0.220000 (  0.213444)
+	  1x: AL(LDAP: No Obj)        0.010000   0.000000   0.010000 (  0.009000)
+	  1x: AL(Net::LDAP: No Obj)   0.030000   0.000000   0.030000 (  0.026847)
+	  1x: LDAP                    0.000000   0.000000   0.000000 (  0.003377)
+	  1x: Net::LDAP               0.020000   0.000000   0.020000 (  0.022662)
+
+	Entries processed by Ruby/ActiveLdap + LDAP: 100
+	Entries processed by Ruby/ActiveLdap + Net::LDAP: 100
+	Entries processed by Ruby/ActiveLdap + LDAP: (without object creation): 100
+	Entries processed by Ruby/ActiveLdap + Net::LDAP: (without object creation): 100
+	Entries processed by Ruby/LDAP: 100
+	Entries processed by Net::LDAP: 100
+
+	Cleaning...

data/benchmark/bench-backend.rb

@@ -0,0 +1,247 @@
+base = File.dirname(__FILE__)
+$LOAD_PATH.unshift(File.expand_path(base))
+$LOAD_PATH.unshift(File.expand_path(File.join(base, "..", "lib")))
+
+require "active_ldap"
+require "benchmark"
+
+include ActiveLdap::GetTextSupport
+
+argv = ARGV.dup
+unless argv.include?("--config")
+  argv.unshift("--config", File.join(base, "config.yaml"))
+end
+argv, opts, options = ActiveLdap::Command.parse_options(argv) do |opts, options|
+  options.prefix = "ou=People"
+
+  opts.on("--prefix=PREFIX",
+          _("Specify prefix for benchmarking"),
+          _("(default: %s)") % options.prefix) do |prefix|
+    options.prefix = prefix
+  end
+end
+
+ActiveLdap::Base.setup_connection
+config = ActiveLdap::Base.configuration
+
+LDAP_HOST = config[:host]
+LDAP_METHOD = config[:method]
+if LDAP_METHOD == :ssl
+  LDAP_PORT = config[:port] || URI::LDAPS::DEFAULT_PORT
+else
+  LDAP_PORT = config[:port] || URI::LDAP::DEFAULT_PORT
+end
+LDAP_BASE = config[:base]
+LDAP_PREFIX = options.prefix
+LDAP_USER = config[:bind_dn]
+LDAP_PASSWORD = config[:password]
+
+class ALUser < ActiveLdap::Base
+  ldap_mapping :dn_attribute => 'uid', :prefix => LDAP_PREFIX,
+               :classes => ['posixAccount', 'person']
+end
+
+class ALUserLdap < ALUser
+end
+ALUserLdap.setup_connection(config.merge(:adapter => "ldap"))
+
+class ALUserNetLdap < ALUser
+end
+ALUserNetLdap.setup_connection(config.merge(:adapter => "net-ldap"))
+
+def search_al_ldap
+  count = 0
+  ALUserLdap.find(:all).each do |e|
+    count += 1
+  end
+  count
+end
+
+def search_al_net_ldap
+  count = 0
+  ALUserNetLdap.find(:all).each do |e|
+    count += 1
+  end
+  count
+end
+
+def search_al_ldap_without_object_creation
+  count = 0
+  ALUserLdap.search.each do |e|
+    count += 1
+  end
+  count
+end
+
+def search_al_net_ldap_without_object_creation
+  count = 0
+  ALUserNetLdap.search.each do |e|
+    count += 1
+  end
+  count
+end
+
+# === search_ldap
+#
+def search_ldap(conn)
+  count = 0
+  conn.search("#{LDAP_PREFIX},#{LDAP_BASE}",
+              LDAP::LDAP_SCOPE_SUBTREE,
+              "(uid=*)") do |e|
+    count += 1
+  end
+  count
+end # -- search_ldap
+
+def search_net_ldap(conn)
+  count = 0
+  conn.search(:base => "#{LDAP_PREFIX},#{LDAP_BASE}",
+              :scope => Net::LDAP::SearchScope_WholeSubtree,
+              :filter => "(uid=*)") do |e|
+    count += 1
+  end
+  count
+end
+
+def ldap_connection
+  require 'ldap'
+  if LDAP_METHOD == :tls
+    conn = LDAP::SSLConn.new(LDAP_HOST, LDAP_PORT, true)
+  else
+    conn = LDAP::Conn.new(LDAP_HOST, LDAP_PORT)
+  end
+  conn.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
+  conn.bind(LDAP_USER, LDAP_PASSWORD) if LDAP_USER and LDAP_PASSWORD
+  conn
+rescue LoadError
+  nil
+end
+
+def net_ldap_connection
+  require 'net/ldap'
+  net_ldap_conn = Net::LDAP::Connection.new(:host => LDAP_HOST,
+                                            :port => LDAP_PORT)
+  if LDAP_USER and LDAP_PASSWORD
+    net_ldap_conn.setup_encryption(:method => :start_tls) if LDAP_METHOD == :tls
+    net_ldap_conn.bind(:method => :simple,
+                       :username => LDAP_USER,
+                       :password => LDAP_PASSWORD)
+  end
+  net_ldap_conn
+rescue LoadError
+  nil
+end
+
+def populate_base
+  ActiveLdap::Populate.ensure_base
+  if ActiveLdap::Base.search.empty?
+    raise "Can't populate #{ActiveLdap::Base.base}"
+  end
+end
+
+def populate_users
+  ou_class = Class.new(ActiveLdap::Base)
+  ou_class.ldap_mapping :dn_attribute => "ou",
+                        :prefix => "",
+                        :classes => ["top", "organizationalUnit"]
+  ou_class.new(LDAP_PREFIX.split(/=/)[1]).save!
+
+  100.times do |i|
+    name = i.to_s
+    user = ALUser.new(name)
+    user.uid_number = 100000 + i
+    user.gid_number = 100000 + i
+    user.cn = name
+    user.sn = name
+    user.home_directory = "/nonexistent"
+    user.save!
+  end
+end
+
+def populate
+  populate_base
+  populate_users
+end
+
+# === main
+#
+def main(do_populate)
+  if do_populate
+    puts(_("Populating..."))
+    dumped_data = ActiveLdap::Base.dump(:scope => :sub)
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    populate
+    puts
+  end
+
+  # Standard connection
+  #
+  ldap_conn = ldap_connection
+  net_ldap_conn = net_ldap_connection
+
+  al_ldap_count = 0
+  al_net_ldap_count = 0
+  al_ldap_count_without_object_creation = 0
+  al_net_ldap_count_without_object_creation = 0
+  ldap_count = 0
+  net_ldap_count = 0
+  Benchmark.bmbm(20) do |x|
+    [1].each do |n|
+      GC.start
+      x.report("%3dx: AL(LDAP)" % n) do
+        n.times {al_ldap_count = search_al_ldap}
+      end
+      GC.start
+      x.report("%3dx: AL(Net::LDAP)" % n) do
+        n.times {al_net_ldap_count = search_al_net_ldap}
+      end
+      GC.start
+      x.report("%3dx: AL(LDAP: No Obj)" % n) do
+        n.times do
+          al_ldap_count_without_object_creation =
+            search_al_ldap_without_object_creation
+        end
+      end
+      x.report("%3dx: AL(Net::LDAP: No Obj)" % n) do
+        n.times do
+          al_net_ldap_count_without_object_creation =
+            search_al_net_ldap_without_object_creation
+        end
+      end
+      GC.start
+      if ldap_conn
+        x.report("%3dx: LDAP" % n) do
+          n.times {ldap_count = search_ldap(ldap_conn)}
+        end
+      end
+      GC.start
+      if net_ldap_conn
+        x.report("%3dx: Net::LDAP" % n) do
+          n.times {net_ldap_count = search_net_ldap(net_ldap_conn)}
+        end
+      end
+    end
+  end
+
+  puts
+  puts(_("Entries processed by Ruby/ActiveLdap + LDAP: %d") % al_ldap_count)
+  puts(_("Entries processed by Ruby/ActiveLdap + Net::LDAP: %d") % \
+       al_net_ldap_count)
+  puts(_("Entries processed by Ruby/ActiveLdap + LDAP: " \
+         "(without object creation): %d") % \
+       al_ldap_count_without_object_creation)
+  puts(_("Entries processed by Ruby/ActiveLdap + Net::LDAP: " \
+         "(without object creation): %d") % \
+       al_net_ldap_count_without_object_creation)
+  puts(_("Entries processed by Ruby/LDAP: %d") % ldap_count)
+  puts(_("Entries processed by Net::LDAP: %d") % net_ldap_count)
+ensure
+  if do_populate
+    puts
+    puts(_("Cleaning..."))
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    ActiveLdap::Base.load(dumped_data)
+  end
+end
+
+main(LDAP_USER && LDAP_PASSWORD)

data/benchmark/bench-instantiate.rb

@@ -0,0 +1,98 @@
+base = File.dirname(__FILE__)
+$LOAD_PATH.unshift(File.expand_path(base))
+$LOAD_PATH.unshift(File.expand_path(File.join(base, "..", "lib")))
+
+require "active_ldap"
+require "benchmark"
+
+include ActiveLdap::GetTextSupport
+
+argv = ARGV.dup
+unless argv.include?("--config")
+  argv.unshift("--config", File.join(base, "config.yaml"))
+end
+argv, opts, options = ActiveLdap::Command.parse_options(argv) do |opts, options|
+  options.prefix = "ou=People"
+
+  opts.on("--prefix=PREFIX",
+          _("Specify prefix for benchmarking"),
+          _("(default: %s)") % options.prefix) do |prefix|
+    options.prefix = prefix
+  end
+end
+
+ActiveLdap::Base.setup_connection
+config = ActiveLdap::Base.configuration
+
+LDAP_PREFIX = options.prefix
+LDAP_USER = config[:bind_dn]
+LDAP_PASSWORD = config[:password]
+
+N_USERS = 100
+
+class ALUser < ActiveLdap::Base
+  ldap_mapping :dn_attribute => 'uid', :prefix => LDAP_PREFIX,
+               :classes => ['posixAccount', 'person']
+end
+
+def populate_base
+  ActiveLdap::Populate.ensure_base
+  if ActiveLdap::Base.search.empty?
+    raise "Can't populate #{ActiveLdap::Base.base}"
+  end
+end
+
+def populate_users
+  ou_class = Class.new(ActiveLdap::Base)
+  ou_class.ldap_mapping :dn_attribute => "ou",
+                        :prefix => "",
+                        :classes => ["top", "organizationalUnit"]
+  ou_class.new(LDAP_PREFIX.split(/=/)[1]).save!
+
+  N_USERS.times do |i|
+    name = i.to_s
+    user = ALUser.new(name)
+    user.uid_number = 100000 + i
+    user.gid_number = 100000 + i
+    user.cn = name
+    user.sn = name
+    user.home_directory = "/nonexistent"
+    user.save!
+  end
+end
+
+def populate
+  populate_base
+  populate_users
+end
+
+def main(do_populate)
+  if do_populate
+    puts(_("Populating..."))
+    dumped_data = ActiveLdap::Base.dump(:scope => :sub)
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    populate
+    puts
+  end
+
+  Benchmark.bmbm(20) do |x|
+    n = 100
+    GC.start
+    x.report("search 100 entries") do
+      n.times {ALUser.search}
+    end
+    GC.start
+    x.report("instantiate 1 entry") do
+      n.times {ALUser.first}
+    end
+  end
+ensure
+  if do_populate
+    puts
+    puts(_("Cleaning..."))
+    ActiveLdap::Base.delete_all(nil, :scope => :sub)
+    ActiveLdap::Base.load(dumped_data)
+  end
+end
+
+main(LDAP_USER && LDAP_PASSWORD)

data/benchmark/config.yaml.sample

@@ -0,0 +1,5 @@
+host: 127.0.0.1
+base: dc=bench,dc=local
+method: :tls
+bind_dn: cn=admin,dc=local
+password: secret