bkblz 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7636a95e10db31242f5b3e666734c62e16f870da
+  data.tar.gz: 54425688a09f9dcec3d598ad9b9fc312e1cb8c42
+SHA512:
+  metadata.gz: 73aa799368884833b533d5ae3e8f23f7dd3b4c0a8aa0126c69509420520b290bb631721860b788a66ab0d2b13839b27fcb68e064ad07adb635285234ac932eca
+  data.tar.gz: ba3359e74fc5b8e49da7f21ebd60a8f5e59d4ee421633a22dbd0d71428455120f16b294b72e7d012c467eac147832dddc1cbefca3e4287e9024f25fad22e5c54

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bkblz.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Erick Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rb

@@ -0,0 +1,141 @@
+$: << 'lib'
+require 'all'
+
+# Run `ruby README.rb` for a working demo, but first add your
+# applicatoin key and account id in the slots below.
+Bkblz.configure do |config_map|
+  config_map.merge!(
+    :application_key => "!!! APP KEY !!!",
+    :account_id => "!!! ACCOUNT ID !!!",
+    :debug_http => false,
+    :log_level => :info # change this to :debug for more info
+  )
+end
+
+Bkblz.log.info do <<EOS
+# Step 1, the block above configures some defaults (including the
+# logger, which is why this is after the configure block), see
+# Bkblz::Config for details. This is where to set the account_id
+# and application_key.
+EOS
+end
+
+if Bkblz.config.account_id.match /!!!/
+  Bkblz.log.error "you didn't fill in your credentials, read the comments"
+  exit 1
+end
+
+Bkblz.log.info do <<EOS
+# Step 2, using the config above, create an authorized session. All
+# requests will run in the context of this session. See
+# +Bkblz::V1::Session#authorize+.
+EOS
+end
+Bkblz::V1::Session.authorize Bkblz.config do |api_session|
+  Bkblz.log.info "API session => #{api_session}"
+
+  Bkblz.log.info do <<EOS
+# Step 3, first try to find an existing bucket named my-test-bucket,
+# we'll use that if it exists. All requests in a session are sent
+# through the session so that the request object gets access to the
+# auth credentials.
+EOS
+  end
+  buckets = api_session.send(Bkblz::V1::ListBucketsRequest.new).buckets
+  bucket = buckets.select { |b| b.bucket_name == "my-test-bucket" }.first
+  Bkblz.log.info "bucket list => #{buckets}"
+
+  Bkblz.log.info do <<EOS
+# Step 4, otherwise create a new my-test-bucket
+EOS
+  end
+  unless bucket
+    bucket = Bkblz::V1::Model::Bucket.new \
+      :bucket_name => "my-test-bucket",
+      :bucket_type => "allPrivate",
+      :account_id => api_session.account_id
+
+    Bkblz.log.info do <<EOS
+# Step 5, pass a model to the CreateBucketRequest,
+# models are just named wrappers with dynamic methods
+# around the JSON responses provided back from the Bkblz
+# API. See lib/bkblz/v1/models.rb for a list of defined API
+# objects. See Bkblz::V1::Model::Base for how it work.
+EOS
+    end
+    request = Bkblz::V1::CreateBucketRequest.new bucket
+    Bkblz.log.info "bucket model => #{bucket}"
+
+    # Bkblz::V1::Response objects are returned from +send+. Some
+    # provide a to_model method if they declare the +response_model+
+    # in the class definition.
+    bucket = api_session.send(request).to_model
+    Bkblz.log.info "created bucket => #{bucket.bucket_name}/#{bucket.bucket_id}"
+  end
+
+  Bkblz.log.info do <<EOS
+# Step 6, uploading a file begins with getting a dynamic URL from the API.
+EOS
+  end
+  upload_auth = api_session.send(
+    Bkblz::V1::GetUploadUrlRequest.new bucket.bucket_id).to_model
+  Bkblz.log.info "upload file URL => #{upload_auth.upload_url}"
+
+
+  Bkblz.log.info do <<EOS
+# Step 7, use the upload_auth model (a
+# Bkblz::V1::Model::UploadAuth) to upload some files.
+EOS
+  end
+  5.times do |i|
+    body = "some text #{i}"
+    file_name = "some_text_#{i}.txt"
+    content_type = nil
+
+    upload_file_info = api_session.send(
+      Bkblz::V1::UploadFileRequest.new upload_auth, body, file_name,
+                                           content_type, Time.now.to_i * 1000).to_model
+    Bkblz.log.info "uploaded file => #{upload_file_info.file_name}"
+  end
+
+  Bkblz.log.info do <<EOS
+# Step 8, we uploaded 5 files above, here we'll read back out
+# metadata from the first 2 files in the bucket.
+EOS
+  end
+  list_files_response = api_session.send(
+    Bkblz::V1::ListFileVersionsRequest.new bucket, 2)
+  bucket_files_info = list_files_response.files
+  Bkblz.log.info "first 2 files => #{bucket_files_info.map(&:file_name).join "\n"}"
+
+  Bkblz.log.info do <<EOS
+# Step 9, the response object returned object is a
+# Bkblz::Api::PaginatedResponse. Use its +has_more?+ and
+# +next_request+ methods to page through more results.
+EOS
+  end
+  while list_files_response.has_more?
+    list_files_response = api_session.send list_files_response.next_request 100
+    bucket_files_info.concat list_files_response.files
+    Bkblz.log.info "next N files => #{list_files_response.files.map(&:file_name).join "\n"}"
+  end
+
+  Bkblz.log.info do <<EOS
+# Step 10, delete all the files in the bucket that we added. This is
+# a service requirement to deleting a bucket.
+EOS
+  end
+  bucket_files_info.each do |file_info|
+    request = Bkblz::V1::DeleteFileVersionRequest.new file_info
+    delete_file_version_response = api_session.send request
+    Bkblz.log.info "deleted file => #{delete_file_version_response.to_model.file_name}"
+  end
+
+  Bkblz.log.info do <<EOS
+# Step 11, delete the bucket.
+EOS
+  end
+  request = Bkblz::V1::DeleteBucketRequest.new bucket
+  delete_bucket_response = api_session.send request
+  Bkblz.log.info "deleted bucket => #{bucket.bucket_name}/#{bucket.bucket_id}"
+end

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc "Run me to get an overview of using the API"
+task :readme do
+  require './README'
+end

data/bkblz.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bkblz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bkblz"
+  spec.version       = Bkblz::VERSION
+  spec.authors       = ["Erick Johnson"]
+  spec.email         = ["erick@vos.io"]
+
+  spec.summary       = "Bkblz GEM for the Backblaze B2 API. https://www.backblaze.com/b2/docs/"
+  spec.description   = spec.description
+  spec.homepage      = "https://github.com/erickj/bkblz"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/all.rb

@@ -0,0 +1,6 @@
+require "bkblz/core_ext"
+require "bkblz/map_key_formatter"
+
+require "bkblz"
+require "bkblz/v1/all"
+require "bkblz/version"

data/lib/bkblz.rb

@@ -0,0 +1,35 @@
+require "bkblz/config"
+require "bkblz/logger"
+
+module Bkblz
+
+  BaseError = Class.new ::StandardError
+
+  class << self
+    def configure(&block)
+      @config = Bkblz::Config.configure @config, &block
+      config_changed
+    end
+
+    def config
+      unless @config
+        @config = Bkblz::Config.configure
+        config_changed
+      end
+      @config
+    end
+
+    def log
+      @logger ||= config_logger
+    end
+
+    private
+    def config_changed
+      @logger = nil
+    end
+
+    def config_logger
+      @logger = Bkblz::Logger.configure config
+    end
+  end
+end

data/lib/bkblz/config.rb

@@ -0,0 +1,35 @@
+module Bkblz
+
+  class Config
+
+    CONFIG_VARS = {
+      :application_key => '',
+      :account_id => '',
+      :debug_http => false,
+
+      :log_device => :stderr, # [:stdout, :stderr, :devnull, path, fd]
+      :log_level => :warn, # [:debug, :info, :warn, :error, :fatal, (-6..-1)]
+      :log_colorize => true
+    }.freeze
+
+    attr_reader *CONFIG_VARS.keys, :config_map
+
+    def initialize(**config_map)
+      config_map.each do |k,v|
+        # allows attr_reader methods from CONFIG_VAR to work
+        instance_variable_set :"@#{k}", v
+      end
+
+      @config_map = config_map
+    end
+
+    class << self
+      def configure(config=nil, &block)
+        map = config ? config.config_map : CONFIG_VARS.dup
+        yield map if block_given?
+        Config.new map
+      end
+    end
+
+  end
+end

data/lib/bkblz/core_ext.rb

@@ -0,0 +1,22 @@
+module Bkblz
+  module CoreExt
+    refine String do
+      def underscore
+        uncamelify = self.gsub /[a-z\W][A-Z]/ do |m|
+          m.gsub /(^.)/, '\1_'
+        end
+        uncamelify.downcase.gsub(/[^a-z0-9]+/, '_')
+      end
+
+      def demodulize
+        self.split('::').last
+      end
+
+      def camelcase
+        self.gsub /_(.)/ do |match|
+          match[1].upcase
+        end
+      end
+    end
+  end
+end

data/lib/bkblz/logger.rb

@@ -0,0 +1,139 @@
+require 'logger'
+
+module Bkblz
+  class Logger
+    COLOR_MAP = {
+      :d => :green,
+      :i => :blue,
+      :w => :yellow,
+      :e => :red,
+      :f => :pink
+    }
+
+    class << self
+      def configure(config)
+        device = configure_device config.log_device
+
+        logger = ::Logger.new device
+        class << logger
+          include LoggerDebugLevels
+        end
+        raise "missing logger debug methods" unless logger.respond_to? :debug1
+
+        logger.level = case config.log_level
+                       when Symbol, String
+                         ::Logger.const_get config.log_level.to_s.upcase
+                       when Integer
+                         # Negative numbers can be used for detailed debug levels
+                         config.log_level
+                       end
+
+        colorize = config.log_colorize && device.tty?
+        logger.formatter = default_formatter colorize
+
+        if config.log_colorize && !device.tty?
+          logger.warn "disabled log colorization for non-tty"
+        end
+
+        logger
+      end
+
+      private
+      def configure_device(device_value)
+        case device_value
+        when :stderr
+          STDERR
+        when :stdout
+          STDOUT
+        when :devnull
+          File.open File::NULL, "w"
+        when Integer
+          IO.new device_value, 'a'
+        when String
+          File.new device_value 'a'
+        else
+          raise ConfigError, "log_device => #{device_value}"
+        end
+      end
+
+      def default_formatter(colorize)
+        lambda do |severity, datetime, progname, msg|
+          s_key = severity[0].downcase.to_sym
+          if colorize && COLOR_MAP[s_key]
+            severity = Styleizer.apply severity, COLOR_MAP[s_key]
+            progname = Styleizer.apply progname, :bold, :dark_gray
+          end
+
+          if progname
+            "[%s] (%s): %s\n" % [severity, progname, msg]
+          else
+            "[%s] %s\n" % [severity, msg]
+          end
+        end
+      end
+    end
+
+    module LoggerDebugLevels
+      NUM_DEBUG_LEVELS = 6
+
+      ##
+      # Adds methods debug1, debug2, ... debug6 for more detailed
+      # debug levels. Set a negative index +logger.level+ to enable
+      # lower levels, e.g. logger.level = -6 for debug6 messages.
+      (1..NUM_DEBUG_LEVELS).to_a.each do |debug_level|
+        debug_method_name = "debug#{debug_level}"
+
+        define_method debug_method_name do |*args, &block|
+          severity = debug_level * -1
+          return if severity < self.level
+
+          debug_at_level severity, *args, &block
+        end
+      end
+
+      def format_severity(severity)
+        if severity < ::Logger::DEBUG
+          return "D" + severity.abs.to_s
+        else
+          super(severity)[0]
+        end
+      end
+
+      private
+      def debug_at_level(severity, progname=nil, &block)
+        raise 'block required for super debug loggers' unless block_given?
+        raise 'progname required for super debug loggers' unless progname
+
+        add severity, nil, progname, &block
+      end
+    end
+
+    class Styleizer
+      class << self
+
+        STYLE_CODES = {
+          :bold => 1,
+          :red => 31,
+          :green => 32,
+          :yellow => 33,
+          :blue => 34,
+          :pink => 35,
+          :light_blue => 36,
+          :light_gray => 37,
+          :dark_gray => 90
+        }
+
+        def apply(str, *styles)
+          return str unless str
+          styles.reduce(str) { |str, style| styleize STYLE_CODES[style], str }
+        end
+
+        private
+        def styleize(color_code, str)
+          "\e[#{color_code}m#{str}\e[0m"
+        end
+      end
+    end
+
+  end
+end

data/lib/bkblz/map_key_formatter.rb

@@ -0,0 +1,21 @@
+module Bkblz
+  class MapKeyFormatter
+    using Bkblz::CoreExt
+
+    def self.underscore_keys(map)
+      modified_map = {}
+      map.each do |k,v|
+        modified_map[k.to_s.underscore.to_sym] = v
+      end
+      modified_map
+    end
+
+    def self.camelcase_keys(map)
+      modified_map = {}
+      map.each do |k,v|
+        modified_map[k.to_s.camelcase.to_sym] = v
+      end
+      modified_map
+    end
+  end
+end

data/lib/bkblz/v1/all.rb

@@ -0,0 +1,16 @@
+require_relative "model_base"
+require_relative "models"
+
+require_relative "session"
+require_relative "response"
+require_relative "request"
+require_relative "error_response"
+
+require_relative "authorize_account"
+require_relative "list_buckets"
+require_relative "create_bucket"
+require_relative "delete_bucket"
+require_relative "get_upload_url"
+require_relative "upload_file"
+require_relative "list_file_versions"
+require_relative "delete_file_version"

data/lib/bkblz/v1/authorize_account.rb

@@ -0,0 +1,24 @@
+module Bkblz
+  module V1
+    class AuthorizeAccountResponse < Response
+      response_accessors :account_id,
+                         :api_url,
+                         :authorization_token,
+                         :download_url,
+                         :minimum_part_size
+    end
+
+    class AuthorizeAccountRequest < Request
+
+      API_URL = "https://api.backblaze.com/b2api/v1/b2_authorize_account"
+
+      response_class AuthorizeAccountResponse
+
+      def build_request(session)
+        req = Net::HTTP::Get.new URI(API_URL)
+        req.basic_auth(session.config.account_id, session.config.application_key)
+        req
+      end
+    end
+  end
+end

data/lib/bkblz/v1/create_bucket.rb

@@ -0,0 +1,22 @@
+module Bkblz
+  module V1
+
+    class CreateBucketResponse < Response
+      response_model Model::Bucket
+    end
+
+    class CreateBucketRequest < Request
+
+      response_class CreateBucketResponse
+      url_suffix "/b2api/v1/b2_create_bucket"
+
+      def initialize(bucket_model)
+        @body = bucket_model.to_map
+      end
+
+      def build_request(session)
+        session.create_post url(session), @body
+      end
+    end
+  end
+end

data/lib/bkblz/v1/delete_bucket.rb

@@ -0,0 +1,23 @@
+module Bkblz
+  module V1
+
+    class DeleteBucketResponse < Response
+      response_model Model::Bucket
+    end
+
+    class DeleteBucketRequest < Request
+
+      response_class DeleteBucketResponse
+      url_suffix "/b2api/v1/b2_delete_bucket"
+
+      def initialize(bucket_model)
+        @body = {:bucket_id => bucket_model.bucket_id,
+                 :account_id => bucket_model.account_id}
+      end
+
+      def build_request(session)
+        session.create_post url(session), @body
+      end
+    end
+  end
+end

data/lib/bkblz/v1/delete_file_version.rb

@@ -0,0 +1,23 @@
+module Bkblz
+  module V1
+
+    class DeleteFileVersionResponse < Response
+      response_model Model::PartialFileInfo
+    end
+
+    class DeleteFileVersionRequest < Request
+
+      response_class DeleteFileVersionResponse
+      url_suffix "/b2api/v1/b2_delete_file_version"
+
+      def initialize(short_file_info)
+        @body = {:file_name => short_file_info.file_name,
+                 :file_id => short_file_info.file_id}
+      end
+
+      def build_request(session)
+        session.create_post url(session), @body
+      end
+    end
+  end
+end

data/lib/bkblz/v1/error_response.rb

@@ -0,0 +1,24 @@
+module Bkblz
+  module V1
+    class ErrorResponse < Response
+
+      response_model V1::Model::Error
+
+      ERROR_TYPE = {
+        400 => :BAD_REQUEST,
+        401 => :UNAUTHORIZED,
+        403 => :FORBIDDEN,
+        408 => :REQUEST_TIMEOUT,
+        429 => :TOO_MANY_REQUESTS,
+        500 => :INTERNAL_ERROR,
+        503 => :SERVICE_UNAVAILABLE
+      }
+
+      def message
+        model = self.to_model
+        error_type = ERROR_TYPE[model.status]
+        "[#{model.status}:#{error_type}:#{model.code}] #{model.message}"
+      end
+    end
+  end
+end

data/lib/bkblz/v1/get_upload_url.rb

@@ -0,0 +1,22 @@
+module Bkblz
+  module V1
+
+    class GetUploadUrlResponse < Response
+      response_model Model::UploadAuth
+    end
+
+    class GetUploadUrlRequest < Request
+
+      response_class GetUploadUrlResponse
+      url_suffix "/b2api/v1/b2_get_upload_url"
+
+      def initialize(bucket_id)
+        @body = {:bucket_id => bucket_id}
+      end
+
+      def build_request(session)
+        session.create_post url(session), @body
+      end
+    end
+  end
+end

data/lib/bkblz/v1/list_buckets.rb

@@ -0,0 +1,18 @@
+module Bkblz
+  module V1
+
+    class ListBucketsResponse < Response
+      response_accessor :buckets, Model::Bucket
+    end
+
+    class ListBucketsRequest < Request
+
+      response_class ListBucketsResponse
+      url_suffix "/b2api/v1/b2_list_buckets"
+
+      def build_request(session)
+        session.create_post url(session), :account_id => session.account_id
+      end
+    end
+  end
+end

data/lib/bkblz/v1/list_file_versions.rb

@@ -0,0 +1,43 @@
+module Bkblz
+  module V1
+
+    class ListFileVersionsResponse < PaginatedResponse
+      response_accessor :files, Model::FileInfo
+      pagination_accessors :next_file_name, :next_file_id
+
+      def build_next_request(limit)
+        bucket = original_request.bucket
+        ListFileVersionsRequest.new bucket, limit, self
+      end
+    end
+
+    class ListFileVersionsRequest < Request
+
+      response_class ListFileVersionsResponse
+      url_suffix "/b2api/v1/b2_list_file_versions"
+
+      attr_reader :bucket
+
+      def initialize(bucket, max_file_count=1000, paginate_from=nil)
+        @bucket = bucket
+        @body = {}
+        @body[:bucket_id] = bucket.bucket_id
+        @body[:max_file_count] = max_file_count
+
+        if paginate_from
+          raise 'invalid paginator' unless paginate_from.is_a? ListFileVersionsResponse
+
+          next_file_name = paginate_from.next_file_name
+          next_file_id = paginate_from.next_file_id
+
+          @body[:start_file_name] = next_file_name if next_file_name
+          @body[:start_file_id] = next_file_id if next_file_id
+        end
+      end
+
+      def build_request(session)
+        session.create_post url(session), @body
+      end
+    end
+  end
+end

data/lib/bkblz/v1/model_base.rb

@@ -0,0 +1,37 @@
+module Bkblz
+  module V1
+    module Model
+
+      def self.define(*fields)
+        model_klass = Class.new BaseModel
+        model_klass.field_accessors *fields
+        model_klass
+      end
+
+      class BaseModel
+
+        class << self
+          def field_accessors(*fields)
+            fields.each do |field|
+              define_method field do |*args|
+                @map[field]
+              end
+            end
+          end
+        end
+
+        def initialize(map)
+          @map = map
+        end
+
+        def to_map
+          @map.dup
+        end
+
+        def to_s
+          "#<%s:%d %s>" % [self.class.name, __id__, @map]
+        end
+      end
+    end
+  end
+end

data/lib/bkblz/v1/models.rb

@@ -0,0 +1,29 @@
+module Bkblz
+  module V1
+    module Model
+
+      # Returned by list_buckets, create_bucket, delete_bucket
+      Bucket = Model.define :account_id, :bucket_id, :bucket_name, :bucket_type
+
+      # Returned by list_file_versions
+      File = Model.define *[
+        :action, :content_length, :file_id, :file_name, :size, :upload_timestamp
+      ]
+
+      # Returned by upload_file
+      FileInfo = Model.define *[
+        :account_id, :bucket_id, :content_length, :content_sha1, :content_type,
+        :file_id, :file_info, :file_name
+      ]
+
+      # Returned by delete_file_version
+      PartialFileInfo = Model.define :file_id, :file_name
+
+      # Returned by get_upload_url
+      UploadAuth = Model.define :bucket_id, :upload_url, :authorization_token
+
+      # Possibly returned by any request
+      Error = Model.define :status, :code, :message
+    end
+  end
+end

data/lib/bkblz/v1/request.rb

@@ -0,0 +1,81 @@
+require 'net/http'
+
+module Bkblz
+  module V1
+
+    TooManyRedirectError = Class.new Bkblz::BaseError
+
+    class RequestError < Bkblz::BaseError
+      def initialize(error_response)
+        super error_response.message
+      end
+    end
+
+    class Request
+
+      class << self
+        def response_class(klass=nil)
+          @response_class = klass unless klass.nil?
+          @response_class
+        end
+
+        def url_suffix(suffix=nil)
+          @url_suffix = suffix unless suffix.nil?
+          @url_suffix
+        end
+      end
+
+      def send(session)
+        request = build_request session
+        Bkblz.log.debug { "sending request => #{request} to URI => #{request.uri}" }
+        http = Net::HTTP.new(request.uri.host, request.uri.port)
+        http.use_ssl = true
+        http.set_debug_output(STDERR) if session.config.debug_http
+
+        build_response fetch(http, request)
+      end
+
+      protected
+
+      def build_request(session)
+        raise 'not implemented'
+      end
+
+      def build_response(response)
+        unless response.kind_of? Net::HTTPSuccess
+          error_response = ErrorResponse.new response, self
+          raise RequestError.new error_response
+        end
+        Bkblz.log.debug { "#build_response => #{response}" }
+
+        response_class = self.class.response_class || Response
+        response_class.new response, self
+      end
+
+      def url(session)
+        raise "no URL suffix for #{self.class}" unless self.class.url_suffix
+        session.create_url(self.class.url_suffix)
+      end
+
+      private
+
+      def fetch(http, request, limit=10)
+        # You should choose a better exception.
+        raise TooManyRedirectError, 'too many HTTP redirects' if limit == 0
+
+        response = http.start { |http| http.request(request) }
+
+        case response
+        when Net::HTTPSuccess then
+          response
+        when Net::HTTPRedirection then
+          location = response['location']
+          Bkblz.log.warn "redirected to #{location}"
+          fetch http, location, limit - 1
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/bkblz/v1/response.rb

@@ -0,0 +1,114 @@
+require 'json'
+
+module Bkblz
+  module V1
+    class Response
+
+      MissingResponseError = Class.new Bkblz::BaseError
+
+      attr_reader :parsed_body, :http_response
+
+      class << self
+
+        def response_model(klass=nil)
+          @response_model = klass unless klass.nil?
+          @response_model
+        end
+
+        def response_accessors(*response_fields)
+          response_fields.each do |response_field|
+            response_accessor response_field
+          end
+        end
+
+        def response_accessor(response_field, model_klass=nil, &block)
+          api_map_key_converter = lambda do |map|
+            raise "not a Hash" unless map.is_a? Hash
+            Bkblz::MapKeyFormatter.underscore_keys map
+          end
+          api_value_transformer = lambda do |value|
+            return value unless model_klass || block_given?
+            return yield value if block_given?
+
+            if value.is_a? Array
+              value.map do |v|
+                model_klass.new api_map_key_converter.call(v)
+              end
+            else
+              model_klass.new api_map_key_converter.call(value)
+            end
+          end
+
+          define_method response_field do |*args|
+            raise MissingResponseError unless @parsed_response
+            return @cache[response_field] if @cache.key? response_field
+
+            value = @parsed_response[response_field]
+            @cache[response_field] = api_value_transformer.call value
+          end
+        end
+      end
+
+      def initialize(http_response, original_request)
+        @http_response = http_response
+        @original_request = original_request
+
+        @parsed_response = parse http_response
+        @cache = {}
+        Bkblz.log.debug { "parsed response => #{@parsed_response}" }
+      end
+
+      attr_reader :original_request
+      protected :original_request
+
+      def [](key)
+        @parsed_response[key]
+      end
+
+      def to_model
+        raise 'no response model defined' unless self.class.response_model
+        self.class.response_model.new @parsed_response.dup
+      end
+
+      private
+      def parse(http_response)
+        parsed_json = JSON.parse http_response.body, {
+                                   :allow_nan => true,
+                                   :symbolize_names => true,
+                                   :max_nesting => 4
+                                 }
+        Bkblz::MapKeyFormatter.underscore_keys parsed_json
+      end
+    end
+
+    class PaginatedResponse < Response
+
+      NoMorePagesError = Class.new Bkblz::BaseError
+
+      class << self
+
+        attr_reader :pagination_fields
+        def pagination_accessors(*pagination_fields)
+          response_accessors *pagination_fields
+
+          @pagination_fields ||= []
+          @pagination_fields.concat pagination_fields
+        end
+      end
+
+      def has_more?
+        self.class.pagination_fields.any? { |f| !self[f].nil? }
+      end
+
+      def next_request(limit=nil)
+        raise NoMorePagesError unless has_more?
+        build_next_request(limit)
+      end
+
+      private
+      def build_next_request(limit)
+        raise "not implemented"
+      end
+    end
+  end
+end

data/lib/bkblz/v1/session.rb

@@ -0,0 +1,72 @@
+require 'uri'
+
+module Bkblz
+  module V1
+
+    SessionNotAuthorizedError = Class.new Bkblz::BaseError
+
+    class Session
+
+      class << self
+        def authorize(config, &block)
+          session = Session.new config
+          session.auth_response =
+            session.send Bkblz::V1::AuthorizeAccountRequest.new
+
+          yield(session) if block_given?
+          session
+        end
+      end
+
+      attr_accessor :config, :auth_response
+
+      def initialize(config)
+        @config = config
+      end
+
+      def send(request)
+        request.send self
+      end
+
+      def account_id
+        check_authorized
+        auth_response.account_id
+      end
+
+      def authorized?
+        !!auth_response && !!auth_response.authorization_token
+      end
+
+      def create_url(url_suffix)
+        check_authorized
+        URI.join auth_response.api_url, url_suffix
+      end
+
+      def create_post(url, body=nil, addl_headers={})
+        Bkblz.log.debug { "creating post for request => #{url}" }
+        check_authorized
+
+        uri = url.is_a?(URI) ? url : URI(url)
+        request = Net::HTTP::Post.new uri
+
+        if body.is_a? Hash
+          body = Bkblz::MapKeyFormatter.camelcase_keys(body).to_json
+        end
+        request.body = body if body
+
+        headers = {:"Authorization" => auth_response.authorization_token}
+        headers.merge(addl_headers).each do |k,v|
+          Bkblz.log.debug2 { "adding request header => #{k}:#{v}" }
+          request.add_field k.to_s, v unless v.nil?
+        end
+
+        request
+      end
+
+      private
+      def check_authorized
+        raise SessionNotAuthorizedError unless authorized?
+      end
+    end
+  end
+end

data/lib/bkblz/v1/upload_file.rb

@@ -0,0 +1,50 @@
+require "digest/sha1"
+
+module Bkblz
+  module V1
+
+    TooManyBzInfoHeadersError = Class.new Bkblz::BaseError
+
+    class UploadFileResponse < Response
+      response_model Model::FileInfo
+    end
+
+    class UploadFileRequest < Request
+
+      response_class UploadFileResponse
+
+      REQUIRED_HEADERS = {
+                          :"Authorization" => nil,
+                          :"X-Bz-File-Name" => nil,
+                          :"Content-Type" => "b2/x-auto",
+                          :"Content-Length" => nil,
+                          :"X-Bz-Content-Sha1" => nil
+      }
+
+      def initialize(upload_auth, body, file_name, content_type=nil,
+                     last_modified_millis=nil, **bz_info)
+        unless last_modified_millis
+          # Recommended https://www.backblaze.com/b2/docs/b2_upload_file.html
+          bz_info["src_last_modified_millis"] = last_modified_millis
+        end
+        raise TooManyBzInfoHeadersError, bz_info_headers if bz_info.size > 10
+
+        @upload_url = upload_auth.upload_url
+        @body = body.is_a?(IO) ? body.read : body
+        @headers = REQUIRED_HEADERS.dup
+        bz_info.each do |k,v|
+          @headers["X-Bz-Info-#{k.to-s}".to_sym] = v
+        end
+
+        @headers[:"Authorization"] = upload_auth.authorization_token
+        @headers[:"X-Bz-File-Name"] = file_name
+        @headers[:"Content-Length"] = @body.size
+        @headers[:"X-Bz-Content-Sha1"] = Digest::SHA1.hexdigest @body
+      end
+
+      def build_request(session)
+        session.create_post @upload_url, @body, @headers
+      end
+    end
+  end
+end

data/lib/bkblz/version.rb

@@ -0,0 +1,3 @@
+module Bkblz
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: bkblz
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Erick Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: ''
+email:
+- erick@vos.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.rb
+- Rakefile
+- bkblz.gemspec
+- lib/all.rb
+- lib/bkblz.rb
+- lib/bkblz/config.rb
+- lib/bkblz/core_ext.rb
+- lib/bkblz/logger.rb
+- lib/bkblz/map_key_formatter.rb
+- lib/bkblz/v1/all.rb
+- lib/bkblz/v1/authorize_account.rb
+- lib/bkblz/v1/create_bucket.rb
+- lib/bkblz/v1/delete_bucket.rb
+- lib/bkblz/v1/delete_file_version.rb
+- lib/bkblz/v1/error_response.rb
+- lib/bkblz/v1/get_upload_url.rb
+- lib/bkblz/v1/list_buckets.rb
+- lib/bkblz/v1/list_file_versions.rb
+- lib/bkblz/v1/model_base.rb
+- lib/bkblz/v1/models.rb
+- lib/bkblz/v1/request.rb
+- lib/bkblz/v1/response.rb
+- lib/bkblz/v1/session.rb
+- lib/bkblz/v1/upload_file.rb
+- lib/bkblz/version.rb
+homepage: https://github.com/erickj/bkblz
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Bkblz GEM for the Backblaze B2 API. https://www.backblaze.com/b2/docs/
+test_files: []