bitbroker 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52b3d5bc540ac0446b4b6fe9eff2a4f64a806f11
-  data.tar.gz: 78a2121112db9467da940e40afd59d0dc57b262c
+  metadata.gz: ca31c10d84f52d9aaebce0fb53b9ed19afcfbb43
+  data.tar.gz: 2195c0fd65b83741ece9d8163e2c2b56a0ee590a
 SHA512:
-  metadata.gz: e7b33204425476104f7218dcfa634284085a65cb8605c9e93b70e3d51357560ba4a57d8a2b52bf0448193099a71841f0c710906afd5e2834af4a46a74d51ecde
-  data.tar.gz: 29d50c8abf6d4c7722bbc099ef4f8add9efc655acc7ec947f6b65d26efb840d0fd9bce5c58d67451f21da1931628b2ce8913abcb81359ca8003d15d3570fbd62
+  metadata.gz: 5e2a4671faf3d8907d9811febb0a958eaf932afc9251baf8be8dc533bc7fefad5c4cf7bdb162d7332ac7b9bad4dd6020018b748a1b634f75a8aec924f8d4ade2
+  data.tar.gz: bec351376c5e7ee3ef35895efb8baf6e70faf23da2608ab3b6c3d8af2faaf3caccbdba84c8973803ec6c9f633ced8a7f1f881efe694e73850f1151380a949299

data/.gitignore

@@ -6,5 +6,7 @@
 /doc/
 /pkg/
 /spec/reports/
+/spec/.test
 /tmp/
 /vendor/
+*.swp

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+-r turnip/rspec

data/Gemfile

@@ -1,4 +1,10 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in bitbroker.gemspec
+gem 'rspec'
 gem 'gemspec'
+gem 'msgpack'
+gem 'fileutils'
+gem 'listen', '~> 3.0'
+gem 'macaddr', '1.7.1'
+gem 'turnip'

data/bin/bitbroker-start

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'bitbroker'
+
+PIDFILE = BitBroker::Config.path_pid
+BitBroker::Log.level = Logger::DEBUG
+
+if FileTest.exists? PIDFILE
+  puts "(NOTICE) bitbroker is now running"
+  exit
+end
+
+BitBroker::Manager.start
+
+puts "bitbroker is started."

data/bin/bitbroker-stop

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'bitbroker'
+
+PIDFILE = BitBroker::Config.path_pid
+
+def is_stopped? pid
+  begin
+    Process.getpgid(pid)
+    false
+  rescue Errno::ESRCH => _
+    true
+  end
+end
+
+unless FileTest.exists? PIDFILE
+  puts "(NOTICE) bitbroker is not running"
+  exit
+end
+
+pids = File.read(PIDFILE).split(/\n/).map{|x| x.to_i}
+pids.each do |pid|
+  Process.kill("TERM", pid)
+end
+
+while pids.size > 0
+  pid = pids.shift
+  unless is_stopped? pid
+    pids.push(pid)
+  end
+end
+File.unlink PIDFILE
+
+puts "bitbroker is stopped."

data/bitbroker.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   end
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = "bin"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 

data/lib/bitbroker.rb

@@ -1,5 +1,15 @@
 require "bitbroker/version"
+require 'bitbroker/solvant'
+require 'bitbroker/observer'
+require 'bitbroker/broker'
+require 'bitbroker/metadata'
+require 'bitbroker/manager'
+require 'bitbroker/manager_impl'
+require 'bitbroker/config'
+require 'bitbroker/log'
 
 module Bitbroker
-  # Your code goes here...
+  def self.version
+    VERSION
+  end
 end

data/lib/bitbroker/broker.rb

@@ -0,0 +1,108 @@
+require 'bunny'
+require 'msgpack'
+require 'openssl'
+
+module BitBroker
+  # This method communicate with AMQP for transmitting and receiving data
+  class Broker
+    RKEY_DATA = 'data'
+    RKEY_METADATA = 'metadata'
+    ENCRYPT_ALGORITHM = "AES-256-CBC"
+
+    def initialize(config)
+      @connection = Bunny.new(:host     => config[:mqconfig]['host'],
+                              :vhost    => config[:mqconfig]['vhost'],
+                              :user     => config[:mqconfig]['user'],
+                              :password => config[:mqconfig]['passwd'])
+      @connection.start
+      @channel = @connection.create_channel
+      @exchange = @channel.direct(config[:label])
+      @passwd = config[:passwd].to_s + config[:label]
+    end
+
+    def finish
+      @channel.close
+      @connection.close
+    end
+  end
+
+  class Publisher < Broker
+    def initialize(config)
+      super(config)
+    end
+
+    def send_data(data)
+      send(RKEY_DATA, data)
+    end
+    def send_metadata(data)
+      send(RKEY_METADATA, data)
+    end
+    def send_p_data(dest, data)
+      send(RKEY_DATA + dest, data)
+    end
+    def send_p_metadata(dest, data)
+      send(RKEY_METADATA + dest, data)
+    end
+
+    private
+    def send(rkey, data)
+      @exchange.publish(encode(MessagePack.pack({
+        'data' => data,
+        'from' => Mac.addr,
+      })), :routing_key => rkey)
+    end
+
+    def encode(data)
+      cipher = OpenSSL::Cipher::Cipher.new(ENCRYPT_ALGORITHM)
+      cipher.encrypt
+      cipher.pkcs5_keyivgen(@passwd)
+      cipher.update(data) + cipher.final
+    end
+  end
+
+  class Subscriber < Broker
+    SIGNAL_TERM = 'TERM'
+
+    def initialize(config)
+      super(config)
+    end
+
+    def recv_data(&block)
+      recv(RKEY_DATA, &block)
+    end
+    def recv_metadata(&block)
+      recv(RKEY_METADATA, &block)
+    end
+    def recv_p_data(&block)
+      recv(RKEY_DATA + Mac.addr, &block)
+    end
+    def recv_p_metadata(&block)
+      recv(RKEY_METADATA + Mac.addr, &block)
+    end
+
+    private
+    def recv(rkey, &block)
+      queue = @channel.queue('', :exclusive => true)
+      queue.bind(@exchange, :routing_key => rkey)
+      begin
+        queue.subscribe(:block => true) do |info, prop, binary|
+          msg = MessagePack.unpack(decode(binary))
+
+          if msg['from'] != Mac.addr
+            block.call(msg['data'], msg['from'])
+          end
+        end
+      rescue OpenSSL::Cipher::CipherError => e
+        Log.warn("[Subscriber] #{e.to_s}")
+      rescue Exception => _
+        finish
+      end
+    end
+    def decode(encrypted_data)
+      cipher = OpenSSL::Cipher::Cipher.new(ENCRYPT_ALGORITHM)
+      cipher.decrypt
+      cipher.pkcs5_keyivgen(@passwd)
+      cipher.update(encrypted_data) + cipher.final
+    end
+  end
+end

data/lib/bitbroker/config.rb

@@ -0,0 +1,26 @@
+require 'yaml'
+
+module BitBroker
+  class Config
+    DEFAULT_PATH_CONFIG = "#{ENV['HOME']}/.bitbroker/config.yml"
+    DEFAULT_PATH_PID = "#{ENV['HOME']}/.bitbroker/pid"
+
+    def self.[](param)
+      YAML.load_file(path_config)[param]
+    end
+
+    def self.path_config
+      @path_config ||= DEFAULT_PATH_CONFIG
+    end
+    def self.path_pid
+      @path_pid ||= DEFAULT_PATH_PID
+    end
+
+    def self.set_config(path)
+      unless FileTest.exist? path
+        raise InvalidFile path
+      end
+      @path_config = path
+    end
+  end
+end

data/lib/bitbroker/exception.rb

@@ -0,0 +1,5 @@
+module BitBroker
+  class InvalidArguemnt < StandardError; end
+  class DiscomfortDirectoryStructure < StandardError; end
+  class InvalidFile < StandardError; end
+end

data/lib/bitbroker/log.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module BitBroker
+  class Log
+    DEFAULT_LOGFILE = '/tmp/bitbroker.log'
+
+    def self.method_missing(m, *args, &block)
+      logger.method(m).call(*args)
+    end
+
+    private
+    def self.logger
+      @logger ||= init_logger
+    end
+
+    def self.init_logger
+      Logger.new(logfile)
+    end
+
+    def self.logfile
+      BitBroker::Config['logfile'] != nil ? BitBroker::Config['logfile'] : DEFAULT_LOGFILE
+    end
+  end
+end

data/lib/bitbroker/manager.rb

@@ -0,0 +1,84 @@
+require 'yaml'
+require 'macaddr'
+require 'msgpack'
+require 'time'
+require 'thread'
+
+require 'bitbroker/manager_impl'
+
+module BitBroker
+  ### This object is created for each directory
+  class Manager < ManagerImpl
+
+    def self.start
+      BitBroker::Config['directories'].each do |entry|
+        fork do
+          Process.daemon
+          File.open(PIDFILE, 'a') do |f|
+            f.write("#{$$}\n")
+          end
+
+          begin
+            manager = BitBroker::Manager.new({
+              :mqconfig => BitBroker::Config['mqconfig'],
+              :path => entry['path'],
+              :name => entry['name'],
+            })
+
+            manager.start
+            manager.advertise
+
+            loop {}
+          rescue Exception => _
+            manager.stop
+          end
+        end
+      end
+    end
+
+    def initialize(opts)
+      super(opts)
+    end
+
+    def advertise
+      @metadata.advertise(@publisher)
+    end
+
+    def start
+      # start observer that watches changing of local file-system
+      @observer = do_start_observer
+
+      # start receivers that consume message of remote nodes
+      @metadata_receiver = do_start_metadata_receiver
+      @p_metadata_receiver = do_start_p_metadata_receiver
+
+      @data_receiver = do_start_data_receiver
+      @p_data_receiver = do_start_p_data_receiver
+
+      # start collector that maintains the shared directory will be same with remote ones.
+      @collector = do_start_collector
+    end
+
+    def stop
+      # for observer
+      @observer.raise 'stop'
+      @observer.join
+
+      # for receiver
+      @metadata_receiver.raise "stop"
+      @metadata_receiver.join
+
+      @p_metadata_receiver.raise "stop"
+      @p_metadata_receiver.join
+
+      @data_receiver.raise "stop"
+      @data_receiver.join
+
+      @p_data_receiver.raise "stop"
+      @p_data_receiver.join
+
+      # for collector
+      @collector.kill
+    end
+  end
+end

data/lib/bitbroker/manager_impl.rb

@@ -0,0 +1,278 @@
+module BitBroker
+  class ManagerImpl
+    def initialize(opts)
+      # validate user created arguments
+      validate(opts)
+
+      ### prepare brokers
+      @config = {
+        :mqconfig => opts[:mqconfig],
+        :label => opts[:name],
+        :dirpath => form_dirpath(opts[:path]),
+      }
+
+      @metadata = Metadata.new(@config[:dirpath])
+
+      @publisher = Publisher.new(@config)
+
+      @deficients = @suggestions = []
+      @semaphore = Mutex.new
+
+      # internal variable in this class to know who modified/crated file
+      @file_activities = []
+    end
+
+    def form_dirpath path
+        path[-1] == '/' ? form_dirpath(path.chop) : path
+    end
+    def validate(opts)
+      raise InvalidArgument("Specified path is not directory") unless File.directory?(opts[:path])
+    end
+
+    def do_start_observer
+      def handle_add(path)
+        Log.debug("[ManagerImpl] (handle_add) path:#{path}")
+
+        rpath = @metadata.get_rpath(path)
+        if obj = @file_activities.find {|x| x.path == rpath}
+          @file_activities.delete(obj)
+        else
+          # create metadata info
+          @metadata.create(rpath)
+
+          # upload target file
+          Solvant.new(@metadata.dir, rpath).upload(@publisher)
+        end
+      end
+
+      def handle_mod(path)
+        Log.debug("[ManagerImpl] (handle_mod) path:#{path}")
+
+        rpath = @metadata.get_rpath(path)
+        if obj = @file_activities.find {|x| x.path == rpath}
+          @file_activities.delete(obj)
+        else
+          # upload target file
+          Solvant.new(@metadata.dir, rpath).upload(@publisher)
+
+          # update fileinfo
+          @metadata.get_with_path(rpath).update
+
+          @metadata.advertise(@publisher)
+        end
+      end
+
+      def handle_rem(path)
+        rpath = @metadata.get_rpath(path)
+
+        #@metadata.remove_with_path(rpath)
+        file = @metadata.get_with_path(rpath)
+        if file != nil
+          Log.debug("[ManagerImpl] (handle_rem) path:#{path}")
+
+          file.remove
+          @metadata.advertise(@publisher)
+        end
+      end
+
+      Thread.new do
+        Observer.new(@config[:dirpath]) do |mod, add, rem|
+          mod.each {|x| handle_mod(x)}
+          add.each {|x| handle_add(x)}
+          rem.each {|x| handle_rem(x)}
+        end
+      end
+    end
+
+    def do_start_collector
+      Thread.new do
+        loop do
+          deficient = @deficients.first
+          if deficient != nil
+            candidates = @suggestions.select { |x| x['path'] == deficient['path'] }
+            if candidates.size > 0
+              candidate = candidates[rand(candidates.size)]
+
+              @metadata.request(@publisher, [candidate], candidate['from'])
+
+              @semaphore.synchronize do
+                @suggestions = @suggestions.reject {|x| x['path'] == deficient['path']}
+                @deficients.delete(deficient)
+              end
+            end
+          end
+          Thread.pass
+        end
+      end
+    end
+
+    def do_start_metadata_receiver
+      Thread.new do
+        receiver = Subscriber.new(@config)
+        receiver.recv_metadata do |msg, from|
+          case msg['type']
+          when Metadata::TYPE_ADVERTISE then
+            receive_advertise(msg['data'], from)
+          when Metadata::TYPE_REQUEST_ALL then
+            receive_request_all(msg['data'], from)
+          end
+        end
+      end
+    end
+
+    def do_start_p_metadata_receiver
+      Thread.new do
+        receiver = Subscriber.new(@config)
+        receiver.recv_p_metadata do |msg, from|
+          case msg['type']
+          when Metadata::TYPE_SUGGESTION then
+            receive_suggestion(msg['data'], from)
+          when Metadata::TYPE_REQUEST then
+            receive_request(msg['data'], from)
+          end
+        end
+      end
+    end
+
+    def do_start_data_receiver
+      Thread.new do
+        receiver = Subscriber.new(@config)
+        receiver.recv_data do |binary, from|
+          path = MessagePack.unpack(binary)['path']
+
+          Log.debug("[ManagerImpl] (data_receiver) path: #{path}")
+
+          @file_activities.push(FileActivity.create(path))
+
+          Solvant.load_binary(@config[:dirpath], binary)
+        end
+      end
+    end
+    def do_start_p_data_receiver
+      Thread.new do
+        receiver = Subscriber.new(@config)
+        receiver.recv_p_data do |binary, from|
+          path = MessagePack.unpack(binary)['path']
+
+          Log.debug("[ManagerImpl] (p_data_receiver) path: #{path}")
+
+          @file_activities.push(FileActivity.create(path))
+
+          Solvant.load_binary(@config[:dirpath], binary)
+        end
+      end
+    end
+
+    def receive_advertise(data, from)
+      def updated?(remote)
+        case f = @metadata.get_with_path(remote['path'])
+        when nil # this means target file doesn't exist in local.
+          true
+        else
+          f.size != remote['size'] and
+          not f.removed?
+        end
+      end
+
+      def removed?(remote)
+        case f = @metadata.get_with_path(remote['path'])
+        when nil
+          false
+        else
+          remote['status'].to_i & Metadata::FileInfo::STATUS_REMOVED > 0
+        end
+      end
+      Log.debug("[ManagerImpl] (receive_advertise) <#{from}> data:#{data}")
+
+      deficients = []
+      data.each do |remote|
+        if removed? remote
+          Log.debug("[ManagerImpl] (receive_advertise) remove: #{remote}")
+
+          # set file_activities
+          @file_activities.push(FileActivity.remove(remote['path']))
+
+          # remove FileInfo object which metadata has
+          @metadata.remove_with_path(remote['path'])
+
+          # remove actual file in local FS
+          Solvant.new(@config[:dirpath], remote['path']).remove
+        else updated? remote
+          deficients.push(remote)
+
+          fpath = "#{@config[:dirpath]}/#{remote['path']}"
+          if FileTest.exist? fpath
+            Log.debug("[ManagerImpl] trancated(#{fpath}, #{remote['size']})")
+
+            # truncate files when target file is cut down
+            File.truncate(fpath, remote['size'])
+          end
+        end
+      end
+
+      # request all deficients files
+      @metadata.request_all(@publisher, deficients)
+
+      # record deficient files to get it from remote node
+      @semaphore.synchronize do
+        @deficients += deficients
+      end
+    end
+
+    def receive_request_all(data, from)
+      def has_file?(remote)
+        @metadata.get_with_path(remote['path']) != nil
+      end
+      Log.debug("[ManagerImpl] (receive_request_all) <#{from}> data:#{data}")
+
+      files = data.map {|f| @metadata.get_with_path(f['path'])}.select{|x| x != nil}
+      if files != []
+        Log.debug("[ManagerImpl] (receive_request_all) files:#{files}")
+        @metadata.suggestion(@publisher, files.map{|x| x.to_h}, from)
+      end
+    end
+
+    def receive_suggestion(data, from)
+      Log.debug("[ManagerImpl] (receive_suggestion) <#{from}> data:#{data}")
+
+      data.each {|x| x['from'] = from}
+      @semaphore.synchronize do
+        @suggestions += data
+      end
+    end
+
+    def receive_request(data, from)
+      Log.debug("[ManagerImpl] (receive_request) <#{from}> data:#{data}")
+
+      data.each do |remote|
+        f = @metadata.get_with_path(remote['path'])
+
+        Solvant.new(@config[:dirpath], f.path).upload_to(@publisher, from)
+      end
+    end
+
+    class FileActivity
+      STATUS_REMOVED = 1 << 0
+
+      attr_reader :path, :mtime
+
+      def initialize(path, mtime, status = 0)
+        @path = path
+        @mtime = mtime
+        @status = status
+      end
+
+      def removed?
+        @status & STATUS_REMOVED > 0
+      end
+
+      def self.create(path)
+        self.new(path, FileTest.exist?(path) ? File.mtime(path) : Time.now)
+      end
+
+      def self.remove(path)
+        self.new(path, nil, STATUS_REMOVED)
+      end
+    end
+  end
+end

data/lib/bitbroker/metadata.rb

@@ -0,0 +1,122 @@
+require 'msgpack'
+
+module BitBroker
+  class Metadata
+    # describes message types
+    TYPE_ADVERTISE = 1<<0
+    TYPE_REQUEST_ALL = 1<<1
+    TYPE_SUGGESTION = 1<<2
+    TYPE_REQUEST = 1<<3
+
+    attr_reader :dir
+
+    def initialize(dir)
+      @dir = dir
+      @files = scanning_files(@dir).map do |path|
+        FileInfo.new(@dir, get_rpath(path))
+      end
+    end
+
+    def get_with_path(path)
+      @files.select{|f| f.path == path}.first
+    end
+    def remove_with_path(path)
+      @files.reject!{|f| f.path == path}
+    end
+    def create(path)
+      if get_with_path(path) == nil
+        @files.push(FileInfo.new(@dir, path))
+      else
+        puts "Warning: #{path} is already created"
+      end
+    end
+
+    ### sending message for broker
+    def advertise(broker)
+      broker.send_metadata({
+        :type => TYPE_ADVERTISE,
+        :data => @files.map{|x| x.to_h },
+      })
+    end
+    def request_all(broker, files)
+      broker.send_metadata({
+        :type => TYPE_REQUEST_ALL,
+        :data => files,
+      })
+    end
+    def suggestion(broker, files, dest)
+      broker.send_p_metadata(dest, {
+        :type => TYPE_SUGGESTION,
+        :data => files,
+      })
+    end
+    def request(broker, files, dest)
+      broker.send_p_metadata(dest, {
+        :type => TYPE_REQUEST,
+        :data => files,
+      })
+    end
+
+    ### utility methods
+    def get_rpath(path)
+      raise DiscomfortDirectoryStructure unless !!path.match(/^#{@dir}/)
+      path.split(@dir).last
+    end
+
+    private
+    def scanning_files(current_dir, &block)
+      arr = []
+      Dir.foreach(current_dir) do |f|
+        if /^\.+$/ !~ f
+          path = "#{current_dir}/#{f}"
+
+          if File.directory? f
+            arr += scanning(path)
+          else
+            arr.push(path)
+          end
+        end
+      end
+      arr
+    end
+    class FileInfo
+      attr_reader :path, :size, :mtime
+
+      # describes file status
+      STATUS_REMOVED = 1 << 0
+
+      def initialize(dirpath, filepath)
+        @fpath = "#{dirpath}/#{filepath}"
+        @path = filepath
+        @status = 0
+
+        self.update
+      end
+      def update
+        if FileTest.exist? @fpath
+          file = File.new(@fpath)
+
+          @size = file.size
+          @mtime = file.mtime
+        else
+          @size = 0
+          @mtime = Time.new(0)
+        end
+      end
+      def removed?
+        @status & STATUS_REMOVED > 0
+      end
+      def remove
+        @status |= STATUS_REMOVED
+      end
+      def to_h
+        {
+          'path' => @path,
+          'status' => @status,
+          'size' => @size,
+          'mtime' => @mtime.to_s,
+        }
+      end
+    end
+  end
+end

data/lib/bitbroker/observer.rb

@@ -0,0 +1,19 @@
+require 'listen'
+
+module BitBroker
+  class Observer
+    def initialize(dir, &block)
+      @target_dir = dir
+
+      @listener = Listen.to(dir) do |mod, add, rem|
+        block.call(mod, add, rem)
+      end
+
+      @listener.start
+    end
+
+    def stop
+      @listener.stop
+    end
+  end
+end

data/lib/bitbroker/solvant.rb

@@ -0,0 +1,84 @@
+require 'msgpack'
+require 'fileutils'
+
+module BitBroker
+  class Solvant
+    DEFAULT_CHUNK_SIZE = 1<<20
+
+    attr_reader :chunks
+
+    def initialize(dirpath, r_path, chunk_size = DEFAULT_CHUNK_SIZE)
+      @f_path = "#{dirpath}/#{r_path}"
+
+      # Validate target file at first
+      if not FileTest.exist? @f_path
+        FileUtils.touch(@f_path)
+      end
+
+      # separate per chunk
+      @chunks = []
+      chunk_splitter(File::Stat.new(@f_path).size, chunk_size) do |offset, size|
+        @chunks.push(Chunk.new({
+          :r_path => r_path,
+          :f_path => @f_path,
+          :size => size,
+          :offset => offset,
+          :chunk_size => chunk_size,
+        }))
+      end
+    end
+
+    # This defines operations to manipulate actual Flie object on FileSystem
+    def remove
+      File.unlink(@f_path)
+    end
+
+    def upload broker
+      @chunks.each do |chunk|
+        broker.send_data(chunk.serialize)
+      end
+    end
+
+    def upload_to(broker, dest)
+      @chunks.each do |chunk|
+        broker.send_p_data(dest, chunk.serialize)
+      end
+    end
+
+    def self.load_binary(dirpath, binary)
+      data = MessagePack.unpack(binary)
+      offset = data['offset'] * data['chunk_size']
+
+      File.binwrite(dirpath + data['path'], data['data'], offset)
+    end
+  
+    private
+    def chunk_splitter(total_size, chunk_size, &block)
+      last = total_size / chunk_size
+      (0..last).each do |i|
+        size = (i == last) ? total_size - chunk_size * i : chunk_size
+
+        block.call(i, size)
+      end
+    end
+
+    class Chunk
+      def initialize(opts)
+        @r_path = opts[:r_path]
+        @f_path = opts[:f_path]
+        @size = opts[:size]
+        @offset = opts[:offset]
+        @chunk_size = opts[:chunk_size]
+      end
+
+      def serialize
+        MessagePack.pack({
+          'path' => @r_path,
+          'data' => File.binread(@f_path, @size, @offset * @chunk_size),
+          'offset' => @offset,
+          'chunk_size' => @chunk_size,
+        })
+      end
+    end
+  end
+end

data/lib/bitbroker/version.rb

@@ -1,3 +1,3 @@
 module Bitbroker
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitbroker
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Hiroyasu OHYAMA
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2015-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,10 +66,21 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/bitbroker-start
+- bin/bitbroker-stop
 - bin/console
 - bin/setup
 - bitbroker.gemspec
 - lib/bitbroker.rb
+- lib/bitbroker/broker.rb
+- lib/bitbroker/config.rb
+- lib/bitbroker/exception.rb
+- lib/bitbroker/log.rb
+- lib/bitbroker/manager.rb
+- lib/bitbroker/manager_impl.rb
+- lib/bitbroker/metadata.rb
+- lib/bitbroker/observer.rb
+- lib/bitbroker/solvant.rb
 - lib/bitbroker/version.rb
 homepage: https://github.com/userlocalhost2000/bitbroker
 licenses: