ruby-libstorj 0.0.0

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

@@ -0,0 +1,71 @@
+module LibStorj
+  module Ext
+    module LibC
+      extend FFI::Library
+      ffi_lib('c')
+
+      attach_function('fopen', [:string, :string], :pointer)
+      attach_function('fclose', [:pointer], :int)
+    end
+
+    module Curl
+      extend FFI::Library
+      ffi_lib('curl')
+
+      attach_function('easy_stderr', 'curl_easy_strerror', [:curl_code], :string)
+
+      def self.curl_code_to_string(error_code)
+        return nil if error_code.nil?
+
+        curl_error = ::LibStorj::Ext::Curl.easy_stderr(error_code)
+        error_code > 0 ? curl_error : ''
+      end
+    end
+
+    module JsonC
+      extend FFI::Library
+      ffi_lib('json-c')
+
+      attach_function('stringify', 'json_object_to_json_string', [:pointer], :string)
+      attach_function('parse', 'json_tokener_parse', [:string], :pointer)
+    end
+
+    module Storj
+      extend FFI::Library
+      ffi_lib('storj')
+
+      JSON_LOGGER = FFI::Function.new :void, [:string, :int, :pointer] do |message, level, handle|
+        puts JSON.dump message: message,
+                       level: level,
+                       timestamp: ::LibStorj.util_timestamp
+      end
+
+      attach_function('util_timestamp', 'storj_util_timestamp', [], :uint64)
+      attach_function('mnemonic_check', 'storj_mnemonic_check', [:string], :bool)
+      attach_function('mnemonic_generate', 'storj_mnemonic_generate', [:int, :pointer], :int)
+
+      attach_function('get_info', 'storj_bridge_get_info', [
+          Env.by_ref,
+          ::LibStorj::Ext::Storj::JsonRequest::CALLBACK,
+          :pointer # uv_after_work_cb*
+      # ::LibStorj::UV::
+      ], :int)
+
+      attach_function('destroy_env', 'storj_destroy_env', [
+          Env.by_ref
+      ], :int)
+
+      attach_function('init_env', 'storj_init_env', [
+          BridgeOptions.by_ref,
+          EncryptOptions.by_ref,
+          HttpOptions.by_ref,
+          LogOptions.by_ref
+      ], Env.by_ref)
+    end
+
+    module UV
+      extend FFI::Library
+      ffi_lib('uv')
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module LibStorj
+  module Ext
+    module Storj
+      class File < FFI::Struct
+        extend FFI::Library
+        ffi_lib('storj')
+
+        attr_reader :name, :id, :size
+
+        # typedef void (*storj_progress_cb)(double progress
+        #                                  uint64_t bytes,
+        #                                  uint64_t total_bytes,
+        #                                  void *handle);
+        PROGRESS_CALLBACK = callback %i[double uint64 uint64 pointer], :void
+
+        # typedef void (*storj_finished_download_cb)(int status, FILE *fd, void *handle);
+        FINISHED_DOWNLOAD_CALLBACK = callback %i[int pointer pointer], :void
+
+        # typedef void (*storj_finished_upload_cb)(int error_status, char *file_id, void *handle);
+        FINISHED_UPLOAD_CALLBACK = callback %i[int string pointer], :void
+
+        def initialize(*args)
+          super(*args)
+
+          @name, @id, @size = self.values_at %i[filename id size]
+        end
+
+        def self.pointer_to_array(pointer, array_length)
+          if pointer.nil? || pointer == FFI::MemoryPointer::NULL || array_length < 1
+            return nil
+          end
+
+          ### #=> [#<LibStorj::Ext::Storj::Bucket ...>, ...]
+          (0..(array_length - 1)).map do |i|
+            File.new pointer[i * size]
+          end
+        end
+
+        attach_function('all', 'storj_bridge_list_files', [
+            Env.by_ref,
+            :string,
+            ::LibStorj::Ext::Storj::JsonRequest::CALLBACK,
+            :pointer # uv_after_work_cb*
+        ], :int)
+
+        private :all
+
+        attach_function('delete', 'storj_bridge_delete_file', [
+            Env.by_ref,
+            :string,
+            :string,
+            ::LibStorj::Ext::Storj::JsonRequest::CALLBACK,
+            :pointer, # after_work_cb
+        ], :int)
+
+        attach_function('resolve', 'storj_bridge_resolve_file', [
+            Env.by_ref,
+            :string,
+            :string,
+            :pointer, # FILE* destination
+            :pointer, # handle
+            PROGRESS_CALLBACK, # progress_cb
+            FINISHED_DOWNLOAD_CALLBACK, # finished_cb
+        ], ::LibStorj::Ext::Storj::DownloadState.by_ref)
+
+        attach_function('store', 'storj_bridge_store_file', [
+            Env.by_ref,
+            ::LibStorj::Ext::Storj::UploadOptions.by_ref,
+            :pointer, # handle
+            PROGRESS_CALLBACK, # progress_cb
+            FINISHED_DOWNLOAD_CALLBACK, # finished_cb
+        ], ::LibStorj::Ext::Storj::UploadState.by_ref)
+
+        attach_function('store_cancel', 'storj_bridge_store_file_cancel', [
+            ::LibStorj::Ext::Storj::UploadState.by_ref
+        ], :int)
+
+        attach_function('resolve_cancel', 'storj_bridge_resolve_file_cancel', [
+            ::LibStorj::Ext::Storj::DownloadState.by_ref
+        ], :int)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module LibStorj
+  module Ext
+    module Storj
+      class GetBucketRequest < FFI::Struct
+        layout :http_options, HttpOptions.by_ref,
+               :encrypt_options, EncryptOptions.by_ref,
+               :options, BridgeOptions.by_ref,
+               :method, :string,
+               :path, :string,
+               :auth, :bool,
+               :body, :pointer, # struct json_object *body;
+               :response, :pointer, # struct json_object *body;
+               :buckets, :pointer,
+               :total_buckets, :uint32,
+               :error_code, :int,
+               :status_code, :int,
+               :handle, :pointer # void*
+
+        def self.after_work_cb
+          args = [::LibStorj::Ext::UV::Work.by_ref, :int]
+
+          FFI::Function.new :void, args do |work_req_ptr|
+            req = self.new work_req_ptr[:data]
+            buckets,total_buckets = req.values_at %i[buckets total_buckets]
+            error = ::LibStorj::Ext::Curl.curl_code_to_string req[:error_code]
+            c_handle = FFI::Function.new :void, %i[string pointer int], req[:handle]
+
+            c_handle.call error, buckets, total_buckets
+          end
+        end
+
+        def self.ruby_handle
+          FFI::Function.new :void, %i[string pointer int] do
+          |error, buckets_pointer, bucket_count|
+            buckets = ::LibStorj::Ext::Storj::Bucket
+                          .pointer_to_array buckets_pointer,
+                                            bucket_count
+
+            yield error, buckets
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module LibStorj
+  module Ext
+    module Storj
+      class JsonRequest < FFI::Struct
+        CALLBACK = callback [:string, :string], :void
+
+        layout :http_options, HttpOptions.by_ref,
+               :options, BridgeOptions.by_ref,
+               :method, :string,
+               :path, :string,
+               :auth, :bool,
+               :body, :pointer, # struct json_object *body;
+               :response, :pointer, # struct json_object *response;
+               :error_code, :int,
+               :status_code, :int,
+               :handle, :pointer # void*
+
+        def self.after_work_cb
+          args = [::LibStorj::Ext::UV::Work.by_ref, :int]
+
+          FFI::Function.new :void, args do |work_req_ptr|
+            req = self.new work_req_ptr[:data]
+            response = ::LibStorj::Ext::JsonC.stringify req[:response]
+            error = ::LibStorj::Ext::Curl.curl_code_to_string req[:error_code]
+            c_handle = FFI::Function.new :void, %i[string pointer], req[:handle]
+
+            c_handle.call(error, response)
+          end
+        end
+
+        def self.ruby_handle(&block)
+          FFI::Function.new :void, %i[string string] do |error, response|
+            begin
+              response = JSON.parse response
+            rescue JSON::ParserError => err
+              error = err
+              response = nil
+            end
+
+            if error.respond_to?(:empty?) && error.empty?
+              response_error = response.nil? ? nil : response['error']
+              error = response_error.nil? ? nil : response_error
+            end
+
+            yield error, response if block_given?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module LibStorj
+  module Ext
+    module Storj
+      class ListFilesRequest < FFI::Struct
+        layout :http_options, HttpOptions.by_ref,
+               :encrypt_options, EncryptOptions.by_ref,
+               :options, BridgeOptions.by_ref,
+               :bucket_id, :string,
+               :method, :string,
+               :path, :string,
+               :auth, :bool,
+               :body, :pointer, # struct json_object *body;
+               :response, :pointer, # struct json_object *response;
+               :files, :pointer,
+               :total_files, :uint32,
+               :error_code, :int,
+               :status_code, :int,
+               :handle, :pointer # void*
+
+        def self.after_work_cb
+          args = [::LibStorj::Ext::UV::Work.by_ref, :int]
+
+          FFI::Function.new :void, args do |work_req_ptr|
+            req = self.new work_req_ptr[:data]
+            files, total_files, response = req.values_at %i[files total_files response]
+            error = ::LibStorj::Ext::Curl.curl_code_to_string req[:error_code]
+            c_handle = FFI::Function.new :void, %i[string pointer int], req[:handle]
+
+            catch :no_response_error do
+              begin
+                response_string = ::LibStorj::Ext::JsonC.stringify(response)
+                response_hash = JSON.parse(response_string)
+
+                unless response_hash.is_a?(Hash) && !response_hash['error'].nil?
+                  throw :no_response_error
+                end
+
+                error = response_error if response_error && error.empty?
+              rescue JSON::ParserError => err
+                # response didn't contain valid JSON;
+                # therefore, it probably doesn't contain an error message
+              end
+            end
+
+            c_handle.call error, files, total_files
+          end
+        end
+
+        def self.ruby_handle(&block)
+          FFI::Function.new :void, %i[string pointer int] do
+          |error, files_pointer, file_count|
+            files = ::LibStorj::Ext::Storj::File.pointer_to_array files_pointer,
+                                                                  file_count
+
+            error = nil if error.empty?
+
+            yield error, files
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+module LibStorj
+  module Ext
+    # NB: Ruby's ffi doesn't allow assigning to :string' pointer
+    #     types.
+    #
+    #     You can use `FFI::MemoryPointer.from_string` to create a
+    #     string pointer from a ruby string. Or use the
+    #     `FFI::Pointer#write_string` method to update an existing
+    #     string (or generic) pointer; see below
+    #
+    # NB: All pointer types use have
+    #       `read_<type> (FFI::Pointer#read_<type>)`
+    #                 and
+    #       `write_<type> (FFI::Pointer#write_<type>)`
+    #     methods to read and write respectively
+
+    module Curl
+      extend FFI::Library
+      require 'ruby-libstorj/ext/curl_code'
+
+      enum(:curl_code, CURL_CODES)
+    end
+
+    module Storj
+      extend FFI::Library
+
+      class BridgeOptions < FFI::Struct
+        layout :proto, :pointer,
+               :host, :pointer,
+               :port, :int,
+               :user, :pointer,
+               :pass, :pointer
+      end
+
+      class Bucket < FFI::Struct
+        layout :created, :string,
+               :name, :string,
+               :id, :string,
+               :decrypted, :bool
+      end
+
+      class File < FFI::Struct
+        layout :created, :string,
+               :filename, :string,
+               :mimetype, :string,
+               :erasure, :string,
+               :size, :uint64,
+               :hmac, :string,
+               :id, :string,
+               :decrypted, :bool,
+               :index, :string
+      end
+
+      class UploadState < FFI::Struct
+        layout :env, :pointer,
+               :shard_concurrency, :uint32,
+               :index, :string,
+               :file_name, :string,
+               :file_id, :string,
+               :encrypted_file_name, :string,
+               :original_file, :pointer, # FILE
+               :file_size, :uint64,
+               :bucket_id, :string,
+               :bucket_key, :string,
+               :completed_shards, :uint32,
+               :total_shards, :uint32,
+               :total_data_shards, :uint32,
+               :total_parity_shards, :uint32,
+               :shard_size, :uint64,
+               :total_bytes, :uint64,
+               :uploaded_bytes, :uint64,
+               :exclude, :string,
+               :frame_id, :string,
+               :hmac_id, :string,
+               :encryption_key, :uint8,
+               :encryption_ctr, :uint8,
+               :rs, :bool,
+               :awaiting_parity_shards, :bool,
+               :parity_file_path, :string,
+               :parity_file, :pointer, # FILE
+               :encrypted_file_path, :string,
+               :encrypted_file, :pointer, # FILE
+               :creating_encrypted_file, :bool,
+               :requesting_frame, :bool,
+               :completed_upload, :bool,
+               :creating_bucket_entry, :bool,
+               :received_all_pointers, :bool,
+               :final_callback_called, :bool,
+               :canceled, :bool,
+               :bucket_verified, :bool,
+               :file_verified, :bool,
+               :progress_finished, :bool,
+               :push_shard_limit, :int,
+               :push_frame_limit, :int,
+               :prepare_frame_limit, :int,
+               :frame_request_count, :int,
+               :add_bucket_entry_count, :int,
+               :bucket_verify_count, :int,
+               :file_verify_count, :int,
+               :create_encrypted_file_count, :int,
+               :progress_cb, :pointer, # storj_progress_cb
+               :finished_cb, :pointer, # storj_finished_upload_cb
+               :error_status, :int,
+               :log, :pointer, # storj_log_levels_t
+               :handle, :pointer,
+               :shard, :pointer, # shard_tracker_t
+               :pending_work_count, :int,
+               #NB: workaround; `libstorj` segfaults without this when calling `storj_bridge_store_file`
+               :fake_member, :pointer
+
+        def cancel
+          ::LibStorj::Ext::Storj::File.store_cancel self
+        end
+      end
+
+      class DownloadState < FFI::Struct
+        layout :total_bytes, :uint64,
+               :requesting_info, :bool,
+               :info_fail_count, :uint32,
+               :env, :pointer,
+               :file_id, :string,
+               :bucket_id, :string,
+               :destination, :pointer, # FILE
+               :progress_cb, :pointer, # storj_progress_cb
+               :finished_cb, :pointer, # storj_finished_download_cb
+               :finished, :bool,
+               :canceled, :bool,
+               :shard_size, :uint64,
+               :total_shards, :uint32,
+               :download_max_concurrency, :int,
+               :completed_shards, :uint32,
+               :resolving_shards, :uint32,
+               :pointers, :pointer, # storj_pointer_t
+               :excluded_farmer_ids, :string,
+               :total_pointers, :uint32,
+               :total_parity_pointers, :uint32,
+               :rs, :bool,
+               :recovering_shards, :bool,
+               :truncated, :bool,
+               :pointers_completed, :bool,
+               :pointer_fail_count, :uint32,
+               :requesting_pointers, :bool,
+               :error_status, :int,
+               :writing, :bool,
+               :decrypt_key, :uint8,
+               :decrypt_ctr, :uint8,
+               :hmac, :string,
+               :pending_work_count, :uint32,
+               :log, :pointer, # storj_log_levels_t
+               :handle, :pointer,
+               #NB: workaround; `libstorj` segfaults without this when calling `storj_bridge_resolve_file`
+               :fake_member, :pointer
+
+        def cancel
+          ::LibStorj::Ext::Storj::File.resolve_cancel self
+        end
+      end
+
+      class EncryptOptions < FFI::Struct
+        layout :mnemonic, :pointer
+      end
+
+      class HttpOptions < FFI::Struct
+        layout :user_agent, :pointer,
+               :proxy_url, :pointer,
+               :cainfo_path, :pointer,
+               :low_speed_limit, :long,
+               :low_speed_time, :long,
+               :timeout, :long
+      end
+
+      class LogOptions < FFI::Struct
+        layout :logger, :pointer,
+               :level, :int
+      end
+
+      class Env < FFI::Struct
+        layout :bridge_options, BridgeOptions.by_ref,
+               :encrypt_options, EncryptOptions.by_ref,
+               :http_options, HttpOptions.by_ref,
+               :log_options, LogOptions.by_ref,
+               :tmp_path, :pointer,
+               :loop, :pointer, # uv_loop_t*
+               :log, :pointer # storj_log_levels_t*
+      end
+    end
+
+    module UV
+      extend FFI::Library
+
+      enum :uv_work_req, [
+          :UV_UNKNOWN_REQ, 0,
+          :UV_REQ,
+          :UV_CONNECT,
+          :UV_WRITE,
+          :UV_SHUTDOWN,
+          :UV_UDP_SEND,
+          :UV_FS,
+          :UV_WORK,
+          :UV_GETADDRINFO,
+          :UV_GETNAMEINFO,
+          :UV_REQ_TYPE_PRIVATE,
+          :UV_REQ_TYPE_MAX
+      ]
+
+      class Work < FFI::Struct
+        layout :data, :pointer, # void*
+               # read-only
+               :type, :uv_work_req,
+               # private
+               :active_queue, :pointer,
+               :reserved, :pointer,
+               :loop, :pointer,
+               :work_cb, :pointer,
+               :after_work_cb, :pointer
+
+        # void* active_queue[2];
+        # void* reserved[4];
+        # ...
+        #   UV_WORK_PRIVATE_FIELDS
+        # };
+      end
+    end
+
+  end
+end