swift_client 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cb7d0291c3fcc0d03fd4aa4711c8c7c4a06b46bf
-  data.tar.gz: 8caa6d7f8e4e21ce1567f7d968e6197fd83760f4
+SHA256:
+  metadata.gz: 9703134ee4b5656b16c32f49305288723eb7f66d6942c2f6392ac9f663803c96
+  data.tar.gz: 8f97e98bc8c83e549e4359b53891e0d12b4673a8990426704658a3c78289e546
 SHA512:
-  metadata.gz: 88d70e38c7d901e1625c03d12e7a9e016f7d26a3687c1ad3282cc7c29847a3cdfc168ce275453cfd69aff8e27a7ece108c25d2438c3e989beae693d8c17688dd
-  data.tar.gz: eada405a14079e11075ba3a378461c2975da0ef2107609dcf706dca2373da5fde6eea263376873bab01455e38d84d2dd512feacc9a15b84c9395ef55ae0b2bbc
+  metadata.gz: b06d3358d7d40de924ccdaff5e1de219e1d4882ea5e607f9d9fdff47b260ce57338dbdc92d19f80c5b9908257d3397ca37b6ab38e6a0353ead8f63124e983659
+  data.tar.gz: 1c5fa028f57c0f460d4f4a28b52534033cf4045212ba64df9bd32d58fa2291377a81d5b815249b79e51db71c526405123b23991e94c09daeed2043bb2c9ee624

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+.ruby-version

data/.travis.yml

@@ -1,9 +1,8 @@
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.7
-  - 2.2.3
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
 
 install:
   - "travis_retry bundle install"

data/README.md

@@ -101,7 +101,8 @@ swift_client = SwiftClient.new(
   :auth_url => "https://auth.example.com/v3",
   :storage_url => "https://storage.example.com/v1/AUTH_account",
   :user_id => "user id",
-  :password => "password"
+  :password => "password",
+  :interface => "internal"
 )
 
 # OR
@@ -126,33 +127,83 @@ access the response body and JSON response. Checkout the
 
 SwiftClient offers the following requests:
 
-* head_account -> HTTParty::Response
-* post_account(headers = {}) -> HTTParty::Response
-* head_containers -> HTTParty::Response
-* get_containers(query = {}) -> HTTParty::Response
-* paginate_containers(query = {}) -> Enumerator
-* get_container(container_name, query = {}) -> HTTParty::Response
-* paginate_container(container_name, query = {}) -> Enumerator
-* head_container(container_name) -> HTTParty::Response
-* put_container(container_name, headers = {}) -> HTTParty::Response
-* post_container(container_name, headers = {}) -> HTTParty::Response
-* delete_container(container_name) -> HTTParty::Response
-* put_object(object_name, data_or_io, container_name, headers = {}) -> HTTParty::Response
-* post_object(object_name, container_name, headers = {}) -> HTTParty::Response
-* get_object(object_name, container_name) -> HTTParty::Response
-* head_object(object_name, container_name) -> HTTParty::Response
-* delete_object(object_name, container_name) -> HTTParty::Response
-* get_objects(container_name, query = {}) -> HTTParty::Response
-* paginate_objects(container_name, query = {}) -> Enumerator
-* public_url(object_name, container_name) -> HTTParty::Response
-* temp_url(object_name, container_name, options = {}) -> HTTParty::Response
-* bulk_delete(entries) -> entries
+* `head_account(options = {}) # => HTTParty::Response`
+* `post_account(headers = {}, options = {}) # => HTTParty::Response`
+* `head_containers(options = {}) # => HTTParty::Response`
+* `get_containers(query = {}, options = {}) # => HTTParty::Response`
+* `paginate_containers(query = {}, options = {}) # => Enumerator`
+* `get_container(container_name, query = {}, options = {}) # => HTTParty::Response`
+* `paginate_container(container_name, query = {}, options = {}) # => Enumerator`
+* `head_container(container_name, options = {}) # => HTTParty::Response`
+* `put_container(container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `post_container(container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `delete_container(container_name, options = {}) # => HTTParty::Response`
+* `put_object(object_name, data_or_io, container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `post_object(object_name, container_name, headers = {}, options = {}) # => HTTParty::Response`
+* `get_object(object_name, container_name, options = {}) -> HTTParty::Response`
+* `get_object(object_name, container_name, options = {}) { |chunk| save chunk } # => HTTParty::Response`
+* `head_object(object_name, container_name, options = {}) # => HTTParty::Response`
+* `delete_object(object_name, container_name, options = {}) # => HTTParty::Response`
+* `get_objects(container_name, query = {}, options = {}) # => HTTParty::Response`
+* `paginate_objects(container_name, query = {}, options = {}) # => Enumerator`
+* `public_url(object_name, container_name) # => HTTParty::Response`
+* `temp_url(object_name, container_name, options = {}) # => HTTParty::Response`
+* `bulk_delete(entries, options = {}) # => entries`
+* `post_head(object_name, container_name, _headers = {}, options = {}) # => HTTParty::Response`
+
+By default, the client instructs the Swift server to return JSON via an HTTP Accept header; to disable this pass `:json => false` in `options`. The rest of the `options` are passed directly to the internal [HTTParty](https://rubygems.org/gems/httparty) client.
+
+### Getting large objects
+The `get_object` method with out a block is suitable for small objects that easily fit in memory. For larger objects, specify a block to process chunked data as it comes in.
+
+```ruby
+File.open("/tmp/output", "wb") do |file_io|
+  swift_client.get_object("/large/object", "container") do |chunk|
+    file_io.write(chunk)
+  end
+end
+```
+
+## Re-Using/Sharing/Caching Auth Tokens
+
+Certain OpenStack/Swift providers have limits in place regarding token
+generation. To re-use auth tokens by caching them via memcached, install dalli
+
+`gem install dalli`
+
+and provide an instance of Dalli::Client to SwiftClient:
+
+```ruby
+swift_client = SwiftClient.new(
+  :auth_url => "https://example.com/auth/v1.0",
+  ...
+  :cache_store => Dalli::Client.new
+)
+```
+
+The cache key used to store the auth token will include all neccessary details
+to ensure the auth token won't be used for a different swift account erroneously.
+
+The cache implementation of SwiftClient is not restricted to memcached. To use
+a different one, simply implement a driver for your favorite cache store. See
+[null_cache.rb](https://github.com/mrkamel/swift_client/blob/master/lib/swift_client/null_cache.rb)
+for more info.
 
 ## bulk_delete
 
 Takes an array containing container_name/object_name entries.
 Automatically slices and sends 1_000 items per request.
 
+## Non-chunked uploads
+
+By default files are uploaded in chunks and using a `Transfer-Encoding:
+chunked` header. You can override this by passing a `Transfer-Encoding:
+identity` header:
+
+```ruby
+put_object(object_name, data_or_io, container_name, "Transfer-Encoding" => "identity")
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/mrkamel/swift_client/fork )
@@ -160,3 +211,8 @@ Automatically slices and sends 1_000 items per request.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+## Semantic Versioning
+
+Starting with version 0.2.0, SwiftClient uses Semantic Versioning:
+[SemVer](http://semver.org/)

data/lib/swift_client.rb

@@ -37,61 +37,61 @@ class SwiftClient
     authenticate
   end
 
-  def head_account
-    request :head, "/"
+  def head_account(options = {})
+    request :head, "/", options
   end
 
-  def post_account(headers = {})
-    request :post, "/", :headers => headers
+  def post_account(headers = {}, options = {})
+    request :post, "/", options.merge(:headers => headers)
   end
 
-  def head_containers
-    request :head, "/"
+  def head_containers(options = {})
+    request :head, "/", options
   end
 
-  def get_containers(query = {})
-    request :get, "/", :query => query
+  def get_containers(query = {}, options = {})
+    request :get, "/", options.merge(:query => query)
   end
 
-  def paginate_containers(query = {}, &block)
-    paginate :get_containers, query, &block
+  def paginate_containers(query = {}, options = {}, &block)
+    paginate(:get_containers, query, options, &block)
   end
 
-  def get_container(container_name, query = {})
+  def get_container(container_name, query = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :get, "/#{container_name}", :query => query
+    request :get, "/#{container_name}", options.merge(:query => query)
   end
 
-  def paginate_container(container_name, query = {}, &block)
-    paginate :get_container, container_name, query, &block
+  def paginate_container(container_name, query = {}, options = {}, &block)
+    paginate(:get_container, container_name, query, options, &block)
   end
 
-  def head_container(container_name)
+  def head_container(container_name, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :head, "/#{container_name}"
+    request :head, "/#{container_name}", options
   end
 
-  def put_container(container_name, headers = {})
+  def put_container(container_name, headers = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :put, "/#{container_name}", :headers => headers
+    request :put, "/#{container_name}", options.merge(:headers => headers)
   end
 
-  def post_container(container_name, headers = {})
+  def post_container(container_name, headers = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :post, "/#{container_name}", :headers => headers
+    request :post, "/#{container_name}", options.merge(:headers => headers)
   end
 
-  def delete_container(container_name)
+  def delete_container(container_name, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :delete, "/#{container_name}"
+    request :delete, "/#{container_name}", options
   end
 
-  def put_object(object_name, data_or_io, container_name, headers = {})
+  def put_object(object_name, data_or_io, container_name, headers = {}, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
     mime_type = MIME::Types.of(object_name).first
@@ -103,43 +103,52 @@ class SwiftClient
       extended_headers["Content-Type"] ||= "application/octet-stream"
     end
 
-    extended_headers["Transfer-Encoding"] = "chunked"
+    if extended_headers["Transfer-Encoding"] == "identity"
+      request :put, "/#{container_name}/#{object_name}", options.merge(:body => data_or_io.respond_to?(:read) ? data_or_io.read : data_or_io, :headers => extended_headers)
+    else
+      extended_headers["Transfer-Encoding"] = "chunked"
+      request :put, "/#{container_name}/#{object_name}", options.merge(:body_stream => data_or_io.respond_to?(:read) ? data_or_io : StringIO.new(data_or_io), :headers => extended_headers)
+    end
+  end
 
-    request :put, "/#{container_name}/#{object_name}", :body_stream => data_or_io.respond_to?(:read) ? data_or_io : StringIO.new(data_or_io), :headers => extended_headers
+  def post_object(object_name, container_name, headers = {}, options = {})
+    raise(EmptyNameError) if object_name.empty? || container_name.empty?
+
+    request :post, "/#{container_name}/#{object_name}", options.merge(:headers => headers)
   end
 
-  def post_object(object_name, container_name, headers = {})
+  def get_object(object_name, container_name, options = {}, &block)
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :post, "/#{container_name}/#{object_name}", :headers => headers
+    request(:get, "/#{container_name}/#{object_name}", options.merge(block ? { :stream_body => true } : {}), &block)
   end
 
-  def get_object(object_name, container_name)
+  def head_object(object_name, container_name, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :get, "/#{container_name}/#{object_name}"
+    request :head, "/#{container_name}/#{object_name}", options
   end
 
-  def head_object(object_name, container_name)
+  def post_head(object_name, container_name, _headers = {}, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :head, "/#{container_name}/#{object_name}"
+    request :post, "/#{container_name}/#{object_name}", options.merge(headers: _headers)
   end
 
-  def delete_object(object_name, container_name)
+  def delete_object(object_name, container_name, options = {})
     raise(EmptyNameError) if object_name.empty? || container_name.empty?
 
-    request :delete, "/#{container_name}/#{object_name}"
+    request :delete, "/#{container_name}/#{object_name}", options
   end
 
-  def get_objects(container_name, query = {})
+  def get_objects(container_name, query = {}, options = {})
     raise(EmptyNameError) if container_name.empty?
 
-    request :get, "/#{container_name}", :query => query
+    request :get, "/#{container_name}", options.merge(:query => query)
   end
 
-  def paginate_objects(container_name, query = {}, &block)
-    paginate :get_objects, container_name, query, &block
+  def paginate_objects(container_name, query = {}, options = {}, &block)
+    paginate(:get_objects, container_name, query, options, &block)
   end
 
   def public_url(object_name, container_name)
@@ -160,9 +169,9 @@ class SwiftClient
     "#{storage_url}/#{container_name}/#{object_name}?temp_url_sig=#{signature}&temp_url_expires=#{expires}"
   end
 
-  def bulk_delete(items)
+  def bulk_delete(items, options = {})
     items.each_slice(1_000) do |slice|
-      request :delete, "/?bulk-delete", :body => slice.join("\n"), :headers => { "Content-Type" => "text/plain" }
+      request :delete, "/?bulk-delete", options.merge(:body => slice.join("\n"), :headers => { "Content-Type" => "text/plain" })
     end
 
     items
@@ -183,21 +192,21 @@ class SwiftClient
     headers.keys.detect { |k| k.downcase == key.downcase }
   end
 
-  def request(method, path, opts = {})
+  def request(method, path, opts = {}, &block)
     headers = (opts[:headers] || {}).dup
     headers["X-Auth-Token"] = auth_token
-    headers["Accept"] = "application/json"
+    headers["Accept"] ||= "application/json" unless opts.delete(:json) == false
 
     stream_pos = opts[:body_stream].pos if opts[:body_stream]
 
-    response = HTTParty.send(method, "#{storage_url}#{path}", opts.merge(:headers => headers))
+    response = HTTParty.send(method, "#{storage_url}#{path}", opts.merge(:headers => headers), &block)
 
     if response.code == 401
       authenticate
 
       opts[:body_stream].pos = stream_pos if opts[:body_stream]
 
-      return request(method, path, opts)
+      return request(method, path, opts, &block)
     end
 
     raise(ResponseError.new(response.code, response.message)) unless response.success?
@@ -333,7 +342,8 @@ class SwiftClient
 
     return unless swift_services.size == 1
 
-    swift_endpoints = swift_service["endpoints"].select { |endpoint| endpoint["interface"] == "public" }
+    interface = options[:interface] || "public"
+    swift_endpoints = swift_service["endpoints"].select { |endpoint| endpoint["interface"] == interface }
     swift_endpoint = swift_endpoints.first
 
     return unless swift_endpoints.size == 1
@@ -341,13 +351,13 @@ class SwiftClient
     swift_endpoint["url"]
   end
 
-  def paginate(method, *args, query)
-    return enum_for(:paginate, method, *args, query) unless block_given?
+  def paginate(method, *args, query, options)
+    return enum_for(:paginate, method, *args, query, options) unless block_given?
 
     marker = nil
 
     loop do
-      response = send(method, *args, marker ? query.merge(:marker => marker) : query)
+      response = send(method, *args, marker ? query.merge(:marker => marker) : query, options)
 
       return if response.parsed_response.empty?
 
@@ -357,4 +367,3 @@ class SwiftClient
     end
   end
 end
-

data/lib/swift_client/version.rb

@@ -1,5 +1,4 @@
 
 class SwiftClient
-  VERSION = "0.1.4"
+  VERSION = "0.3.0"
 end
-

data/swift_client.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "httparty"
-  spec.add_dependency "mime-types", "< 3.0"
+  spec.add_dependency "mime-types"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/test/swift_client_test.rb

@@ -77,6 +77,15 @@ class SwiftClientTest < MiniTest::Test
     assert_equal "https://example.com/v1/AUTH_account", @swift_client.storage_url
   end
 
+  def test_v3_authentication_storage_url_from_catalog_with_multiple_endpoints
+    stub_request(:post, "https://auth.example.com/v3/auth/tokens").with(:body => JSON.dump("auth" => { "identity" => { "methods" => ["password"], "password" => { "user" => { "name" => "username", "password" => "secret", "domain" => { "name" => "example.com" }}}}})).to_return(:status => 200, :body => JSON.dump("token" => { "catalog"=> [{ "type" => "object-store", "endpoints" => [{ "interface"=>"public", "url"=> "https://example.com/v1/AUTH_account" }, { "interface"=>"internal", "url"=> "https://example.com/v2/AUTH_account" }] }] }), :headers => { "X-Subject-Token" => "Token", "Content-Type" => "application/json" })
+
+    @swift_client = SwiftClient.new(:auth_url => "https://auth.example.com/v3", :username => "username", :user_domain => "example.com", :password => "secret", :interface => "internal")
+
+    assert_equal "Token", @swift_client.auth_token
+    assert_equal "https://example.com/v2/AUTH_account", @swift_client.storage_url
+  end
+
   def test_v3_authentication_without_storage_url_and_multiple_swifts
     stub_request(:post, "https://auth.example.com/v3/auth/tokens").with(:body => JSON.dump("auth" => { "identity" => { "methods" => ["password"], "password" => { "user" => { "name" => "username", "password" => "secret", "domain" => { "name" => "example.com" }}}}})).to_return(:status => 200, :body => JSON.dump("token" => { "catalog"=> [{ "type" => "object-store", "endpoints" => [{ "interface"=>"public", "url"=> "https://example.com/v1/AUTH_account" }] }, { "type" => "object-store", "endpoints" => [{ "interface"=>"public", "url"=> "https://example.com/v1/AUTH_account" }] }] }), :headers => { "X-Subject-Token" => "Token", "Content-Type" => "application/json" })
 
@@ -245,6 +254,12 @@ class SwiftClientTest < MiniTest::Test
     assert_equal 201, @swift_client.put_object("object", "data", "container", "X-Object-Meta-Test" => "Test").code
   end
 
+  def test_put_object_nonchunked
+    stub_request(:put, "https://example.com/v1/AUTH_account/container/object").with(:body => "data", :headers => { "Transfer-Encoding" => "identity", "Content-Type" => "application/octet-stream", "Accept" => "application/json", "X-Auth-Token" => "Token", "X-Object-Meta-Test" => "Test" }).to_return(:status => 201, :body => "", :headers => {})
+
+    assert_equal 201, @swift_client.put_object("object", "data", "container", "X-Object-Meta-Test" => "Test", "Transfer-Encoding" => "identity").code
+  end
+
   def test_put_object_with_renewed_authorization
     stub_request(:put, "https://example.com/v1/AUTH_account/container/object").with(:body => "data", :headers => { "Transfer-Encoding" => "chunked", "Content-Type" => "application/octet-stream", "Accept" => "application/json", "X-Auth-Token" => "Token" }).to_return({ :status => 401, :body => "", :headers => {}}, { :status => 201, :body => "", :headers => {}})
 
@@ -269,16 +284,38 @@ class SwiftClientTest < MiniTest::Test
     assert_equal 201, @swift_client.put_object("object", StringIO.new("data"), "container", "X-Object-Meta-Test" => "Test").code
   end
 
+  def test_put_object_with_io_nonchunked
+    stub_request(:put, "https://example.com/v1/AUTH_account/container/object").with(:body => "data", :headers => { "Transfer-Encoding" => "identity", "Accept" => "application/json", "X-Auth-Token" => "Token", "X-Object-Meta-Test" => "Test" }).to_return(:status => 201, :body => "", :headers => {})
+
+    assert_equal 201, @swift_client.put_object("object", StringIO.new("data"), "container", "X-Object-Meta-Test" => "Test", "Transfer-Encoding" => "identity").code
+  end
+
   def test_post_object
     stub_request(:post, "https://example.com/v1/AUTH_account/container/object").with(:headers => { "Accept" => "application/json", "X-Auth-Token" => "Token", "X-Object-Meta-Test" => "Test" }).to_return(:status => 201, :body => "", :headers => {})
 
     assert_equal 201, @swift_client.post_object("object", "container", "X-Object-Meta-Test" => "Test").code
   end
 
+  def test_post_head
+    stub_request(:post, 'https://example.com/v1/AUTH_account/container/object').with(headers: { 'Accept' => 'application/json', 'X-Auth-Token' => 'Token', 'X-Delete-At' => '1553524860' }).to_return(status: 201, body: '', headers: {})
+
+    assert_equal 201, @swift_client.post_head('object', 'container', 'X-Delete-At' => '1553524860').code
+  end
+
   def test_get_object
     stub_request(:get, "https://example.com/v1/AUTH_account/container/object").with(:headers => { "Accept" => "application/json", "X-Auth-Token" => "Token" }).to_return(:status => 200, :body => "Body", :headers => {})
+    block_res = 0
+
+    large_body = "Body" * 16384
+    stub_request(:get, "https://example.com/v1/AUTH_account/container/large_object").with(:headers => { "Accept" => "application/json", "X-Auth-Token" => "Token" }).to_return(:status => 200, :body => large_body, :headers => {})
 
     assert_equal "Body", @swift_client.get_object("object", "container").body
+
+    @swift_client.get_object("large_object", "container") do |chunk|
+      block_res += chunk.length
+    end
+
+    assert_equal block_res, large_body.length
   end
 
   def test_head_object
@@ -304,6 +341,14 @@ class SwiftClientTest < MiniTest::Test
     assert_equal objects, @swift_client.get_objects("container-1", :limit => 2, :marker => "object-2").parsed_response
   end
 
+  def test_get_objects_no_json
+    response = "object-2\nobject-3\n"
+
+    stub_request(:get, "https://example.com/v1/AUTH_account/container-1?limit=2&marker=object-2").with(:headers => { "X-Auth-Token" => "Token" }).to_return(:status => 200, :body => response, :headers => { "Content-Type" => "text/html" })
+
+    assert_equal response, @swift_client.get_objects("container-1", { :limit => 2, :marker => "object-2" }, :json => false).body
+  end
+
   def test_paginate_objects
     objects = [
       { "hash" => "Hash", "last_modified" => "Last modified", "bytes" => 1, "name" => "object-1", "content_type" => "Content type" },
@@ -340,4 +385,3 @@ class SwiftClientTest < MiniTest::Test
     assert @swift_client.temp_url("object", "container", :expires_in => 86400) =~ %r{https://example.com/v1/AUTH_account/container/object\?temp_url_sig=[a-f0-9]{40}&temp_url_expires=1086400}
   end
 end
-

data/test/test_helper.rb

@@ -4,4 +4,4 @@ require "minitest"
 require "minitest/autorun"
 require "webmock/minitest"
 require "minitest/unit"
-require "mocha/mini_test"
+require "mocha/minitest"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swift_client
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Benjamin Vetter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-05 00:00:00.000000000 Z
+date: 2020-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -28,16 +28,16 @@ dependencies:
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -146,8 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Small but powerful client to interact with OpenStack Swift