rubysync 0.0.1

data/lib/ruby_sync/connectors/ldap_connector.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+#
+#  Copyright (c) 2007 Ritchie Young. All rights reserved.
+#
+# This file is part of RubySync.
+# 
+# RubySync is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
+# 
+# RubySync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+
+lib_path = File.dirname(__FILE__) + '/..'
+$:.unshift lib_path unless $:.include?(lib_path) || $:.include?(File.expand_path(lib_path))
+
+require 'ruby_sync'
+
+$VERBOSE = false
+require 'net/ldap'
+#$VERBOSE = true
+
+class Net::LDAP::Entry
+  def to_hash
+    return @myhash.dup
+  end
+end
+
+module RubySync::Connectors
+  class LdapConnector < RubySync::Connectors::BaseConnector
+    
+    attr_accessor :host, :port, :bind_method, :username, :password,
+                  :search_filter, :search_base,
+                  :association_attribute # name of the attribute in which to store the association key(s)
+    
+    def started
+      #TODO: If vault, check the schema to make sure that the association_attribute is there
+      @association_attribute ||= 'RubySyncAssociation'
+    end
+    
+    def check
+      Net::LDAP.open(:host=>@host, :port=>@port, :auth=>auth) do |ldap|
+        ldap.search :base => @search_base, :filter => @search_filter do |entry|
+          operations = operations_for_entry(entry)
+          association_key = (is_vault?)? nil : entry.dn
+          yield RubySync::Event.add(self, entry.dn, association_key, operations)
+        end
+      end
+    end
+    
+    # Runs the query specified by the config, gets the objectclass of the first
+    # returned object and returns a list of its allowed attributes
+    def self.fields
+      log.warn "Fields method not yet implemented for LDAP - Sorry."
+      log.warn "Returning a likely sample set."
+      %w{ cn givenName sn }
+    end
+
+    
+    def stopped
+    end
+    
+    def initialize options
+      super options
+      @bind_method ||= :simple
+      @host ||= 'localhost'
+      @port ||= 389
+      @search_filter ||= "cn=*"
+    end
+
+
+    def self.sample_config
+      return <<END
+  options(
+   :host=>'localhost',
+   :port=>10389,
+   :username=>'uid=admin,ou=system',
+   :password=>'secret',
+   :search_filter=>"cn=*",
+   :search_base=>"dc=example,dc=com"
+  # :bind_method=>:simple,
+  )
+END
+    end
+
+
+
+    def add(path, operations)
+      with_ldap do |ldap|
+        return false unless ldap.add :dn=>path, :attributes=>perform_operations(operations)
+      end
+      return true
+    rescue Net::LdapException
+      log.warning "Exception occurred while adding LDAP record"
+      false
+    end
+
+    def modify(path, operations)
+      log.debug "Modifying #{path} with the following operations:\n#{operations.inspect}"
+      with_ldap {|ldap| ldap.modify :dn=>path, :operations=>to_ldap_operations(operations) }
+    end
+
+    def delete(path)
+      with_ldap {|ldap| ldap.delete :dn=>path }
+    end
+
+    def [](path)
+      with_ldap do |ldap|
+        result = ldap.search :base=>path, :scope=>Net::LDAP::SearchScope_BaseObject, :filter=>'objectclass=*'
+        return nil if !result or result.size == 0
+        result[0].to_hash
+      end
+    end
+    
+    def target_transform event
+      event.add_default 'objectclass', 'inetOrgUser'
+      # TODO: Add modifier and timestamp unless LDAP dir does this automatically
+    end
+
+    def associate_with_foreign_key key, path
+      with_ldap do |ldap|
+        ldap.add_attribute(path, @association_attribute, key.to_s)
+      end
+    end
+    
+    def path_for_foreign_key key
+      entry = entry_for_foreign_key key
+      (entry)? entry.dn : nil
+    end
+    
+    def foreign_key_for path
+        entry = self[path]
+        (entry)? entry.dn : nil # TODO: That doesn't look right. Should return an association key, not a path.
+    end
+
+    def remove_foreign_key key
+      with_ldap do |ldap|
+        entry = entry_for_foreign_key key
+        if entry
+          modify :dn=>entry.dn, :operations=>[ [:delete, @association_attribute, key] ]
+        end
+      end
+    end
+
+    def find_associated foreign_key
+      entry = entry_for_foreign_key key
+      (entry)? operations_for_entry(entry) : nil
+    end
+    
+
+private
+
+    def operations_for_entry entry
+      # TODO: This could probably be done better by mixing Enumerable into Entry and then calling collect
+      ops = []
+      entry.each do |name, values|
+        ops << RubySync::Operation.add(name, values)
+      end
+      ops
+    end
+
+    def entry_for_foreign_key key
+      with_ldap do |ldap|
+        result = ldap.search :base=>@search_base, :filter=>"#{@association_attribute}=#{key}"
+        return nil if !result or result.size == 0
+        result[0]
+      end
+    end
+
+
+    def with_ldap
+      result = nil
+      Net::LDAP.open(:host=>@host, :port=>@port, :auth=>auth) do |ldap|
+        result = yield ldap
+      end
+      result
+    end
+    
+    def auth
+      {:method=>@bind_method, :username=>@username, :password=>@password}
+    end
+    
+    # Produce an array of operation arrays suitable for the LDAP library
+    def to_ldap_operations operations
+      operations.map {|op| [op.type, op.subject, op.values]}
+    end
+    
+  end
+end

data/lib/ruby_sync/connectors/memory_connector.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+#
+#  Copyright (c) 2007 Ritchie Young. All rights reserved.
+#
+# This file is part of RubySync.
+# 
+# RubySync is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
+# 
+# RubySync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+
+require "yaml"
+
+class Object
+  
+  # If not already an array, slip into one
+  def as_array
+    (instance_of? Array)? self : [self]
+  end
+end
+
+module RubySync::Connectors
+  class MemoryConnector < RubySync::Connectors::BaseConnector
+
+    def check
+      while event = @events.shift
+        yield event
+      end
+    end
+
+    def is_echo? event
+      event.sets_value?(:modifier, 'rubysync')
+    end
+
+    def associate(association, path)
+      path = normalize(path)
+      log.info "Associating '#{association}' with '#{path}'"
+      entry = @data[path]
+      if entry
+        (@association_index[association.context] ||= {})[association.key] = path
+        (entry[:association] ||= {})[association.context] = association.key
+      end
+    end
+
+    def path_for_association(association)
+      context = @association_index[association.context] || {}
+      context[association.key.to_s]
+    end
+
+    def association_key_for(context, path)
+      path = normalize(path)
+      log.debug "Retrieving association key for '#{path}' within '#{context}'"
+      entry = @data[path]
+      unless entry
+        p @data
+      end
+      if entry && entry[:association] && key = entry[:association][context]
+        return key
+      end
+      log.info "No association found."
+      log.debug entry.inspect
+      return nil
+    end
+    
+    def associations_for path
+      path = normalize path
+      entry = @data[path]
+      (entry[:association] || {}).map do |context, key|
+        RubySync::Association.new(context, key)
+      end
+    end
+    
+    def remove_association(association)
+      path = path_for_association association
+      context = @association_index[association.context]
+      context.delete(association.key) if context
+      entry = @data[path]
+      if entry
+        entry_context = (entry[:association] || {})[association.context]
+        entry_context.delete(association.key) if entry_context
+      end
+    end
+
+
+    def initialize options
+      super
+      @data = {}
+      @events = []
+      @association_index = {}
+    end
+
+    # Normally, the add method is called by the pipeline and simply stores
+    # the data to the datastore and that's it.
+    # In this case, though, we also generate an add event.
+    # This simulates the likely effect that an add would have on a proper datastore
+    # where doing an add would very likely cause an event to be generated that the
+    # pipeline should rightly ignore because it's just a side-effect.
+    # In other words, we're simply simulating an undesirable behaviour for testing
+    # purposes. 
+    def add id, operations
+      id = normalize id
+      raise Exception.new("Item already exists") if @data[id]
+      log.debug "Adding new record with key '#{id}'"
+      @data[id] = perform_operations operations
+      association_key = (is_vault?)? nil : [nil, own_association_key_for(id)]
+      log.info "#{name}: Injecting add event"
+      @events << RubySync::Event.add(self, id, association_key, operations.dup)
+      return id
+    end
+
+    def modify id, operations
+      id = normalize id
+      raise Exception.new("Attempting to modify non-existent record '#{id}'") unless @data[id]
+      perform_operations operations, @data[id]
+      association_key = (is_vault?)? nil : [nil, own_association_key_for(id)]
+      log.info "#{name}: Injecting modify event"
+      if is_vault?
+        associations_for(id).each do |association|
+          @events << (event = RubySync::Event.modify(self, id, association))
+        end
+      else
+        association = [nil, own_association_key_for(id)]
+        @events << (event = RubySync::Event.modify(self, id, association))
+      end
+
+      @events << RubySync::Event.modify(self, id, association_key, operations.dup)
+      return id
+    end
+
+
+    def delete id
+      id = normalize id
+      unless @data[id]
+         log.warn "Can't delete non-existent item '#{id}'"
+         return
+       end
+      log.info "#{name}: Injecting delete events"
+      if is_vault?
+        associations_for(id).each do |association|
+          @events << (event = RubySync::Event.delete(self, id, association))
+          @association_index.delete association
+        end
+      else
+        association = [nil, own_association_key_for(id)]
+        @events << (event = RubySync::Event.delete(self, id, association))
+      end
+      @data.delete id
+    end
+
+    # Put a clue there that we did this change so that we can detect and filter
+    # out the echo.
+    def target_transform event
+      event.payload << RubySync::Operation.new(:add, :modifier, ['rubysync'])
+    end
+    
+    def source_transform event
+      event.drop_changes_to [:modifier, :foreign_key]
+    end
+
+    def drop_pending_events
+      @events = []
+    end
+  
+    def [](key)
+      @data[normalize(key)]
+    end
+      
+    def []=(key, value)
+      @data[normalize(key)] = value
+    end
+
+private
+
+    def normalize(identifier)
+      identifier.to_s
+    end
+
+  end
+end
+

data/lib/ruby_sync/event.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+#
+#  Copyright (c) 2007 Ritchie Young. All rights reserved.
+#
+# This file is part of RubySync.
+# 
+# RubySync is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
+# 
+# RubySync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+
+
+module RubySync
+  
+  class Association
+    attr_accessor :context, # many associations will share the same context
+                            # it is a function of pipeline and the client connector
+                            # to which the association applies
+                  :key      # the key is unique within the context and vault
+    
+    def initialize(context, key)
+      @context = context
+      @key = key
+    end
+    
+    def to_s
+      "#{context}:#{key}"
+    end
+
+  end  
+  
+  class Event
+
+    attr_accessor :type,        # delete, add, modify ...
+                  :source,
+                  :payload,
+                  :source_path,
+                  :target_path,
+                  :association
+
+    
+    def self.delete source, source_path, association=nil
+      self.new(:delete, source, source_path, association)
+    end
+    
+    def self.add source, source_path, association=nil, payload=nil
+      self.new(:add, source, source_path, association, payload)
+    end
+    
+    def self.modify source, source_path, association=nil, payload=nil
+      self.new(:modify, source, source_path, association, payload)
+    end
+
+    def initialize type, source, source_path=nil, association=nil, payload=nil
+      self.type = type.to_sym
+      self.source = source
+      self.source_path = source_path
+      self.association = make_association(association)
+      self.payload = payload
+      @target_path = nil
+    end
+
+    def retrieve_association(context)
+      if self.source.is_vault?
+        self.association ||=  self.source.association_for(context, self.source_path)
+      else
+        if self.association # association key was supplied when the event was created
+          self.association.context = context # just add the context
+        else
+          key = self.source.own_association_key_for(self.source_path)
+          @association = Association.new(context, key)
+        end
+      end
+    end
+    
+    def associated?
+      self.association && self.association.context && self.association.key
+    end
+    
+    def merge other
+      # TODO implement merge
+      log.warning "Event.merge not yet implemented"
+    end
+    
+    # Retrieves all known values for the record affected by this event and
+    # sets the event's type to :add
+    # If the source connector doesn't implement retrieve we'll assume thats
+    # because it can't and that it gave us all it had to start with.
+    def convert_to_add
+      log.info "Converting '#{type}' event to add"
+      if (source.respond_to? :retrieve)
+        full = source.retrieve(source_path)
+        payload = full.payload
+      end
+      @type = :add
+    end
+
+    def convert_to_modify
+      log.info "Converting '#{type}' event to modify"
+      @type = :modify
+    end
+          
+    
+    def to_yaml_properties
+      %w{ @type @source_path @target_path @association @payload}
+    end
+    
+    # True if this event will lead to the field name given being set.
+    # If value is non-nil then if it will lead to it being set to
+    # the value given.
+    # Note: This implementation is not completely accurate. Just looks
+    # at the last operation in the payload. A better implementation would
+    # look at all items that affect the named field to work out the value.
+    def sets_value? subject, value=nil
+      return false if @payload == nil
+      @payload.reverse_each do |op|
+        return true if op.subject == subject.to_s && (value == nil || op.values == value.as_array)
+      end
+      return false
+    end
+    
+    # Remove any operations from the payload that affect fields with the given key or
+    # keys (key can be a single field name or an array of field names).
+    def drop_changes_to subject
+      subjects = subject.as_array
+      uncommitted_operations
+      @uncommitted_operations = @uncommitted_operations.delete_if {|op| subjects.include? op.subject }
+    end
+
+    def drop_all_but_changes_to subject
+      subjects = subject.as_array.map {|s| s.to_s}
+      @uncommitted_operations = uncommitted_operations.delete_if {|op| !subjects.include?(op.subject.to_s)}
+    end
+    
+     # Add a value to a given subject unless it already sets a value
+     def add_default field_name, value
+       add_value field_name, value unless sets_value? field_name
+     end
+     
+     
+     def add_value field_name, value
+       uncommitted_operations << Operation.new(:add, field_name, value.as_array)
+     end
+     
+     def set_value field_name, value
+       uncommitted_operations << Operation.new(:replace, field_name, value.as_array)
+     end
+
+  
+    def uncommitted_operations
+      @uncommitted_operations ||= @payload || []
+      return @uncommitted_operations
+    end
+ 
+    def uncommitted_operations= ops
+      @uncommitted_operations = ops
+    end
+  
+    # Add one or more operations to the list to be performed.
+    # The operations won't be added to the payload until commit_changes
+    # is called and won't be added at all if rollback_changes is called
+    # first.
+    def append new_operations
+      uncommitted_operations
+      @uncommitted_operations += new_operations.as_array
+    end
+
+    # Rollback any changes that 
+    def rollback_changes
+      @uncommitted_operations = nil
+    end
+  
+    def commit_changes
+      if uncommitted_operations 
+        @payload = uncommitted_operations
+        @uncommitted_operations = nil
+      end
+    end
+  
+  protected
+
+  # Try to make a sensible association from the passed in object
+  def make_association o  
+    if o.kind_of? Array
+      return Association.new(o[0],o[1])
+    elsif o.kind_of? RubySync::Association
+      return o
+    elsif o
+      return Association.new(nil, o)
+    else
+      nil
+    end
+  end
+      
+
+
+    # Yield to block for each operation in the payload for which the the subject is
+    # the specified subject
+    def each_operation_on subject
+      return unless payload
+      subjects = subject.as_array.map {|s| s.to_s}
+      payload.each do |op|
+        if subjects.include?(op.subject.to_s)
+          yield(op)
+        end
+      end
+    end
+
+  end  
+
+  
+end
+
+    
+    

data/lib/ruby_sync/operation.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+#
+#  Copyright (c) 2007 Ritchie Young. All rights reserved.
+#
+# This file is part of RubySync.
+# 
+# RubySync is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
+# 
+# RubySync is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License along with RubySync; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+module RubySync
+  
+  # Operations that may be performed on an attribute
+  class Operation
+  
+  attr_accessor :type, :subject, :values
+  
+  
+    def self.add subject, values
+      self.new(:add, subject, values)
+    end
+    
+    def self.delete subject, values
+      self.new(:delete, subject, values)
+    end
+    
+    def self.replace subject, values
+      self.new(:replace, subject, values)
+    end
+      
+  
+    def initialize type, subject, values
+      self.type = type.to_sym
+      self.subject = subject.to_s
+      self.values = values
+    end
+  
+    remove_method :type=
+    def type=(type)
+      unless [:add, :delete, :replace].include? type.to_sym
+        raise Exception.new("Invalid operation type '#{value}'")
+      end
+      @type = type
+    end
+    
+    remove_method :values=
+    def values=(values)
+      @values = values.as_array
+    end
+    
+    # Returns a duplicate of this operation but with the subject
+    # changed to the specified subject 
+    def same_but_on subject
+      op = self.dup
+      op.subject = subject
+      op
+    end
+    
+    # Returns a duplicate of this operation but with the type
+    # changed to the specified type
+    def same_but_as type
+      op = self.dup
+      op.type = type
+      op
+    end
+    
+    # Returns a duplicate of this operation but with the values
+    # changed to those specified
+    def same_but_with values
+      op = self.dub
+      op.values = values
+      op
+    end
+    
+    
+  end
+end