mhc 1.0.0

data/lib/mhc/sync/status_manager.rb

@@ -0,0 +1,142 @@
+module Mhc
+  module Sync
+    ##
+    # It wraps existing database to adds ability to manage etag cache for sync status tracking.
+    # The downstream database is supposed to respond to:
+    #
+    # 1. report_etags
+    #      report_etags(uids = nil) # returns one of:
+    #       => {uid_string => etag_object } # Hash
+    #       => {uid_string => etag_string } # Hash
+    #       => [uid_etag_object] # Array
+    #
+    #    uid_etag_object is an object which respond to #etag and #uid method.
+    #    etag_object is an object which respond to #etag method.
+    #
+    # 2. get_with_etag
+    #      get_with_etag(uid)
+    #      # => [RECORD, etag]
+    #
+    #    Each RECORD has to respond to #to_ics_string or #body that
+    #    returns iCalendar-conformed string.
+    #
+    # 3. put_if_match
+    #      put_if_match(uid, ics_string, expected_etag)
+    #      # => put ics_string if "ETAG" equals to expected_etag
+    #
+    # 4. delete_if_match
+    #      delete_if_match(uid, expected_etag)
+    #      # => delete uid if "ETAG" equals to expected_etag
+    #
+    # expected_etag is a string for sync.  if expected_etag is omitted
+    # (or nil), put_if_match and delete_if_match will ignore
+    # conflictions.
+    #
+    class StatusManager
+      def initialize(real_db, etag_db)
+        @db, @etag_db = real_db, etag_db
+        refresh_status
+      end
+
+      def syncinfo(uid)
+        Status.new(uid, self)
+      end
+
+      def uid_list
+        (@db_status.keys + @etag_status.keys).sort.uniq
+      end
+
+      ##
+      # delegation to original DB with sync-status check.
+      #
+      # To make sure any kind of update is safe,
+      # you may want to check current_record.ex_etag == current_record.etag
+      # (means current_record.unmodified? is true) like:
+      #
+      #    if current_record.unmodified?
+      #      @db.put(new_record)
+      #    end
+      #
+      # However, this will not work. Because this check-and-update
+      # must be an atomic operation.
+      # So, instead, we have to do:
+      #
+      #   @db.put_if_match(new_record, current_record.ex_etag)
+      #
+      def get(uid)
+        res, etag = @db.get_with_etag(uid)
+        @db_status[uid] = etag if etag
+        return Status.new(uid, self, res)
+      end
+
+      def put(modified_record, overwrite = false)
+        current_record = syncinfo(modified_record.uid)
+        expected_etag = overwrite ? nil : current_record.ex_etag
+
+        if @db.put_if_match(current_record.uid, modified_record.to_ics_string, expected_etag)
+          ## XXX: put_if_match should return the new etag value, and we
+          ## have to use it as a new etag for the current record.
+          ## However, some CalDAV servers (Google Calendar) do not
+          ## return any etag on PUT.
+          ## So, we have to PROPFIND immediately after the
+          ## PUT. This is a small crack on atomicity
+          refresh_status(current_record.uid)  # refresh propfind cache.
+          current_record.mark_synced
+          return Status.new(current_record.uid, self)
+        else
+          return nil # put failed.
+        end
+      end
+
+      def delete(uid)
+        current_record = syncinfo(uid)
+        if @db.delete_if_match(current_record.uid, current_record.ex_etag)
+          refresh_status(current_record.uid)
+          current_record.mark_synced
+          return Status.new(current_record.uid, self)
+        else
+          return nil
+        end
+      end
+
+      # propfind with cache
+      def refresh_status(uids = :all)
+        ### XXX: care fore UIDs for partial update.
+        @db_status = make_hash(@db.report_etags)
+        @etag_status = make_hash(@etag_db.report_etags)
+      end
+
+      def etag(uid)
+        if @db_status[uid].respond_to?(:etag)
+          return @db_status[uid].etag
+        else
+          return @db_status[uid]
+        end
+      end
+
+      def ex_etag(uid)
+        @etag_status[uid]
+      end
+
+      def mark_synced(uid, etag)
+        @etag_db.put(uid, etag)
+        return self
+      end
+
+      private
+      ## etag_report is one of:
+      ##   + {uid_string => etag_object } style hash,
+      ##   + {uid_string => etag_string } style hash,
+      ##   + [uid_etag_object] style array,
+      ## uid_etag_object is an object which respond to #etag and #uid method.
+      ## etag_object is an object which respond to #etag method.
+      def make_hash(etag_report)
+        return etag_report if etag_report.respond_to?(:keys)
+        hash = {}
+        etag_report.map {|o| hash[o.uid] = o.etag} if etag_report
+        return hash
+      end
+
+    end # class StatusManager
+  end # module Sync
+end # module Mhc

data/lib/mhc/sync/strategy.rb

@@ -0,0 +1,233 @@
+module Mhc
+  module Sync
+    module Strategy
+
+      class Factory
+        def self.create(strategy)
+          case strategy.to_sym
+          when :mirror
+            return Mirror.new
+          when :sync
+            return Sync.new
+          else
+            raise NotImplementedError, "#{strategy} #{strategy.class}"
+          end
+        end
+      end
+
+      # Our Sync mechanism is very simple, because
+      # we can assume every article is independent
+      # with eath other. It will work well with
+      # iCalendar basis articles.
+      #
+      # We simply follow the rule on the table below:
+      #
+      #                    Side 2
+      #   |---+---------+------------+------------+-------|
+      # S |   | M       | U          | N          | D     |
+      # i |---+---------+------------+------------+-------|
+      # d | M | CNF     | OW 1->2    | CP 1->2    | CNF   |
+      # e | U | OW 2->1 | -          | ?? CP 1->2 | DEL 1 |
+      # 1 | N | CP 2->1 | ?? CP 2->1 | -          | -     |
+      #   | D | CNF     | DEL 2      | -          | -     |
+      #   |---+---------+------------+------------+-------|
+      #
+      #   M, U, N, and D indicate status changes on each article after
+      #   the last sync:
+      #
+      #   + M :: Modified (or Created)
+      #   + U :: Unchanged
+      #   + N :: No Record
+      #   + D :: Deleted
+      #
+      #   Each entry in the table means:
+      #   + -- :: No operation (ignore)
+      #   + ?? :: Not occurred in normal cases
+      #   + OW :: Overwrite
+      #   + CP :: Copy
+      #   + DEL :: Delete
+      #   + CNF :: Conflict
+      #
+      # Before applying the rule to our repository,
+      # we have to set the marks (M, U, N or D) to all articles
+      # in each side.
+      #
+      # strategy = Mhc::Sync::Strategy.create(strategy_name)
+      # strategy name is one of:
+      # * :empty  ... ignore on every status
+      # * :mirror ... mirror from side1 to side2
+      # * :sync   ... sync articles of side1 and side2
+      #
+      # and strategy.whatnow(side1, side2) returns a symbol one of:
+      # * :ignore :: Already synced, ignoreable
+      # * :conflict :: Conflicted
+      # * :delete1 :: Should delete the article of side1
+      # * :delete2 :: Should delete the article of side2
+      # * :copy1_to_2 :: Should copy the article of side1 to side2
+      # * :copy2_to_1 :: Should copy the article of side2 to side1
+      # * :overwrite1_to_2 :: Should overwrite the article of side1 to side2
+      # * :overwrite2_to_1 :: Should overwrite the article of side2 to side1
+      #
+      # side1 and side2 have to respond to:
+      #     #nil?, # #modified?, #unmodified?, #norecord?, #deleted?
+      #
+      class Base
+        def whatnow(side1, side2)
+          # do nothing
+          actions = {
+            "MM" => :ignore,
+            "MU" => :ignore,
+            "MN" => :ignore,
+            "MD" => :ignore,
+
+            "UM" => :ignore,
+            "UU" => :ignore,
+            "UN" => :ignore,
+            "UD" => :ignore,
+
+            "NM" => :ignore,
+            "NU" => :ignore,
+            "NN" => :ignore,
+            "ND" => :ignore,
+
+            "DM" => :ignore,
+            "DU" => :ignore,
+            "DN" => :ignore,
+            "DD" => :ignore,
+          }
+          return actions[status_pair(side1, side2)]
+        end
+
+        private
+        # * Char (M,U,N,D) indicates status change on each article
+        #   after the last sync:
+        #
+        #   + M :: Modified
+        #   + U :: Unchanged
+        #   + N :: No Record
+        #   + D :: Deleted
+        #
+        def status_signature(info)
+          return "N" if info.nil?
+
+          return "M" if info.modified?
+          return "U" if info.unmodified?
+          return "N" if info.norecord?
+          return "D" if info.deleted?
+
+          return "?" # NOTREACHED I hope
+        end
+
+        def status_pair(side1, side2)
+          return status_signature(side1) + status_signature(side2)
+        end
+      end # class Base
+
+      # * Sync side1 and side2
+      #
+      #   simply follow the rule on the table below:
+      #
+      #                    Side 2
+      #   |---+---------+------------+------------+-------|
+      # S |   | M       | U          | N          | D     |
+      # i |---+---------+------------+------------+-------|
+      # d | M | CNF     | CP 1->2    | CP 1->2    | CNF   |
+      # e | U | CP 2->1 | -          | ?? -       | DEL 1 |
+      # 1 | N | CP 2->1 | ?? -       | -          | -     |
+      #   | D | CNF     | DEL 2      | -          | -     |
+      #   |---+---------+------------+------------+-------|
+      #
+      #   + M :: Modified (or Created)
+      #   + U :: Unchanged
+      #   + N :: No Record
+      #   + D :: Deleted
+      #
+      #   + -- :: No operation (ignore)
+      #   + ?? :: Not occurred in normal cases
+      #   + OW :: Overwrite
+      #   + CP :: Copy
+      #   + DEL :: Delete
+      #   + CNF :: Conflict
+      #
+      class Sync < Base
+        def whatnow(side1, side2)
+          actions = {
+            "MM" => :conflict,
+            "MU" => :copy1_to_2,
+            "MN" => :copy1_to_2,
+            "MD" => :conflict,
+
+            "UM" => :copy2_to_1,
+            "UU" => :ignore,
+            "UN" => :ignore,
+            "UD" => :delete1,
+
+            "NM" => :copy2_to_1,
+            "NU" => :ignore,
+            "NN" => :ignore,
+            "ND" => :ignore,
+
+            "DM" => :conflict,
+            "DU" => :delete2,
+            "DN" => :ignore,
+            "DD" => :ignore,
+          }
+          return actions[status_pair(side1, side2)]
+        end
+      end # class Sync
+
+      # * Mirror side1 to side2
+      #
+      #   simply follow the rule on the table below:
+      #
+      #                    Side 2
+      #   |---+---------+----------+------------+---------|
+      # S |   | M       | U        | N          | D       |
+      # i |---+---------+----------+------------+---------|
+      # d | M | OW 1->2 | OW 1->2  | CP 1->2    | CP 1->2 |
+      # e | U | OW 1->2 | --       | ?? --      | CP 1->2 |
+      # 1 | N | DEL 2   | ?? --    | --         | --      |
+      #   | D | DEL 2   | DEL 2    | --         | --      |
+      #   |---+---------+----------+------------+---------|
+      #
+      #   + M :: Modified (or Created)
+      #   + U :: Unchanged
+      #   + N :: No Record
+      #   + D :: Deleted
+      #
+      #   + -- :: No operation (ignore)
+      #   + ?? :: Not occurred in normal cases
+      #   + OW :: Overwrite
+      #   + CP :: Copy
+      #   + DEL :: Delete
+      #
+      class Mirror < Base
+        def whatnow(side1, side2)
+          actions = {
+            "MM" => :overwrite1_to_2,
+            "MU" => :overwrite1_to_2,
+            "MN" => :copy1_to_2,
+            "MD" => :copy1_to_2,
+
+            "UM" => :overwrite1_to_2,
+            "UU" => :ignore,
+            "UN" => :ignore,
+            "UD" => :copy1_to_2,
+
+            "NM" => :delete2,
+            "NU" => :ignore,
+            "NN" => :ignore,
+            "ND" => :ignore,
+
+            "DM" => :delete2,
+            "DU" => :delete2,
+            "DN" => :ignore,
+            "DD" => :ignore,
+          }
+          return actions[status_pair(side1, side2)]
+        end
+      end # class Mirror
+
+    end # module Strategy
+  end # module  Sync
+end # module Mhc

data/lib/mhc/sync/syncinfo.rb

@@ -0,0 +1,98 @@
+################################################################
+# Log maintenance functions.
+#
+# M 2000-04-25 00:06:08 <20.nom@.nomcom> ~nom/Mail/schedule/2000/04/1 Luncheon
+# D 2000-04-25 00:06:08 <20.nom@.nomcom> ~nom/Mail/schedule/2000/04/1 Luncheon
+# S 2000-04-25 00:06:08 user_id
+#
+module Mhc
+  class Log
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def add_entry(entry)
+      file = File.open(@filename, "a+")
+      file.print "#{entry}\n"
+      file.fsync if file.respond_to?("fsync")
+      file.close
+    end
+
+    def each_entry
+      begin
+        file = File.open(@filename)
+        while line = file.gets
+          yield(MhcLogEntry.new(line.chomp))
+        end
+        file.close
+      rescue
+      end
+    end
+
+    def entries()
+      arry = []
+      each_entry{|e|
+        arry << e
+      }
+      return arry
+    end
+
+    def shrink_entries(user_id)
+      hash = {}
+      each_entry{|e|
+        if e.status == 'S' and e.rec_id == user_id
+          hash.clear
+        else
+          hash[e.rec_id] = e
+        end
+      }
+      return hash.values
+    end
+  end # class Log
+end # module Mhc
+
+################
+module Mhc
+    class LogEntry
+    attr :status
+    attr :mtime
+    attr :rec_id
+    attr :path
+    attr :subject
+
+    def initialize(status, mtime = nil, rec_id = nil, path = nil, subject = nil)
+      if mtime.nil?
+        init_from_string(status)
+      else
+        @status, @mtime, @rec_id, @path, @subject =
+          status, mtime, rec_id, path, subject
+      end
+    end
+
+    def to_s
+      return [
+        @status,
+        @mtime.strftime("%Y-%m-%d %H:%M:%S"),
+        @rec_id,
+        @path,
+        @subject
+      ].join(' ')
+    end
+
+    ################
+    private
+    ################
+    def init_from_string(line)
+      str = line.chomp
+      status, yymmdd, hhmmss, rec_id, path, subject = str.split
+      yy, mm, dd = yymmdd.split('-')
+      h,  m,  s  = hhmmss.split(':')
+
+      mtime = ::Time.local(yy.to_i, mm.to_i, dd.to_i,
+                          h .to_i, m .to_i, s .to_i)
+      @status, @mtime, @rec_id, @path, @subject =
+        status, mtime, rec_id, path, subject
+    end
+  end # class LogEntry
+end # module Mhc