immutablebox 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 OHASHI Hideya
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+Immutablebox
+============
+
+A Dropbox clone.
+
+* Manage small and big files.
+* Sync files with other directories.
+* Store files as many pieces like BitTorrent.
+* Replicate pieces to other directories.
+* You can choose directories as you like. (NFS, Samba, FUSE(FTP, WebDAV), ...)
+
+Installation
+------------
+
+TODO
+
+* `gem install immutablebox`
+
+Usage
+-----
+
+* `ib commit` commit all outstanding changes
+* `ib init` create a new repository in the given directory
+* `ib log` show revision history of entire repository
+* `ib status` show changed files in the working directory
+* `ib update` update working directory (or switch revisions)
+
+Below are not implemented yet.
+
+* `ib pull` pull changes from the specified source
+* `ib push` push changes to the specified destination
+* `ib replicate` replicate pieces with other repository
+* `ib verify` verify all pieces of the repository
+
+Tutorial
+--------
+
+* `mkdir MyBox`
+* `cd MyBox`
+* `ib init`
+* `mv ../YourFolder1 ../YourFile.txt .`
+* `ib commit`
+* `ib log`
+* `vi YourFile.txt`
+* `ib status`
+* `ib commit`
+* `ib log`
+* `rm YourFile.txt`
+* `ib status`
+* `ib update`
+* `vi YourFile.txt`

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "immutablebox"
+  gem.homepage = "http://github.com/ohac/immutablebox"
+  gem.license = "MIT"
+  gem.summary = %Q{Social folder sharing/backup tool which using BitTorrent.}
+  gem.description = %Q{Social folder sharing/backup tool which using BitTorrent.}
+  gem.email = "ohachige@gmail.com"
+  gem.authors = ["OHASHI Hideya"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_runtime_dependency 'base32', '>= 0.1.2'
+  gem.add_runtime_dependency 'bencode', '>= 0.6.0'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "immutablebox #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/ib

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# vim: filetype=ruby
+
+self_file =
+  if File.symlink?(__FILE__)
+    require 'pathname'
+    Pathname.new(__FILE__).realpath
+  else
+    __FILE__
+  end
+$:.unshift(File.dirname(self_file) + "/../lib")
+
+require 'immutablebox'
+
+tracker = 'udp://tracker.publicbt.com:80/announce'
+priv = false
+name = File.basename(FileUtils.pwd)
+IB_DIR_GAP = "#{IB_DIR}/gap"
+IB_DIR_TORRENTS = "#{IB_DIR}/torrents/#{name}"
+IB_DIR_PIECES = "#{IB_DIR}/pieces"
+storage = LocalStorage.new(IB_DIR_PIECES)
+
+def get_last_torrent
+  return unless File.directory? IB_DIR_TORRENTS
+  torrent = Dir.entries(IB_DIR_TORRENTS).sort_by{|dir| dir.split.first.to_i}
+  return if torrent.size == 2 # '.', '..'
+  File.join(IB_DIR_TORRENTS, torrent.last)
+end
+
+command = (ARGV.shift or 'help').to_sym
+case command
+when :commit, :ci
+  last_infohash = begin
+    torrent = get_last_torrent
+    if torrent
+      torrentobj = Torrent.new(File.read(torrent))
+      torrentobj.info.infohash
+    end
+  end
+  gap = !ARGV.shift.nil?
+  img = make_torrent(name, '.', tracker, priv, gap)
+  if last_infohash
+    new_infohash = Torrent.new(img).info.infohash
+    exit if last_infohash == new_infohash
+  end
+  torrentfile = "#{IB_DIR_TORRENTS}/#{Time.now.to_i}.torrent"
+  File.open(torrentfile, 'wb') do |fd|
+    fd.write(img)
+  end
+  begin
+    storage.open
+    load_torrent(torrentfile) do |piece_hash, piece|
+      storage.put(piece_hash, piece)
+    end
+  ensure
+    storage.close
+  end
+when :init
+  FileUtils.mkdir_p IB_DIR_GAP
+  FileUtils.mkdir_p IB_DIR_TORRENTS
+  FileUtils.mkdir_p IB_DIR_PIECES
+when :log
+  exit unless File.directory? IB_DIR_TORRENTS
+  Dir.entries(IB_DIR_TORRENTS).each do |dir|
+    next unless /\.torrent\z/ === dir
+    puts Time.at(dir.split.first.to_i)
+  end
+when :status, :st
+  torrent = get_last_torrent
+  exit unless torrent
+  torrentobj = Torrent.new(File.read(torrent))
+  begin
+    storage.open
+    changes = load_torrent(torrent) do |piece_hash, piece|
+    end
+    changes.each do |file|
+      puts "M #{file}"
+    end
+    trackedfiles = torrentobj.info.files.map do |file|
+      if file['path'][0] != IB_DIR
+        file['path'].join('/')
+      end
+    end
+    allfiles = []
+    walk('.') do |file|
+      next if file.index("./#{IB_DIR}/") == 0
+      filename = file.split('/', 2).last
+      puts "? #{filename}" unless trackedfiles.include?(filename)
+    end
+  ensure
+    storage.close
+  end
+when :update, :up
+  torrent = get_last_torrent
+  exit unless torrent
+  begin
+    storage.open
+    changes = load_torrent(torrent) do |piece_hash, piece|
+    end
+    save_torrent(torrent, storage, changes)
+  ensure
+    storage.close
+  end
+when :verify
+  p :verify
+else
+  p :help
+end

data/lib/immutablebox.rb

@@ -0,0 +1,303 @@
+require 'rubygems'
+require 'bencode'
+require 'base32'
+require 'cgi'
+require 'digest/sha1'
+require 'fileutils'
+require 'zlib'
+
+IB_DIR = '.ib'
+
+class Torrent
+  def self.str2hex(str)
+    str.unpack('C*').map{|v|"%02x" % v}.join
+  end
+
+  class Info
+    def initialize(info)
+      @info = info
+      @info_hash = Digest::SHA1.digest(BEncode.dump(info))
+      @piece_length = info['piece length']
+      @name = info['name']
+      @files = info['files'] || [{
+        'length' => info['length'], 'path' => [@name]
+      }]
+      pieces = info['pieces']
+      @pieces = (pieces.size / 20).times.map{|i| pieces[i * 20, 20]}
+    end
+
+    attr :info
+    attr :info_hash
+    attr :files
+    attr :piece_length
+    attr :name
+    attr :pieces
+
+    def magnet
+      "magnet:?xt=urn:btih:%s" % Base32.encode(@info_hash)
+    end
+
+    def infohash
+      Torrent.str2hex(@info_hash)
+    end
+  end
+
+  def initialize(img)
+    torrent = BEncode.load(img)
+    @announce = torrent['announce']
+    @creation_date = torrent['creation date']
+    @info = Info.new(torrent['info'])
+  end
+
+  attr :info
+  attr :creation_date
+  attr :announce
+
+  def to_s
+    "%s&tr=%s" % [@info.to_s, CGI.escape(@announce)]
+  end
+
+  def inspect
+    @info.inspect
+  end
+end
+
+def load_torrent(tname)
+  modifiedfiles = []
+  torrent = Torrent.new(File.read(tname))
+  info = torrent.info
+  pieces = info.pieces.clone
+  piece_length = info.piece_length
+
+  files = []
+  piece = nil
+  info.files.each do |file|
+    file_size = file['length']
+    fd = if file['path'][0] != IB_DIR
+      filename = file['path'].join('/')
+      files << filename
+      if File.exist?(filename)
+        File.open(filename, 'rb')
+      else
+        StringIO.new(' ' * file_size)
+      end
+    end
+    begin
+      loop do
+        if fd
+          if piece.nil?
+            piece = fd.read(piece_length)
+            unless piece
+              files = []
+              break
+            end
+          else
+            piece += fd.read(piece_length - piece.size)
+          end
+        else
+          unless piece
+            files = []
+            break
+          end
+          piece += "\000" * file_size
+        end
+        break if piece.size < piece_length
+        piece_hash = Digest::SHA1.digest(piece)
+        if pieces.shift == piece_hash # good piece
+          yield(piece_hash, piece)
+        else
+          modifiedfiles += files
+        end
+        piece = nil
+      end
+    ensure
+      fd.close if fd
+    end
+  end
+
+  if piece
+    piece_hash = Digest::SHA1.digest(piece)
+    if pieces.shift == piece_hash # good piece
+      yield(piece_hash, piece)
+    else
+      modifiedfiles += files
+    end
+  end
+  modifiedfiles.uniq
+end
+
+def save_torrent(tname, storage, files)
+  torrent = Torrent.new(File.read(tname))
+  info = torrent.info
+  pieces = info.pieces.clone
+  piece_length = info.piece_length
+  info.files.each do |file|
+    next if file['path'][0] == IB_DIR
+    file_size = file['length']
+    filename = file['path'].join('/')
+    if files.include?(filename)
+      File.open(filename, 'wb') do |fd|
+        n = file_size / piece_length
+        mod = file_size % piece_length
+        n.times do |i|
+          piece_hash = pieces.shift
+          piece = storage.get(piece_hash)
+          fd.write(piece)
+        end
+        if mod > 0
+          piece_hash = pieces.shift
+          piece = storage.get(piece_hash)
+          fd.write(piece[0, mod])
+        end
+      end
+    else
+      piece_hash = pieces.shift((file_size + piece_length - 1) / piece_length)
+    end
+  end
+end
+
+def walk(path, &block)
+  Dir.entries(path).select{|d| !(/\A\.+\z/.match d)}.each do |e|
+    file = File.join(path, e)
+    if File.directory?(file)
+      walk(file, &block)
+    else
+      yield file
+    end
+  end
+end
+
+def split_path(path)
+  d = path
+  rv = []
+  loop do
+    d, f = File.split(d)
+    rv.insert(0, f)
+    break if d == '.'
+  end
+  rv
+end
+
+TORRENT_PIECE_SIZE = 2 ** 18
+
+def make_torrent(name, path, tracker, priv, gap = false)
+  torrent_pieces = []
+  piece = ''
+  gapn = 0
+  files = []
+  walk(path) do |file|
+    next if file.index("./#{IB_DIR}/") == 0
+    fileinfo = { 'path' => split_path(file) }
+    files << fileinfo
+    filesize = 0
+    File.open(file, 'rb') do |fd|
+      loop do
+        data = fd.read(TORRENT_PIECE_SIZE - piece.size)
+        break if data.nil?
+        piece << data
+        if piece.size == TORRENT_PIECE_SIZE
+          torrent_pieces << Digest::SHA1.digest(piece)
+          filesize += piece.size
+          piece = ''
+        end
+      end
+    end
+    if piece.size > 0
+      filesize += piece.size
+      fileinfo['length'] = filesize
+      gapsize = TORRENT_PIECE_SIZE - piece.size
+      gapfile = "#{IB_DIR}/gap/#{gapn}"
+      gapimage = "\000" * gapsize
+      fileinfo = { 'length' => gapsize, 'path' => gapfile.split('/') }
+      files << fileinfo
+      gapn += 1
+      piece << gapimage
+      torrent_pieces << Digest::SHA1.digest(piece)
+      piece = ''
+      if gap
+        File.open(gapfile, 'wb'){|fd| fd.write(gapimage)}
+      end
+    else
+      fileinfo['length'] = filesize
+    end
+  end
+
+  torrent = {
+    'announce' => tracker,
+    'created by' => 'statictorrent 0.0.0',
+    'creation date' => Time.now.to_i,
+    'info' => {
+      'length' => TORRENT_PIECE_SIZE * torrent_pieces.size,
+      'name' => name,
+      'private' => priv ? 1 : 0,
+      'pieces' => torrent_pieces.join,
+      'piece length' => TORRENT_PIECE_SIZE,
+      'files' => files,
+    }
+  }
+  BEncode.dump(torrent)
+end
+
+class Storage
+  def open
+  end
+  def close
+  end
+  def put
+  end
+  def get
+  end
+end
+
+class LocalStorage < Storage
+  def initialize(dir)
+    @dir = dir
+  end
+  def open
+    FileUtils.mkdir_p(@dir)
+  end
+  def compress?(piece)
+    limit = 3 * TORRENT_PIECE_SIZE / 256
+    [' ', "\n", "\000"].map{|c| piece.count(c)}.max < limit
+  end
+  def getfilename(piece_hash)
+    "#{@dir}/#{Torrent.str2hex(piece_hash)}"
+  end
+  def put(piece_hash, piece)
+    filename = getfilename(piece_hash)
+    return if File.exist?(filename)
+    File.open(filename, 'wb') do |fd|
+      fd.write(compress?(piece) ? piece : Zlib::Deflate.deflate(piece))
+    end
+  end
+  def get(piece_hash)
+    filename = getfilename(piece_hash)
+    return unless File.exist?(filename)
+    piece = File.open(filename, 'rb'){|fd| fd.read}
+    if piece.size == TORRENT_PIECE_SIZE
+      piece
+    else
+      Zlib::Inflate.inflate(piece)
+    end
+  end
+end
+
+class DistributedStorage < Storage
+  def initialize
+    @storages = []
+  end
+  def <<(storage)
+    @storages << storage
+    self
+  end
+  def open
+    @storages.each(&:open)
+  end
+  def close
+    @storages.each(&:close)
+  end
+  def put(piece_hash, piece)
+    dice = piece_hash.unpack('L').first % @storages.size
+    @storages[dice].put(piece_hash, piece)
+  end
+end

data/test.sh

@@ -0,0 +1,54 @@
+#!/bin/sh
+rm -fr sandbox
+mkdir sandbox
+cd sandbox
+
+../bin/ib init
+echo 1 >1
+echo 2 >2
+echo 3 >3
+
+../bin/ib st >actual
+cat <<EOF >.ib/expected
+? 1
+? 2
+? 3
+EOF
+diff -u .ib/expected actual
+
+ACTUAL=`../bin/ib log | wc -l`
+if [ $ACTUAL -ne 0 ]; then
+  echo $ACTUAL
+fi
+
+../bin/ib ci
+
+ACTUAL=`../bin/ib log | wc -l`
+if [ $ACTUAL -ne 1 ]; then
+  echo $ACTUAL
+fi
+
+../bin/ib ci
+
+ACTUAL=`../bin/ib log | wc -l`
+if [ $ACTUAL -ne 1 ]; then
+  echo $ACTUAL
+fi
+
+ACTUAL=`../bin/ib st | wc -l`
+if [ $ACTUAL -ne 0 ]; then
+  echo $ACTUAL
+fi
+
+rm 2
+../bin/ib st >actual
+cat <<EOF >.ib/expected
+M 2
+EOF
+diff -u .ib/expected actual
+
+../bin/ib up
+ACTUAL=`../bin/ib st | wc -l`
+if [ $ACTUAL -ne 0 ]; then
+  echo $ACTUAL
+fi

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'immutablebox'
+
+class Test::Unit::TestCase
+end

data/test/test_immutablebox.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestImmutablebox < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    true
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: immutablebox
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- OHASHI Hideya
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-15 00:00:00 +09:00
+default_executable: ib
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: base32
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  requirement: *id005
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: bencode
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  requirement: *id006
+  prerelease: false
+description: Social folder sharing/backup tool which using BitTorrent.
+email: ohachige@gmail.com
+executables: 
+- ib
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/ib
+- lib/immutablebox.rb
+- test.sh
+- test/helper.rb
+- test/test_immutablebox.rb
+has_rdoc: true
+homepage: http://github.com/ohac/immutablebox
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Social folder sharing/backup tool which using BitTorrent.
+test_files: 
+- test/helper.rb
+- test/test_immutablebox.rb