powerhome-activeldap 3.2.3

data/examples/userls

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH << File.join(base, "lib")
+$LOAD_PATH << File.join(base, "examples")
+
+require 'active_ldap'
+require 'objects/user'
+require 'objects/group'
+
+require 'base64'
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  opts.banner += " USER_NAME"
+end
+
+if argv.size == 1
+  name = argv.shift
+else
+  $stderr.puts opts
+  exit 1
+end
+
+pwb = Proc.new do |user|
+  ActiveLdap::Command.read_password("[#{user}] Password: ")
+end
+
+ActiveLdap::Base.setup_connection(:password_block => pwb,
+                                  :allow_anonymous => false)
+
+unless User.exists?(name)
+  $stderr.puts("User #{name} doesn't exist.")
+  exit 1
+end
+
+user = User.find(name)
+puts user.to_ldif
+
+groups = []
+primary_group = user.primary_group
+if primary_group.exists?
+  groups << "#{primary_group.cn}[#{primary_group.gid_number}]"
+end
+puts "Groups by name only: #{user.groups(false).join(', ')}"
+user.groups.sort_by do |group|
+  group.id
+end.collect do |group|
+  groups << "#{group.cn}[#{group.gid_number}]"
+end
+puts "Groups: #{groups.join(', ')}"

data/examples/usermod

@@ -0,0 +1,42 @@
+#!/usr/bin/ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH << File.join(base, "lib")
+$LOAD_PATH << File.join(base, "examples")
+
+require 'active_ldap'
+require 'objects/user'
+require 'objects/group'
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  opts.banner += " USER_NAME CN UID"
+end
+
+if argv.size == 3
+  name, cn, uid = argv
+else
+  $stderr.puts opts
+  exit 1
+end
+
+pwb = Proc.new do |user|
+  ActiveLdap::Command.read_password("[#{user}] Password: ")
+end
+
+ActiveLdap::Base.setup_connection(:password_block => pwb,
+                                  :allow_anonymous => false)
+
+unless User.exists?(name)
+  $stderr.puts("User #{name} doesn't exist.")
+  exit 1
+end
+
+user = User.find(name)
+user.cn = cn
+user.uid_number = uid
+user.gid_number = uid
+unless user.save
+  puts "failed"
+  puts user.errors.full_messages
+  exit 1
+end

data/examples/usermod-binary-add

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH << File.join(base, "lib")
+$LOAD_PATH << File.join(base, "examples")
+
+require 'active_ldap'
+require 'objects/user'
+require 'objects/group'
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  opts.banner += " USER_NAME CN UID"
+end
+
+if argv.size == 3
+  name, cn, uid = argv
+else
+  $stderr.puts opts
+  exit 1
+end
+
+pwb = Proc.new do |user|
+  ActiveLdap::Command.read_password("[#{user}] Password: ")
+end
+
+ActiveLdap::Base.setup_connection(:password_block => pwb,
+                                  :allow_anonymous => false)
+
+unless User.exists?(name)
+  $stderr.puts("User #{name} doesn't exist.")
+  exit 1
+end
+
+user = User.find(name)
+user.cn = cn
+user.uid_number = uid
+user.gid_number = uid
+
+user.add_class('strongAuthenticationUser')
+cert_file = File.join(File.dirname(__FILE__), 'example.der')
+File.open(cert_file) do |input|
+  input.set_encoding("ascii-8bit") if input.respond_to?(:set_encoding)
+  user.user_certificate = input.read
+end
+
+unless user.save
+  puts "failed"
+  puts user.errors.full_messages
+  exit 1
+end

data/examples/usermod-binary-add-time

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH << File.join(base, "lib")
+$LOAD_PATH << File.join(base, "examples")
+
+require 'active_ldap'
+require 'objects/user'
+require 'objects/group'
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  opts.banner += " USER_NAME CN UID"
+end
+
+if argv.size == 3
+  name, cn, uid = argv
+else
+  $stderr.puts opts
+  exit 1
+end
+
+pwb = Proc.new do |user|
+  ActiveLdap::Command.read_password("[#{user}] Password: ")
+end
+
+ActiveLdap::Base.setup_connection(:password_block => pwb,
+                                  :allow_anonymous => false)
+
+unless User.exists?(name)
+  $stderr.puts("User #{name} doesn't exist.")
+  exit 1
+end
+
+100.times do |i|
+  user = User.find(name)
+  user.cn = cn
+  user.uid_number = uid
+  user.gid_number = uid
+
+  user.add_class('strongAuthenticationUser')
+  cert_file = File.join(File.dirname(__FILE__), 'example.der')
+  File.open(cert_file) do |input|
+    input.set_encoding("ascii-8bit") if input.respond_to?(:set_encoding)
+    user.user_certificate = input.read
+  end
+
+  unless user.save
+    puts "failed #{i}"
+    puts user.errors.full_messages
+    exit 1
+  end
+
+  # puts "success [#{i}]"
+end

data/examples/usermod-binary-del

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH << File.join(base, "lib")
+$LOAD_PATH << File.join(base, "examples")
+
+require 'active_ldap'
+require 'objects/user'
+require 'objects/group'
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  opts.banner += " USER_NAME CN UID"
+end
+
+if argv.size == 3
+  name, cn, uid = argv
+else
+  $stderr.puts opts
+  exit 1
+end
+
+pwb = Proc.new do |user|
+  ActiveLdap::Command.read_password("[#{user}] Password: ")
+end
+
+ActiveLdap::Base.setup_connection(:password_block => pwb,
+                                  :allow_anonymous => false)
+
+unless User.exists?(name)
+  $stderr.puts("User #{name} doesn't exist.")
+  exit 1
+end
+
+user = User.find(name)
+user.cn = cn
+user.uid_number = uid
+user.gid_number = uid
+
+if user.classes.include?('strongAuthenticationUser')
+  user.user_certificate = nil
+  user.remove_class('strongAuthenticationUser')
+end
+
+unless user.save
+  puts "failed"
+  puts user.errors.full_messages
+  exit 1
+end

data/examples/usermod-lang-add

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby
+
+base = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH << File.join(base, "lib")
+$LOAD_PATH << File.join(base, "examples")
+
+require 'active_ldap'
+require 'objects/user'
+require 'objects/group'
+
+argv, opts, options = ActiveLdap::Command.parse_options do |opts, options|
+  opts.banner += " USER_NAME CN UID"
+end
+
+if argv.size == 3
+  name, cn, uid = argv
+else
+  $stderr.puts opts
+  exit 1
+end
+
+pwb = Proc.new do |user|
+  ActiveLdap::Command.read_password("[#{user}] Password: ")
+end
+
+ActiveLdap::Base.setup_connection(:password_block => pwb,
+                                  :allow_anonymous => false)
+
+unless User.exists?(name)
+  $stderr.puts("User #{name} doesn't exist.")
+  exit 1
+end
+
+user = User.find(name)
+user.cn = [cn, {'lang-en-us' => cn}]
+user.uid_number = uid
+user.gid_number = uid
+
+unless user.save
+  puts "failed"
+  puts user.errors.full_messages
+  exit 1
+end

data/lib/active_ldap.rb

@@ -0,0 +1,85 @@
+require "rubygems"
+require "active_model"
+require "active_support/core_ext"
+
+require "active_ldap/version"
+
+module ActiveLdap
+  autoload :Command, "active_ldap/command"
+end
+
+if RUBY_PLATFORM.match('linux')
+  require 'active_ldap/timeout'
+else
+  require 'active_ldap/timeout_stub'
+end
+
+require 'active_ldap/get_text'
+
+require 'active_ldap/compatible'
+
+require 'active_ldap/base'
+
+require 'active_ldap/distinguished_name'
+require 'active_ldap/ldif'
+require 'active_ldap/xml'
+
+require 'active_ldap/persistence'
+
+require 'active_ldap/associations'
+require 'active_ldap/attributes'
+require 'active_ldap/attribute_methods'
+require 'active_ldap/attribute_methods/query'
+require 'active_ldap/attribute_methods/before_type_cast'
+require 'active_ldap/attribute_methods/read'
+require 'active_ldap/attribute_methods/write'
+require 'active_ldap/attribute_methods/dirty'
+require 'active_ldap/configuration'
+require 'active_ldap/connection'
+require 'active_ldap/operations'
+require 'active_ldap/object_class'
+require 'active_ldap/human_readable'
+
+require 'active_ldap/acts/tree'
+
+require 'active_ldap/populate'
+require 'active_ldap/escape'
+require 'active_ldap/user_password'
+require 'active_ldap/helper'
+
+require 'active_ldap/validations'
+require 'active_ldap/callbacks'
+
+
+ActiveLdap::Base.class_eval do
+  include ActiveLdap::Persistence
+
+  include ActiveLdap::Associations
+  include ActiveModel::MassAssignmentSecurity
+  include ActiveLdap::Attributes
+  include ActiveLdap::AttributeMethods
+  include ActiveLdap::AttributeMethods::BeforeTypeCast
+  include ActiveLdap::AttributeMethods::Write
+  include ActiveLdap::AttributeMethods::Dirty
+  include ActiveLdap::AttributeMethods::Query
+  include ActiveLdap::AttributeMethods::Read
+  include ActiveLdap::Configuration
+  include ActiveLdap::Connection
+  include ActiveLdap::Operations
+  include ActiveLdap::ObjectClass
+
+  include ActiveLdap::Acts::Tree
+
+  include ActiveLdap::Validations
+  include ActiveLdap::Callbacks
+  include ActiveLdap::HumanReadable
+end
+
+unless defined?(ACTIVE_LDAP_CONNECTION_ADAPTERS)
+  ACTIVE_LDAP_CONNECTION_ADAPTERS = %w(ldap net_ldap jndi)
+end
+
+ACTIVE_LDAP_CONNECTION_ADAPTERS.each do |adapter|
+  require "active_ldap/adapter/#{adapter}"
+end
+

data/lib/active_ldap/action_controller/ldap_benchmarking.rb

@@ -0,0 +1,55 @@
+module ActiveLdap
+  module ActionController
+    module LdapBenchmarking
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :render_with_benchmark, :active_ldap
+          if private_method_defined?(:view_runtime)
+            alias_method_chain :view_runtime, :active_ldap
+          else
+            alias_method_chain :rendering_runtime, :active_ldap
+          end
+        end
+      end
+
+      protected
+      def render_with_benchmark_with_active_ldap(*args, &block)
+        if logger
+          ldap_runtime_before_render = ActiveLdap::Base.reset_runtime
+        end
+        result = render_with_benchmark_without_active_ldap(*args, &block)
+        if logger
+          @ldap_runtime_before_render = ldap_runtime_before_render
+          @ldap_runtime_after_render = ActiveLdap::Base.reset_runtime
+          if defined?(@rendering_runtime)
+            @rendering_runtime -= @ldap_runtime_after_render
+          else
+            @view_runtime -= @ldap_runtime_after_render
+          end
+        end
+        result
+      end
+
+      private
+      def rendering_runtime_with_active_ldap(runtime)
+        result = rendering_runtime_without_active_ldap(runtime)
+        ldap_runtime = ActiveLdap::Base.reset_runtime
+        ldap_runtime += @ldap_runtime_before_render || 0
+        ldap_runtime += @ldap_runtime_after_render || 0
+        ldap_percentage = ldap_runtime * 100 / runtime
+        result + (" | LDAP: %.5f (%d%%)" % [ldap_runtime, ldap_percentage])
+      end
+
+      def view_runtime_with_active_ldap
+        result = view_runtime_without_active_ldap
+        ldap_runtime = ActiveLdap::Base.reset_runtime
+        @ldap_runtime_before_render ||= 0
+        @ldap_runtime_after_render ||= 0
+        ldap_runtime += @ldap_runtime_before_render
+        ldap_runtime += @ldap_runtime_after_render
+        result + (", LDAP: %.0f" % (ldap_runtime * 1000))
+      end
+    end
+  end
+end
+

data/lib/active_ldap/acts/tree.rb

@@ -0,0 +1,78 @@
+module ActiveLdap
+  module Acts
+    module Tree
+      def self.included(base)
+        base.class_eval do
+          extend(ClassMethods)
+          association_accessor(:children) do |target|
+            Association::Children.new(target, {})
+          end
+        end
+      end
+
+      module ClassMethods
+        def root(options={})
+          find(:first, options.merge(:scope => :base))
+        end
+      end
+
+      # Returns list of ancestors, starting from parent until root.
+      #
+      #   subchild1.ancestors # => [child1, root]
+      def ancestors
+        node, nodes = self, []
+        nodes << node = node.parent while node.parent
+        nodes
+      end
+
+      # Returns the root node of the tree.
+      def root
+        node = self
+        node = node.parent while node.parent
+        node
+      end
+
+      # Returns all siblings of the current node.
+      #
+      #   subchild1.siblings # => [subchild2]
+      def siblings
+        self_and_siblings - [self]
+      end
+
+      # Returns all siblings and a reference to the current node.
+      #
+      #   subchild1.self_and_siblings # => [subchild1, subchild2]
+      def self_and_siblings
+        parent ? parent.children : [self]
+      end
+
+      def parent
+        if base == self.class.base
+          nil
+        else
+          find(:first, :base => base, :scope => :base)
+        end
+      end
+
+      def parent=(entry)
+        if entry.is_a?(String) or entry.is_a?(DN)
+          base = entry
+        elsif entry.respond_to?(:dn)
+          base = entry.dn
+          if entry.respond_to?(:clear_association_cache)
+            entry.clear_association_cache
+          end
+        else
+          message = _("parent must be an entry or parent DN: %s") % entry.inspect
+          raise ArgumentError, message
+        end
+        unless new_entry?
+          self.class.delete_entry(dn, :connection => connection)
+          @new_entry = true
+        end
+        self.dn = "#{dn_attribute}=#{id},#{base}"
+        save
+      end
+    end
+  end
+end