qinium 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97006dadb420603b659536192b0d996ddb925d6ec024fc5553970b437b45553e
+  data.tar.gz: 2de51b37c7a5e8c314724c2594525885e086ea5d764888b922d6f91cec2e1c66
+SHA512:
+  metadata.gz: 5f907d3494a958568d0aeabfc978133b1eabd46f04da4e55e536da7b8611e0bec2dc0f1a92772c4e588ad5c9f5f6f46c6abb6d5e9842abc79f091de5f4b5553e
+  data.tar.gz: ddc54d441f0dca3e48a6f7a14762f7b5d37624e10100a2561b1ef06bd8541c3156c5ed6d72fec2b194b5d307cb55803be874f67028349c848254a4c3127eb174

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-08-10
+
+- Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in qinium.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+
+gem "vcr", "~> 6.1"
+
+gem "webmock", "~> 3.17"

data/Gemfile.lock

@@ -0,0 +1,68 @@
+PATH
+  remote: .
+  specs:
+    qinium (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.2)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.5.0)
+    hashdiff (1.0.1)
+    parallel (1.22.1)
+    parser (3.1.1.0)
+      ast (~> 2.4.1)
+    public_suffix (4.0.7)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.27.0)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.16.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.17.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.1.0)
+    vcr (6.1.0)
+    webmock (3.17.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  qinium!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+  vcr (~> 6.1)
+  webmock (~> 3.17)
+
+BUNDLED WITH
+   2.3.9

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 张小辉
+
+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.md

@@ -0,0 +1,33 @@
+# Qinium
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/qinium`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add qinium
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install qinium
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/qinium.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/qinium/auth.rb

@@ -0,0 +1,36 @@
+class Qinium
+  module Auth
+    extend self
+
+    def calculate_hmac_sha1_digest(secret_key, str)
+      OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha1"), secret_key, str)
+    end
+
+    def generate_access_token(access_key, secret_key, url, body = {})
+      encoded_sign = generate_access_token_sign_with_mac(secret_key, url, body)
+
+      "#{access_key}:#{encoded_sign}"
+    end
+
+    def generate_access_token_sign_with_mac(secret_key, url, body)
+      ### 解析URL，生成待签名字符串
+      uri = URI.parse(url)
+      signing_str = uri.path
+
+      # 如有QueryString部分，则需要加上
+      query_string = uri.query
+      signing_str += "?" + query_string if query_string.is_a?(String) && !query_string.empty?
+
+      # 追加换行符
+      signing_str += "\n"
+
+      # 如果有Body，则也加上
+      # （仅限于mime == "application/x-www-form-urlencoded"的情况）
+      signing_str += body if body.is_a?(String) && !body.strip.empty?
+
+      ### 生成数字签名
+      sign = calculate_hmac_sha1_digest(secret_key, signing_str)
+      Utils.urlsafe_base64_encode(sign)
+    end
+  end
+end

data/lib/qinium/client.rb

@@ -0,0 +1,138 @@
+class Qinium
+  class Client
+    include Qinium::Utils
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    # rubocop: disable Style/SingleLineMethods
+    def user_agent; config.user_agent end
+    def access_key; config.access_key end
+    def secret_key; config.secret_key end
+    # rubocop: enable Style/SingleLineMethods
+
+    def get(url, opts = {})
+      opts[:raise] = true unless opts.key?(:raise)
+      req_headers = {
+        connection: "close",
+        accept: "*/*",
+        user_agent: user_agent
+      }
+      req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == "https"
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      logger.debug "Get #{uri}"
+      logger.debug " options: #{opts.to_json}"
+
+      req = Net::HTTP::Get.new(uri)
+      req_headers.each_pair do |key, value|
+        req.add_field key, value
+      end
+      res = http.request(req)
+      code = res.code.to_i
+      body = res.body
+      headers = res.header.to_hash.transform_values do |v|
+        v.join(", ")
+      end
+
+      if headers["content-type"] == "application/json"
+        body = begin
+          JSON.parse(body)
+        rescue StandardError
+          {}
+        end
+      end
+      raise APIError.new(code, body, headers) if opts[:raise] && !success?(code)
+
+      [code, body, headers]
+    end
+
+    def post(url, req_body = "", opts = {})
+      opts[:raise] = true unless opts.key?(:raise)
+      req_headers = {
+        connection: "close",
+        accept: "*/*",
+        user_agent: user_agent
+      }
+      req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      if uri.scheme == "https"
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+
+      logger.debug "POST #{uri}"
+      logger.debug "    body: #{req_body[0, 50]}"
+      logger.debug " headers: #{opts.to_json}"
+
+      req = Net::HTTP::Post.new(uri)
+      req_headers.each_pair do |key, value|
+        req.add_field key, value
+      end
+      req.body = req_body
+      res = http.request(req)
+      code = res.code.to_i
+      body = res.body
+      headers = res.header.to_hash.transform_values do |v|
+        v.join(", ")
+      end
+      if headers["content-type"] == "application/json"
+        body = begin
+          JSON.parse(body)
+        rescue StandardError
+          nil
+        end
+      end
+      raise APIError.new(code, body, headers) if opts[:raise] && !success?(code)
+
+      [code, body, headers]
+    end
+
+    def management_get(url)
+      access_token = Auth.generate_access_token(access_key, secret_key, url)
+      get(url, headers: {
+            "Content-Type" => "application/x-www-form-urlencoded",
+            "Authorization" => "QBox " + access_token
+          })
+    end
+
+    def management_post(url, body = nil)
+      body = JSON.dump(body) if body && body.size > 0
+      access_token = Auth.generate_access_token(access_key, secret_key, url, body)
+      post(url, body, headers: {
+             "Content-Type" => "application/x-www-form-urlencoded",
+             "Authorization" => "QBox " + access_token
+           })
+    end
+
+    def self.success?(http_code)
+      http_code.between?(200, 299)
+    end
+
+    def success?(http_code)
+      self.class.success?(http_code)
+    end
+
+    def self.to_query(params)
+      if params.is_a?(Hash)
+        total_param = params.map do |key, value|
+          %(#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s).gsub("+", "%20")})
+        end
+        return total_param.join("&")
+      end
+
+      params
+    end
+  end
+end

data/lib/qinium/config.rb

@@ -0,0 +1,66 @@
+class Qinium
+  class Config < Configurable
+    def initialize(options = {})
+      options[:protocol] ||= :https
+      options = if options[:protocol] == :http
+                  http_options.merge(options)
+                else
+                  https_options.merge(options)
+                end
+      super(default_options.merge(options))
+    end
+
+    def up_host(bucket = self.bucket)
+      HostManager.new(self).up_host(bucket)
+    end
+
+    def put_policy_options
+      @put_policy_options ||= self[:put_policy_options] || Configurable.new
+    end
+
+    private
+
+    def default_options
+      {
+        user_agent: "QiniumRuby/#{VERSION} (#{RUBY_PLATFORM}) Ruby/#{RUBY_VERSION}",
+        method: :post,
+        content_type: "application/x-www-form-urlencoded",
+        auth_url: "https://acc.qbox.me/oauth2/token",
+        access_key: "",
+        secret_key: "",
+        auto_reconnect: true,
+        max_retry_times: 3,
+        block_size: 1024 * 1024 * 4,
+        chunk_size: 1024 * 256,
+        enable_debug: true,
+        tmpdir: Dir.tmpdir + File::SEPARATOR + "QiniuRuby",
+        multi_region: false,
+        bucket_private: false
+      }.freeze
+    end
+
+    def http_options
+      {
+        rs_host: "http://rs.qiniu.com",
+        rsf_host: "http://rsf.qbox.me",
+        pub_host: "http://pu.qbox.me:10200",
+        eu_host: "http://eu.qbox.me",
+        uc_host: "http://uc.qbox.me",
+        api_host: "http://api.qiniu.com",
+        protocol: :http
+      }.freeze
+    end
+
+    def https_options
+      {
+        rs_host: "https://rs.qbox.me",
+        rsf_host: "https://rsf.qbox.me",
+        pub_host: "https://pu.qbox.me",
+        eu_host: "https://eu.qbox.me",
+        uc_host: "https://uc.qbox.me",
+        api_host: "https://api.qiniu.com",
+        protocol: :https
+      }.freeze
+    end
+  end
+end

data/lib/qinium/configurable.rb

@@ -0,0 +1,26 @@
+class Qinium
+  class Configurable < Hash
+    def initialize(defaults = {})
+      defaults.each_pair do |k, v|
+        self[k.to_sym] = v.is_a?(Hash) ? Configurable.new(v) : v
+      end
+    end
+
+    def []=(k, v)
+      super(k.to_sym, v)
+    end
+
+    def method_missing(method, *args)
+      if method.to_s.end_with?("=")
+        self[method.to_s[0..-2].to_sym] = args[0]
+      else
+        fetch(method.to_sym)
+      end
+    end
+
+    def respond_to_missing?(method)
+      key = method.to_s.end_with?("=") ? method.to_s[0..-2].to_sym : method
+      key?(key)
+    end
+  end
+end

data/lib/qinium/errors.rb

@@ -0,0 +1,14 @@
+class Qinium
+  Error = Class.new(StandardError)
+
+  class APIError < StandardError
+    attr_reader :code, :body, :headers
+
+    def initialize(code, body, headers)
+      @code = code
+      @body = body
+      @headers = headers
+      super(body)
+    end
+  end
+end

data/lib/qinium/host_manager.rb

@@ -0,0 +1,91 @@
+class Qinium
+  class HostManager
+    class Cache
+      def initialize
+        @mutex = Mutex.new
+        @hosts = {}
+      end
+
+      def read(access_key, bucket, &block)
+        @mutex.synchronize do
+          key = cache_key(access_key, bucket)
+          data = @hosts[key]
+          if data && Time.now.to_i > data["expires_at"]
+            @hosts.delete key
+            data = nil
+          end
+          if data.nil?
+            data = block.call
+            data["expires_at"] = Time.now.to_i + data["ttl"]
+            @hosts[key] = data.freeze
+          end
+          data
+        end
+      end
+
+      def write(access_key, bucket, hosts)
+        @mutex.synchronize do
+          @hosts[cache_key(access_key, bucket)] = hosts
+        end
+      end
+
+      def delete(access_key, bucket)
+        @mutex.synchronize do
+          @hosts.delete(cache_key(access_key, bucket))
+        end
+      end
+
+      def cache_key(access_key, bucket)
+        Digest::SHA1.base64digest "#{access_key}-#{bucket}"
+      end
+    end
+
+    def self.cache
+      @cache ||= Cache.new
+    end
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def up_host(bucket, opts = {})
+      up_hosts(bucket, opts)[0]
+    end
+
+    def up_hosts(bucket, opts = {})
+      hosts = hosts(bucket)
+      hosts[extract_protocol(opts)]["up"]
+    end
+
+    def hosts(bucket)
+      raise Error, "access_key is missing" if Utils.blank?(access_key)
+      raise Error, "bucket is missing" if Utils.blank?(bucket)
+
+      cache.read(access_key, bucket) do
+        query = Client.to_query(ak: access_key, bucket: bucket)
+        url = "#{config.uc_host}/v1/query?#{query}"
+        http = Client.new(config)
+        code, body, headers = http.get(url)
+        raise APIError.new(code, body, headers) unless Client.success?(code)
+
+        body
+      end
+    end
+
+    private
+
+    def cache
+      self.class.cache
+    end
+
+    def access_key
+      config.access_key
+    end
+
+    def extract_protocol(opts)
+      (opts[:protocol] || config.protocol).to_s
+    end
+  end
+end

data/lib/qinium/object.rb

@@ -0,0 +1,50 @@
+class Qinium
+  class Object
+    include Qinium::Utils
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    # rubocop: disable Style/SingleLineMethods
+    def config; client.config end
+    def bucket; config.bucket end
+    # rubocop: enable Style/SingleLineMethods
+
+    def mkblk(blk, token:, host: nil)
+      host ||= config.up_host
+      client.post("#{host}/mkblk/#{blk.size}", blk, headers: {
+                    "Content-Type" => "application/octet-stream",
+                    "Content-Length" => blk.size,
+                    "Authorization" => "UpToken #{token}"
+                  })
+    end
+
+    def mkfile(token:, file_size:, blocks:, key: nil, fname: nil, mime_type: nil, user_vars: nil)
+      url = config.up_host
+      url += "/mkfile/#{file_size}"
+      url += "/key/#{urlsafe_base64_encode(key)}" if key
+      url += "/fname/#{urlsafe_base64_encode(fname)}" if fname
+      url += "/mimeType/#{urlsafe_base64_encode(mime_type)}" if mime_type
+      url += "/x:user-var/#{urlsafe_base64_encode(user_vars)}" if user_vars
+      client.post(url, blocks.join(","), headers: {
+                    "Context-Type" => "text/plain",
+                    "Authorization" => "UpToken #{token}"
+                  })
+    end
+
+    def delete(key, bucket: self.bucket)
+      client.management_post(config.rs_host + "/delete/" + Utils.encode_entry_uri(
+        bucket, key
+      ))
+    end
+
+    def list(bucket: self.bucket, marker: "", limit: 1000, prefix: "", delimiter: "")
+      query_string = to_query_string(bucket: bucket, marker: marker, limit: limit, prefix: prefix,
+                                     delimiter: delimiter)
+      client.management_get(config.rsf_host + "/list?" + query_string)
+    end
+  end
+end

data/lib/qinium/put_policy.rb

@@ -0,0 +1,91 @@
+class Qinium
+  class PutPolicy
+    include Qinium::Utils
+
+    DEFAULT_AUTH_SECONDS = 300
+
+    PARAMS = {
+      # 字符串类型参数
+      scope: "scope",
+      is_prefixal_scope: "isPrefixalScope",
+      save_key: "saveKey",
+      end_user: "endUser",
+      return_url: "returnUrl",
+      return_body: "returnBody",
+      callback_url: "callbackUrl",
+      callback_host: "callbackHost",
+      callback_body: "callbackBody",
+      callback_body_type: "callbackBodyType",
+      persistent_ops: "persistentOps",
+      persistent_notify_url: "persistentNotifyUrl",
+      persistent_pipeline: "persistentPipeline",
+
+      # 数值类型参数
+      deadline: "deadline",
+      insert_only: "insertOnly",
+      fsize_min: "fsizeMin",
+      fsize_limit: "fsizeLimit",
+      detect_mime: "detectMime",
+      mime_limit: "mimeLimit",
+      uphosts: "uphosts",
+      global: "global",
+      delete_after_days: "deleteAfterDays",
+      file_type: "fileType"
+    }
+
+    PARAMS.each_pair do |key, _|
+      attr_accessor key
+    end
+
+    attr_reader :config, :bucket, :key
+
+    def initialize(config, bucket: nil, key: nil, expires_in: DEFAULT_AUTH_SECONDS)
+      @config = config
+      scope!(bucket || config.bucket, key)
+      expires_in! expires_in
+    end
+
+    def scope!(bucket, key = nil)
+      @bucket = bucket
+      @key    = key
+
+      @scope = if key.nil?
+                 # 新增语义，文件已存在则失败
+                 bucket
+               else
+                 # 覆盖语义，文件已存在则直接覆盖
+                 "#{bucket}:#{key}"
+               end
+    end
+
+    def expires_in!(seconds)
+      @deadline = Time.now.to_i + seconds
+    end
+
+    def to_json(*_args)
+      args = {}
+
+      PARAMS.each_pair do |key, fld|
+        val = __send__(key)
+        args[fld] = val unless val.nil?
+      end
+
+      args.to_json
+    end
+
+    def to_token
+      access_key = config.access_key
+      secret_key = config.secret_key
+
+      ### 生成待签名字符串
+      encoded_put_policy = urlsafe_base64_encode(to_json)
+
+      ### 生成数字签名
+      sign = Auth.calculate_hmac_sha1_digest(secret_key, encoded_put_policy)
+      encoded_sign = urlsafe_base64_encode(sign)
+
+      ### 生成上传授权凭证
+      "#{access_key}:#{encoded_sign}:#{encoded_put_policy}"
+    end
+  end
+end

data/lib/qinium/utils.rb

@@ -0,0 +1,43 @@
+class Qinium
+  module Utils
+    extend self
+
+    def urlsafe_base64_encode(content)
+      Base64.encode64(content).strip.gsub("+", "-").gsub("/", "_").gsub(/\r?\n/, "")
+    end
+
+    def urlsafe_base64_decode(encoded_content)
+      Base64.decode64 encoded_content.gsub("_", "/").gsub("-", "+")
+    end
+
+    def encode_entry_uri(bucket, key)
+      entry_uri = bucket + ":" + key
+      urlsafe_base64_encode(entry_uri)
+    end
+
+    def blank?(obj)
+      case obj
+      when String then obj.strip.empty?
+      when NilClass then true
+      when Array, Hash then obj.size.zero?
+      else
+        false
+      end
+    end
+
+    def to_query_string(hash)
+      args = []
+      hash.keys.sort_by(&:to_s).each do |key|
+        value = hash[key]
+        next if value.nil?
+
+        args.push("#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}")
+      end
+      args.join("&")
+    end
+
+    def logger
+      @logger ||= Logger.new(STDOUT, level: Qinium.logger_level)
+    end
+  end
+end

data/lib/qinium/version.rb

@@ -0,0 +1,3 @@
+class Qinium
+  VERSION = "0.1.1"
+end

data/lib/qinium.rb

@@ -0,0 +1,39 @@
+class Qinium
+  require "logger"
+  require "base64"
+  require "tempfile"
+  require "openssl"
+  require "digest/sha1"
+  require "cgi"
+  require "net/http"
+  require "json"
+  require "qinium/version"
+  require "qinium/errors"
+  require "qinium/utils"
+  require "qinium/configurable"
+  require "qinium/config"
+  require "qinium/client"
+  require "qinium/host_manager"
+  require "qinium/auth"
+  require "qinium/object"
+  require "qinium/put_policy"
+
+  @logger_level = :info
+  class << self
+    attr_accessor :logger_level
+  end
+
+  attr_reader :config
+
+  def initialize(options = {})
+    @config = Config.new(options)
+  end
+
+  def object
+    @object ||= Object.new(client)
+  end
+
+  def client
+    @client ||= Client.new(config)
+  end
+end

data/qinium.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "lib/qinium/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "qinium"
+  spec.version = Qinium::VERSION
+  spec.authors = ["xiaohui"]
+  spec.email = ["xiaohui@tanmer.com"]
+
+  spec.summary = "Qiniu Cloud Storage SDK for multi-tenant system"
+  spec.description = "Qiniu Cloud Storage SDK for multi-tenant system, can call API with multiple accounts"
+  spec.homepage = "https://github.com/xiaohui-zhangxh/qinium"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+
+  spec.require_paths = ["lib"]
+end

data/sig/qinium.rbs

@@ -0,0 +1,4 @@
+module Qinium
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: qinium
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- xiaohui
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-08-10 00:00:00.000000000 Z
+dependencies: []
+description: Qiniu Cloud Storage SDK for multi-tenant system, can call API with multiple
+  accounts
+email:
+- xiaohui@tanmer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/qinium.rb
+- lib/qinium/auth.rb
+- lib/qinium/client.rb
+- lib/qinium/config.rb
+- lib/qinium/configurable.rb
+- lib/qinium/errors.rb
+- lib/qinium/host_manager.rb
+- lib/qinium/object.rb
+- lib/qinium/put_policy.rb
+- lib/qinium/utils.rb
+- lib/qinium/version.rb
+- qinium.gemspec
+- sig/qinium.rbs
+homepage: https://github.com/xiaohui-zhangxh/qinium
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/xiaohui-zhangxh/qinium
+  source_code_uri: https://github.com/xiaohui-zhangxh/qinium
+  changelog_uri: https://github.com/xiaohui-zhangxh/qinium/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Qiniu Cloud Storage SDK for multi-tenant system
+test_files: []