root/test.rb @ edb319df
02029fe9 | Marc Dequènes (Duck) | #!/usr/bin/ruby -Ku
|
|
$KCODE = 'UTF8'
|
|||
require 'jcode'
|
|||
require 'yaml'
|
|||
require 'active_ldap'
|
|||
require 'cmdparse2'
|
|||
require 'pathname'
|
|||
c26f67e5 | Marc Dequènes (Duck) | class Hash
|
|
def recursive_symbolize_keys!
|
|||
symbolize_keys!
|
|||
values.select { |v| v.is_a?(Hash) }.each { |h| h.recursive_symbolize_keys! }
|
|||
self
|
|||
end
|
|||
end
|
|||
02029fe9 | Marc Dequènes (Duck) | config_str_prv = IO.read("config/private.conf")
|
|
config_str = IO.read("config/test.conf")
|
|||
c26f67e5 | Marc Dequènes (Duck) | config = YAML.load(config_str_prv).merge(YAML.load(config_str)).recursive_symbolize_keys!
|
|
ActiveLdap::Base.setup_connection(config[:ldap])
|
|||
02029fe9 | Marc Dequènes (Duck) | ||
cmdparser = CmdParse::CommandParser.new(true)
|
|||
cmdparser.program_name = ""
|
|||
cmdparser.program_version = [0, 0, 1]
|
|||
cmdparser.options = CmdParse::OptionParserWrapper.new do |opt|
|
|||
opt.separator "Global options:"
|
|||
opt.on("--debug", "Output debug info without being formated") {|t| $debug_opt = true }
|
|||
opt.on("--expert", "Output extra info for expert users") {|t| $expert_opt = true }
|
|||
23fe62d2 | Marc Dequènes (Duck) | opt.on("--handles", "Output with handles (objects/field/... keys used for manipulations)") {|t| $handles_opt = true }
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
cmdparser.add_command(CmdParse::HelpCommand.new)
|
|||
cmdparser.add_command(CmdParse::VersionCommand.new)
|
|||
edb319df | Marc Dequènes (Duck) | module ActiveLdap
|
|
class DistinguishedName
|
|||
def shift
|
|||
@rdns.shift
|
|||
end
|
|||
end
|
|||
end
|
|||
02029fe9 | Marc Dequènes (Duck) | ||
module LdapMapper
|
|||
class LdapObject < ActiveLdap::Base
|
|||
class_inheritable_accessor :presentation, :mapper
|
|||
edb319df | Marc Dequènes (Duck) | ldap_mapping :prefix => '', :classes => ['top'], :scope => :sub
|
|
# temporary method until active_ldap is fixed: return a DN object (see #23932)
|
|||
def dn_obj
|
|||
ActiveLdap::DistinguishedName.parse(self.dn)
|
|||
end
|
|||
02029fe9 | Marc Dequènes (Duck) | def name
|
|
23fe62d2 | Marc Dequènes (Duck) | name = self[dn_attribute].is_a?(Array) ? self[dn_attribute][0] : self[dn_attribute]
|
|
name.strip
|
|||
end
|
|||
def human_name
|
|||
[self.class.presentation[:name_attribute], 'displayName', 'cn'].each do |attr|
|
|||
if self.has_attribute?(attr) and self.attribute_present?(attr)
|
|||
name = self[attr].is_a?(Array) ? self[attr][0] : self[attr]
|
|||
return name.strip
|
|||
end
|
|||
end
|
|||
return ""
|
|||
02029fe9 | Marc Dequènes (Duck) | end
|
|
def description
|
|||
23fe62d2 | Marc Dequènes (Duck) | [self.class.presentation[:desc_attribute], 'description'].each do |attr|
|
|
02029fe9 | Marc Dequènes (Duck) | if self.has_attribute?(attr) and self.attribute_present?(attr)
|
|
return self[attr].is_a?(Array) ? self[attr][0] : self[attr]
|
|||
end
|
|||
end
|
|||
return ""
|
|||
end
|
|||
cdce3438 | Marc Dequènes (Duck) | def possible_relations
|
|
self.associations.collect {|assoc| assoc.to_s } - ['children']
|
|||
end
|
|||
8519224c | Marc Dequènes (Duck) | def relations
|
|
cdce3438 | Marc Dequènes (Duck) | rel_list = []
|
|
rel_list += self.class.presentation[:associated_relations] if self.class.presentation[:associated_relations]
|
|||
aspects.each do |aspect|
|
|||
aspect_data = self.class.mapper.get_aspect(aspect)
|
|||
if defined?(aspect_data[:presentation][:associated_relations]) and aspect_data[:presentation][:associated_relations]
|
|||
rel_list += aspect_data[:presentation][:associated_relations]
|
|||
end
|
|||
end
|
|||
rel_list & possible_relations
|
|||
8519224c | Marc Dequènes (Duck) | end
|
|
ed02e398 | Marc Dequènes (Duck) | ||
02029fe9 | Marc Dequènes (Duck) | def aspects
|
|
473b6a8b | Marc Dequènes (Duck) | present_aspects = []
|
|
329f366a | Marc Dequènes (Duck) | (self.class.presentation[:allowed_aspects] || []).each do |aspect|
|
|
02029fe9 | Marc Dequènes (Duck) | aspect_data = self.class.mapper.get_aspect(aspect)
|
|
c26f67e5 | Marc Dequènes (Duck) | aspect_mapping = aspect_data[:mapping]
|
|
473b6a8b | Marc Dequènes (Duck) | present_aspects << aspect if self.classes & aspect_mapping[:classes] == aspect_mapping[:classes]
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
present_aspects
|
|||
end
|
|||
c26f67e5 | Marc Dequènes (Duck) | ||
def objectclasses_attr_list(objectclass_list)
|
|||
objectclass_list = [objectclass_list] unless objectclass_list.is_a? Array
|
|||
list = []
|
|||
objectclass_list.each do |objectclass|
|
|||
objectclass_obj = ActiveLdap::Base.schema.object_class(objectclass)
|
|||
attr_list = objectclass_obj.must + objectclass_obj.may
|
|||
list += attr_list.collect{|attr| attr.human_attribute_name }
|
|||
end
|
|||
list
|
|||
end
|
|||
8519224c | Marc Dequènes (Duck) | def organized_data(options = {})
|
|
473b6a8b | Marc Dequènes (Duck) | options.symbolize_keys!
|
|
options[:expert] ||= false;
|
|||
options[:skip_binary] ||= false;
|
|||
c26f67e5 | Marc Dequènes (Duck) | ignored_attrs = self.class.presentation[:hidden_attributes] || []
|
|
473b6a8b | Marc Dequènes (Duck) | ignored_attrs += (self.class.presentation[:expert_attributes] || []) unless options[:expert]
|
|
c26f67e5 | Marc Dequènes (Duck) | attr_list = self.attributes.keys - ignored_attrs
|
|
473b6a8b | Marc Dequènes (Duck) | aspects = self.aspects
|
|
cdce3438 | Marc Dequènes (Duck) | rel_list = self.possible_relations
|
|
8519224c | Marc Dequènes (Duck) | ||
ed02e398 | Marc Dequènes (Duck) | # first pass to take aspects forced relations into account
|
|
c26f67e5 | Marc Dequènes (Duck) | obj_aspects = {}
|
|
473b6a8b | Marc Dequènes (Duck) | aspects.each do |aspect|
|
|
aspect_data = self.class.mapper.get_aspect(aspect)
|
|||
8519224c | Marc Dequènes (Duck) | if defined?(aspect_data[:presentation][:associated_attributes]) and aspect_data[:presentation][:associated_attributes]
|
|
9681b76a | Marc Dequènes (Duck) | taken_attr_list = aspect_data[:presentation][:associated_attributes] & (attr_list + ignored_attrs)
|
|
8519224c | Marc Dequènes (Duck) | unless taken_attr_list.empty?
|
|
obj_aspects[aspect] ||= {}
|
|||
obj_aspects[aspect].merge!(fetch_attributes_data(taken_attr_list, options))
|
|||
attr_list -= taken_attr_list
|
|||
end
|
|||
end
|
|||
c26f67e5 | Marc Dequènes (Duck) | ||
8519224c | Marc Dequènes (Duck) | if defined?(aspect_data[:presentation][:associated_relations]) and aspect_data[:presentation][:associated_relations]
|
|
taken_rel_list = aspect_data[:presentation][:associated_relations] & rel_list
|
|||
unless taken_rel_list.empty?
|
|||
obj_aspects[aspect] ||= {}
|
|||
obj_aspects[aspect].merge!(fetch_relations_data(taken_rel_list, options))
|
|||
rel_list -= taken_rel_list
|
|||
end
|
|||
end
|
|||
c26f67e5 | Marc Dequènes (Duck) | end
|
|
473b6a8b | Marc Dequènes (Duck) | # manage general attributes
|
|
c26f67e5 | Marc Dequènes (Duck) | obj_info = {}
|
|
473b6a8b | Marc Dequènes (Duck) | if self.class.presentation[:associate_unclaimed_attributes]
|
|
c26f67e5 | Marc Dequènes (Duck) | taken_attr_list = attr_list
|
|
else
|
|||
473b6a8b | Marc Dequènes (Duck) | taken_attr_list = []
|
|
if self.class.presentation.has_key?(:associated_attributes)
|
|||
taken_attr_list += self.class.presentation[:associated_attributes]
|
|||
end
|
|||
taken_attr_list += objectclasses_attr_list(self.required_classes + (self.class.presentation[:optional_classes] || []))
|
|||
end
|
|||
taken_attr_list = taken_attr_list.uniq & attr_list
|
|||
obj_info = fetch_attributes_data(taken_attr_list, options)
|
|||
attr_list -= taken_attr_list
|
|||
9649c3cb | Marc Dequènes (Duck) | ||
# manage general relations
|
|||
if self.class.presentation[:associated_relations]
|
|||
taken_rel_list = self.class.presentation[:associated_relations] & rel_list
|
|||
unless taken_rel_list.empty?
|
|||
obj_info.merge!(fetch_relations_data(taken_rel_list, options))
|
|||
rel_list -= taken_rel_list
|
|||
end
|
|||
end
|
|||
473b6a8b | Marc Dequènes (Duck) | ||
# second pass to dispath the remaining attributes
|
|||
unless attr_list.empty?
|
|||
aspects.each do |aspect|
|
|||
aspect_data = self.class.mapper.get_aspect(aspect)
|
|||
taken_attr_list = (objectclasses_attr_list(aspect_data[:mapping][:classes]) & attr_list)
|
|||
obj_aspects[aspect] ||= {}
|
|||
obj_aspects[aspect].merge!(fetch_attributes_data(taken_attr_list, options))
|
|||
attr_list -= taken_attr_list
|
|||
break if attr_list.empty?
|
|||
end
|
|||
c26f67e5 | Marc Dequènes (Duck) | end
|
|
[obj_info, obj_aspects]
|
|||
end
|
|||
8519224c | Marc Dequènes (Duck) | ||
edb319df | Marc Dequènes (Duck) | def family_parent_dn
|
|
pdn = self.dn_obj.dup
|
|||
pdn.shift
|
|||
pdn
|
|||
end
|
|||
def family_children
|
|||
LdapObject.find(:all, :base => self.dn, :scope => :one)
|
|||
end
|
|||
def family_children_dn
|
|||
self.family_children.collect {|obj| obj.dn }
|
|||
end
|
|||
def family_siblings
|
|||
# cannot substract, as the ruby object signature may be different
|
|||
LdapObject.find(:all, :base => self.family_parent_dn.to_s, :scope => :one).select{|obj| obj.dn != self.dn }
|
|||
end
|
|||
def family_siblings_dn
|
|||
self.family_siblings.collect {|obj| obj.dn }
|
|||
end
|
|||
8519224c | Marc Dequènes (Duck) | protected
|
|
def fetch_attributes_data(attr_list, options = {})
|
|||
attr_data = self.attributes.select {|key, val| attr_list.include?(key) and not (options[:skip_binary] and ActiveLdap::Base.schema.attribute(key).binary?) }
|
|||
Hash[attr_data]
|
|||
end
|
|||
def fetch_relations_data(rel_list, options = {})
|
|||
rel_data = rel_list.collect do |rel|
|
|||
data = self.send(rel).collect{|g| g.name }
|
|||
data.empty? ? nil : ["rel:" + rel, data]
|
|||
end
|
|||
Hash[rel_data.compact]
|
|||
end
|
|||
02029fe9 | Marc Dequènes (Duck) | end
|
|
class Controller
|
|||
def initialize(mod_container = LdapMapper::Objects)
|
|||
@mod_container = mod_container
|
|||
@object_definitions = {}
|
|||
@aspects = {}
|
|||
end
|
|||
def set_aspect(aspect_name, aspect_def)
|
|||
@aspects[aspect_name] = aspect_def
|
|||
end
|
|||
def get_aspect(aspect_name)
|
|||
c26f67e5 | Marc Dequènes (Duck) | @aspects[aspect_name.to_sym]
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
def self.object_name_to_klass_name(obj_name)
|
|||
c26f67e5 | Marc Dequènes (Duck) | "LdapObject" + obj_name.to_s.capitalize
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
def load_object(obj_name, obj_def)
|
|||
c26f67e5 | Marc Dequènes (Duck) | obj_mapping = obj_def[:mapping]
|
|
02029fe9 | Marc Dequènes (Duck) | klass_name = self.class.object_name_to_klass_name(obj_name)
|
|
# create class
|
|||
@mod_container.module_eval(<<-EOS)
|
|||
class #{klass_name} < LdapMapper::LdapObject; end
|
|||
EOS
|
|||
# configure class
|
|||
klass = find_klass(obj_name)
|
|||
c26f67e5 | Marc Dequènes (Duck) | klass.presentation = obj_def[:presentation]
|
|
02029fe9 | Marc Dequènes (Duck) | klass.mapper = self
|
|
klass.ldap_mapping obj_mapping.reject {|key, val| not ActiveLdap::Base::VALID_LDAP_MAPPING_OPTIONS.include?(key) }
|
|||
ed02e398 | Marc Dequènes (Duck) | # store definition for later relations processing
|
|
02029fe9 | Marc Dequènes (Duck) | @object_definitions[obj_name] = obj_def
|
|
end
|
|||
def find_klass(obj_name)
|
|||
klass_name = self.class.object_name_to_klass_name(obj_name)
|
|||
return nil unless @mod_container.const_defined?(klass_name)
|
|||
@mod_container.const_get(klass_name)
|
|||
end
|
|||
# run it _once_ when all objects are loaded
|
|||
ed02e398 | Marc Dequènes (Duck) | def load_relations
|
|
02029fe9 | Marc Dequènes (Duck) | @object_definitions.each_pair do |obj_name, obj_def|
|
|
b119396d | Marc Dequènes (Duck) | obj_rel = {}
|
|
obj_rel.merge!(obj_def[:relations]) if obj_def.include?(:relations)
|
|||
if obj_def[:presentation].has_key?(:allowed_aspects)
|
|||
obj_def[:presentation][:allowed_aspects].each do |rel|
|
|||
rel_data = get_aspect(rel)
|
|||
obj_rel.merge!(rel_data[:relations]) if rel_data.has_key?(:relations) and rel_data[:relations]
|
|||
end
|
|||
end
|
|||
next if obj_rel.empty?
|
|||
02029fe9 | Marc Dequènes (Duck) | ||
klass = find_klass(obj_name)
|
|||
ed02e398 | Marc Dequènes (Duck) | obj_rel.each_pair do |field_name, rel|
|
|
foreign_klass = find_klass(rel[:object])
|
|||
rel[:class_name] = foreign_klass.to_s
|
|||
02029fe9 | Marc Dequènes (Duck) | ||
ed02e398 | Marc Dequènes (Duck) | case rel[:type]
|
|
02029fe9 | Marc Dequènes (Duck) | when :belongs_to
|
|
ed02e398 | Marc Dequènes (Duck) | klass.belongs_to field_name, rel.reject {|key, val| not ActiveLdap::Associations::ClassMethods::VALID_BELONGS_TO_OPTIONS.include?(key) }
|
|
02029fe9 | Marc Dequènes (Duck) | when :has_many
|
|
ed02e398 | Marc Dequènes (Duck) | klass.has_many field_name, rel.reject {|key, val| not ActiveLdap::Associations::ClassMethods::VALID_HAS_MANY_OPTIONS.include?(key) }
|
|
02029fe9 | Marc Dequènes (Duck) | else
|
|
ed02e398 | Marc Dequènes (Duck) | raise "bug in '#{obj_name}' object relations (wrong type)"
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
end
|
|||
end
|
|||
end
|
|||
end
|
|||
# default location for mapped objects
|
|||
module Objects
|
|||
end
|
|||
end
|
|||
I18n.load_path += Dir[File.join(Pathname.new(".").realpath, "locale", "*.yml")]
|
|||
I18n.default_locale = :en
|
|||
ldapctl = LdapMapper::Controller.new
|
|||
c26f67e5 | Marc Dequènes (Duck) | config[:aspects].each_pair do |aspect_name, aspect_data|
|
|
02029fe9 | Marc Dequènes (Duck) | ldapctl.set_aspect(aspect_name, aspect_data)
|
|
end
|
|||
c26f67e5 | Marc Dequènes (Duck) | config[:objects].each_pair do |obj_name, obj_data|
|
|
02029fe9 | Marc Dequènes (Duck) | ldapctl.load_object(obj_name, obj_data)
|
|
end
|
|||
ed02e398 | Marc Dequènes (Duck) | ldapctl.load_relations
|
|
02029fe9 | Marc Dequènes (Duck) | ||
cmd = CmdParse::Command.new('list', false)
|
|||
cmd.short_desc = "list objects"
|
|||
cmd.set_execution_block do |args|
|
|||
if args.size != 1
|
|||
STDERR.puts "syntax error: no object name given"
|
|||
exit 1
|
|||
end
|
|||
23fe62d2 | Marc Dequènes (Duck) | obj_hdl = args[0]
|
|
obj_klass = ldapctl.find_klass(obj_hdl)
|
|||
02029fe9 | Marc Dequènes (Duck) | if obj_klass.nil?
|
|
23fe62d2 | Marc Dequènes (Duck) | STDERR.puts "No such object '#{obj_hdl}'."
|
|
02029fe9 | Marc Dequènes (Duck) | exit 2
|
|
end
|
|||
23fe62d2 | Marc Dequènes (Duck) | obj_human_name = I18n.t(obj_hdl, :scope => 'objects', :default => "Object '#{obj_hdl}'")
|
|
puts "=== List of #{obj_human_name.pluralize} ==="
|
|||
02029fe9 | Marc Dequènes (Duck) | obj_klass.find(:all).each do |obj|
|
|
23fe62d2 | Marc Dequènes (Duck) | str = obj.human_name
|
|
str += " [#{obj.name}]" if $handles_opt
|
|||
str += ": #{obj.description}" unless obj.description.empty?
|
|||
puts str
|
|||
02029fe9 | Marc Dequènes (Duck) | end
|
|
end
|
|||
cmdparser.add_command(cmd)
|
|||
23fe62d2 | Marc Dequènes (Duck) | def translate_data_key(name)
|
|
8519224c | Marc Dequènes (Duck) | if name.index(":")
|
|
type, key = name.split(":")
|
|||
case type
|
|||
when 'rel'
|
|||
I18n.t(key, :scope => 'relations', :default => name)
|
|||
else
|
|||
raise "Cannot translate unknown data key type"
|
|||
end
|
|||
else
|
|||
att = ActiveLdap::Base.schema.attribute(name)
|
|||
I18n.t(att.human_attribute_name, :scope => 'attribute_types', :default => att.human_attribute_description)
|
|||
end
|
|||
473b6a8b | Marc Dequènes (Duck) | end
|
|
02029fe9 | Marc Dequènes (Duck) | ||
8519224c | Marc Dequènes (Duck) | def display_data(attr_data)
|
|
473b6a8b | Marc Dequènes (Duck) | attr_data.each_pair do |key, val|
|
|
9681b76a | Marc Dequènes (Duck) | field_name = translate_data_key(key)
|
|
23fe62d2 | Marc Dequènes (Duck) | field_name += " [#{key}]" if $handles_opt
|
|
9681b76a | Marc Dequènes (Duck) | puts field_name + ": " + (val.is_a?(Array) ? val.sort.collect{|v| v.to_s }.join(", ") : val.to_s)
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
end
|
|||
cmd = CmdParse::Command.new('show', false)
|
|||
cmd.short_desc = "show object information"
|
|||
cmd.set_execution_block do |args|
|
|||
if args.size < 1
|
|||
STDERR.puts "syntax error: no object name given"
|
|||
exit 1
|
|||
end
|
|||
if args.size < 2
|
|||
STDERR.puts "syntax error: no item name given"
|
|||
exit 1
|
|||
end
|
|||
23fe62d2 | Marc Dequènes (Duck) | obj_hdl = args[0]
|
|
obj_klass = ldapctl.find_klass(obj_hdl)
|
|||
02029fe9 | Marc Dequènes (Duck) | if obj_klass.nil?
|
|
23fe62d2 | Marc Dequènes (Duck) | STDERR.puts "No such object '#{obj_hdl}'."
|
|
02029fe9 | Marc Dequènes (Duck) | exit 2
|
|
end
|
|||
23fe62d2 | Marc Dequènes (Duck) | item_hdl = args[1]
|
|
02029fe9 | Marc Dequènes (Duck) | begin
|
|
23fe62d2 | Marc Dequènes (Duck) | item = obj_klass.find(item_hdl)
|
|
02029fe9 | Marc Dequènes (Duck) | rescue ActiveLdap::EntryNotFound
|
|
23fe62d2 | Marc Dequènes (Duck) | STDERR.puts "No such item '#{obj_hdl}/#{item_hdl}'"
|
|
02029fe9 | Marc Dequènes (Duck) | exit 2
|
|
end
|
|||
23fe62d2 | Marc Dequènes (Duck) | obj_human_name = I18n.t(obj_hdl, :scope => 'objects', :default => "Object '#{obj_hdl}'")
|
|
name = item.human_name
|
|||
name += " [#{item.name}]" if $handles_opt
|
|||
puts "=== #{obj_human_name}: #{name} ==="
|
|||
9681b76a | Marc Dequènes (Duck) | ||
02029fe9 | Marc Dequènes (Duck) | if $debug_opt
|
|
puts item.to_s
|
|||
9681b76a | Marc Dequènes (Duck) | puts "--- Detected Info ---"
|
|
473b6a8b | Marc Dequènes (Duck) | puts "aspects: " + item.aspects.sort.join(", ")
|
|
8519224c | Marc Dequènes (Duck) | ||
cdce3438 | Marc Dequènes (Duck) | puts "--- Family ---"
|
|
edb319df | Marc Dequènes (Duck) | puts "parent: " + item.family_parent_dn.to_s
|
|
puts "siblings: " + item.family_siblings_dn.join(", ")
|
|||
puts "children: " + item.family_children_dn.join(", ")
|
|||
cdce3438 | Marc Dequènes (Duck) | ||
9681b76a | Marc Dequènes (Duck) | puts "--- Relations ---"
|
|
8519224c | Marc Dequènes (Duck) | item.relations.each do |rel|
|
|
puts "#{rel}: " + item.send(rel).collect{|g| g.name }.join(", ")
|
|||
end
|
|||
02029fe9 | Marc Dequènes (Duck) | else
|
|
8519224c | Marc Dequènes (Duck) | obj_info, obj_aspects = item.organized_data(:expert => $expert_opt, :skip_binary => true)
|
|
02029fe9 | Marc Dequènes (Duck) | ||
8519224c | Marc Dequènes (Duck) | display_data(obj_info)
|
|
02029fe9 | Marc Dequènes (Duck) | ||
473b6a8b | Marc Dequènes (Duck) | obj_aspects.each_pair do |aspect_name, aspect_data|
|
|
9681b76a | Marc Dequènes (Duck) | aspect_display_name = I18n.t(aspect_name, :scope => 'aspects', :default => "Aspect '#{aspect_name}'")
|
|
puts "--- #{aspect_display_name} ---"
|
|||
8519224c | Marc Dequènes (Duck) | display_data(aspect_data)
|
|
02029fe9 | Marc Dequènes (Duck) | end
|
|
end
|
|||
end
|
|||
cmdparser.add_command(cmd)
|
|||
cmdparser.parse
|