ruby-libstorj 0.0.0

data/lib/ruby-libstorj/ext/upload_options.rb

@@ -0,0 +1,38 @@
+module LibStorj
+  module Ext
+    module Storj
+      class UploadOptions < FFI::Struct
+        layout :prepare_frame_limit, :int,
+               :push_frame_limit, :int,
+               :push_shard_limit, :int,
+               :rs, :bool,
+               :index, :pointer, # char*
+               :bucket_id, :pointer, # char*
+               :file_name, :pointer, # char*
+               :fd, :pointer # FILE*
+
+        def initialize(bucket_id:,
+                       file_path:,
+                       file_name: nil,
+                       index: nil)
+          if file_path.nil? || !::File.exists?(file_path)
+            raise Errno::ENOENT.new(file_path || 'nil')
+          end
+
+          file_name = ::File.basename(file_path) if !file_name
+          super()
+
+          self[:prepare_frame_limit] = 1
+          self[:push_frame_limit] = 64
+          self[:push_shard_limit] = 64
+          self[:rs] = true
+          self[:index] = (index.is_a?(String) && index.length == 64) ?
+                             index : FFI::MemoryPointer::NULL
+          self[:bucket_id] = FFI::MemoryPointer.from_string bucket_id
+          self[:file_name] = FFI::MemoryPointer.from_string file_name
+          self[:fd] = ::LibStorj::Ext::LibC.fopen file_path, 'r'
+        end
+      end
+    end
+  end
+end

data/lib/ruby-libstorj/libstorj.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'ffi'
+require 'date'
+
+module LibStorj
+  # NB: not currently used but useful for debugging
+  require 'ruby-libstorj/struct'
+  require 'ruby-libstorj/ext/types'
+  require 'ruby-libstorj/ext/json_request'
+  require 'ruby-libstorj/ext/get_bucket_request'
+  require 'ruby-libstorj/ext/create_bucket_request'
+  require 'ruby-libstorj/ext/list_files_request'
+  require 'ruby-libstorj/ext/bucket'
+  require 'ruby-libstorj/ext/ext'
+  require 'ruby-libstorj/ext/upload_options'
+  require 'ruby-libstorj/ext/file'
+
+  require 'ruby-libstorj/env'
+  require 'ruby-libstorj/mixins/storj'
+
+  extend ::LibStorj::Ext::Storj::Mixins
+end

data/lib/ruby-libstorj/mixins/storj.rb

@@ -0,0 +1,27 @@
+module LibStorj
+  module Ext
+    module Storj
+      module Mixins
+        def util_timestamp
+          ::LibStorj::Ext::Storj.util_timestamp
+        end
+
+        def util_datetime
+          # '%Q' - Number of milliseconds since 1970-01-01 00:00:00 UTC.
+          DateTime.strptime(::LibStorj::Ext::Storj.util_timestamp.to_s, '%Q')
+        end
+
+        def mnemonic_check(mnemonic)
+          ::LibStorj::Ext::Storj.mnemonic_check(mnemonic)
+        end
+
+        # default to highest strength; strength range: (128..256)
+        def mnemonic_generate(strength = 256)
+          pointer = FFI::MemoryPointer.new :pointer, 1
+          ::LibStorj::Ext::Storj.mnemonic_generate(strength, pointer)
+          pointer.read_pointer.read_string
+        end
+      end
+    end
+  end
+end

data/lib/ruby-libstorj/struct.rb

@@ -0,0 +1,42 @@
+module LibStorj
+  class FFI::Struct
+    # allows for destructuring. NB: `values_at` members array order
+    #   must match assignment order!
+    #
+    # example: ```
+    #       bucket = ::LibStorj::Ext::Bucket.new
+    #       name, id, decrypted = bucket.values_at(:name, :id, :decrypted)
+    #       # OR name, id, decrypted = bucket.values_at([:name, :id, :decrypted])
+    #       # OR name, id, decrypted = bucket.values_at(%i[name id decrypted])
+    #       ```
+
+    def values_at(*members)
+      members.flatten.map {|member_name| self[member_name]}
+    end
+
+    # convenience method for inspecting struct hierarchies
+    def map_layout
+      # NB: Hash[ [ [key, value], ... ] ] → new_hash
+      Hash[members.map do |member_name|
+        member = self[member_name]
+        value = member.is_a?(FFI::Struct) ? member.map_layout : member
+        if value.is_a? FFI::Pointer
+          next [member_name, nil] if value.null?
+
+          # attempt to read as string
+          begin
+            string_value = value.read_string
+            # update value to string_value if it contains only printable characters
+            if string_value =~ /^[[:print:]]*$/
+              value = string_value
+            end
+          rescue
+            # do nothing...
+            # let value remain a pointer if an exception was raised
+          end
+        end
+        [member_name, value]
+      end]
+    end
+  end
+end

data/ruby-libstorj.gemspec

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# require File.expand_path("../lib/ruby-libstorj/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ruby-libstorj'
+  gem.version       = '0.0.0' #LibStorj::VERSION
+  gem.license       = 'AGPL-3.0'
+  gem.authors       = ['Bryan White']
+  gem.email         = ['bryanchriswhite@gmail.com', 'bryan@storj.io']
+  gem.homepage      = 'https://github.com/storj/ruby-libstorj'
+  gem.summary       = 'libstorj bindings for Ruby'
+  gem.description   = 'Ruby bindings to the libstorj C Storj API library' # TODO: elaborate
+
+  # gem.extensions << 'ext/Rakefile'
+  # TODO: uncomment if this gem needs to build native extensions
+  gem.extensions = %w[ext/ruby-libstorj/extconf.rb]
+
+  gem.required_ruby_version = '>= 2.0.0'
+  gem.require_paths = ['lib']
+
+  # TODO: is this necessary?
+  # gem.add_runtime_dependency     '<gem name>', '~> <version>'
+  #
+  # gem.add_development_dependency '<gem name', '~> <version>'
+
+  gem.files         = `git ls-files`.split("\n").reject {|f| f =~ /^test/}
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  # Add the submodule to the gem
+  relative_path = File.expand_path("../", __FILE__) + '/'
+  `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+
+    if (ENV['OS'] == 'Windows_NT') && submodule_path[0] == '/'
+      # Detect if cygwin path is being used by git
+      submodule_path = submodule_path[1..-1]
+      submodule_path.insert(1, ':')
+    end
+
+    # for each submodule, change working directory to that submodule
+    Dir.chdir(submodule_path) do
+      # Make the submodule path relative
+      submodule_path = submodule_path.gsub(/#{relative_path}/i, '')
+
+      # issue git ls-files in submodule's directory
+      submodule_files = `git ls-files`.split($\)
+
+      # prepend the submodule path to create relative file paths
+      submodule_files_paths = submodule_files.map do |filename|
+        File.join(submodule_path, filename)
+      end
+
+      # add relative paths to gem.files
+      gem.files += submodule_files_paths
+    end
+  end
+end

data/spec/helpers/options.yml.example

@@ -0,0 +1,22 @@
+bridge:
+  proto: https
+  port: 443
+  host: api.storj.io
+  user: yourusername
+  pass: yourpassword
+
+encrypt:
+  mnemonic: 'this is not really a mnemonic and i hope it does not break anything'
+
+http:
+  user_agent: 'curl/7.52.1'
+  proxy_url:
+  #cainfo_path: #-- leave blank to use curl default CA bundle, see:
+  #                 (https://curl.haxx.se/libcurl/c/CURLOPT_CAINFO.html)
+  low_speed_limit: 30720
+  low_speed_time: 20
+  timeout: 60
+
+log:
+  logger: JSON_LOGGER
+  level: 0

data/spec/helpers/shared_rake_examples.rb

@@ -0,0 +1,132 @@
+def lookup_task(task_name)
+  begin
+    ::Rake::Task[task_name]
+  rescue RuntimeError
+    raise "exception raised when looking up rake task: #{task_name}"
+  end
+end
+
+
+shared_examples 'defines the target task' do
+  it 'defines the target task' do
+    task = instantiate
+    begin
+      registered_task = ::Rake::Task[task_name]
+      expect(registered_task).to be_equal(task.target_task)
+    rescue RuntimeError => err
+      fail("exception raised trying to lookup task: #{task_name}")
+    end
+  end
+end
+
+shared_context 'invokes all dependencies when invoked' do
+  it 'invokes all depencencies when invoked' do
+    task = instantiate
+    deps.each do |dep_name|
+      begin
+        dep_task = ::Rake::Task[dep_name]
+      rescue RuntimeError
+        raise "exception raised when looking up rake task: #{dep_name}"
+      end
+
+      task.invoke(*expected_args.values)
+      expect(dep_task.already_invoked).to be(true)
+
+      #-- reset
+      task.reenable
+    end
+  end
+end
+
+shared_context 'invokes all dependencies when invoked via any alias' do
+  it 'invokes all depencencies when invoked via any alias' do
+    task = instantiate
+    alias_names.map(&method(:lookup_task)).each do |alias_task|
+      alias_task.invoke(*expected_args.values)
+
+      deps.map(&method(:lookup_task)).each do |dep_task|
+        expect(dep_task.already_invoked).to be(true)
+
+        #-- reset
+        dep_task.reenable
+      end
+
+      #-- reset
+      alias_task.reenable
+    end
+  end
+end
+
+shared_examples 'gets invoked with args via any alias' do
+  it 'gets invoked with args via any alias' do
+    yield_counter = 0
+    task = described_class.new task_name,
+                               alias_names: alias_names,
+                               args_deps_hash: {args => deps} do
+    |actual_task, actual_args, actual_deps|
+      yield_counter += 1
+      expect(task.target_task).to be(actual_task)
+      expect(expected_args).to eq(actual_args.to_hash)
+      expect(deps).to eq(actual_deps)
+    end
+
+
+    alias_names.map(&method(:lookup_task)).each do |alias_task|
+      alias_task.invoke(*expected_args.values)
+
+      #-- reset
+      task.reenable
+      alias_task.reenable
+    end
+
+    expect(yield_counter > 0).to be(true)
+    expect(yield_counter).to be(alias_names.count)
+  end
+end
+
+shared_examples 'gets invoked via any alias' do
+  it 'gets invoked via any alias' do
+    task = instantiate
+    alias_names.each do |alias_name|
+      begin
+        alias_task = ::Rake::Task[alias_name]
+      rescue RuntimeError
+        raise "exception raised when looking up rake task: #{alias_name}"
+      end
+
+      alias_task.invoke(*expected_args.values)
+      expect(task.already_invoked).to be(true)
+
+      #-- reset
+      task.reenable
+      alias_task.reenable
+    end
+  end
+end
+
+shared_examples 'yields to the block' do
+  it 'yields the rake task, args, and dependencies to the block' do
+    task = described_class.new task_name,
+                               alias_names: alias_names,
+                               args_deps_hash: {args => deps} do
+    |actual_task, actual_args, actual_deps|
+      expect(task.target_task).to be(actual_task)
+      expect(expected_args).to eq(actual_args.to_hash)
+      expect(deps).to eq(actual_deps)
+    end
+
+
+    task.invoke(*expected_args.values)
+
+    #-- reset
+    task.reenable
+  end
+end
+
+shared_context 'raises `ArgumentError`' do
+  it 'raises an `ArgumentError`' do
+    expect do
+      instantiate
+    end.to raise_error(ArgumentError)
+  end
+end

data/spec/helpers/storj_options.rb

@@ -0,0 +1,96 @@
+module LibStorjTest
+  require 'yaml'
+  require 'ruby-libstorj'
+
+  def build_options(type_map)
+    options_yml = YAML.load_file "#{__dir__}/options.yml"
+    options_yml.to_a.map do |option_group|
+      group_name, options = option_group
+
+      option_type = type_map[group_name.to_sym]
+      member_field_hash = Hash[option_type.members.zip option_type.layout.fields]
+      option_instance = option_type.new
+
+      options.each do |option|
+        name, value = [option[0].to_sym, option[1]]
+
+        if name == :logger
+          option_instance[:logger] = ::LibStorj::Ext::Storj.const_get value
+
+          next
+        end
+
+        option_field = member_field_hash[name]
+
+        # TODO: check types and/or error handle
+        if option_field.nil?
+          option_instance = FFI::MemoryPointer::NULL
+        elsif option_field.is_a?(FFI::StructLayout::Pointer)
+          # Assuming pointers are strings
+          #
+          pointer = FFI::MemoryPointer.from_string(value.nil? ? '' : value)
+          option_instance[name] = pointer
+        else
+          option_instance[name] = value
+        end
+
+      end
+
+      option_instance
+    end
+  end
+
+  def default_options
+    build_options bridge: ::LibStorj::Ext::Storj::BridgeOptions,
+                  encrypt: ::LibStorj::Ext::Storj::EncryptOptions,
+                  http: ::LibStorj::Ext::Storj::HttpOptions,
+                  log: ::LibStorj::Ext::Storj::LogOptions
+  end
+
+  def get_test_bucket_id(&block)
+    instance.get_buckets do |error, buckets|
+      throw(:no_bucket) if buckets.nil?
+
+      test_bucket = buckets.find {|bucket| bucket.name == test_bucket_name}
+      throw(:no_bucket) unless test_bucket
+      block.call test_bucket.id
+    end
+  end
+
+  def get_test_file_id(&block)
+    get_test_bucket_id do |test_bucket_id|
+      instance.list_files test_bucket_id do |error, files|
+        throw(:no_file) if files.nil?
+
+        test_file = files.find {|file| file.name == test_file_name}
+        throw(:no_file) unless test_file
+        block.call test_file.id, test_bucket_id
+      end
+    end
+  end
+
+
+  def clean_buckets(&block)
+    catch(:no_bucket) do
+      return get_test_bucket_id do |id|
+        instance.delete_bucket(id, &block)
+      end
+    end
+
+    yield if block_given?
+  end
+
+  def clean_files(&block)
+    catch(:no_bucket) do
+      return get_test_bucket_id do |test_bucket_id|
+        catch(:no_file) do
+          get_test_file_id do |test_file_id|
+            instance.delete_file(test_bucket_id, test_file_id, &block)
+          end
+        end
+      end
+    end
+
+    yield if block_given?
+  end
+end