rmega 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53ab6c3f8d9135aac13fa5d8556a530d33f0076c
-  data.tar.gz: e8df74fafe4202607824754b35ffed9558638ef3
+  metadata.gz: 461e31696b324da1fdd11d8164b9284f9d0ead32
+  data.tar.gz: 6edaa46bdd45cee1447af2bd569bdd812fddb207
 SHA512:
-  metadata.gz: 7ca62565f0f2207053354845a74e03bc58ce6612e231b9a70b65d218a25ec79342f709c9513a37f647bcfc61fdb2e1a45b18a42688ff84638e326029af826d49
-  data.tar.gz: c9082a0e4792a461ef87941969a047413a0593a003ae46338ddfc23a2ac08362fae04f492dd8c217049ed08851040ceea7e08f0cd14422a8131a4435569c2e46
+  metadata.gz: 7c38cbd4d4510fa270bf269f57fe3d6fef4730ed421065ffee8d0762ecbd8d47acd2a84311f699193635b7cb6a1bc31c5519778cd1c2f4ac3c9779035ebfe2dd
+  data.tar.gz: 1d731406b6c5096f9cb12240ce3af9016b2fd5d728e2594af69156d559c557f7581b0d6c08b566b6a4a98c206bba6dbcd3c1fb40b4c6fcd7c7cd8ddd39a9fd1e

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+## 0.1.6
+
+### New Features
+
+* \#7 Rmega now supports shared folders and files.
+
+* The method `Storage#folders` can now be used to get a list of your
+  first-level folders + first-level shared folders.
+
+* The error codes list is now updated (up to the number -22).
+
+
+### Changes
+
+* Rmega will now attempt a request up to 10 times (in case of SocketError
+  or if the server is temporary busy) before raising the error.
+
+* Fixed a race condition that cause corrupted downloads

data/README.md

@@ -5,17 +5,6 @@ Requirements: Ruby 1.9.3+ and OpenSSL 0.9.8r+
 
 
 This is the result of a reverse engineering of the MEGA javascript code.  
-Work in progress, further functionality are coming.
-
-
-Supported features are:
-  * Login
-  * Searching and browsing
-  * Creating folders
-  * Download of files and folders (multi-thread)
-  * Download with public links (multi-thread)
-  * Upload of files (multi-thread)
-  * Deleting and trashing
 
 
 ## Installation

data/TODO.md

@@ -1,7 +1,7 @@
-## Rmega todos
+## TODO
 
   * Handle timeouts in download/upload
   * Handle error code -3 response, that is "A temporary congestion or server malfunction prevented your request from being processed.". I noticed that this occurs quite often when creating/deleting a folder node :/
   * Sometimes uploaded data is corrupted
   * Search for TODO in the project for other minor tasks
-  * Resist the hypnotoad's will
+  * Refactor the pool class

data/lib/rmega/crypto/aes_ctr.rb

@@ -10,6 +10,8 @@ module Rmega
         raise "invalid nonce" if nonce.size != 4 or !nonce.respond_to?(:pack)
         raise "invalid key" if key.size != 4 or !key.respond_to?(:pack)
 
+        nonce = nonce.dup
+
         mac = [nonce[0], nonce[1], nonce[0], nonce[1]]
         enc = nil
         a32 = Utils.str_to_a32 data

data/lib/rmega/crypto/crypto.rb

@@ -25,12 +25,9 @@ module Rmega
       pkey
     end
 
-    def decrypt_sid(key, csid, privk)
-      # if csid ...
-      t = Utils.mpi2b Utils.base64urldecode(csid)
+    def decrypt_rsa_privk(key, privk)
       privk = Utils.a32_to_str decrypt_key(key, Utils.base64_to_a32(privk))
       rsa_privk = Array.new 4
-      # else if tsid (todo)
 
       # Decompose private key
       4.times do |i|
@@ -39,6 +36,13 @@ module Rmega
         privk = privk[l..-1]
       end
 
+      rsa_privk
+    end
+
+    def decrypt_sid(rsa_privk, csid)
+      # if csid ...
+      t = Utils.mpi2b Utils.base64urldecode(csid)
+
       # TODO - remove execjs and build the key using the ruby lib
       # rsa_key = Crypto::Rsa.build_rsa_key rsa_privk
       decrypted_t = Rsa.decrypt t, rsa_privk

data/lib/rmega/errors.rb

@@ -0,0 +1,55 @@
+module Rmega
+  module Errors
+
+    # Check out the error codes list at https://mega.co.nz/#doc (section 11)
+    CODES = {
+      -1  => 'An internal error has occurred. Please submit a bug report, detailing the exact circumstances in which this error occurred.',
+      -2  => 'You have passed invalid arguments to this command.',
+      -3  => 'A temporary congestion or server malfunction prevented your request from being processed. No data was altered. Retry. Retries must be spaced with exponential backoff.',
+      -4  => 'You have exceeded your command weight per time quota. Please wait a few seconds, then try again (this should never happen in sane real-life applications).',
+      -5  => 'The upload failed. Please restart it from scratch.',
+      -6  => 'Too many concurrent IP addresses are accessing this upload target URL.',
+      -7  => 'The upload file packet is out of range or not starting and ending on a chunk boundary.',
+      -8  => 'The upload target URL you are trying to access has expired. Please request a fresh one.',
+      -9  => 'Object (typically, node or user) not found',
+      -10 => 'Circular linkage attempted',
+      -11 => 'Access violation (e.g., trying to write to a read-only share)',
+      -12 => 'Trying to create an object that already exists',
+      -13 => 'Trying to access an incomplete resource',
+      -14 => 'A decryption operation failed (never returned by the API)',
+      -15 => 'Invalid or expired user session, please relogin',
+      -16 => 'User blocked',
+      -17 => 'Request over quota',
+      -18 => 'Resource temporarily not available, please try again later',
+      -19 => 'Too many connections on this resource',
+      -20 => 'Write failed',
+      -21 => 'Read failed',
+      -22 => 'Invalid application key; request not processed',
+    }.freeze
+
+    class ServerError < StandardError
+      attr_reader :code, :message
+      attr_accessor :temporary
+
+      def initialize(value, opts = {})
+        if msg = Errors::CODES[value.to_i]
+          @code = value.to_i
+          @message = msg || "Error code #{@code}"
+        else
+          @message = value
+        end
+
+        self.temporary = opts[:temporary] || false
+
+        super(@message)
+      end
+
+      def temporary?
+        self.temporary || [-3, -18, -6].include?(@code)
+      end
+    end
+  end
+
+  # Backward compatibility
+  RequestError = Errors::ServerError
+end

data/lib/rmega/loggable.rb

@@ -1,18 +1,26 @@
 require 'logger'
+require 'active_support/concern'
 
 module Rmega
+  def self.logger
+    @logger ||= begin
+      logger = Logger.new($stdout)
+      logger.level = Logger::ERROR
+      logger
+    end
+  end
+
   module Loggable
+    extend ActiveSupport::Concern
+
     def logger
-      @@logger ||= begin
-        Logger.new($stdout).tap do |l|
-          l.formatter = Proc.new { | severity, time, progname, msg| "#{msg}\n" }
-          l.level = Logger::ERROR
-        end
-      end
+      Rmega.logger
     end
 
-    def self.included(base)
-      base.send(:extend, self)
+    module ClassMethods
+      def logger
+        Rmega.logger
+      end
     end
   end
 end

data/lib/rmega/nodes/downloadable.rb

@@ -0,0 +1,71 @@
+require 'rmega/pool'
+require 'rmega/utils'
+
+module Rmega
+  module Nodes
+    module Downloadable
+
+      # Creates the local file allocating filesize-n bytes (of /dev/zero) for it.
+      # Opens the local file to start writing from the beginning of it.
+      def allocate(path)
+        `dd if=/dev/zero of="#{path}" bs=1 count=0 seek=#{filesize} > /dev/null 2>&1`
+        raise "Unable to create file #{path}" if ::File.size(path) != filesize
+
+        ::File.open(path, 'r+b').tap { |f| f.rewind }
+      end
+
+      # Downloads a part of the remote file, starting from the start-n byte
+      # and ending after size-n bytes.
+      def download_chunk(start, size)
+        stop = start + size - 1
+        url = "#{storage_url}/#{start}-#{stop}"
+        HTTPClient.new.get_content(url)
+      end
+
+      # Writes a buffer in the local file, starting from the start-n byte.
+      def write_chunk(file, start, buffer)
+        file.seek(start)
+        file.write(buffer)
+      end
+
+      def decrypt_chunk(start, encrypted_buffer)
+        k = decrypted_file_key
+        nonce = [k[4], k[5], (start/0x1000000000) >> 0, (start/0x10) >> 0]
+        decrypt_key = [k[0] ^ k[4], k[1] ^ k[5], k[2] ^ k[6], k[3] ^ k[7]]
+        Crypto::AesCtr.decrypt(decrypt_key, nonce, encrypted_buffer)[:data]
+      end
+
+      def download(path)
+        path = ::File.expand_path(path)
+        path = Dir.exists?(path) ? ::File.join(path, name) : path
+
+        logger.info "Download #{name} (#{filesize} bytes) => #{path}"
+
+        pool = Pool.new
+        write_mutex = Mutex.new
+        file = allocate(path)
+
+        progress = Progress.new(total: filesize, caption: 'Download')
+
+        Utils.chunks(filesize).each do |start, size|
+          pool.defer do
+            encrypted_buffer = download_chunk(start, size)
+
+            write_mutex.synchronize do
+              clean_buffer = decrypt_chunk(start, encrypted_buffer)
+              progress.increment(size)
+              write_chunk(file, start, clean_buffer)
+            end
+          end
+        end
+
+        # waits for the last running threads to finish
+        pool.wait_done
+
+        file.flush
+      ensure
+        file.close rescue nil
+      end
+    end
+  end
+end

data/lib/rmega/nodes/expandable.rb

@@ -1,10 +1,12 @@
 require 'rmega/utils'
-require 'rmega/uploader'
+require 'rmega/nodes/uploadable'
 require 'rmega/crypto/crypto'
 
 module Rmega
   module Nodes
     module Expandable
+      include Uploadable
+
       def create_folder(name)
         key = Crypto.random_key
         encrypted_attributes = Utils.a32_to_base64 Crypto.encrypt_attributes(key[0..3], {n: name.strip})
@@ -17,48 +19,6 @@ module Rmega
       def upload_url(filesize)
         session.request(a: 'u', s: filesize)['p']
       end
-
-      def upload(local_path)
-        local_path = ::File.expand_path(local_path)
-        filesize = ::File.size(local_path)
-
-        ul_key = Crypto.random_key
-        aes_key = ul_key[0..3]
-        nonce = ul_key[4..5]
-
-        file_mac = [0, 0, 0, 0]
-
-        uploader = Uploader.new(filesize: filesize, base_url: upload_url(filesize), local_path: local_path)
-
-        uploader.upload do |start, clean_buffer|
-          # TODO: should be (chunk_start/0x1000000000) >>> 0, (chunk_start/0x10) >>> 0
-          nonce = [nonce[0], nonce[1], (start/0x1000000000) >> 0, (start/0x10) >> 0]
-
-          encrypted = Crypto::AesCtr.encrypt(aes_key, nonce, clean_buffer)
-          chunk_mac = encrypted[:mac]
-
-          file_mac = [file_mac[0] ^ chunk_mac[0], file_mac[1] ^ chunk_mac[1],
-                      file_mac[2] ^ chunk_mac[2], file_mac[3] ^ chunk_mac[3]]
-          file_mac = Crypto::Aes.encrypt(ul_key[0..3], file_mac)
-
-          encrypted[:data]
-        end
-
-        file_handle = uploader.last_result
-
-        attribs = {n: ::File.basename(local_path)}
-        encrypt_attribs = Utils.a32_to_base64 Crypto.encrypt_attributes(ul_key[0..3], attribs)
-
-        meta_mac = [file_mac[0] ^ file_mac[1], file_mac[2] ^ file_mac[3]]
-
-        key = [ul_key[0] ^ ul_key[4], ul_key[1] ^ ul_key[5], ul_key[2] ^ meta_mac[0],
-               ul_key[3] ^ meta_mac[1], ul_key[4], ul_key[5], meta_mac[0], meta_mac[1]]
-
-        encrypted_key = Utils.a32_to_base64 Crypto.encrypt_key(session.master_key, key)
-        session.request a: 'p', t: handle, n: [{h: file_handle, t: 0, a: encrypt_attribs, k: encrypted_key}]
-
-        attribs[:n]
-      end
     end
   end
 end

data/lib/rmega/nodes/file.rb

@@ -1,11 +1,12 @@
-require 'rmega/downloader'
 require 'rmega/nodes/node'
 require 'rmega/nodes/deletable'
+require 'rmega/nodes/downloadable'
 
 module Rmega
   module Nodes
     class File < Node
       include Deletable
+      include Downloadable
 
       def storage_url
         @storage_url ||= data['g'] || request(a: 'g', g: 1, n: handle)['g']
@@ -15,24 +16,8 @@ module Rmega
         data['s']
       end
 
-      def download(path)
-        path = ::File.expand_path(path)
-        path = Dir.exists?(path) ? ::File.join(path, name) : path
-
-        logger.info "Download #{name} (#{size} bytes) => #{path}"
-
-        k = decrypted_file_key
-        k = [k[0] ^ k[4], k[1] ^ k[5], k[2] ^ k[6], k[3] ^ k[7]]
-        nonce = decrypted_file_key[4..5]
-
-        donwloader = Downloader.new(base_url: storage_url, filesize: size, local_path: path)
-
-        donwloader.download do |start, buffer|
-          nonce = [nonce[0], nonce[1], (start/0x1000000000) >> 0, (start/0x10) >> 0]
-          Crypto::AesCtr.decrypt(k, nonce, buffer)[:data]
-        end
-
-        path
+      def filesize
+        size
       end
     end
   end

data/lib/rmega/nodes/node.rb

@@ -11,7 +11,7 @@ module Rmega
 
       attr_reader :data, :session
 
-      delegate :storage, :request, :to => :session
+      delegate :storage, :request, :shared_keys, :rsa_privk, :to => :session
 
       def initialize(session, data)
         @session = session
@@ -20,7 +20,7 @@ module Rmega
 
       def public_url
         @public_url ||= begin
-          b64_dec_key = Utils.a32_to_base64 decrypted_file_key[0..7]
+          b64_dec_key = Utils.a32_to_base64(decrypted_file_key[0..7])
           "https://mega.co.nz/#!#{public_handle}!#{b64_dec_key}"
         end
       end
@@ -41,35 +41,65 @@ module Rmega
         data['p']
       end
 
-      def owner_key
-        data['k'].split(':').first
+      def name
+        attributes['n'] if attributes
       end
 
-      def name
-        return attributes['n'] if attributes
+      def file_keys
+        return {} unless data['k']
+
+        pairs = data['k'].split('/')
+        pairs.inject({}) do |hash, pair|
+          h, k = pair.split(':')
+          hash[h] = k
+          hash
+        end
       end
 
       def file_key
-        data['k'].split(':').last
+        file_keys.values.first
       end
 
-      def decrypted_file_key
-        if data['k']
-          Crypto.decrypt_key session.master_key, Utils.base64_to_a32(file_key)
+      def shared_root?
+        data['su'] && data['sk'] && data['k']
+      end
+
+      def process_shared_key
+        h = (shared_keys.keys & file_keys.keys).first
+        return [h, shared_keys[h]] if h
+
+        sk = data['sk']
+
+        return unless sk
+
+        shared_key = if sk.size > 22
+          sk = Rmega::Utils.mpi2b(Rmega::Utils.base64urldecode(sk))
+          dec_sk = Rmega::Crypto::Rsa.decrypt(sk, rsa_privk)
+          Utils.str_to_a32(Rmega::Utils.b2s(dec_sk)[0..15])
         else
-          Utils.base64_to_a32 public_url.split('!').last
+          Crypto.decrypt_key session.master_key, Utils.base64_to_a32(data['sk'])
         end
+
+        shared_keys[handle] = shared_key
+        [handle, shared_key]
       end
 
-      def can_decrypt_attributes?
-        !data['u'] or data['u'] == owner_key
+      def decrypted_file_key
+        h, shared_key = *process_shared_key
+
+        if shared_key
+          Crypto.decrypt_key(shared_key, Utils.base64_to_a32(file_keys[h]))
+        elsif file_key
+          Crypto.decrypt_key(session.master_key, Utils.base64_to_a32(file_key))
+        else
+          Utils.base64_to_a32(public_url.split('!').last)
+        end
       end
 
       def attributes
-        @attributes ||= begin
-          return nil unless can_decrypt_attributes?
-          Crypto.decrypt_attributes decrypted_file_key, (data['a'] || data['at'])
-        end
+        encrypted = data['a'] || data['at']
+        return if !encrypted or encrypted.empty?
+        Crypto.decrypt_attributes(decrypted_file_key, encrypted)
       end
 
       def type

data/lib/rmega/nodes/uploadable.rb

@@ -0,0 +1,83 @@
+require 'rmega/utils'
+require 'rmega/pool'
+require 'rmega/progress'
+
+module Rmega
+  module Nodes
+    module Uploadable
+      def upload_chunk(base_url, start, buffer)
+        size = buffer.length
+        stop = start + size - 1
+        url = "#{base_url}/#{start}-#{stop}"
+
+        HTTPClient.new.post(url, buffer).body
+      end
+
+      def read_chunk(file, start, size)
+        file.seek(start)
+        file.read(size)
+      end
+
+      def encrypt_chunck(rnd_key, file_mac, start, clean_buffer)
+        nonce = [rnd_key[4], rnd_key[5], (start/0x1000000000) >> 0, (start/0x10) >> 0]
+
+        encrypted = Crypto::AesCtr.encrypt(rnd_key[0..3], nonce, clean_buffer)
+        chunk_mac, data = encrypted[:mac], encrypted[:data]
+
+        file_mac = [file_mac[0] ^ chunk_mac[0], file_mac[1] ^ chunk_mac[1],
+                    file_mac[2] ^ chunk_mac[2], file_mac[3] ^ chunk_mac[3]]
+
+        file_mac = Crypto::Aes.encrypt(rnd_key[0..3], file_mac)
+
+        data
+      end
+
+      def upload(path)
+        path = ::File.expand_path(path)
+        filesize = ::File.size(path)
+        file = ::File.open(path, 'rb')
+
+        ul_key = Crypto.random_key
+        file_mac = [0, 0, 0, 0]
+        file_handle = nil
+        base_url = upload_url(filesize)
+
+        pool = Pool.new
+        read_mutex = Mutex.new
+
+        progress = Progress.new(total: filesize, caption: 'Upload')
+
+        Utils.chunks(filesize).each do |start, size|
+          pool.defer do
+            encrypted_buffer = nil
+
+            read_mutex.synchronize do
+              clean_buffer = read_chunk(file, start, size)
+              encrypted_buffer = encrypt_chunck(ul_key, file_mac, start, clean_buffer)
+            end
+
+            file_handle = upload_chunk(base_url, start, encrypted_buffer)
+            progress.increment(size)
+          end
+        end
+
+        pool.wait_done
+
+        attribs = {n: ::File.basename(path)}
+        encrypt_attribs = Utils.a32_to_base64(Crypto.encrypt_attributes(ul_key[0..3], attribs))
+
+        meta_mac = [file_mac[0] ^ file_mac[1], file_mac[2] ^ file_mac[3]]
+
+        key = [ul_key[0] ^ ul_key[4], ul_key[1] ^ ul_key[5], ul_key[2] ^ meta_mac[0],
+               ul_key[3] ^ meta_mac[1], ul_key[4], ul_key[5], meta_mac[0], meta_mac[1]]
+
+        encrypted_key = Utils.a32_to_base64 Crypto.encrypt_key(session.master_key, key)
+        request(a: 'p', t: handle, n: [{h: file_handle, t: 0, a: encrypt_attribs, k: encrypted_key}])
+
+        attribs[:n]
+      ensure
+        file.close
+      end
+    end
+  end
+end

data/lib/rmega/options.rb

@@ -4,6 +4,8 @@ module Rmega
   def self.default_options
     {
       upload_timeout:       120,
+      max_retries:          10,
+      retry_interval:       1,
       api_request_timeout:  20,
       api_url:              'https://eu.api.mega.co.nz/cs'
     }

data/lib/rmega/pool.rb

@@ -2,63 +2,58 @@ require 'thread'
 
 module Rmega
   class Pool
-    MAX = 5
+    MAX = 4
 
-    def initialize(max)
-      max ||= MAX
+    def initialize(max = MAX)
       Thread.abort_on_exception = true
+
       @mutex = Mutex.new
-      @threads = Array.new(max)
-    end
+      @resource = ConditionVariable.new
+      @max = max || MAX
 
-    # Gets the first position of the pool in which
-    # a thread could be started.
-    def available_slot
-      @threads.each_with_index do |thread, index|
-        return index if thread.nil? or !thread.alive?
-      end
-      nil
+      @running = []
+      @queue = []
     end
 
-    def synchronize(&block)
-      @mutex.synchronize(&block)
+    def defer(&block)
+      synchronize { @queue << block }
+      process_queue
     end
 
-    # Returns true if all the threads are finished,
-    # false otherwise.
-    def done?
-      @threads.each { |thread| return false if thread and thread.alive? }
-      true
+    def wait_done
+      synchronize { @resource.wait(@mutex) }
     end
 
-    # Blocking. Waits until all the threads are finished.
-    def wait_done
-      sleep 0.01 until done?
+    private
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
     end
 
-    # Blocking. Waits until a pool's slot become available and
-    # returns that position.
-    # TODO: raise an error on wait timeout.
-    def wait_available_slot
-      while true
-        index = available_slot
-        return index if index
-        sleep 0.01
+    def process_queue
+      synchronize do
+        if @running.size < @max
+          proc = @queue.shift
+          @running << Thread.new(&thread_proc(&proc)) if proc
+        end
       end
     end
 
-    # Sends a KILL signal to all the threads.
-    def shutdown
-      @threads.each { |thread| thread.kill if thread.respond_to?(:kill) }
-      @threads.map! { nil }
+    def done?
+      synchronize { @queue.empty? && @running.empty? }
+    end
+
+    def signal_done
+      synchronize { @resource.signal }
     end
 
-    # Blocking. Starts a new thread with the given block when a pool's slot
-    # become available.
-    def defer(&block)
-      index = wait_available_slot
-      @threads[index].kill if @threads[index].respond_to?(:kill)
-      @threads[index] = Thread.new(&block)
+    def thread_proc(&block)
+      Proc.new do
+        block.call
+        @running.reject! { |thread| thread == Thread.current }
+        process_queue
+        signal_done if done?
+      end
     end
   end
 end

data/lib/rmega/session.rb

@@ -1,5 +1,5 @@
 require 'rmega/storage'
-require 'rmega/request_error'
+require 'rmega/errors'
 require 'rmega/crypto/crypto'
 require 'rmega/utils'
 
@@ -11,11 +11,12 @@ module Rmega
   class Session
     include Loggable
 
-    attr_reader :email, :request_id, :sid, :master_key
+    attr_reader :email, :request_id, :sid, :master_key, :shared_keys, :rsa_privk
 
     def initialize(email, password)
       @email = email
       @request_id = random_request_id
+      @shared_keys = {}
 
       login(password)
     end
@@ -25,6 +26,7 @@ module Rmega
     end
 
     delegate :api_url, :api_request_timeout, to: :options
+    delegate :max_retries, :retry_interval, to: :options
 
     def storage
       @storage ||= Storage.new(self)
@@ -39,7 +41,8 @@ module Rmega
       @master_key = Crypto.decrypt_key(encrypted_key, Utils.base64_to_a32(resp['k']))
 
       # Generates the session id
-      @sid = Crypto.decrypt_sid(@master_key, resp['csid'], resp['privk'])
+      @rsa_privk = Crypto.decrypt_rsa_privk(@master_key, resp['privk'])
+      @sid = Crypto.decrypt_sid(@rsa_privk, resp['csid'])
     end
 
     def random_request_id
@@ -52,14 +55,28 @@ module Rmega
       end
     end
 
-    def request(body)
+    def request(content, retries = max_retries)
       @request_id += 1
-      logger.debug "POST #{request_url}\n#{body.inspect}"
-      response = HTTPClient.new.post(request_url, [body].to_json, timeout: api_request_timeout)
-      logger.debug "#{response.code}\n#{response.body}"
-      resp = JSON.parse(response.body).first
-      raise RequestError.new(resp) if RequestError.error_code?(resp)
-      resp
+      logger.debug "POST #{request_url} #{content.inspect}"
+
+      response = HTTPClient.new.post(request_url, [content].to_json, timeout: api_request_timeout)
+      code, body = response.code.to_i, response.body
+
+      logger.debug("#{code} #{body}")
+
+      if code == 500 && body.to_s.empty?
+        raise Errors::ServerError.new("Server too busy", temporary: true)
+      else
+        json = JSON.parse(body).first
+        raise Errors::ServerError.new(json) if json.to_s =~ /\A\-\d+\z/
+        json
+      end
+    rescue SocketError, Errors::ServerError => error
+      raise(error) if retries < 0
+      raise(error) if error.respond_to?(:temporary?) && !error.temporary?
+      retries -= 1
+      sleep(retry_interval)
+      retry
     end
   end
 end

data/lib/rmega/storage.rb

@@ -24,7 +24,20 @@ module Rmega
 
     def nodes
       results = session.request(a: 'f', c: 1)['f']
-      results.map { |node_data| Nodes::Factory.build(session, node_data) }
+
+      results.map do |node_data|
+        node = Nodes::Factory.build(session, node_data)
+        node.process_shared_key if node.shared_root?
+        node
+      end
+    end
+
+    def folders
+      list = nodes
+      root_handle = list.find { |node| node.type == :root }.handle
+      list.select do |node|
+        node.shared_root? || (node.type == :folder && node.parent_handle == root_handle)
+      end
     end
 
     def trash

data/lib/rmega/version.rb

@@ -1,3 +1,3 @@
 module Rmega
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/spec/integration/login_spec.rb

@@ -12,7 +12,7 @@ describe 'Login' do
 
     context 'when email and password are invalid' do
       it 'raises an error' do
-        expect { Rmega.login('a@apple.com', 'b') }.to raise_error(Rmega::RequestError)
+        expect { Rmega.login('a@apple.com', 'b') }.to raise_error(Rmega::Errors::ServerError)
       end
     end
   end

data/spec/integration/rmega_account.yml.example

@@ -0,0 +1,2 @@
+email: insert_email_here
+password: insert_pass_here

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rmega
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Daniele Molteni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -102,6 +102,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -113,9 +114,10 @@ files:
 - lib/rmega/crypto/crypto.rb
 - lib/rmega/crypto/rsa.rb
 - lib/rmega/crypto/rsa_mega.js
-- lib/rmega/downloader.rb
+- lib/rmega/errors.rb
 - lib/rmega/loggable.rb
 - lib/rmega/nodes/deletable.rb
+- lib/rmega/nodes/downloadable.rb
 - lib/rmega/nodes/expandable.rb
 - lib/rmega/nodes/factory.rb
 - lib/rmega/nodes/file.rb
@@ -125,13 +127,12 @@ files:
 - lib/rmega/nodes/root.rb
 - lib/rmega/nodes/trash.rb
 - lib/rmega/nodes/traversable.rb
+- lib/rmega/nodes/uploadable.rb
 - lib/rmega/options.rb
 - lib/rmega/pool.rb
 - lib/rmega/progress.rb
-- lib/rmega/request_error.rb
 - lib/rmega/session.rb
 - lib/rmega/storage.rb
-- lib/rmega/uploader.rb
 - lib/rmega/utils.rb
 - lib/rmega/version.rb
 - rmega.gemspec
@@ -139,6 +140,7 @@ files:
 - spec/integration/file_upload_spec.rb
 - spec/integration/folder_operations_spec.rb
 - spec/integration/login_spec.rb
+- spec/integration/rmega_account.yml.example
 - spec/integration_spec_helper.rb
 - spec/rmega/lib/crypto/aes_spec.rb
 - spec/rmega/lib/crypto/crypto_spec.rb
@@ -173,6 +175,7 @@ test_files:
 - spec/integration/file_upload_spec.rb
 - spec/integration/folder_operations_spec.rb
 - spec/integration/login_spec.rb
+- spec/integration/rmega_account.yml.example
 - spec/integration_spec_helper.rb
 - spec/rmega/lib/crypto/aes_spec.rb
 - spec/rmega/lib/crypto/crypto_spec.rb

data/lib/rmega/downloader.rb

@@ -1,70 +0,0 @@
-require 'rmega/loggable'
-require 'rmega/utils'
-require 'rmega/pool'
-require 'rmega/progress'
-
-module Rmega
-  class Downloader
-    include Loggable
-
-    attr_reader :pool, :base_url, :filesize, :local_path
-
-    def initialize(params)
-      @pool = Pool.new(params[:threads])
-      @filesize = params[:filesize]
-      @base_url = params[:base_url]
-      @local_path = params[:local_path]
-    end
-
-    # Creates the local file allocating filesize-n bytes (of /dev/zero) for it.
-    # Opens the local file to start writing from the beginning of it.
-    def allocate
-      `dd if=/dev/zero of="#{local_path}" bs=1 count=0 seek=#{filesize} > /dev/null 2>&1`
-      raise "Unable to create file #{local_path}" if File.size(local_path) != filesize
-
-      ::File.open(local_path, 'r+b').tap { |f| f.rewind }
-    end
-
-    # Downloads a part of the remote file, starting from the start-n byte
-    # and ending after size-n bytes.
-    def download_chunk(start, size)
-      stop = start + size - 1
-      url = "#{base_url}/#{start}-#{stop}"
-      HTTPClient.new.get_content(url)
-    end
-
-    # Writes a buffer in the local file, starting from the start-n byte.
-    def write_chunk(start, buffer)
-      @local_file.seek(start)
-      @local_file.write(buffer)
-    end
-
-    def chunks
-      Utils.chunks(filesize)
-    end
-
-    def download(&block)
-      @local_file = allocate
-
-      progress = Progress.new(total: filesize, caption: 'Download')
-
-      chunks.each do |start, size|
-        pool.defer do
-          encrypted_buffer = download_chunk(start, size)
-          clean_buffer = yield(start, encrypted_buffer)
-          progress.increment(size)
-          pool.synchronize { write_chunk(start, clean_buffer) }
-        end
-      end
-
-      # waits for the last running threads to finish
-      pool.wait_done
-
-      @local_file.flush
-
-      pool.shutdown
-    ensure
-      @local_file.close rescue nil
-    end
-  end
-end

data/lib/rmega/request_error.rb

@@ -1,35 +0,0 @@
-module Rmega
-  class RequestError < StandardError
-    def initialize(error_code)
-      message = self.class.errors[error_code]
-      super("Error #{error_code}: #{message}")
-    end
-
-    def self.error_code?(number)
-      number.respond_to?(:to_i) and number.to_i < 0
-    end
-
-    def self.errors
-      {
-        -1  => 'An internal error has occurred. Please submit a bug report, detailing the exact circumstances in which this error occurred.',
-        -2  => 'You have passed invalid arguments to this command.',
-        -3  => 'A temporary congestion or server malfunction prevented your request from being processed. No data was altered. Retry. Retries must be spaced with exponential backoff.',
-        -4  => 'You have exceeded your command weight per time quota. Please wait a few seconds, then try again (this should never happen in sane real-life applications).',
-        -5  => 'The upload failed. Please restart it from scratch.',
-        -6  => 'Too many concurrent IP addresses are accessing this upload target URL.',
-        -7  => 'The upload file packet is out of range or not starting and ending on a chunk boundary.',
-        -8  => 'The upload target URL you are trying to access has expired. Please request a fresh one.',
-        -9  => 'Object (typically, node or user) not found',
-        -10 => 'Circular linkage attempted',
-        -11 => 'Access violation (e.g., trying to write to a read-only share)',
-        -12 => 'Trying to create an object that already exists',
-        -13 => 'Trying to access an incomplete resource',
-        -14 => 'A decryption operation failed (never returned by the API)',
-        -15 => 'Invalid or expired user session, please relogin',
-        -16 => 'User blocked',
-        -17 => 'Request over quota',
-        -18 => 'Resource temporarily not available, please try again later'
-      }
-    end
-  end
-end

data/lib/rmega/uploader.rb

@@ -1,58 +0,0 @@
-require 'rmega/loggable'
-require 'rmega/utils'
-require 'rmega/pool'
-require 'rmega/progress'
-
-module Rmega
-  class Uploader
-    include Loggable
-
-    attr_reader :pool, :base_url, :filesize, :local_path, :last_result
-
-    def initialize(params)
-      @pool = Pool.new(params[:threads])
-      @filesize = params[:filesize]
-      @base_url = params[:base_url]
-      @local_path = params[:local_path]
-      @last_result = nil
-    end
-
-    def upload_chunk(start, buffer)
-      size = buffer.length
-      stop = start + size - 1
-      url = "#{base_url}/#{start}-#{stop}"
-
-      HTTPClient.new.post(url, buffer).body
-    end
-
-    def read_chunk(start, size)
-      @local_file.seek(start)
-      @local_file.read(size)
-    end
-
-    def chunks
-      Utils.chunks(filesize)
-    end
-
-    def upload(&block)
-      @local_file = ::File.open(local_path, 'rb')
-
-      progress = Progress.new(total: filesize, caption: 'Upload')
-
-      chunks.each do |start, size|
-
-        pool.defer do
-          clean_buffer = pool.synchronize { read_chunk(start, size) }
-          encrypted_buffer = yield(start, clean_buffer)
-          @last_result = upload_chunk(start, encrypted_buffer)
-          progress.increment(clean_buffer.size)
-        end
-      end
-
-      pool.wait_done
-      pool.shutdown
-    ensure
-      @local_file.close
-    end
-  end
-end