synchrotron 0.0.1

data/bin/synchrotron

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+
+require 'synchrotron'
+
+module Synchrotron
+  config = {}
+
+  # Parse command-line options.
+  options = Trollop.options do
+    version "#{APP_NAME} #{APP_VERSION}\n" << APP_COPYRIGHT
+    banner <<-BANNER
+Synchrotron monitors a local directory tree and performs nearly instantaneous
+one-way synchronization of changes to a remote directory.
+
+Usage:
+  synchrotron <remote dir> [local dir]
+BANNER
+
+    text "\nOptions:"
+    opt :dry_run,      "Show what would have been synced, but don't sync it", :short => '-n'
+    opt :exclude,      "Pathname or pattern to exclude", :short => :none, :multi => true, :type => :string
+    opt :exclude_from, "File containing pathnames and patterns to exclude", :short => :none, :multi => true, :type => :string
+    opt :rsync_path,   "Path to the rsync binary", :short => :none, :default => '/usr/bin/rsync'
+    opt :verbosity,    "Output verbosity: debug, info, warn, error, or fatal", :short => '-V', :default => 'info'
+  end
+
+  config[:remote_path] = ARGV.shift or abort("Error: Remote path not specified")
+  config[:local_path]  = File.expand_path(ARGV.shift || '.') + '/'
+
+  config.merge!(options)
+
+  config[:exclude]      ||= []
+  config[:exclude_from] ||= []
+
+  # Validate options.
+  abort("Error: Directory not found: #{config[:local_path]}") unless File.exist?(config[:local_path])
+  abort("Error: Not a directory: #{config[:local_path]}") unless File.directory?(config[:local_path])
+  abort("Error: rsync not found at #{config[:rsync_path]}") unless File.exist?(config[:rsync_path])
+
+  Synchrotron.init(config)
+
+  Synchrotron.log.info "Performing initial sync..."
+  Synchrotron.sync
+
+  Synchrotron.monitor
+
+end

data/lib/synchrotron/ignore.rb

@@ -0,0 +1,72 @@
+module Synchrotron; class Ignore
+
+  GLOB_PATTERNS = {'*' => '.*', '?' => '.'}
+  REGEX_COMMENT = /#.*$/
+  REGEX_REGEX   = /^\s*(%r(.).*\2[imxouesn]*)\s*$/i
+
+  def initialize(list = [])
+    @cache    = {}
+    @globs    = []
+    @regexes  = []
+
+    @list     = list.to_a
+    @log      = Synchrotron.log
+
+    compile(@list)
+  end
+
+  def add(list)
+    compile(list.to_a)
+  end
+
+  def add_file(filename)
+    File.open(filename, 'r') {|f| compile(f.readlines) }
+  end
+
+  def match(path)
+    _path = Synchrotron.relative_path(path.strip)
+
+    return @cache[_path] if @cache.has_key?(_path)
+
+    @cache[_path] = match = @globs.any? {|glob| _path =~ glob } ||
+        @regexes.any? {|regex| _path =~ regex }
+
+    @log.insane "Ignoring #{_path}" if match
+    match
+  end
+
+  private
+
+  def compile(list)
+    globs   = []
+    regexes = []
+    lineno  = 0
+
+    list.each do |line|
+      lineno += 1
+
+      # Strip comments.
+      line.sub!(REGEX_COMMENT, '')
+      line.strip!
+
+      # Skip empty lines.
+      next if line.empty?
+
+      if line =~ REGEX_REGEX
+        regexes << Thread.start { $SAFE = 4; eval($1) }.value
+      else
+        globs << glob_to_regex(line)
+      end
+    end
+
+    @cache    = {}
+    @globs   += globs
+    @regexes += regexes
+  end
+
+  def glob_to_regex(str)
+    regex = str.gsub(/(.)/) {|c| GLOB_PATTERNS[$1] || Regexp.escape(c) }
+    Regexp.new("#{regex}$")
+  end
+
+end; end

data/lib/synchrotron/logger.rb

@@ -0,0 +1,50 @@
+module Synchrotron
+
+class Logger
+  attr_reader :level, :output
+
+  LEVELS = {
+    :fatal  => 0,
+    :error  => 1,
+    :warn   => 2,
+    :info   => 3,
+    :debug  => 4,
+    :insane => 5
+  }
+
+  def initialize(level = :info, output = $stdout)
+    self.level  = level.to_sym
+    self.output = output
+  end
+
+  def const_missing(name)
+    return LEVELS[name] if LEVELS.key?(name)
+    raise NameError, "uninitialized constant: #{name}"
+  end
+
+  def method_missing(name, *args)
+    return log(name, *args) if LEVELS.key?(name)
+    raise NoMethodError, "undefined method: #{name}"
+  end
+
+  def level=(level)
+    raise ArgumentError, "invalid log level: #{level}" unless LEVELS.key?(level)
+    @level = level
+  end
+
+  def log(level, msg)
+    return true if LEVELS[level] > LEVELS[@level] || msg.nil? || msg.empty?
+    @output.puts "[#{Time.new.strftime('%b %d %H:%M:%S')}] [#{level}] #{msg}"
+    true
+
+  rescue => e
+    false
+  end
+
+  def output=(output)
+    raise ArgumentError, "output must be an instance of class IO" unless output.is_a?(IO)
+    @output = output
+  end
+end
+
+end

data/lib/synchrotron/scanner.rb

@@ -0,0 +1,32 @@
+# Not currently used.
+
+module Synchrotron; class Scanner
+  attr_reader :paths, :root
+
+  def initialize(root)
+    @paths = {}
+    @root  = File.expand_path(root)
+  end
+
+  def scan(path = @root)
+    changed = {}
+    ignored = []
+
+    Find.find(path) do |p|
+      if Synchrotron.ignore.match(p)
+        ignored << p
+        Find.prune
+      end
+
+      old  = @paths[p]
+      stat = File.lstat(p)
+
+      changed[p] = stat if old.nil? || stat.ino != old.ino ||
+          stat.mtime != old.mtime || stat.size != old.size
+    end
+
+    @paths.merge!(changed) unless changed.empty?
+    {:changed => changed.values.sort, :ignored => ignored}
+  end
+
+end; end

data/lib/synchrotron/stream.rb

@@ -0,0 +1,44 @@
+module Synchrotron; class Stream
+
+  def initialize(paths, callback, since = OSX::KFSEventStreamEventIdSinceNow)
+    @log     = Synchrotron.log
+    @started = false
+    @stream  = OSX.FSEventStreamCreate(nil, callback, nil, paths.to_a, since, 0.5, 0)
+
+    raise "failed to create FSEventStream" unless check_stream
+
+    OSX.FSEventStreamScheduleWithRunLoop(@stream, OSX.CFRunLoopGetCurrent(),
+        OSX::KCFRunLoopDefaultMode)
+  end
+
+  def release
+    stop
+    OSX.FSEventStreamInvalidate(@stream)
+    OSX.FSEventStreamRelease(@stream)
+
+    @log.debug "FSEventStream released"
+  end
+
+  def start
+    return if @started
+    raise "failed to start FSEventStream" unless OSX.FSEventStreamStart(@stream)
+    @started = true
+
+    @log.debug "FSEventStream started"
+  end
+
+  def stop
+    return unless @started
+    OSX.FSEventStreamStop(@stream)
+    @started = false
+
+    @log.debug "FSEventStream stopped"
+  end
+
+  private
+
+  def check_stream
+    !!@stream
+  end
+
+end; end

data/lib/synchrotron/version.rb

@@ -0,0 +1,9 @@
+module Synchrotron
+  APP_NAME      = 'Synchrotron'
+  APP_VERSION   = '0.0.1'
+  APP_AUTHOR    = 'Ryan Grove'
+  APP_EMAIL     = 'ryan@wonko.com'
+  APP_URL       = 'http://github.com/rgrove/synchrotron/'
+  APP_COPYRIGHT = 'Copyright (c) 2009 Ryan Grove <ryan@wonko.com>. All ' <<
+                  'rights reserved.'
+end

data/lib/synchrotron.rb

@@ -0,0 +1,120 @@
+# Prepend this file's directory to the include path if it's not there already.
+$:.unshift(File.dirname(File.expand_path(__FILE__)))
+$:.uniq!
+
+require 'find'
+require 'pathname'
+require 'set'
+require 'osx/foundation'
+
+OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+
+require 'synchrotron/ignore'
+require 'synchrotron/logger'
+require 'synchrotron/stream'
+require 'synchrotron/version'
+
+module Synchrotron; class << self
+  attr_reader :config, :ignore, :log, :scanner
+
+  def init(config = {})
+    @config = {
+      :dry_run      => false,
+      :exclude      => [],
+      :exclude_from => [],
+      :local_path   => File.expand_path('.'),
+      :remote_path  => nil,
+
+      :rsync_options => [
+        '--compress',
+        '--human-readable',
+        '--links',
+        '--recursive',
+        '--times',
+        '--verbose'
+      ],
+
+      :rsync_path => '/usr/bin/rsync',
+      :verbosity  => :info
+    }.merge(config)
+
+    @log       = Logger.new(@config[:verbosity])
+    @ignore    = Ignore.new(@config[:exclude])
+    @regex_rel = Regexp.new("^#{Regexp.escape(@config[:local_path].chomp('/'))}/?")
+
+    @config[:rsync_options] << '--dry-run' if @config[:dry_run]
+
+    local_exclude_file = File.join(@config[:local_path], '.synchrotron-exclude')
+    @config[:exclude_from] << local_exclude_file if File.exist?(local_exclude_file)
+    @config[:exclude_from].each {|filename| @ignore.add_file(filename) }
+
+    @callback = proc do |stream, context, event_count, paths, marks, event_ids|
+      changed = Set.new
+      paths.regard_as('*')
+      event_count.times {|i| changed.add(paths[i]) unless @ignore.match(paths[i]) }
+
+      changed = coalesce_changes(changed)
+      return if changed.empty?
+
+      @log.info "Change detected"
+      changed.each {|path| sync(path) }
+    end
+
+    @stream  = Stream.new(config[:local_path], @callback)
+
+    @log.info "Local path : #{@config[:local_path]}"
+    @log.info "Remote path: #{@config[:remote_path]}"
+  end
+
+  def coalesce_changes(changes)
+    coalesced = {}
+
+    changes.each do |path|
+      next if coalesced.include?(path)
+
+      pn = Pathname.new(path)
+
+      coalesced[pn.to_s] = true unless catch :matched do
+        pn.descend {|p| throw(:matched, true) if coalesced.include?(p.to_s) }
+        false
+      end
+    end
+
+    coalesced.keys.sort
+  end
+
+  def monitor
+    @log.info "Watching for changes"
+    @stream.start
+
+    begin
+      OSX.CFRunLoopRun()
+    rescue Interrupt
+      @stream.release
+    end
+  end
+
+  def relative_path(path)
+    path.sub(@regex_rel, '')
+  end
+
+  def sync(path = @config[:local_path])
+    rsync_local   = escape_arg(path)
+    rsync_options = @config[:rsync_options].join(' ')
+    rsync_remote  = escape_arg(File.join(@config[:remote_path], relative_path(path)))
+
+    # Build exclusion list.
+    @config[:exclude].each {|p| rsync_options << " --exclude #{escape_arg(p)}" }
+    @config[:exclude_from].each {|f| rsync_options << " --exclude-from #{escape_arg(f)}"}
+
+    puts `#{@config[:rsync_path]} #{rsync_options} #{rsync_local} #{rsync_remote}`
+    puts
+  end
+
+  private
+
+  def escape_arg(str)
+    "'#{str.gsub("'", "\\'")}'"
+  end
+
+end; end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: synchrotron
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ryan Grove
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-04 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.13"
+    version: 
+description: 
+email: ryan@wonko.com
+executables: 
+- synchrotron
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/synchrotron
+- lib/synchrotron.rb
+- lib/synchrotron/ignore.rb
+- lib/synchrotron/logger.rb
+- lib/synchrotron/scanner.rb
+- lib/synchrotron/stream.rb
+- lib/synchrotron/version.rb
+has_rdoc: true
+homepage: http://github.com/rgrove/synchrotron/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Synchrotron monitors a local directory tree and performs nearly instantaneous one-way synchronization of changes to a remote directory.
+test_files: []
+