ruby-libstorj 0.0.0

data/ext/ruby-libstorj/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+REQUIRED_LIBS = %w[curl uv storj]
+
+REQUIRED_LIBS.each do |lib_name|
+  abort "missing C library: #{lib_name}" unless have_library(lib_name)
+end
+
+create_makefile('ruby-libstorj/ruby-libstorj')

data/ext/ruby-libstorj/ruby-libstorj.cc

@@ -0,0 +1,17 @@
+#include <string.h>
+#include <storj.h>
+
+using namespace std;
+
+extern "C"
+void Init_ruby_libstorj(void) {
+/*
+ *  Experiment here...
+ *
+ *      the goal of this implementation is to use ruby FFI
+ *      as much as possible for better compatibility/support
+ *      as well as more accessibility from the ruby side
+ */
+
+//    printf("C: hello from `Init_ruby_libstorj`!");
+}

data/lib/ruby-libstorj.rb

@@ -0,0 +1 @@
+require 'ruby-libstorj/libstorj'

data/lib/ruby-libstorj/arg_forwarding_task.rb

@@ -0,0 +1,58 @@
+# NB: ArgForwardingTask allows aliasing of rake tasks
+#     while also forwarding arguments. We're using it here to allow
+#     the tasks, "spec", and "test" work identically
+module LibStorj
+  require 'rake'
+
+  class ArgForwardingTask
+    include Rake::DSL
+
+    attr_reader :target_task
+    attr_reader :alias_tasks
+
+    def initialize(target_name, alias_names: [nil], args_deps_hash:, &block)
+      @alias_tasks = {}
+      @target_task = nil
+
+
+      if alias_names.nil? || alias_names.empty? || alias_names.reject {|t| !t}.empty?
+        unless block
+          throw ArgumentError.new 'either a block or at least one alias is required for `ArgFowardingTask.new`'
+        end
+
+        block_wrapper = Proc.new do |task, args|
+          deps = args_deps_hash.values.flatten
+          yield task, args, deps
+        end
+
+        # if no aliases, just register the target
+        #
+        #:call-seq:
+        #      ... v-- We're using this signature --v
+        #      Rake::Task.define_task task_name, arguments => dependencies
+        #(see https://github.com/ruby/rake/blob/68ef9140c11d083d8bb7ee5da5b0543e3a7df73d/lib/rake/dsl_definition.rb#L28)
+        @target_task = task(target_name, args_deps_hash, &block_wrapper)
+      else
+        if block_given?
+          block_wrapper = Proc.new do |task, args|
+            deps = args_deps_hash.values.flatten
+            yield task, args, deps
+          end
+
+          @target_task = task(target_name, args_deps_hash, &block_wrapper)
+        else
+          @target_task = task(target_name, args_deps_hash)
+        end
+        alias_names.flatten.each do |task_name|
+          @alias_tasks[task_name] = task(task_name, args_deps_hash) do |t, args|
+            @target_task.invoke(*args.to_a)
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      @target_task.method(name).call(*args, &block)
+    end
+  end
+end

data/lib/ruby-libstorj/env.rb

@@ -0,0 +1,178 @@
+module LibStorj
+  class Env
+    require 'libuv'
+    require 'json'
+    attr_reader :storj_env
+
+    C_ANALOGUE = ::LibStorj::Ext::Storj::Env
+
+    def initialize(*options)
+      @storj_env = ::LibStorj::Ext::Storj.method(:init_env).call(*options)
+      # use ruby libuv's default_loop
+      @storj_env[:loop] = ::Libuv::Ext.default_loop
+    end
+
+    def destroy
+      ::LibStorj::Ext::Storj.destroy_env @storj_env
+    end
+
+    def get_info(&block)
+      ruby_handle = ::LibStorj::Ext::Storj::JsonRequest.ruby_handle(&block)
+      after_work_cb = ::LibStorj::Ext::Storj::JsonRequest.after_work_cb do |error|
+        yield error if block_given?
+      end
+
+      # calls uv_queue_work
+      status = ::LibStorj::Ext::Storj.get_info @storj_env,
+                                      ruby_handle,
+                                      after_work_cb
+      reactor.run # calls uv_run
+      status
+    end
+
+    def delete_bucket(bucket_id, &block)
+      req_data_type = ::LibStorj::Ext::Storj::JsonRequest
+      after_work_cb = req_data_type.after_work_cb
+      ruby_handle = req_data_type.ruby_handle do |error|
+        yield error if block_given?
+      end
+
+      # calls uv_queue_work
+      status = ::LibStorj::Ext::Storj::Bucket.delete @storj_env,
+                                              bucket_id,
+                                              ruby_handle,
+                                              after_work_cb
+      reactor.run # calls uv_run
+      status
+    end
+
+    def get_buckets(&block)
+      req_data_type = ::LibStorj::Ext::Storj::GetBucketRequest
+      after_work_cb = req_data_type.after_work_cb
+      ruby_handle = req_data_type.ruby_handle(&block)
+
+      # calls uv_queue_work
+      status = ::LibStorj::Ext::Storj::Bucket.all @storj_env,
+                                           ruby_handle,
+                                           after_work_cb
+      reactor.run # calls uv_run
+      status
+    end
+
+    def create_bucket(name, &block)
+      req_data_type = ::LibStorj::Ext::Storj::CreateBucketRequest
+      after_work_cb = req_data_type.after_work_cb
+      ruby_handle = req_data_type.ruby_handle(&block)
+
+      # calls uv_queue_work
+      status = ::LibStorj::Ext::Storj::Bucket.create @storj_env,
+                                              name,
+                                              ruby_handle,
+                                              after_work_cb
+      reactor.run # calls uv_run
+      status
+    end
+
+    def list_files(bucket_id, &block)
+      req_data_type = ::LibStorj::Ext::Storj::ListFilesRequest
+      after_work_cb = req_data_type.after_work_cb
+      ruby_handle = req_data_type.ruby_handle(&block)
+
+      status = ::LibStorj::Ext::Storj::File.all @storj_env,
+                                         bucket_id,
+                                         ruby_handle,
+                                         after_work_cb
+      reactor.run # calls uv_run
+      status
+    end
+
+    def delete_file(bucket_id, file_id, &block)
+      req_data_type = ::LibStorj::Ext::Storj::JsonRequest
+      after_work_cb = req_data_type.after_work_cb
+      ruby_handle = req_data_type.ruby_handle(&block)
+
+      # calls uv_queue_work
+      status = ::LibStorj::Ext::Storj::File.delete @storj_env,
+                                            bucket_id,
+                                            file_id,
+                                            ruby_handle,
+                                            after_work_cb
+      reactor.run # calls uv_run
+      status
+    end
+
+    def resolve_file(bucket_id:,
+                     file_id:,
+                     file_path:,
+                     progress_proc: nil,
+                     finished_proc: nil,
+                     &block)
+      file_descriptor = ::LibStorj::Ext::LibC.fopen(file_path, 'w+')
+      progress_cb = FFI::Function.new :void, %i[double uint64 uint64 pointer] do
+      |progress, downloaded_bytes, total_bytes, handle|
+        progress_proc.call progress, downloaded_bytes, total_bytes if progress_proc
+      end
+
+      # TODO: decide precedence
+      finished_proc = finished_proc || block
+      finished_cb = FFI::Function.new :void, %i[int pointer pointer] do |status, file_id, handle|
+        # do error handling based on status
+        ::LibStorj::Ext::LibC.fclose(file_descriptor)
+        finished_proc.call file_id
+      end
+
+      # ruby_handle = FFI::MemoryPointer::NULL
+      ruby_handle = FFI::Function.new :void, [] do
+      end
+
+      # calls uv_queue_work
+      state = ::LibStorj::Ext::Storj::File.resolve @storj_env,
+                                                            bucket_id,
+                                                            file_id,
+                                                            file_descriptor,
+                                                            ruby_handle,
+                                                            progress_cb,
+                                                            finished_cb
+      reactor.run # calls uv_run
+      state
+    end
+
+    def store_file(bucket_id:,
+                   file_path:,
+                   progress_proc: nil,
+                   finished_proc: nil,
+                   options: {},
+                   &block)
+      default_options = {
+          bucket_id: bucket_id,
+          file_path: file_path,
+      }
+
+      options = options.merge(default_options) {|key, oldval| oldval}
+      upload_options =
+          ::LibStorj::Ext::Storj::UploadOptions.new options
+
+      progress_cb = FFI::Function.new :void, %i[double uint64 uint64 pointer] do
+      |progress, bytes, total_bytes|
+        progress_proc.call progress, bytes, total_bytes if progress_proc
+      end
+
+      #TODO: decide precedence
+      finished_proc = finished_proc || block
+      finished_cb = FFI::Function.new :void, %i[int string pointer] do
+      |status, file_id, handle|
+        # do error handling based on status
+        finished_proc.call file_id
+      end
+
+      # calls uv_queue_work
+      state = ::LibStorj::Ext::Storj::File.store @storj_env,
+                                                 upload_options,
+                                                 FFI::MemoryPointer::NULL,
+                                                 progress_cb,
+                                                 finished_cb
+      reactor.run #calls uv_run
+      state
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module LibStorj
+  module Ext
+    module Storj
+      class Bucket < FFI::Struct
+        extend FFI::Library
+        ffi_lib('storj')
+
+        attr_reader :name, :id
+
+        def initialize(*args)
+          super(*args)
+
+          @name = self[:name]
+          @id = self[:id]
+        end
+
+        def self.all(*args)
+          _all(*args)
+        end
+
+        def self.create(*args)
+          _create(*args)
+        end
+
+        def self.delete(*args)
+          _delete(*args)
+        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|
+            Bucket.new pointer[i * size]
+          end
+        end
+
+        attach_function('_all', 'storj_bridge_get_buckets', [
+            Env.by_ref,
+            ::LibStorj::Ext::Storj::JsonRequest::CALLBACK,
+            :pointer # uv_after_work_cb*
+        # ::LibStorj::UV::
+        ], :int)
+
+        private :_all
+
+        attach_function('_create', 'storj_bridge_create_bucket', [
+            Env.by_ref,
+            :string,
+            ::LibStorj::Ext::Storj::JsonRequest::CALLBACK,
+            :pointer # uv_after_work_cb*
+        # ::LibStorj::UV::
+        ], :int)
+
+        private :_create
+
+        attach_function('_delete', 'storj_bridge_delete_bucket', [
+            Env.by_ref,
+            :string,
+            ::LibStorj::Ext::Storj::JsonRequest::CALLBACK,
+            :pointer # uv_after_work_cb*
+        # ::LibStorj::UV::
+        ], :int)
+
+        private :_delete
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module LibStorj
+  module Ext
+    module Storj
+      class CreateBucketRequest < FFI::Struct
+        layout :http_options, HttpOptions.by_ref,
+               :encrypt_options, EncryptOptions.by_ref,
+               :bridge_options, BridgeOptions.by_ref,
+               :bucket_name, :string,
+               :encrypted_bucket_name, :string,
+               :response, :pointer, # struct json_object *response;
+               :bucket, Bucket.by_ref,
+               :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 = 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]
+
+            next c_handle.call(error, ::FFI::MemoryPointer::NULL) unless error.empty?
+
+            status_code, bucket = req.values_at %i[status_code bucket]
+            if ((status_code > 299) || bucket.id.nil?) && error.empty?
+              response_error = JSON.parse(response)['error']
+              error = response_error
+              next c_handle.call(error, ::FFI::MemoryPointer::NULL)
+            end
+
+            bucket_pointer = req[:bucket]
+            c_handle.call nil, bucket_pointer
+          end
+        end
+
+        def self.ruby_handle(&block)
+          FFI::Function.new :void, %i[string pointer] do |error, bucket_pointer|
+            bucket = if bucket_pointer.null?
+                       nil
+                     else
+                       ::LibStorj::Ext::Storj::Bucket.new(bucket_pointer)
+                     end
+
+            yield error, bucket if block_given?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+module LibStorj
+  module Ext
+    module Curl
+      CURL_CODES = [
+        #   /* All possible error codes from all sorts of curl functions. Future versions
+        #    may return other values, stay prepared.
+        #
+        #    Always add new return codes last. Never *EVER* remove any. The return
+        #    codes must remain the same!
+        #  */
+        #
+        :CURLE_OK, 0,
+        :CURLE_UNSUPPORTED_PROTOCOL,    #/* 1 */
+        :CURLE_FAILED_INIT,             #/* 2 */
+        :CURLE_URL_MALFORMAT,           #/* 3 */
+        :CURLE_NOT_BUILT_IN,            #/* 4 - [was obsoleted in August 2007 for
+                                       #       7.17.0, reused in April 2011 for 7.21.5] */
+        :CURLE_COULDNT_RESOLVE_PROXY,   #/* 5 */
+        :CURLE_COULDNT_RESOLVE_HOST,    #/* 6 */
+        :CURLE_COULDNT_CONNECT,         #/* 7 */
+        :CURLE_WEIRD_SERVER_REPLY,      #/* 8 */
+        :CURLE_REMOTE_ACCESS_DENIED,    #/* 9 a service was denied by the server
+                                       #     due to lack of access - when login fails
+                                       #     this is not returned. */
+        :CURLE_FTP_ACCEPT_FAILED,       #/* 10 - [was obsoleted in April 2006 for
+                                       #        7.15.4, reused in Dec 2011 for 7.24.0]*/
+        :CURLE_FTP_WEIRD_PASS_REPLY,    #/* 11 */
+        :CURLE_FTP_ACCEPT_TIMEOUT,      #/* 12 - timeout occurred accepting server
+                                       #        [was obsoleted in August 2007 for 7.17.0,
+                                       #        reused in Dec 2011 for 7.24.0]*/
+        :CURLE_FTP_WEIRD_PASV_REPLY,    #/* 13 */
+        :CURLE_FTP_WEIRD_227_FORMAT,    #/* 14 */
+        :CURLE_FTP_CANT_GET_HOST,       #/* 15 */
+        :CURLE_HTTP2,                   #/* 16 - A problem in the http2 framing layer.
+                                       #        [was obsoleted in August 2007 for 7.17.0,
+                                       #        reused in July 2014 for 7.38.0] */
+        :CURLE_FTP_COULDNT_SET_TYPE,    #/* 17 */
+        :CURLE_PARTIAL_FILE,            #/* 18 */
+        :CURLE_FTP_COULDNT_RETR_FILE,   #/* 19 */
+        :CURLE_OBSOLETE20,              #/* 20 - NOT USED */
+        :CURLE_QUOTE_ERROR,             #/* 21 - quote command failure */
+        :CURLE_HTTP_RETURNED_ERROR,     #/* 22 */
+        :CURLE_WRITE_ERROR,             #/* 23 */
+        :CURLE_OBSOLETE24,              #/* 24 - NOT USED */
+        :CURLE_UPLOAD_FAILED,           #/* 25 - failed upload "command" */
+        :CURLE_READ_ERROR,              #/* 26 - couldn't open/read from file */
+        :CURLE_OUT_OF_MEMORY,           #/* 27 */
+        # /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error
+        # instead of a memory allocation error if CURL_DOES_CONVERSIONS
+        # is defined
+        # */
+        :CURLE_OPERATION_TIMEDOUT,      #/* 28 - the timeout time was reached */
+        :CURLE_OBSOLETE29,              #/* 29 - NOT USED */
+        :CURLE_FTP_PORT_FAILED,         #/* 30 - FTP PORT operation failed */
+        :CURLE_FTP_COULDNT_USE_REST,    #/* 31 - the REST command failed */
+        :CURLE_OBSOLETE32,              #/* 32 - NOT USED */
+        :CURLE_RANGE_ERROR,             #/* 33 - RANGE "command" didn't work */
+        :CURLE_HTTP_POST_ERROR,         #/* 34 */
+        :CURLE_SSL_CONNECT_ERROR,       #/* 35 - wrong when connecting with SSL */
+        :CURLE_BAD_DOWNLOAD_RESUME,     #/* 36 - couldn't resume download */
+        :CURLE_FILE_COULDNT_READ_FILE,  #/* 37 */
+        :CURLE_LDAP_CANNOT_BIND,        #/* 38 */
+        :CURLE_LDAP_SEARCH_FAILED,      #/* 39 */
+        :CURLE_OBSOLETE40,              #/* 40 - NOT USED */
+        :CURLE_FUNCTION_NOT_FOUND,      #/* 41 */
+        :CURLE_ABORTED_BY_CALLBACK,     #/* 42 */
+        :CURLE_BAD_FUNCTION_ARGUMENT,   #/* 43 */
+        :CURLE_OBSOLETE44,              #/* 44 - NOT USED */
+        :CURLE_INTERFACE_FAILED,        #/* 45 - CURLOPT_INTERFACE failed */
+        :CURLE_OBSOLETE46,              #/* 46 - NOT USED */
+        :CURLE_TOO_MANY_REDIRECTS,      #/* 47 - catch endless re-direct loops */
+        :CURLE_UNKNOWN_OPTION,          #/* 48 - User specified an unknown option */
+        :CURLE_TELNET_OPTION_SYNTAX,    #/* 49 - Malformed telnet option */
+        :CURLE_OBSOLETE50,              #/* 50 - NOT USED */
+        :CURLE_PEER_FAILED_VERIFICATION,# /* 51 - peer's certificate or fingerprint
+                                       #         wasn't verified fine */
+        :CURLE_GOT_NOTHING,             #/* 52 - when this is a specific error */
+        :CURLE_SSL_ENGINE_NOTFOUND,     #/* 53 - SSL crypto engine not found */
+        :CURLE_SSL_ENGINE_SETFAILED,    #/* 54 - can not set SSL crypto engine as
+                                       #        default */
+        :CURLE_SEND_ERROR,              #/* 55 - failed sending network data */
+        :CURLE_RECV_ERROR,              #/* 56 - failure in receiving network data */
+        :CURLE_OBSOLETE57,              #/* 57 - NOT IN USE */
+        :CURLE_SSL_CERTPROBLEM,         #/* 58 - problem with the local certificate */
+        :CURLE_SSL_CIPHER,              #/* 59 - couldn't use specified cipher */
+        :CURLE_SSL_CACERT,              #/* 60 - problem with the CA cert (path?) */
+        :CURLE_BAD_CONTENT_ENCODING,    #/* 61 - Unrecognized/bad encoding */
+        :CURLE_LDAP_INVALID_URL,        #/* 62 - Invalid LDAP URL */
+        :CURLE_FILESIZE_EXCEEDED,       #/* 63 - Maximum file size exceeded */
+        :CURLE_USE_SSL_FAILED,          #/* 64 - Requested FTP SSL level failed */
+        :CURLE_SEND_FAIL_REWIND,        #/* 65 - Sending the data requires a rewind
+                                       #        that failed */
+        :CURLE_SSL_ENGINE_INITFAILED,   #/* 66 - failed to initialise ENGINE */
+        :CURLE_LOGIN_DENIED,            #/* 67 - user, password or similar was not
+                                       #        accepted and we failed to login */
+        :CURLE_TFTP_NOTFOUND,           #/* 68 - file not found on server */
+        :CURLE_TFTP_PERM,               #/* 69 - permission problem on server */
+        :CURLE_REMOTE_DISK_FULL,        #/* 70 - out of disk space on server */
+        :CURLE_TFTP_ILLEGAL,            #/* 71 - Illegal TFTP operation */
+        :CURLE_TFTP_UNKNOWNID,          #/* 72 - Unknown transfer ID */
+        :CURLE_REMOTE_FILE_EXISTS,      #/* 73 - File already exists */
+        :CURLE_TFTP_NOSUCHUSER,         #/* 74 - No such user */
+        :CURLE_CONV_FAILED,             #/* 75 - conversion failed */
+        :CURLE_CONV_REQD,               #/* 76 - caller must register conversion
+                                       #        callbacks using curl_easy_setopt options
+                                       #        CURLOPT_CONV_FROM_NETWORK_FUNCTION,
+                                       #        CURLOPT_CONV_TO_NETWORK_FUNCTION, and
+                                       #        CURLOPT_CONV_FROM_UTF8_FUNCTION */
+        :CURLE_SSL_CACERT_BADFILE,      #/* 77 - could not load CACERT file, missing
+                                       #        or wrong format */
+        :CURLE_REMOTE_FILE_NOT_FOUND,   #/* 78 - remote file not found */
+        :CURLE_SSH,                     #/* 79 - error from the SSH layer, somewhat
+                                       #        generic so the error message will be of
+                                       #        interest when this has happened */
+        :CURLE_SSL_SHUTDOWN_FAILED,     #/* 80 - Failed to shut down the SSL
+                                       #        connection */
+        :CURLE_AGAIN,                   #/* 81 - socket is not ready for send/recv,
+                                       #        wait till it's ready and try again (Added
+                                       #        in 7.18.2) */
+        :CURLE_SSL_CRL_BADFILE,         #/* 82 - could not load CRL file, missing or
+                                       #            wrong format (Added in 7.19.0) */
+        :CURLE_SSL_ISSUER_ERROR,        #/* 83 - Issuer check failed.  (Added in
+                                       #        7.19.0) */
+        :CURLE_FTP_PRET_FAILED,         #/* 84 - a PRET command failed */
+        :CURLE_RTSP_CSEQ_ERROR,         #/* 85 - mismatch of RTSP CSeq numbers */
+        :CURLE_RTSP_SESSION_ERROR,      #/* 86 - mismatch of RTSP Session Ids */
+        :CURLE_FTP_BAD_FILE_LIST,       #/* 87 - unable to parse FTP file list */
+        :CURLE_CHUNK_FAILED,            #/* 88 - chunk callback reported error */
+        :CURLE_NO_CONNECTION_AVAILABLE, #/* 89 - No connection available, the
+                                       #        session will be queued */
+        :CURLE_SSL_PINNEDPUBKEYNOTMATCH,#/* 90 - specified pinned public key did not
+                                       #        match */
+        :CURLE_SSL_INVALIDCERTSTATUS,   #/* 91 - invalid certificate status */
+        :CURLE_HTTP2_STREAM,            #/* 92 - stream error in HTTP/2 framing layer */
+        :CURL_LAST                      #/* never use! */
+      ]
+    end
+  end
+end