morhekil-prisync 0.2.1

data/README

@@ -0,0 +1,23 @@
+prisync is a pseudo-realtime file synchronization daemon. It uses rsync utility in background
+to transfer changes and inotify kernel events to monitor changes - thus it can be run only
+on Linux with inotify-capable kernel. Can be used to keep two local folders or (usually)
+to keep files on two servers in sync.
+
+Usage: ssync [options]
+    -p, --local-path PATH            Local path to synchronize and monitor for changes,
+                                     defaults to current directory if omitted
+    -r, --target-path PATH           Target (remote) path to sync with. If you want to sync with
+                                     a remote host it should be given as user@host:/remote/path/
+        --ssh-port [PORT]            SSH port to use if you want to sync with remote host via SSH tunnel,
+                                     you HAVE to specify remote host in the target-path option
+    -t, --timeout [SECONDS]          Time to wait for any new changes to arrive before
+                                     starting the actual synchronization, use to not trigger
+                                     multiple synchronizations for repetitive event sources like
+                                     file uploading, default value is 5 seconds
+    -x, --exclude [REGEXP]           Exclusion mask, should be specified as a valid Regexp. Items
+                                     matching this regexp will be excluded from monitoring and will not
+                                     trigger synchronization but will still be synced by rsync
+    -s, --sync-on-start              Triggers initial synchronization on start
+    -v, --verbose                    Run verbosely with debug output
+        --dry                        Only print the rsync command without actually executing it
+    -h, --help                       Show help

data/bin/prisync

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require File.dirname(__FILE__) + '/../lib/prisync'
+
+# get a list of files in the specified path
+
+options = { :local_path => Dir::pwd }
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: prisync [options]"
+  
+  opts.on('-p', '--local-path PATH', 'Local path to synchronize and monitor for changes,',
+          'defaults to current directory if omitted') do |path|
+    options[:local_path] = path
+  end
+
+  opts.on('-r', '--target-path PATH', 'Target (remote) path to sync with. If you want to sync with',
+          'a remote host it should be given as user@host:/remote/path/') do |path|
+    options[:remote_path] = path
+  end
+
+  opts.on('--ssh-port [PORT]', Integer, 'SSH port to use if you want to sync with remote host via SSH tunnel,',
+          'you HAVE to specify remote host in the target-path option') do |port|
+    options[:ssh_port] = port
+  end
+
+  opts.on('-t', '--timeout [SECONDS]', Integer, 'Time to wait for any new changes to arrive before',
+          'starting the actual synchronization, use to not trigger',
+          'multiple synchronizations for repetitive event sources like',
+          'file uploading, default value is '+Prisync::DEFAULT_TIMEOUT.to_s+' seconds') do |secs|
+    options[:timeout] = secs
+  end
+
+  opts.on('-x', '--exclude [REGEXP]', Regexp, 'Exclusion mask, should be specified as a valid Regexp. Items',
+          'matching this regexp will be excluded from monitoring and will not',
+          'trigger synchronization but will still be synced by rsync') do |exclude|
+    options[:exclude] = exclude
+  end
+
+  opts.on('-s', '--sync-on-start', 'Triggers initial synchronization on start') do
+    options[:sync_on_start] = true
+  end
+
+  opts.on('-v', '--verbose', 'Run verbosely with debug output') do
+    options[:debug] = true
+  end
+
+  opts.on('--dry', 'Only print the rsync command without actually executing it') do
+    options[:dryrun] = true
+  end
+
+  opts.on_tail('-h', '--help', 'Show help') do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+sync = Prisync.new
+sync.start(options)
+

data/lib/inotify.rb

@@ -0,0 +1,211 @@
+# Version 0.3.0 (2005-09-27) by James Le Cuirot <chewi@ffaura.com>
+#	masks updated
+#	syscalls instead of /dev/inotify for linux-2.6.13 (are the archs correct?)
+#	start/stop methods added for threading
+#	ignore_dir_recursively method added
+#	Events class removed : not necessary
+#	(wd <=> dir) hashed both ways : needed for ignore
+#	default watch mask is IN_ALL_EVENTS
+#	UnsupportedPlatformError class added to deal with unsupported CPUs and OSes
+#
+# Version 0.2.3 (2005-01-18) by oxman
+#	function ignore_dir : was added
+#
+# Version 0.2.2 (2005-01-18) by oxman
+#	cleaning code (big thanks to gnome at #ruby-lang)
+#	rename next_event in each_event (thanks kig)
+#
+# Version 0.2.1 (2005-01-18) by oxman
+#	class Events : use real mask
+#
+# Version 0.2.0 (2005-01-18) by oxman
+#	function watch_dir : only watch
+#	function next_event : was added
+#	function watch_dir_recursively : was added
+#
+# Version 0.1.1 (2005-01-17) by oxman
+# Correct IN_ var for inotify 0.18
+
+module INotify
+	require 'rbconfig'
+        require 'io/nonblock'
+	
+	class UnsupportedPlatformError < RuntimeError
+	end
+	
+	case Config::CONFIG["arch"]
+	
+		when /i[3-6]86-linux/
+			INOTIFY_INIT = 291
+			INOTIFY_ADD_WATCH = 292
+			INOTIFY_RM_WATCH = 293
+		
+		when /x86_64-linux/
+			INOTIFY_INIT = 253
+			INOTIFY_ADD_WATCH = 254
+			INOTIFY_RM_WATCH = 255
+		
+		when /powerpc(64)?-linux/
+			INOTIFY_INIT = 275
+			INOTIFY_ADD_WATCH = 276
+			INOTIFY_RM_WATCH = 277
+		
+		when /ia64-linux/
+			INOTIFY_INIT = 1277
+			INOTIFY_ADD_WATCH = 1278
+			INOTIFY_RM_WATCH = 1279
+		
+		when /s390-linux/
+			INOTIFY_INIT = 284
+			INOTIFY_ADD_WATCH = 285
+			INOTIFY_RM_WATCH = 286
+		
+		when /alpha-linux/
+			INOTIFY_INIT = 444
+			INOTIFY_ADD_WATCH = 445
+			INOTIFY_RM_WATCH = 446
+		
+		when /sparc(64)?-linux/
+			INOTIFY_INIT = 151
+			INOTIFY_ADD_WATCH = 152
+			INOTIFY_RM_WATCH = 156
+		
+		when /arm-linux/
+			INOTIFY_INIT = 316
+			INOTIFY_ADD_WATCH = 317
+			INOTIFY_RM_WATCH = 318
+
+		when /sh-linux/
+			INOTIFY_INIT = 290
+			INOTIFY_ADD_WATCH = 291
+			INOTIFY_RM_WATCH = 292
+
+		else raise UnsupportedPlatformError, Config::CONFIG["arch"]
+			
+	end
+
+	Mask = Struct::new(:value, :name)
+
+	Masks = {
+		:IN_ACCESS			=> Mask::new(0x00000001, 'access'),
+		:IN_MODIFY			=> Mask::new(0x00000002, 'modify'),
+		:IN_ATTRIB			=> Mask::new(0x00000004, 'attrib'),
+		:IN_CLOSE_WRITE		=> Mask::new(0x00000008, 'close_write'),
+		:IN_CLOSE_NOWRITE	=> Mask::new(0x00000010, 'close_nowrite'),
+		:IN_OPEN			=> Mask::new(0x00000020, 'open'),
+		:IN_MOVED_FROM		=> Mask::new(0x00000040, 'moved_from'),
+		:IN_MOVED_TO		=> Mask::new(0x00000080, 'moved_to'),
+		:IN_CREATE			=> Mask::new(0x00000100, 'create'),
+		:IN_DELETE			=> Mask::new(0x00000200, 'delete'),
+		:IN_DELETE_SELF		=> Mask::new(0x00000400, 'delete_self'),
+		:IN_UNMOUNT			=> Mask::new(0x00002000, 'unmount'),
+		:IN_Q_OVERFLOW		=> Mask::new(0x00004000, 'q_overflow'),
+		:IN_IGNORED			=> Mask::new(0x00008000, 'ignored'),
+	}
+
+	Masks.each {|key, value|
+		const_set(key, value)
+	}
+	
+	OrMasks = {
+		:IN_CLOSE		=> Mask::new(IN_CLOSE_WRITE.value | IN_CLOSE_NOWRITE.value, 'close'),
+		:IN_MOVE		=> Mask::new(IN_MOVED_FROM.value | IN_MOVED_TO.value, 'moved'),
+		:IN_ALL_EVENTS	=> Mask::new(IN_ACCESS.value | IN_MODIFY.value | IN_ATTRIB.value | IN_CLOSE_WRITE.value | IN_CLOSE_NOWRITE.value | IN_OPEN.value | IN_MOVED_FROM.value | IN_MOVED_TO.value | IN_DELETE.value | IN_CREATE.value | IN_DELETE_SELF.value, 'all_events')
+	}
+	
+	OrMasks.each {|key, value|
+		const_set(key, value)
+	}
+	
+	AllMasks = Masks.merge OrMasks
+	
+	require 'find'
+
+	class INotify
+		def initialize
+			@wd_dir = Hash.new
+			@dir_wd = Hash.new
+			@io = IO.open(syscall(INOTIFY_INIT))
+		end
+
+		def close
+			@io.close
+		end
+
+		def watch_dir (dir, option = IN_ALL_EVENTS)
+			wd = syscall(INOTIFY_ADD_WATCH, @io.fileno, dir, option.value)
+			
+			if wd >= 0
+				@dir_wd[dir] = wd
+				@wd_dir[wd] = dir
+			end
+			
+			return wd
+		end
+
+		def ignore_dir (dir)
+			syscall(INOTIFY_RM_WATCH, @io.fileno, @dir_wd[dir])
+		end
+
+		def watch_dir_recursively (dir, option = IN_ALL_EVENTS)
+			Find.find(dir) { |sub_dir| watch_dir(sub_dir, option) if (File::directory?(sub_dir) == true) }
+		end
+		
+		def ignore_dir_recursively (dir)
+			Find.find(dir) { |sub_dir| ignore_dir(sub_dir) if (File::directory?(sub_dir) == true) }
+		end
+		
+		def next_events( is_nonblocking = false )
+			
+			events = Array.new
+	
+			begin
+        @io.nonblock = is_nonblocking
+			  begin
+          read_cnt = @io.read(16)
+          wd, mask, cookie, len = read_cnt.unpack('lLLL')
+          read_cnt = @io.read(len)
+          filename = read_cnt.unpack('Z*')
+        rescue Errno::EAGAIN
+          return events
+        ensure
+          @io.nonblock = false
+        end
+			end while (mask & IN_Q_OVERFLOW.value) != 0
+			
+			AllMasks.each_value do |m|
+				next if m.value == IN_ALL_EVENTS.value
+				events.push Event.new(@wd_dir[wd].to_s, filename.to_s, m.name.to_s, cookie) if (m.value & mask) != 0
+			end
+			
+			return events
+		end
+		
+		def each_event
+			loop { next_events.each { |event| yield event } }
+		end
+		
+		def start
+			@thread = Thread.new { loop { next_events.each { |event| yield event } } }
+		end
+		
+		def stop
+			@thread.exit
+		end
+	end
+
+	class Event
+		attr_reader :path, :filename, :type, :cookie
+
+		def initialize (path, filename, type, cookie)
+			@path = path
+			@filename = filename
+			@type = type
+			@cookie = cookie
+		end
+
+		def dump
+			"path: " + @path.to_s + ", filename: " + @filename.to_s + ", type: " + @type.to_s + ", cookie: " + @cookie.to_s
+		end
+	end
+end

data/lib/prisync.rb

@@ -0,0 +1,99 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'inotify.rb'
+require 'pp'
+
+class Prisync 
+
+  DEFAULT_TIMEOUT = 5
+
+  # Initializes INotify events listener object
+  def initialize
+    @inotify = INotify::INotify.new
+    @inotify_mask = INotify::Mask.new(INotify::IN_MODIFY.value | INotify::IN_DELETE.value | INotify::IN_CREATE.value | INotify::IN_MOVED_TO.value, 'filechange')
+  end
+
+  # Starts the synchronization process, options are
+  #   :local_path - local path to watch for changes,
+  #   :target_path - target (remote) path to sync with,
+  #   :ssh_port - SSH port to use if syncing remotely over the ssh tunnel
+  #   :timeout - seconds to wait for any new changes to arrive before starting the actual synchronization
+  #   :exclude - regexp for excluding files, if omitted or nil - no excluding,
+  #   :sync_on_start - trigger synchronization on start if set,
+  #   :dryrun - run rsync with --dry-run option to not perform any actual changes if set,
+  #   :debug - print out extra debug information if set
+  def start(opts)
+    
+    # init runtime parameters
+    @exclude = opts[:exclude].kind_of?(Regexp) ? opts[:exclude] : nil
+    @pending_changes = opts[:sync_on_start] ? true : false
+    @timeout = opts[:timeout] || DEFAULT_TIMEOUT
+    @is_debug = opts[:debug]
+    @is_dryrun = opts[:dryrun]
+    # build the rsync command
+    @rsync_cmd = 'rsync -azcC --force --delete '
+    @rsync_cmd += '--dry-run ' if opts[:dryrun]
+    @rsync_cmd += '--progress ' if @is_debug
+    @rsync_cmd += "-e \"ssh -p#{opts[:ssh_port]}\" " if opts[:ssh_port]
+    @rsync_cmd += "#{opts[:local_path]} #{opts[:remote_path]}"
+
+    # Start inotify watcher
+    @inotify.watch_dir_recursively(opts[:local_path], @inotify_mask)
+    # Catch INT and TERM signals to perform a clean up after ourselves
+    %w{INT TERM}.each do |signal_name|
+      Signal.trap(signal_name, proc { self.cleanup })
+    end
+
+    print "Started synchronization with the following options:\n#{opts.pretty_inspect}\n\n" if @is_debug
+    
+    while (true) do
+      begin
+        self.monitor_changes
+      rescue
+        print "Exception: ",$!, "\n"
+      end
+    end
+
+  end
+
+  # Monitors for changes and initiates syncing in case syncable changes were detected
+  def monitor_changes
+    # Check to see if we've got any new changes
+    new_changes = false
+    while ( (events = @inotify.next_events(true)).size > 0 ) do
+      print "Detected #{events.size} new events\n" if @is_debug
+      new_changes = true if events.find { |event| @exclude.nil? || event.filename !~ @exclude }
+      print "Has synchronizable changes\n" if new_changes && @is_debug
+    end
+    
+    # Check if we've got any pending changes those need to be synced and timeout has passed indicating that we're ready to go
+    if (@pending_changes && !new_changes) then
+      print "Synchronizing...\n" if @is_debug
+      self.synchronize
+      @pending_changes = false
+    end
+    
+    # Update pending status and wait for a timeout
+    @pending_changes = true if new_changes
+    print "Pending changes\n" if @pending_changes && @is_debug
+    sleep @timeout
+      
+  end
+
+  # Actually synchronizes the files by calling rsync using the pre-built command line
+  def synchronize
+    print "#{@rsync_cmd}\n" if @is_debug
+    system @rsync_cmd
+    errorvalue = $?
+    errorvalue = errorvalue.exitstatus if errorvalue.kind_of?(Process::Status)
+    $stderr.print "rsync error status #{errorvalue}\n" if @is_debug
+    self.cleanup if errorvalue == 20 || errorvalue == 255
+  end
+
+  # Cleans up before exit, closing inotify connection
+  def cleanup
+    print "Cleaning up...\n" if @is_debug
+    @inotify.close
+    exit 0
+  end
+end

data/prisync.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |s|
+  s.name = 'prisync'
+  s.version = "0.2.1"
+  s.date     = "2008-10-01"
+  s.summary = "Pseudo-realtime file synchronization daemon."
+  s.description = %{Prisync allows to synchronize to local or remote directories in a pseudo-realtime fashion.
+  Filesystem changes are monitored with inotify kernel events, rsync utility is used for the actual
+  synchronization and can be run over SSH.%}
+  s.has_rdoc = false
+  
+  s.files = ['lib/inotify.rb',
+    'lib/prisync.rb',
+    'bin/prisync',
+    'prisync.gemspec',
+    'README'
+  ]
+
+  s.bindir = 'bin'
+  s.executables = ['prisync']
+
+  s.require_path = 'lib'
+
+  s.author = "Oleg Ivanov"
+  s.email = "morhekil@morhekil.net"
+  s.homepage = "http://morhekil.net"
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: morhekil-prisync
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Oleg Ivanov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Prisync allows to synchronize to local or remote directories in a pseudo-realtime fashion. Filesystem changes are monitored with inotify kernel events, rsync utility is used for the actual synchronization and can be run over SSH.%
+email: morhekil@morhekil.net
+executables: 
+- prisync
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/inotify.rb
+- lib/prisync.rb
+- bin/prisync
+- prisync.gemspec
+- README
+has_rdoc: false
+homepage: http://morhekil.net
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Pseudo-realtime file synchronization daemon.
+test_files: []
+