rmega 0.0.6 → 0.1.0

data/lib/rmega/nodes/node.rb

@@ -1,122 +1,80 @@
+require 'rmega/loggable'
+require 'rmega/utils'
+require 'rmega/crypto/crypto'
+require 'rmega/nodes/traversable'
+
 module Rmega
-  class Node
-    attr_reader :data, :session
+  module Nodes
+    class Node
+      include Loggable
+      include Traversable
+
+      attr_reader :data, :session
 
-    def initialize session, data
-      @session = session
+      delegate :storage, :request, :to => :session
 
-      if self.class.mega_url?(data)
-        @data = self.class.public_data(session, data)
-        @public_url = data
-      else
+      def initialize(session, data)
+        @session = session
         @data = data
       end
-    end
-
-    def self.fabricate session, data
-      type_name = mega_url?(data) ? :file : type_by_number(data['t'])
-      node_class = Rmega.const_get("#{type_name}_node".camelize) rescue nil
-      node_class ||= Rmega::Node
-      node_class.new session, data
-    end
-
-    def self.types
-      {file: 0, folder: 1, root: 2, inbox: 3, trash: 4}
-    end
-
-    def self.type_by_number number
-      founded_type = types.find { |k, v| number == v }
-      founded_type.first if founded_type
-    end
-
-    def self.mega_url? url
-      !!(url.to_s =~ /^https:\/\/mega\.co\.nz\/#!.*$/i)
-    end
-
-    def logger
-      Rmega.logger
-    end
-
-    # Member actions
-
-    def public_url
-      return @public_url if @public_url
-      return nil if type != :file
-      b64_dec_key = Utils.a32_to_base64 decrypted_file_key[0..7]
-      "https://mega.co.nz/#!#{public_handle}!#{b64_dec_key}"
-    end
-
-    def trash
-      trash_node_public_handle = storage.trash_node.public_handle
-      request a: 'm', n: handle, t: trash_node_public_handle
-    end
-
-
-    # Delegate to session
-
-    delegate :storage, :request, :to => :session
-
-
-    # Other methods
 
-    def self.public_data session, public_url
-      public_handle, key = public_url.strip.split('!')[1, 2]
-      session.request a: 'g', g: 1, p: public_handle
-    end
-
-    def public_handle
-      @public_handle ||= request(a: 'l', n: handle)
-    end
+      def public_url
+        @public_url ||= begin
+          b64_dec_key = Utils.a32_to_base64 decrypted_file_key[0..7]
+          "https://mega.co.nz/#!#{public_handle}!#{b64_dec_key}"
+        end
+      end
 
-    def handle
-      data['h']
-    end
+      def public_url=(url)
+        @public_url = url
+      end
 
-    def parent_handle
-      data['p']
-    end
+      def public_handle
+        @public_handle ||= request(a: 'l', n: handle)
+      end
 
-    def filesize
-      data['s']
-    end
+      def handle
+        data['h']
+      end
 
-    def owner_key
-      data['k'].split(':').first
-    end
+      def parent_handle
+        data['p']
+      end
 
-    def name
-      return attributes['n'] if attributes
-    end
+      def owner_key
+        data['k'].split(':').first
+      end
 
-    def file_key
-      data['k'].split(':').last
-    end
+      def name
+        return attributes['n'] if attributes
+      end
 
-    def decrypted_file_key
-      if data['k']
-        Crypto.decrypt_key session.master_key, Utils.base64_to_a32(file_key)
-      else
-        Utils.base64_to_a32 public_url.split('!').last
+      def file_key
+        data['k'].split(':').last
       end
-    end
 
-    def can_decrypt_attributes?
-      !data['u'] or data['u'] == owner_key
-    end
+      def decrypted_file_key
+        if data['k']
+          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'])
+      def can_decrypt_attributes?
+        !data['u'] or data['u'] == owner_key
       end
-    end
 
-    def type
-      self.class.type_by_number data['t']
-    end
+      def attributes
+        @attributes ||= begin
+          return nil unless can_decrypt_attributes?
+          Crypto.decrypt_attributes decrypted_file_key, (data['a'] || data['at'])
+        end
+      end
 
-    def delete
-      request a: 'd', n: handle
+      def type
+        Factory.type(data['t'])
+      end
     end
   end
 end

data/lib/rmega/nodes/root.rb

@@ -0,0 +1,12 @@
+require 'rmega/nodes/node'
+require 'rmega/nodes/expandable'
+require 'rmega/nodes/traversable'
+
+module Rmega
+  module Nodes
+    class Root < Node
+      include Expandable
+      include Traversable
+    end
+  end
+end

data/lib/rmega/nodes/trash.rb

@@ -0,0 +1,18 @@
+require 'rmega/nodes/node'
+require 'rmega/nodes/traversable'
+
+module Rmega
+  module Nodes
+    class Trash < Node
+      include Traversable
+
+      def empty!
+        children.each do |node|
+          node.delete if node.respond_to?(:delete)
+        end
+
+        empty?
+      end
+    end
+  end
+end

data/lib/rmega/nodes/traversable.rb

@@ -0,0 +1,26 @@
+module Rmega
+  module Nodes
+    module Traversable
+      def children
+        storage.nodes.select { |node| node.parent_handle == handle }
+      end
+
+      def folders
+        children.select { |node| node.type == :folder }
+      end
+
+      def files
+        children.select { |node| node.type == :file }
+      end
+
+      def parent
+        return unless parent_handle
+        storage.nodes.find { |node| node.handle == parent_handle }
+      end
+
+      def empty?
+        children.size == 0
+      end
+    end
+  end
+end

data/lib/rmega/options.rb

@@ -0,0 +1,16 @@
+require 'ostruct'
+
+module Rmega
+  def self.default_options
+    {
+      show_progress:        true,
+      upload_timeout:       120,
+      api_request_timeout:  20,
+      api_url:              'https://eu.api.mega.co.nz/cs'
+    }
+  end
+
+  def self.options
+    @options ||= OpenStruct.new(default_options)
+  end
+end

data/lib/rmega/pool.rb

@@ -1,13 +1,11 @@
 require 'thread'
 
-class Thread
-  # Helper to create a Pool instance.
-  def self.pool(max)
-    Pool.new(max)
-  end
-
+module Rmega
   class Pool
+    MAX = 5
+
     def initialize(max)
+      max ||= MAX
       Thread.abort_on_exception = true
       @mutex = Mutex.new
       @threads = Array.new(max)

data/lib/rmega/progress.rb

@@ -0,0 +1,34 @@
+module Rmega
+  class Progress
+
+    def initialize(params)
+      @filesize = params[:filesize]
+      @verb = params[:verb].capitalize
+      @progress = 0
+
+      render
+    end
+
+    def render
+      percentage = (100.0 * @progress / @filesize).round(2)
+      message = "#{@verb} in progress #{format_bytes(@progress)} of #{format_bytes(@filesize)} (#{percentage}%)"
+      rtrn = "\n" if @filesize == @progress
+
+      print "\r#{' '*(message.size + 15)}\r#{message}#{rtrn}"
+    end
+
+    def increment(bytes)
+      @progress += bytes
+
+      render
+    end
+
+    def format_bytes(bytes, round = 2)
+      units = ['bytes', 'kb', 'MB', 'GB', 'TB', 'PB']
+      e = (bytes == 0 ? 0 : Math.log(bytes)) / Math.log(1024)
+      value = bytes.to_f / (1024 ** e.floor)
+
+      "#{value.round(round)}#{units[e]}"
+    end
+  end
+end

data/lib/rmega/{api_request_error.rb → request_error.rb}

@@ -1,18 +1,15 @@
 module Rmega
-  class ApiRequestError < StandardError
-    attr_reader :code
-
-    def initialize error_code
-      @code = error_code
-      error_description = self.class.all_messages[@code]
-      super "Received error code #{@code}. #{error_description}".strip
+  class RequestError < StandardError
+    def initialize(error_code)
+      message = self.class.errors[error_code]
+      super("Error #{error_code}: #{message}")
     end
 
-    def self.is_error_code? number
-      (Integer(number) && number.to_i < 0) rescue false
+    def self.error_code?(number)
+      number.respond_to?(:to_i) and number.to_i < 0
     end
 
-    def self.all_messages
+    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.',

data/lib/rmega/session.rb

@@ -1,63 +1,52 @@
+require 'rmega/storage'
+require 'rmega/request_error'
+require 'rmega/crypto/crypto'
+require 'rmega/utils'
+
 module Rmega
+  def self.login(email, password)
+    Session.new(email, password).storage
+  end
+
   class Session
+    include Loggable
+
     attr_accessor :email, :request_id, :sid, :master_key
 
-    def initialize email, password_str
+    def initialize(email, password)
       self.email = email
       self.request_id = random_request_id
 
-      login password_str
+      login(password)
     end
 
-    def logger
-      Rmega.logger
-    end
-
-
-    # Delegate to Rmega.options
-
     def options
       Rmega.options
     end
 
-    def api_request_timeout
-      options.api_request_timeout
-    end
-
-    def api_url
-      options.api_url
-    end
-
-
-    # Cache the Storage class
+    delegate :api_url, :api_request_timeout, to: :options
 
     def storage
-      @storage ||= Storage.new self
+      @storage ||= Storage.new(self)
     end
 
-
-    # Login-related methods
-
-    def login password_str
-      uh = Crypto.stringhash Crypto.prepare_key_pw(password_str), email
+    def login(password)
+      uh = Crypto.stringhash Crypto.prepare_key_pw(password), email
       resp = request a: 'us', user: email, uh: uh
 
       # Decrypt the master key
-      encrypted_key = Crypto.prepare_key_pw password_str
+      encrypted_key = Crypto.prepare_key_pw password
       self.master_key = Crypto.decrypt_key encrypted_key, Utils.base64_to_a32(resp['k'])
 
       # Generate the session id
       self.sid = Crypto.decrypt_sid master_key, resp['csid'], resp['privk']
     end
 
-
-    # Api requests methods
-
     def random_request_id
       rand(1E7..1E9).to_i
     end
 
-    def request body
+    def request(body)
       self.request_id += 1
       url = "#{api_url}?id=#{request_id}"
       url << "&sid=#{sid}" if sid
@@ -66,7 +55,7 @@ module Rmega
       response = HTTPClient.new.post url, [body].to_json, timeout: api_request_timeout
       logger.debug "#{response.code}\n#{response.body}"
       resp = JSON.parse(response.body).first
-      raise ApiRequestError.new(resp) if ApiRequestError.is_error_code?(resp)
+      raise RequestError.new(resp) if RequestError.error_code?(resp)
       resp
     end
   end

data/lib/rmega/storage.rb

@@ -1,19 +1,17 @@
+require 'rmega/utils'
+require 'rmega/crypto/crypto'
+require 'rmega/nodes/factory'
+
 module Rmega
   class Storage
+    include Loggable
 
     attr_reader :session
 
-    def initialize session
+    def initialize(session)
       @session = session
     end
 
-    def logger
-      Rmega.logger
-    end
-
-
-    # Quota-related methods
-
     def used_space
       quota['cstrg']
     end
@@ -26,81 +24,34 @@ module Rmega
       session.request a: 'uq', strg: 1
     end
 
-
-    # Nodes management
-
     def nodes
-      nodes = session.request a: 'f', c: 1
-      nodes['f'].map { |node_data| Node.fabricate(session, node_data) }
-    end
-
-    def nodes_by_type type
-      nodes.select { |n| n.type == type }
-    end
-
-    def nodes_by_name name_regexp
-      nodes.select do |node|
-        node.name and node.name =~ name_regexp
-      end
-    end
-
-    def trash_node
-      @trash ||= nodes_by_type(:trash).first
+      result = session.request(a: 'f', c: 1)
+      result['f'].map { |node_data| Nodes::Factory.build(session, node_data) }
     end
 
-    def root_node
-      @root_node ||= nodes_by_type(:root).first
+    def trash
+      @trash ||= nodes.find { |n| n.type == :trash }
     end
 
-    def create_folder parent_node, folder_name
-      FolderNode.create session, parent_node, folder_name
+    def root
+      @root_node ||= nodes.find { |n| n.type == :root }
     end
 
-
-    # Handle node download
-
-    def self.chunks size
-      list = {}
-      p = 0
-      pp = 0
-      i = 1
-
-      while i <= 8 and p < size - (i * 0x20000)
-        list[p] = i * 0x20000
-        pp = p
-        p += list[p]
-        i += 1
-      end
-
-      while p < size
-        list[p] = 0x100000
-        pp = p
-        p += list[p]
-      end
-
-      if size - pp > 0
-        list[pp] = size - pp
-      end
-      list
-    end
-
-    def download public_url, path
-      Node.fabricate(session, public_url).download(path)
+    def download(public_url, path)
+      Nodes::Factory.build_from_url(session, public_url).download(path)
     end
 
-
-    # Handle file upload
-
-    def upload_url filesize
+    # TODO: refactor upload part
+    def upload_url(filesize)
       session.request(a: 'u', s: filesize)['p']
     end
 
-    def upload_chunk url, start, chunk
+    def upload_chunk(url, start, chunk)
       response = HTTPClient.new.post "#{url}/#{start}", chunk, timeout: Rmega.options.upload_timeout
       response.body
     end
 
-    def upload local_path, parent_node = root_node
+    def upload(local_path, parent_node = root)
       local_path = File.expand_path local_path
       filesize = File.size local_path
       upld_url = upload_url filesize
@@ -114,7 +65,7 @@ module Rmega
 
       Utils.show_progress :upload, filesize
 
-      self.class.chunks(filesize).each do |chunk_start, chunk_size|
+      Utils.chunks(filesize).each do |chunk_start, chunk_size|
         buffer = local_file.read chunk_size
 
         # TODO: should be (chunk_start/0x1000000000) >>> 0, (chunk_start/0x10) >>> 0

data/lib/rmega/uploader.rb

@@ -0,0 +1,58 @@
+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(filesize: filesize, verb: 'upload')
+
+      chunks.each do |start, size|
+
+        pool.defer do
+          clean_buffer = pool.syncronize { read_chunk(start, size) }
+          encrypted_buffer = yield(start, clean_buffer)
+          @last_result = upload_chunk(start, encrypted_buffer)
+          progress.increment(buffer.size)
+        end
+      end
+
+      pool.wait_done
+      pool.shutdown
+    ensure
+      @local_file.close
+    end
+  end
+end