rmega 0.1.0 → 0.1.1

data/lib/rmega/downloader.rb

@@ -46,7 +46,7 @@ module Rmega
     def download(&block)
       @local_file = allocate
 
-      progress = Progress.new(filesize: filesize, verb: 'download')
+      progress = Progress.new(total: filesize, caption: 'Download')
 
       chunks.each do |start, size|
         pool.defer do

data/lib/rmega/options.rb

@@ -3,7 +3,6 @@ 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'

data/lib/rmega/progress.rb

@@ -2,33 +2,48 @@ module Rmega
   class Progress
 
     def initialize(params)
-      @filesize = params[:filesize]
-      @verb = params[:verb].capitalize
-      @progress = 0
+      @total = params[:total]
+      @caption = params[:caption]
+      @bytes = 0
+      @start_time = Time.now
 
-      render
+      show
     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
+    def show
+      percentage = (100.0 * @bytes / @total).round(2)
 
-      print "\r#{' '*(message.size + 15)}\r#{message}#{rtrn}"
+      message = "[#{@caption}] #{humanize(@bytes)} of #{humanize(@total)}"
+
+      if ended?
+        message << ". Completed in #{elapsed_time} sec.\n"
+      else
+        message << " (#{percentage}%)"
+      end
+
+      blank_line = ' ' * (message.size + 15)
+      print "\r#{blank_line}\r#{message}"
     end
 
-    def increment(bytes)
-      @progress += bytes
+    def elapsed_time
+      (Time.now - @start_time).round(2)
+    end
 
-      render
+    def ended?
+      @total == @bytes
+    end
+
+    def increment(bytes)
+      @bytes += bytes
+      show
     end
 
-    def format_bytes(bytes, round = 2)
+    def humanize(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]}"
+      "#{value.round(round)} #{units[e]}"
     end
   end
 end

data/lib/rmega/session.rb

@@ -11,11 +11,11 @@ module Rmega
   class Session
     include Loggable
 
-    attr_accessor :email, :request_id, :sid, :master_key
+    attr_reader :email, :request_id, :sid, :master_key
 
     def initialize(email, password)
-      self.email = email
-      self.request_id = random_request_id
+      @email = email
+      @request_id = random_request_id
 
       login(password)
     end
@@ -32,27 +32,30 @@ module Rmega
 
     def login(password)
       uh = Crypto.stringhash Crypto.prepare_key_pw(password), email
-      resp = request a: 'us', user: email, uh: uh
+      resp = request(a: 'us', user: email, uh: uh)
 
-      # Decrypt the master key
-      encrypted_key = Crypto.prepare_key_pw password
-      self.master_key = Crypto.decrypt_key encrypted_key, Utils.base64_to_a32(resp['k'])
+      # Decrypts the master key
+      encrypted_key = Crypto.prepare_key_pw(password)
+      @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']
+      # Generates the session id
+      @sid = Crypto.decrypt_sid(@master_key, resp['csid'], resp['privk'])
     end
 
     def random_request_id
       rand(1E7..1E9).to_i
     end
 
+    def request_url
+      "#{api_url}?id=#{@request_id}".tap do |url|
+        url << "&sid=#{@sid}" if @sid
+      end
+    end
+
     def request(body)
-      self.request_id += 1
-      url = "#{api_url}?id=#{request_id}"
-      url << "&sid=#{sid}" if sid
-      logger.info "POST #{url}"
-      logger.info "#{body.inspect}"
-      response = HTTPClient.new.post url, [body].to_json, timeout: api_request_timeout
+      @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)

data/lib/rmega/storage.rb

@@ -1,5 +1,3 @@
-require 'rmega/utils'
-require 'rmega/crypto/crypto'
 require 'rmega/nodes/factory'
 
 module Rmega
@@ -21,12 +19,12 @@ module Rmega
     end
 
     def quota
-      session.request a: 'uq', strg: 1
+      session.request(a: 'uq', strg: 1)
     end
 
     def nodes
-      result = session.request(a: 'f', c: 1)
-      result['f'].map { |node_data| Nodes::Factory.build(session, node_data) }
+      results = session.request(a: 'f', c: 1)['f']
+      results.map { |node_data| Nodes::Factory.build(session, node_data) }
     end
 
     def trash
@@ -34,68 +32,11 @@ module Rmega
     end
 
     def root
-      @root_node ||= nodes.find { |n| n.type == :root }
+      @root ||= nodes.find { |n| n.type == :root }
     end
 
     def download(public_url, path)
       Nodes::Factory.build_from_url(session, public_url).download(path)
     end
-
-    # TODO: refactor upload part
-    def upload_url(filesize)
-      session.request(a: 'u', s: filesize)['p']
-    end
-
-    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)
-      local_path = File.expand_path local_path
-      filesize = File.size local_path
-      upld_url = upload_url filesize
-
-      ul_key = Crypto.random_key
-      aes_key = ul_key[0..3]
-      nonce = ul_key[4..5]
-      local_file = File.open local_path, 'rb'
-      file_handle = nil
-      file_mac = [0, 0, 0, 0]
-
-      Utils.show_progress :upload, filesize
-
-      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
-        nonce = [nonce[0], nonce[1], (chunk_start/0x1000000000) >> 0, (chunk_start/0x10) >> 0]
-
-        encrypted_buffer = Crypto::AesCtr.encrypt aes_key, nonce, buffer
-        chunk_mac = encrypted_buffer[:mac]
-
-        file_handle = upload_chunk upld_url, chunk_start, encrypted_buffer[: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 ul_key[0..3], file_mac
-        Utils.show_progress :upload, filesize, chunk_size
-      end
-
-      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: parent_node.handle, n: [{h: file_handle, t: 0, a: encrypt_attribs, k: encrypted_key}]
-
-      nil
-    ensure
-      local_file.close if local_file
-    end
   end
 end

data/lib/rmega/uploader.rb

@@ -37,15 +37,15 @@ module Rmega
     def upload(&block)
       @local_file = ::File.open(local_path, 'rb')
 
-      progress = Progress.new(filesize: filesize, verb: 'upload')
+      progress = Progress.new(total: filesize, caption: 'Upload')
 
       chunks.each do |start, size|
 
         pool.defer do
-          clean_buffer = pool.syncronize { read_chunk(start, size) }
+          clean_buffer = pool.synchronize { read_chunk(start, size) }
           encrypted_buffer = yield(start, clean_buffer)
           @last_result = upload_chunk(start, encrypted_buffer)
-          progress.increment(buffer.size)
+          progress.increment(clean_buffer.size)
         end
       end
 

data/lib/rmega/utils.rb

@@ -1,5 +1,3 @@
-require 'rmega/utils'
-
 module Rmega
   module Utils
     extend self

data/lib/rmega/version.rb

@@ -1,3 +1,3 @@
 module Rmega
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/rmega.rb

@@ -3,7 +3,6 @@ require 'active_support/core_ext/object/to_json'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/string/inflections'
 require 'httpclient'
-require 'ruby-progressbar'
 require 'execjs'
 require 'rmega/version'
 require 'rmega/options'

data/spec/integration/file_upload_spec.rb

@@ -0,0 +1,79 @@
+require 'integration_spec_helper'
+require 'fileutils'
+
+describe 'File upload' do
+
+  if account_file_exists?
+
+    before(:all) { @storage = login }
+
+    context 'upload a small file to the root folder' do
+
+      before(:all) do
+        @name = "i_like_trains_#{rand(1E20)}"
+        @content = @name
+      end
+
+      def find_file
+        @storage.root.files.find { |f| f.name == @name }
+      end
+
+      let(:path) { File.join(temp_folder, @name) }
+
+      before do
+        File.open(path, 'wb') { |f| f.write(@content) }
+        @storage.root.upload(path)
+      end
+
+      it 'finds the uploaded file' do
+        file = find_file
+        file.delete
+        expect(file).not_to be_nil
+      end
+
+      context 'download the same file' do
+
+        let(:download_path) { "#{path}.downloaded" }
+
+        before do
+          file = find_file
+          file.download(download_path)
+          file.delete
+        end
+
+        it 'has the expected content' do
+          expect(File.read(download_path)).to eql @content
+        end
+      end
+    end
+
+    context 'upload a big file to a specific folder' do
+
+      before(:all) do
+        @name = "mine_turtles_#{rand(1E20)}"
+        @path = File.join(temp_folder, @name)
+        @buffer = "rofl" * 1024
+
+        File.open(@path, 'wb') do |f|
+          512.times { f.write(@buffer) }
+        end
+      end
+
+      let!(:folder) { @storage.root.create_folder(@name) }
+
+      before(:all) { folder.upload(@path) }
+
+      it 'finds the uploaded file and verify its content' do
+        file = folder.files.find { |f| f.name == @name }
+        download_path = "#{@path}.downloaded"
+        file.download(download_path)
+
+        File.open(download_path, 'rb') do |f|
+          512.times { expect(f.read(@buffer.size)).to eq(@buffer) }
+        end
+      end
+
+      after { folder.delete }
+    end
+  end
+end

data/spec/integration_spec_helper.rb

@@ -22,6 +22,6 @@ def temp_folder
 end
 
 RSpec.configure do |config|
-  config.before { FileUtils.mkdir_p(temp_folder) }
-  config.after { FileUtils.rm_rf(temp_folder) }
+  config.before(:all) { FileUtils.mkdir_p(temp_folder) }
+  config.after(:all) { FileUtils.rm_rf(temp_folder) }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rmega
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -148,6 +148,7 @@ files:
 - lib/rmega/version.rb
 - rmega.gemspec
 - spec/integration/file_download_spec.rb
+- spec/integration/file_upload_spec.rb
 - spec/integration/folder_operations_spec.rb
 - spec/integration/login_spec.rb
 - spec/integration_spec_helper.rb
@@ -181,6 +182,7 @@ specification_version: 3
 summary: mega.co.nz ruby api
 test_files:
 - spec/integration/file_download_spec.rb
+- spec/integration/file_upload_spec.rb
 - spec/integration/folder_operations_spec.rb
 - spec/integration/login_spec.rb
 - spec/integration_spec_helper.rb