dorkbox 0.9.0

data/executables/dorkbox

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require 'dorkbox'
+
+require 'optparse'
+require 'pp'
+
+# This hash will hold all of the options 
+# parsed from the command-line by 
+# OptionParser. 
+options = {}
+
+optparse = OptionParser.new do |opts|
+  # TODO: Put command-line options here
+
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on('-h', '--help', 'Display this screen') do
+    puts opts
+    exit
+  end
+end
+optparse.parse!
+
+command = ARGV[0]
+ARGV.shift
+
+VALID_COMMANDS = ['create', 'connect', 'sync', 'sync_tracked', 'cleanup_tracked']
+
+VALID_COMMANDS.include?(command) or exit(1)
+## TODO: something like dorkbox clone with remote
+
+Dorkbox::send(command.to_sym, *ARGV)

data/executables/test

@@ -0,0 +1,7 @@
+require 'minitest/unit'
+require 'minitest/spec'
+require 'minitest/mock'
+
+require 'dorkbox_test'
+
+MiniTest::Unit.autorun

data/lib/dorkbox.rb

@@ -0,0 +1,243 @@
+#!/usr/bin/env ruby
+require 'open3'
+require 'io/wait'
+
+module BashLike
+  ALWAYS_PRINT_STDOUT=false
+  ALWAYS_ECHO_CMDLINE=true
+  EXCEPTION_ON_NONZERO_STATUS=true
+  LOGFILE=nil
+  LOGFILE_MAX_LINES=5000
+
+  def `(cmdline)
+    c(cmdline, true)
+    return $exit == 0 ? true : false
+  end
+
+  def c(cmdline, print_each_line=ALWAYS_PRINT_STDOUT)
+    $stdout.puts "+ #{cmdline}" if ALWAYS_ECHO_CMDLINE
+    Open3.popen3(cmdline) { |stdin, stdout, stderr, wait_thr|
+      all_out = ''
+      all_err = ''
+      while wait_thr.alive?
+        if !(stderr.ready? || stdout.ready?)
+          sleep(0.1)
+          next
+        end
+        current_out = stdout.read(stdout.nread)
+        current_err = stderr.read(stderr.nread)
+        all_out = all_out + current_out
+        all_err = all_err + current_err
+        $stdout.puts current_out if (print_each_line && !current_out.empty?)
+        $stderr.puts current_err if !current_err.empty?
+      end
+      status = wait_thr.value
+      # do it once more to catch everything that was buffered
+      current_out = stdout.read()
+      current_err = stderr.read()
+      all_out = all_out + current_out
+      all_err = all_err + current_err
+      $stdout.puts current_out if (print_each_line && !current_out.empty?)
+      $stderr.puts current_err if !current_err.empty?
+      $out = all_out
+      $err = all_err
+      $exit = status.exitstatus
+      raise StandardError.new("ERROR: #{cmdline.split()[0]} -> exit status #{status.exitstatus}") if (status.exitstatus != 0 && EXCEPTION_ON_NONZERO_STATUS)
+      all_out
+    }
+  end
+
+  def log(message)
+    if $global_log.nil? and !LOGFILE.nil?
+      # remove the exceeding lines
+      if File.exists?(LOGFILE)
+        f = File.open(LOGFILE, "r")
+        lines = f.readlines()
+        retain_from = [lines.size, LOGFILE_MAX_LINES].min
+        retain_lines = lines[-retain_from..-1]
+        f.close()
+      else
+        retain_lines=[]
+      end
+      $global_log = File.open(LOGFILE, "w")
+      $global_log.write(retain_lines.join(''))
+    end
+
+    final_message = "[#{Time.now.to_s}] #{message}"
+    $global_log.puts(final_message) unless $global_log.nil?
+    $stdout.puts(final_message)
+  end
+
+end
+
+include BashLike
+# BASHINGTHEBASH END - write your things down there
+
+USAGE = '
+create: create new repository with passed remote, that should exist and be empty.
+connect: connect to existing repository
+sync: sync current repository
+sync_tracked: sync all tracked repositories
+cleanup_tracked: cleanup tracked repositories that don''t exist anymore
+
+MISSING:
+notification on conflict
+re-track repository (if moved)
+refactoring for better architecture
+'
+
+
+require 'socket'
+require 'securerandom'
+require 'yaml'
+require 'tempfile'
+
+module Dorkbox
+
+  CONFLICT_STRING='CONFLICT_MUST_MANUALLY_MERGE'
+  GITIGNORE='.gitignore'
+  DORKBOX_CONFIG_PATH = File.join(Dir.home, ".dorkbox.yml")
+  DORKBOX_CRONTAB_COMMENT = '# dorkbox sync cronjob'
+
+  def create_new_client_id
+    'dorkbox-' + Socket.gethostname() + "-" + SecureRandom.urlsafe_base64(5)
+  end
+
+  def align_client_ref_to_master(dorkbox_client_id)
+    `git update-ref refs/heads/#{dorkbox_client_id} master`
+  end
+
+  def configure_client_id(dorkbox_client_id)
+    `git config --local dorkbox.client-id #{dorkbox_client_id}`
+  end
+
+  def retrieve_client_id
+    dorkbox_client_id = c("git config --get dorkbox.client-id").strip()
+  end
+
+  def enable_dorkbox_cronjob(current_path=File.expand_path(__FILE__))
+    cron_start = "#{DORKBOX_CRONTAB_COMMENT} start\n"
+    cron_end = "#{DORKBOX_CRONTAB_COMMENT} end\n"
+    old_crontab = c('crontab -l 2>/dev/null || /bin/true')
+    old_crontab.sub!(/#{cron_start}.*?#{cron_end}/m, '')
+
+    tmp = Tempfile.new("dorkbox-temp")
+    if (old_crontab.size > 0) && (old_crontab[-1] != "\n")
+      old_crontab.concat("\n")
+    end
+
+    old_crontab.concat(cron_start).concat("*/5 * * * * #{current_path}\n").concat(cron_end)
+    tmp.puts(old_crontab)
+    tmp.flush()
+    `crontab #{tmp.path}`
+    tmp.close()
+  end
+
+# we should lock the config file on this.
+  def track
+    begin
+      cfg = YAML.load_file(DORKBOX_CONFIG_PATH)
+    rescue Errno::ENOENT
+      cfg = {:track => []}
+    end
+    cfg[:track].push(File.expand_path(Dir.pwd))
+    cfg[:track].uniq!
+    File.open(DORKBOX_CONFIG_PATH, 'w') { |f| f.write(cfg.to_yaml) }
+  end
+
+  def cleanup_tracked
+    begin
+      cfg = YAML.load_file(DORKBOX_CONFIG_PATH)
+    rescue Errno::ENOENT
+      return
+    end
+    # TODO: check for dorkbox-enabled dir, e.g. try retrieving client id
+    cfg[:track].select! { |d| Dir.exists?(d) }
+    File.open(DORKBOX_CONFIG_PATH, 'w') { |f| f.write(cfg.to_yaml) }
+  end
+
+  def sync_tracked
+    begin
+      cfg = YAML.load_file(DORKBOX_CONFIG_PATH)
+    rescue Errno::ENOENT
+      return
+    end
+    cfg[:track].each { |d| Dir.chdir(d) { sync() } }
+  end
+
+
+  def create(dorkbox_remote)
+    log "Will create new dorkbox-enabled repository in local directory. Remote #{dorkbox_remote} should exist and be empty."
+    if Dir.exists?('.git')
+      raise StandardError.new("git repository found.")
+    end
+    `git init`
+    File.open(GITIGNORE, 'a') { |f|
+      f.puts(CONFLICT_STRING)
+    }
+    `git remote add dorkbox #{dorkbox_remote}`
+    `git add #{GITIGNORE}`
+    `git commit -m 'enabling dorkbox'`
+    dorkbox_client_id = create_new_client_id
+    configure_client_id(dorkbox_client_id)
+    align_client_ref_to_master(dorkbox_client_id)
+    `git push -u dorkbox master #{dorkbox_client_id}`
+    track()
+    log "New dorkbox enabled with remote #{dorkbox_remote}"
+    dorkbox_client_id
+  end
+
+  def connect(dorkbox_remote)
+    log "Will create new git repo in local directory and connect to remote existing dorkbox repository #{dorkbox_remote}"
+    if Dir.exists?('.git')
+      raise StandardError.new("git repository found.")
+    end
+    `git init`
+    `git remote add dorkbox #{dorkbox_remote}`
+    `git fetch --all`
+    `git checkout master`
+    # TODO: check for hostname duplication and/or autogenerate client ids
+    dorkbox_client_id = create_new_client_id
+    configure_client_id(dorkbox_client_id)
+    align_client_ref_to_master(dorkbox_client_id)
+    `git push -u dorkbox master #{dorkbox_client_id}`
+    track()
+    dorkbox_client_id
+  end
+
+
+  def sync
+    if File.exists?(CONFLICT_STRING)
+      log "Conflict found, not syncing."
+      raise StandardError.new("Conflict found, not syncing.")
+    end
+    `git fetch --all`
+    `git add -A`
+    any_change = c("git diff --staged").strip()
+    if !any_change.empty?
+      `git commit -m "Automatic dorkbox commit"`
+    end
+    begin
+      dorkbox_client_id = retrieve_client_id
+      `git merge --ff-only dorkbox/master`
+      align_client_ref_to_master(dorkbox_client_id)
+      `git push dorkbox master #{dorkbox_client_id}`
+    rescue
+      # TODO: check which error actually happens and think about
+      # a solving strategy.
+      log "Error while syncing, stopping until solved."
+      FileUtils.touch(CONFLICT_STRING)
+      raise StandardError.new("Conflict found, syncing stopped.")
+    end
+    log "sync succeeded"
+  end
+end
+
+
+
+
+
+
+
+
+

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: dorkbox
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Alan Franzoni
+autorequire: 
+bindir: executables
+cert_chain: []
+date: 2015-05-25 00:00:00.000000000 Z
+dependencies: []
+description: dead simple personal file syncing
+email: username@franzoni.eu
+executables:
+- dorkbox
+- test
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dorkbox.rb
+- executables/dorkbox
+- executables/test
+homepage: https://github.com/alanfranz/dorkbox
+licenses:
+- Apache-2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ! 'dorkbox: dead simple personal file syncing'
+test_files: []