backblaze 0.1.0.pre.alpha → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 068ed971b2bfb14ba4c2723d0ed6a8ab6e532028
-  data.tar.gz: d318da137e35f01461104b7b80532944fcc362c5
+  metadata.gz: 58cfca96218c6f265a44d93fdeaf373a51431b7f
+  data.tar.gz: 12856ac81e879a92feb8177a17a1d15b83df8504
 SHA512:
-  metadata.gz: 03c6c97c22963300e0deb4bfda498fbeef9e946a793a8897a21638da5a173154400ef715fd1b16f726198ee2a46bbd2f45c9c5752801c1ee25fc4b0c667fd550
-  data.tar.gz: 37b8599f0d5b54152efd63e54c55ed4b1002dafcb68de058e17ee0c8200cbff2f7ed438e76d53e05f936f9aa21a6fc86360e65d04a88bf8d474c3e9610025a6c
+  metadata.gz: 02635c9ba73cbadd3610481e70bc92cd93b42a8fefa4005aaed57e3683b5c60d6a45ef641f074156a341924d515f59dab6b29fe8e25b6cc0c1f250b92dae04cb
+  data.tar.gz: 1d1a3dcc23ada161c464dff4f93864062ffee887400403629ff7753faab660e964b288c39e164137eccf4902a9b6d7ac2bcc24b5860ba5f71901f39ae8b170e1

data/.gitignore

@@ -8,3 +8,4 @@
 /spec/reports/
 /tmp/
 .DS_Store
+.b2_login*

data/README.md

@@ -1,6 +1,6 @@
 # Backblaze
 
-The Backblaze ruby gem is an implementation of the [Backblaze B2 Cloud Storage API](https://www.backblaze.com/b2/docs/). In addition to simplifying calls, it also implements an object oriented structure for dealing with files.
+The Backblaze ruby gem is an implementation of the [Backblaze B2 Cloud Storage API](https://www.backblaze.com/b2/docs/). In addition to simplifying calls, it also implements an object oriented structure for dealing with files. Calling the api through different objects will not cause each to get updated. Always assume that data retrieved is just a snapshot from when the object was retrieved.
 
 ## Installation
 

data/Rakefile

@@ -4,3 +4,33 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+task :console do
+  require 'pry'
+  require 'backblaze'
+
+  def reload!
+    headers = Backblaze::B2::Base.headers
+    vars = Backblaze::B2.instance_variables.map{|k| [k, Backblaze::B2.instance_variable_get(k)]}.to_h
+    base_uri = Backblaze::B2::Base.base_uri
+    files = $LOADED_FEATURES.select { |feat| feat =~ /\/backblaze\// }
+    files.each { |file| load file }
+    vars.each do |key, value|
+      Backblaze::B2.instance_variable_set(key, value)
+    end
+    Backblaze::B2::Base.base_uri(base_uri)
+    Backblaze::B2::Base.headers(headers)
+    true
+  end
+
+  # Will try to auto load the first .b2_login file it finds
+  success = false
+  Dir['.b2_login*'].each do |file|
+    break if success
+    puts file
+    success = Backblaze::B2.credentials_file(file, raise_errors: false, logging: true)
+  end
+
+  ARGV.clear
+  Pry.start
+end

data/lib/backblaze/b2.rb

@@ -1,10 +1,11 @@
 require "backblaze/b2/base"
 require "backblaze/b2/bucket"
 require "backblaze/b2/file"
+require "backblaze/b2/file_version"
 
 module Backblaze::B2
   class << self
-    attr_reader :account_id, :token, :api_url, :download_url
+    attr_reader :account_id, :token, :api_url, :download_url, :api_path
 
     ##
     # Authenticates with the server to get the authorization data. Raises an error if there is a problem
@@ -17,7 +18,8 @@ module Backblaze::B2
       options = {
         basic_auth: {username: account_id, password: application_key}
       }
-      response = HTTParty.get("https://api.backblaze.com/b2api/v1/b2_authorize_account", options)
+      api_path = "/#{api_path}/".gsub(/\/+/, '/')
+      response = HTTParty.get("https://api.backblaze.com#{api_path}b2_authorize_account", options)
       raise Backblaze::AuthError.new(response) unless response.code == 200
 
       @account_id = response['accountId']
@@ -29,5 +31,36 @@ module Backblaze::B2
       Backblaze::B2::Base.base_uri "#{@api_url}#{api_path}"
       Backblaze::B2::Base.headers 'Authorization' => @token, 'Content-Type' => 'application/json'
     end
+
+    def credentials_file(filename, raise_errors: true, logging: false)
+      opts = nil
+      open(filename, 'r') do |f|
+        if ::File.extname(filename) == '.json'
+          require 'json'
+          opts = JSON.load(f)
+        else
+          require 'psych'
+          opts = Psych.load(f.read)
+        end
+      end
+      parsed = {}
+      [:application_key, :account_id, :api_path].each do |key|
+        if opts[key.to_s].is_a? String
+          parsed[key] = opts[key.to_s]
+        end
+      end
+      if [:application_key, :account_id].inject(true) { |status, key| status && !parsed[key].nil? }
+        puts "Attempting #{parsed[:account_id]}" if logging
+        login(parsed)
+        true
+      else
+        puts "Missing params" if logging
+        false
+      end
+    rescue => e
+      puts e if logging
+      raise e if raise_errors
+      false
+    end
   end
 end

data/lib/backblaze/b2/base.rb

@@ -23,5 +23,73 @@ module Backblaze::B2
         self.class.send(req, path, options, &block)
       end
     end
+
+    protected
+
+    def file_versions(bucket_id:, convert:, limit:, double_check_server:, file_name: nil, &block)
+      retreive_count = (double_check_server ? 0 : -1)
+      files = file_list(bucket_id: bucket_id, limit: limit, retreived: retreive_count, file_name: file_name, first_file: nil, start_field: 'startFileId'.freeze)
+
+      files.map! do |f|
+        if block.nil?
+          Backblaze::B2::FileVersion.new(f)
+        else
+          block.call(f)
+        end
+      end if convert
+      files.compact
+    end
+
+    def file_list(limit:, retreived:, first_file:, start_field:, bucket_id:, file_name: nil)
+      params = {'bucketId'.freeze => bucket_id}
+      if limit == -1
+        params['maxFileCount'.freeze] = 1000
+      elsif limit > 1000
+        params['maxFileCount'.freeze] = 1000
+      elsif limit > 0
+        params['maxFileCount'.freeze] = limit
+      else
+        return []
+      end
+      unless first_file.nil?
+        params[start_field] = first_file
+      end
+
+      response = post("/b2_list_file_#{start_field == 'startFileName' ? 'names' : 'versions'}", body: params.to_json)
+
+      files = response['files'.freeze]
+      halt = false
+      files.map! do |f|
+        if halt
+          nil
+        else
+          ret = Hash[f.map{|k,v| [Backblaze::Utils.underscore(k).to_sym, v]}]
+          if file_name && file_name != ret[:file_name]
+            halt = true
+          end
+          halt ? nil : ret
+        end
+      end.compact!
+
+      retreived = retreived + files.size if retreived >= 0
+      if limit > 0
+        limit = limit - (retreived >= 0 ? files.size : 1000)
+        limit = 0 if limit < 0
+      end
+
+      next_item = response[start_field.sub('start'.freeze, 'next'.freeze)]
+
+      if (limit > 0 || limit == -1) && !!next_item && !halt
+        files.concat file_list(
+          first_file: next_item,
+          limit: limit,
+          retreived: retreived,
+          start_field: start_field,
+          bucket_id: bucket_id
+        )
+      else
+        files
+      end
+    end
   end
 end

data/lib/backblaze/b2/bucket.rb

@@ -3,14 +3,13 @@ module Backblaze::B2
   ##
   # A class to represent the online buckets. Mostly used for file access
   class Bucket < Base
-
     ##
     # Creates a bucket from all of the possible parameters. This sould be rarely used and instead use a finder or creator
     # @param [#to_s] bucket_name the bucket name
     # @param [#to_s] bucket_id the bucket id
     # @param [#to_s] bucket_type the bucket publicity type
     # @param [#to_s] account_id the account to which this bucket belongs
-    def initialize(bucket_name:, bucket_id:, bucket_type:, account_id:)
+    def initialize(bucket_name:, bucket_id:, bucket_type:, account_id:, cache: false)
       @bucket_name = bucket_name
       @bucket_id = bucket_id
       @bucket_type = bucket_type
@@ -66,17 +65,18 @@ module Backblaze::B2
     # @return [Array<Hash>] when convert is false
     # @note many of these methods are for the recusion
     def file_names(limit: 100, cache: false, convert: true, double_check_server: false)
-      if cache && !@file_cache.nil?
-        if limit <= @file_cache[:limit] && convert == @file_cache[:convert]
-          return @file_cache[:files]
+      if cache && !@file_name_cache.nil?
+        if limit <= @file_name_cache[:limit] && convert == @file_name_cache[:convert]
+          return @file_name_cache[:files]
         end
       end
 
       retreive_count = (double_check_server ? 0 : -1)
-      files = file_list(limit: limit, retreived: retreive_count, first_file: nil, start_field: 'startFileName'.freeze)
+      files = file_list(bucket_id: bucket_id, limit: limit, retreived: retreive_count, first_file: nil, start_field: 'startFileName'.freeze)
 
+      merge_params = {bucket_id: bucket_id}
       files.map! do |f|
-        Backblaze::B2::File.new(f)
+        Backblaze::B2::File.new(f.merge(merge_params))
       end if convert
       if cache
         @file_name_cache = {limit: limit, convert: convert, files: files}
@@ -84,6 +84,27 @@ module Backblaze::B2
       files
     end
 
+    def file_versions(limit: 100, cache: false, convert: true, double_check_server: false)
+      if cache && !@file_versions_cache.nil?
+        if limit <= @file_versions_cache[:limit] && convert == @file_versions_cache[:convert]
+          return @file_versions_cache[:files]
+        end
+      end
+      file_versions = super(limit: 100, convert: convert, double_check_server: double_check_server, bucket_id: bucket_id)
+      files = file_versions.group_by {|version| convert ? version.file_name : version[:file_name]}
+      if convert
+        files = files.map do |name, versions|
+          File.new(file_name: name, bucket_id: bucket_id, versions: versions)
+        end
+      end
+      if cache
+        @file_versions_cache = {limit: limit, convert: convert, files: files}
+      else
+        @file_versions_cache = {}
+      end
+      files
+    end
+
     class << self
       ##
       # Create a bucket
@@ -102,54 +123,23 @@ module Backblaze::B2
 
         raise Backblaze::BucketError.new(response) unless response.code / 100 == 2
 
-        params = %w(account_id bucket_id bucket_name bucket_type).map {|e| [e.to_sym, response[camelize(e)]]}.to_h
+        params = Hash[response.map{|k,v| [Backblaze::Utils.underscore(k).to_sym, v]}]
 
         new(params)
       end
-    end
 
-    private
-
-    def file_list(limit:, retreived:, first_file:, start_field:)
-      params = {'bucketId' => bucket_id}
-      if limit == -1
-        params['maxFileCount'.freeze] = 1000
-      elsif limit > 1000
-        params['maxFileCount'.freeze] = 1000
-      elsif limit > 0
-        params['maxFileCount'.freeze] = limit
-      else
-        return []
-      end
-      unless first_file.nil?
-        params[start_field] = first_file
-      end
-
-      response = post("/b2_list_file_#{start_field == 'startFileName' ? 'names' : 'versions'}", body: params.to_json)
-
-      files = response['files']
-      files.map! do |f|
-        f.map {|k, v| [underscore(k).to_sym, v]}.to_h
-      end
-
-      retreived = retreived + files.size if retreived >= 0
-      if limit > 0
-        limit = limit - (retreived >= 0 ? files.size : 1000)
-        limit = 0 if limit < 0
-      end
-
-      next_item = response[start_field.sub('start', 'next')]
-
-      if (limit > 0 || limit == -1) && !!next_item
-        files.concat file_list(
-          first_file: next_item,
-          limit: limit,
-          convert: convert,
-          retreived: retreived,
-          start_field: start_field
-        )
-      else
-        files
+      ##
+      # List buckets for account
+      # @return [Array<Backblaze::Bucket>] buckets for this account
+      def buckets
+        body = {
+          accountId: Backblaze::B2.account_id
+        }
+        response = post('/b2_list_buckets', body: body.to_json)
+        response['buckets'].map do |bucket|
+          params = Hash[bucket.map{|k,v| [Backblaze::Utils.underscore(k).to_sym, v]}]
+          new(params)
+        end
       end
     end
   end

data/lib/backblaze/b2/file.rb

@@ -1,8 +1,83 @@
 module Backblaze::B2
   class File < Base
-    def initialize(file_id:, file_name:, size:, account_id:)
-      @versions = []
+    def initialize(file_name:, bucket_id:, versions: nil, **file_version_args)
+      @file_name = file_name
+      @bucket_id = bucket_id
+      if versions
+        @fetched_all = true
+        @versions = versions
+      else
+        @fetched_all = false
+        @versions = [FileVersion.new(file_version_args.merge(file_name: file_name))]
+      end
+    end
+
+    def [](version)
+      versions[version]
+    end
+
+    def file_name
+      @file_name
+    end
+    alias_method :name, :file_name
+
+    def versions
+      unless @fetched_all
+        @versions = file_versions(bucket_id: @bucket_id, convert: true, limit: -1, double_check_server: false, file_name: file_name)
+        @fetched_all = true
+      end
+      @versions
+    end
+
+    def latest
+      @versions.first
+    end
+
+    def destroy!(thread_count: 4)
+      versions
+      thread_count = @versions.length if thread_count > @versions.length || thread_count < 1
+      lock = Mutex.new
+      errors = []
+      threads = []
+      thread_count.times do
+        threads << Thread.new do
+          version = nil
+          loop do
+            lock.synchronize { version = @versions.pop }
+            break if version.nil?
+            begin
+              version.destroy!
+            rescue Backblaze::FileError => e
+              lock.synchronize { errors << e }
+            end
+          end
+        end
+      end
+      threads.map(&:join)
+      @destroyed = true
+      if errors.any?
+        raise Backblaze::DestroyErrors.new(errors)
+      end
+    end
+
+    def exists?
+      !@destroyed
+    end
+
+    def method_missing(m, *args, &block)
+      if latest.respond_to?(m)
+        latest.send(m, *args, &block)
+      else
+        super
+      end
+    end
 
+    def respond_to?(m)
+      if latest.respond_to?(m)
+        true
+      else
+        super
+      end
     end
   end
 end

data/lib/backblaze/b2/file_version.rb

@@ -1,5 +1,33 @@
 module Backblaze::B2
   class FileVersion < Base
+    attr_reader :file_id, :size, :action, :upload_timestamp, :file_name
 
+    def initialize(file_id:, size:, upload_timestamp:, action:, file_name:)
+      @file_id = file_id
+      @size = size
+      @action = action
+      @file_name = file_name
+      @upload_timestamp = Time.at(upload_timestamp / 1000.0)
+    end
+
+    def get_info
+      unless defined?(@get_info)
+        response = post('/b2_get_file_info', body: {fileId: file_id}.to_json)
+        raise Backblaze::FileError.new(response) unless response.code == 200
+
+        @get_info = Hash[response.map{|k,v| [Backblaze::Utils.underscore(k).to_sym, v]}]
+      end
+      @get_info
+    end
+
+    def destroy!
+      response = post('/b2_delete_file_version', body: {fileName: file_name, fileId: file_id}.to_json)
+      raise Backblaze::FileError.new(response) unless response.code == 200
+      @destroyed = true
+    end
+
+    def exists?
+      !@destroyed
+    end
   end
 end

data/lib/backblaze/errors.rb

@@ -53,6 +53,24 @@ module Backblaze
     end
   end
 
+  ##
+  # Errors destroying file versions
+  class DestroyErrors < Error
+    ##
+    # Creates the Error
+    # @param [Array<Backblaze::FileError>] errors errors raised destroying files
+    def initialize(errors)
+      @errors = errors
+    end
+
+    ##
+    # The Backblaze B2 error messages which broke things
+    # @return [Array<Backblaze::FileError>] errors errors raised destroying files
+    def errors
+      @errors
+    end
+  end
+
   ##
   # Error class for authentication errors
   class AuthError < RequestError; end
@@ -60,4 +78,8 @@ module Backblaze
   ##
   # Error class for bucket errors
   class BucketError < RequestError; end
+
+  ##
+  # Error class for file errors
+  class FileError < RequestError; end
 end

data/lib/backblaze/version.rb

@@ -1,3 +1,3 @@
 module Backblaze
-  VERSION = "0.1.0-alpha"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backblaze
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha
+  version: 0.2.0
 platform: ruby
 authors:
 - Winston Durand
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-30 00:00:00.000000000 Z
+date: 2015-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -151,9 +151,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5