activeldap 0.9.0

data/TODO

@@ -0,0 +1,25 @@
+- 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/bench-al.rb

@@ -0,0 +1,202 @@
+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, opts, options = ActiveLdap::Command.parse_options 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.establish_connection
+config = ActiveLdap::Base.configuration
+
+LDAP_HOST = config[:host]
+LDAP_PORT = config[:port]
+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
+
+# === search_al
+#
+def search_al
+  count = 0
+  ALUser.find(:all).each do |e|
+    count += 1
+  end
+  count
+end # -- search_al
+
+def search_al_without_object_creation
+  count = 0
+  ALUser.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'
+  conn = LDAP::Conn.new(LDAP_HOST, LDAP_PORT)
+  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.bind(:method => :simple,
+                       :username => LDAP_USER,
+                       :password => LDAP_PASSWORD)
+  end
+  net_ldap_conn
+rescue LoadError
+  nil
+end
+
+def populate_base
+  suffixes = []
+  ActiveLdap::Base.base.split(/,/).reverse_each do |suffix|
+    prefix = suffixes.join(",")
+    suffixes.unshift(suffix)
+    name, value = suffix.split(/=/, 2)
+    next unless name == "dc"
+    dc_class = Class.new(ActiveLdap::Base)
+    dc_class.ldap_mapping :dn_attribute => "dc",
+                          :prefix => "",
+                          :scope => :base,
+                          :classes => ["top", "dcObject", "organization"]
+    dc_class.instance_variable_set("@base", prefix)
+    next if dc_class.exists?(value, :prefix => "dc=#{value}")
+    dc = dc_class.new(value)
+    dc.o = dc.dc
+    begin
+      dc.save
+    rescue ActiveLdap::OperationNotPermitted
+    end
+  end
+
+  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
+  end
+
+  # Standard connection
+  #
+  ldap_conn = ldap_connection
+  net_ldap_conn = net_ldap_connection
+
+  al_count = 0
+  al_count_without_object_creation = 0
+  ldap_count = 0
+  net_ldap_count = 0
+  Benchmark.bm(20) do |x|
+    [1].each do |n|
+      x.report("%3dx: AL" % n) {n.times {al_count = search_al}}
+      x.report("%3dx: AL(No Obj)" % n) do
+        n.times do
+          al_count_without_object_creation = search_al_without_object_creation
+        end
+      end
+      if ldap_conn
+        x.report("%3dx: LDAP" % n) do
+          n.times {ldap_count = search_ldap(ldap_conn)}
+        end
+      end
+      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(_("Entries processed by Ruby/ActiveLdap: %d") % al_count)
+  puts(_("Entries processed by Ruby/ActiveLdap (without object creation): " \
+         "%d") % al_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(_("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=localcomain
+method: :tls
+bind_dn: cn=user-name,dc=localdomain
+password: secret

data/examples/al-admin/README

@@ -0,0 +1,182 @@
+== Welcome to Rails
+
+Rails is a web-application and persistence framework that includes everything
+needed to create database-backed web-applications according to the
+Model-View-Control pattern of separation. This pattern splits the view (also
+called the presentation) into "dumb" templates that are primarily responsible
+for inserting pre-built data in between HTML tags. The model contains the
+"smart" domain objects (such as Account, Product, Person, Post) that holds all
+the business logic and knows how to persist themselves to a database. The
+controller handles the incoming requests (such as Save New Account, Update
+Product, Show Post) by manipulating the model and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails.  You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting started
+
+1. At the command prompt, start a new rails application using the rails command
+   and your application name. Ex: rails myapp
+   (If you've downloaded rails in a complete tgz or zip, this step is already done)
+2. Change directory into myapp and start the web server: <tt>script/server</tt> (run with --help for options)
+3. Go to http://localhost:3000/ and get "Welcome aboard: You’re riding the Rails!"
+4. Follow the guidelines to start developing your application
+
+
+== Web Servers
+
+By default, Rails will try to use Mongrel and lighttpd if they are installed, otherwise
+Rails will use the WEBrick, the webserver that ships with Ruby. When you run script/server,
+Rails will check if Mongrel exists, then lighttpd and finally fall back to WEBrick. This ensures
+that you can always get up and running quickly.
+
+Mongrel is a Ruby-based webserver with a C-component (which requires compilation) that is
+suitable for development and deployment of Rails applications. If you have Ruby Gems installed,
+getting up and running with mongrel is as easy as: <tt>gem install mongrel</tt>.
+More info at: http://mongrel.rubyforge.org
+
+If Mongrel is not installed, Rails will look for lighttpd. It's considerably faster than
+Mongrel and WEBrick and also suited for production use, but requires additional
+installation and currently only works well on OS X/Unix (Windows users are encouraged
+to start with Mongrel). We recommend version 1.4.11 and higher. You can download it from
+http://www.lighttpd.net.
+
+And finally, if neither Mongrel or lighttpd are installed, Rails will use the built-in Ruby
+web server, WEBrick. WEBrick is a small Ruby web server suitable for development, but not
+for production.
+
+But of course its also possible to run Rails on any platform that supports FCGI.
+Apache, LiteSpeed, IIS are just a few. For more information on FCGI,
+please visit: http://wiki.rubyonrails.com/rails/pages/FastCGI
+
+
+== Debugging Rails
+
+Have "tail -f" commands running on the server.log and development.log. Rails will
+automatically display debugging and runtime information to these files. Debugging
+info will also be shown in the browser on requests from 127.0.0.1.
+
+
+== Breakpoints
+
+Breakpoint support is available through the script/breakpointer client. This
+means that you can break out of execution at any point in the code, investigate
+and change the model, AND then resume execution! Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.find(:all)
+      breakpoint "Breaking out from the list"
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the breakpointer window. Here you can do things like:
+
+Executing breakpoint "Breaking out from the list" at .../webrick_server.rb:16 in 'breakpoint'
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8 @attributes={\"title\"=>nil, \"body\"=>nil, \"id\"=>\"1\"}>,
+       #<Post:0x14a6620 @attributes={\"title\"=>\"Rails you know!\", \"body\"=>\"Only ten..\", \"id\"=>\"2\"}>]"
+  >> @posts.first.title = "hello from a breakpoint"
+  => "hello from a breakpoint"
+
+...and even better is that you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you press CTRL-D
+
+
+== Console
+
+You can interact with the domain model by starting the console through <tt>script/console</tt>.
+Here you'll have all parts of the application configured, just like it is when the
+application is running. You can inspect domain models, change values, and save to the
+database. Starting the script without arguments will launch it in the development environment.
+Passing an argument will specify a different environment, like <tt>script/console production</tt>.
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+To reload your controllers and models after launching the console run <tt>reload!</tt>
+
+
+
+== Description of contents
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from ApplicationController
+  which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb.
+  Most models will descend from ActiveRecord::Base.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.rhtml for the WeblogsController#index action. All views use eRuby
+  syntax.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the common
+  header/footer method of wrapping views. In your views, define a layout using the
+  <tt>layout :default</tt> and create a file named default.rhtml. Inside default.rhtml,
+  call <% yield %> to render the view using this layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are generated
+  for you automatically when using script/generate for controllers. Helpers can be used to
+  wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database, and other dependencies.
+
+components
+  Self-contained mini-applications that can bundle together controllers, models, and views.
+
+db
+  Contains the database schema in schema.rb.  db/migrate contains all
+  the sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when generated
+  using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that doesn't
+  belong under controllers, models, or helpers. This directory is in the load path.
+
+public
+  The directory available for the web server. Contains subdirectories for images, stylesheets,
+  and javascripts. Also contains the dispatchers and the default HTML files. This should be
+  set as the DOCUMENT_ROOT of your web server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the script/generate scripts, template
+  test files will be generated for you and placed in this directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins subdirectory.
+  This directory is in the load path.

data/examples/al-admin/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'

data/examples/al-admin/app/controllers/account_controller.rb

@@ -0,0 +1,59 @@
+class AccountController < ApplicationController
+  before_filter :force_logout, :only => [:sign_up, :login, :logout]
+
+  def index
+    if logged_in?
+      redirect_to(top_path)
+    else
+      redirect_to(:action => 'login')
+    end
+  end
+
+  def login
+    return unless request.post?
+    self.current_user = User.authenticate(params[:login], params[:password])
+    if logged_in?
+      if params[:remember_me] == "1"
+        current_user.remember_me
+        cookies[:auth_token] = {
+          :value => current_user.remember_token,
+          :expires => current_user.remember_token_expires_at
+        }
+      end
+      redirect_back_or_default(top_url)
+      flash[:notice] = _("Logged in successfully")
+    else
+      flash[:notice] = _("Login or Password is incorrect")
+    end
+  end
+
+  def sign_up
+    @user = LdapUser.new(params[:user])
+    @required_attributes = @user.must.collect(&:name)
+    return unless request.post?
+
+    if @user.save
+      @system_user = User.create(:login => @user.id)
+      unless @system_user.new_record?
+        self.current_user = @system_user
+        redirect_back_or_default(top_path)
+        flash[:notice] = _("Thanks for signing up!")
+      end
+    end
+    @user.password = @user.password_confirmation = nil
+  end
+
+  def logout
+    flash[:notice] = _("You have been logged out.")
+    redirect_back_or_default(top_path)
+  end
+
+  private
+  def force_logout
+    current_user.forget_me if logged_in?
+    self.current_user = nil
+    cookies.delete :auth_token
+    reset_session
+    true
+  end
+end

data/examples/al-admin/app/controllers/application.rb

@@ -0,0 +1,34 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  # Pick a unique cookie name to distinguish our session data from others'
+  session :session_key => '_al-admin_session_id'
+
+  init_gettext "al-admin"
+
+  include ExceptionNotifiable
+
+  include AuthenticatedSystem
+  before_filter :login_from_cookie
+
+  private
+  def default_url_options(options)
+    default_options = {}
+    lang = params["lang"]
+    default_options["lang"] = lang if lang
+    default_options.merge(options)
+  end
+
+  def current_ldap_user
+    logged_in? ? current_user.ldap_user : nil
+  end
+
+  def schema
+    @schema ||= current_ldap_user.schema
+  end
+
+  def authorized?
+    current_ldap_user.connected?
+  end
+end

data/examples/al-admin/app/controllers/attributes_controller.rb

@@ -0,0 +1,17 @@
+class AttributesController < ApplicationController
+  before_filter :login_required
+
+  def index
+    @attributes = schema.attributes
+  end
+
+  def show
+    key = params[:id].to_a.flatten.compact[0]
+    raise ActiveRecord::RecordNotFound if key.nil?
+    @attribute = schema.attributes.find do |attribute|
+      attribute.name == key or
+        attribute.id == key
+    end
+    raise ActiveRecord::RecordNotFound if @attribute.nil?
+  end
+end

data/examples/al-admin/app/controllers/directory_controller.rb

@@ -0,0 +1,47 @@
+class DirectoryController < ApplicationController
+  before_filter :login_required, :except => [:populate]
+  before_filter :empty_entries_required, :only => [:populate]
+
+  verify :xhr => true, :only => [:entry],
+         :render => {:text => "Bad Request", :status => 400}
+
+  def index
+    @root = Entry.root(find_options)
+  end
+
+  def entry
+    dn = params[:dn]
+    if Entry.base == dn
+      @entry = Entry.root(find_options)
+    else
+      @entry = Entry.find(dn, find_options)
+    end
+    render(:partial => "_entry/entry", :object => @entry)
+  end
+
+  def populate
+    ActiveLdap::Populate.ensure_base
+    ActiveLdap::Populate.ensure_ou(LdapUser.prefix)
+  end
+
+  private
+  def empty_entries_required
+    return true if Entry.empty?
+
+    flash.now[:notice] = _("Populating is only for initialization")
+    redirect_to(top_url)
+    false
+  end
+
+  def find_options
+    {:connection => current_ldap_user.connection}
+  end
+
+  def access_denied
+    if action_name == "entry"
+      render(:text => "Unauthorized", :status => 401)
+    else
+      super
+    end
+  end
+end

data/examples/al-admin/app/controllers/object_classes_controller.rb

@@ -0,0 +1,17 @@
+class ObjectClassesController < ApplicationController
+  before_filter :login_required
+
+  def index
+    @object_classes = schema.object_classes
+  end
+
+  def show
+    key = params[:id].to_a.flatten.compact[0]
+    raise ActiveRecord::RecordNotFound if key.nil?
+    @object_class = schema.object_classes.find do |object_class|
+      object_class.name == key or
+        object_class.id == key
+    end
+    raise ActiveRecord::RecordNotFound if @object_class.nil?
+  end
+end

data/examples/al-admin/app/controllers/syntaxes_controller.rb

@@ -0,0 +1,17 @@
+class SyntaxesController < ApplicationController
+  before_filter :login_required
+
+  def index
+    @syntaxes = schema.ldap_syntaxes
+  end
+
+  def show
+    key = params[:id].to_a.flatten.compact[0]
+    raise ActiveRecord::RecordNotFound if key.nil?
+    @syntax = schema.ldap_syntaxes.find do |syntax|
+      syntax.name == key or
+        syntax.id == key
+    end
+    raise ActiveRecord::RecordNotFound if @syntax.nil?
+  end
+end

data/examples/al-admin/app/controllers/users_controller.rb

@@ -0,0 +1,51 @@
+class UsersController < ApplicationController
+  verify :method => :post, :only => [:update],
+         :redirect_to => {:action => :index}
+
+  before_filter :login_required
+
+  def index
+    @users = find(:all)
+  end
+
+  def show
+    @user = find(params[:id])
+  end
+
+  def edit
+    @user = find(params[:id])
+  end
+
+  def update
+    @user = find(params[:id])
+    previous_user_password = @user.user_password
+    @user.replace_class(params["object-classes"])
+    if @user.update_attributes(params[:user])
+      if previous_user_password != @user.user_password and @user.connected?
+        @user.bind(@user.password)
+      end
+      flash[:notice] = _('User was successfully updated.')
+      redirect_to :action => 'show', :id => @user
+    else
+      @user.password = @user.password_confirmation = nil
+      render :action => 'edit'
+    end
+  end
+
+  def update_object_classes
+    @user = find(params[:id])
+    @user.replace_class(params["object-classes"])
+    available_attributes = @user.attribute_names(true)
+    attributes = {}
+    (params[:user] || {}).each do |key, value|
+      attributes[key] = value if available_attributes.include?(key)
+    end
+    @user.attributes = attributes
+    render(:partial => "attributes_update_form")
+  end
+
+  private
+  def find(*args)
+    current_ldap_user.find(*args)
+  end
+end

data/examples/al-admin/app/controllers/welcome_controller.rb

@@ -0,0 +1,10 @@
+class WelcomeController < ApplicationController
+  include UrlHelper
+
+  def index
+    unless logged_in?
+      flash.keep(:notice)
+      redirect_to(:login_path)
+    end
+  end
+end