docker-api 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8c844030bda8d245234ddd5d977ad5202b9a2f0a2e34175579790d79e6f584b
-  data.tar.gz: 5b793f7689d091a8a765853511e4f0f8f495338250cdec62bce30fc7a83d5117
+  metadata.gz: 8bd06b9a57651660c10d8e279df9ee588c3eaed258e4ced980f4090a5728a0b3
+  data.tar.gz: 07f5419a9f3e02af5db30e41fa91fd12afb01cfed84bae20d19fda55de27819b
 SHA512:
-  metadata.gz: d5ce08a8dfbe1e5377ceb62d8186e4973ca6f7fa8d166bd9177f8f4a3338dc2dfeb3d735d3c54e31b15373f4124cc87d509d369a34e0f1598291105a4593947f
-  data.tar.gz: d27a38af366bbb20febcc3699238a56f5c52d24394780c25d3caf72bc6f9314fb8bae6dd9c7f53cd5ff30558f5bbc353d22fc9f236913a2d8786488c9a702aea
+  metadata.gz: e778d8fbb81217c9ad405e0879b8e5754e17e79f6bdb072e717a2ac2e7ab044e3a62a8aab0c3d58fc1094a578ef4480451b478a4161e611a1ce10bbb980564cc
+  data.tar.gz: aa0670fd34bd8a2ee4aa16422af84a462451bde78807fe9d9ce2401bc4006f432e79b06d38a86aa0d2ee6d2c2a3cc2ca35b2c67e513565b91bd1ee351df75466

data/README.md

@@ -1,8 +1,8 @@
 docker-api
 ==========
-[![Gem Version](https://badge.fury.io/rb/docker-api.svg)](https://badge.fury.io/rb/docker-api) [![Code Climate](https://codeclimate.com/github/upserve/docker-api.svg)](https://codeclimate.com/github/upserve/docker-api)
+[![Gem Version](https://badge.fury.io/rb/docker-api.svg)](https://badge.fury.io/rb/docker-api)
 
-This gem provides an object-oriented interface to the [Docker Engine API](https://docs.docker.com/develop/sdk/). Every method listed there is implemented. At the time of this writing, docker-api is meant to interface with Docker version 1.4.*
+This gem provides an object-oriented interface to the [Docker Engine API](https://docs.docker.com/develop/sdk/). Every method listed there is implemented. The gem does not pin an API version, so requests use the daemon's default. It is tested against Docker 28 and 29.
 
 If you're interested in using Docker to package your apps, we recommend the [dockly](https://github.com/upserve/dockly) gem. Dockly provides a simple DSL for describing Docker containers that install as Debian packages and are controlled by upstart scripts.
 
@@ -41,7 +41,7 @@ At this time, basic `podman` support has been added via the podman docker-compat
 Follow the [installation instructions](https://docs.docker.com/install/), and then run:
 
 ```shell
-$ sudo docker -d
+$ sudo dockerd
 ```
 
 This will daemonize Docker so that it can be used for the remote API calls.
@@ -138,15 +138,15 @@ Docker.authenticate!('username' => 'docker-fan-boi', 'password' => 'i<3docker',
 
 ## Images
 
-Just about every method here has a one-to-one mapping with the [Images](https://docs.docker.com/engine/reference/api/docker_remote_api_v1.14/#2-2-images) section of the API. If an API call accepts query parameters, these can be passed as an Hash to it's corresponding method. Also, note that `Docker::Image.new` is a private method, so you must use `.create`, `.build`, `.build_from_dir`, `build_from_tar`, or `.import` to make an instance.
+Just about every method here has a one-to-one mapping with the [Images](https://docs.docker.com/reference/api/engine/) section of the API. If an API call accepts query parameters, these can be passed as an Hash to it's corresponding method. Also, note that `Docker::Image.new` is a private method, so you must use `.create`, `.build`, `.build_from_dir`, `build_from_tar`, or `.import` to make an instance.
 
 ```ruby
 require 'docker'
 # => true
 
 # Pull an Image.
-# docker command for reference: docker pull ubuntu:14.04
-image = Docker::Image.create('fromImage' => 'ubuntu:14.04')
+# docker command for reference: docker pull ubuntu:24.04
+image = Docker::Image.create('fromImage' => 'ubuntu:24.04')
 # => Docker::Image { :id => ae7ffbcd1, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
 # Insert a local file into an Image.
@@ -194,12 +194,12 @@ image.run('ls -l')
 # Remove the Image from the server.
 # docker command for reference: docker rmi -f <IMAGE.ID>
 image.remove(:force => true)
-# => true
+# => "[{\"Untagged\":\"base2:latest\"}]\n"
 
 # Export a single Docker Image to a file
 # docker command for reference: docker save <IMAGE.ID> my_export.tar
 image.save('my_export.tar')
-# => Docker::Image { :id => 66b712aef, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
+# => nil
 
 # Return the raw image binary data
 image.save
@@ -225,7 +225,7 @@ File.open('my-export.tar') do |file|
 end
 
 # Create an Image from a Dockerfile as a String.
-Docker::Image.build("from base\nrun touch /test")
+Docker::Image.build("FROM debian:stable\nRUN touch /test")
 # => Docker::Image { :id => b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
 # Create an Image from a Dockerfile.
@@ -256,7 +256,7 @@ Docker::Image.all
 # => [Docker::Image { :id => b750fe79269d2ec9a3c593ef05b4332b1d1a02a62b4accb2c21d589ff2f5f2dc, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }, Docker::Image { :id => 8dbd9e392a964056420e5d58ca5cc376ef18e2de93b5cc90e868a1bbc8318c1c, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }]
 
 # Get Image from the server, with id
-# docker command for reference: docker images <IMAGE.ID>
+# docker command for reference: docker inspect <IMAGE.ID>
 Docker::Image.get('df4f1bdecf40')
 # => Docker::Image { :id => eb693ec80, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
@@ -298,13 +298,13 @@ Docker::Image.search('term' => 'sshd')
 
 ## Containers
 
-Much like the Images, this object also has a one-to-one mapping with the [Containers](https://docs.docker.com/engine/reference/api/docker_remote_api_v1.14/#2-1-containers) section of the API. Also like Images, `.new` is a private method, so you must use `.create` to make an instance.
+Much like the Images, this object also has a one-to-one mapping with the [Containers](https://docs.docker.com/reference/api/engine/) section of the API. Also like Images, `.new` is a private method, so you must use `.create` to make an instance.
 
 ```ruby
 require 'docker'
 
 # Create a Container.
-container = Docker::Container.create('Cmd' => ['ls'], 'Image' => 'base')
+container = Docker::Container.create('Cmd' => ['ls'], 'Image' => 'debian:stable')
 # => Docker::Container { :id => 492510dd38e4, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
 # Get more information about the Container.
@@ -423,15 +423,15 @@ container.changes
 # => [{'Path'=>'/dev', 'Kind'=>0}, {'Path'=>'/dev/kmsg', 'Kind'=>1}]
 
 # Copy files/directories from the Container. Note that these are exported as tars.
-container.copy('/etc/hosts') { |chunk| puts chunk }
-
-hosts0000644000000000000000000000023412100405636007023 0ustar
-127.0.0.1       localhost
-::1             localhost ip6-localhost ip6-loopback
-fe00::0         ip6-localnet
-ff00::0         ip6-mcastprefix
-ff02::1         ip6-allnodes
-ff02::2         ip6-allrouters
+container.archive_out('/etc/hosts') { |chunk| puts chunk }
+
+# hosts0000644000000000000000000000023412100405636007023 0ustar
+# 127.0.0.1       localhost
+# ::1             localhost ip6-localhost ip6-loopback
+# fe00::0         ip6-localnet
+# ff00::0         ip6-mcastprefix
+# ff02::1         ip6-allnodes
+# ff02::2         ip6-allrouters
 # => Docker::Container { :id => a1759f3e2873, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
 # Wait for the current command to finish executing. If an argument is given,
@@ -445,13 +445,13 @@ container.attach(:stream => true, :stdin => nil, :stdout => true, :stderr => tru
 # => [["bin\nboot\ndev\netc\nhome\nlib\nlib64\nmedia\nmnt\nopt\nproc\nroot\nrun\nsbin\nselinux\nsrv\nsys\ntmp\nusr\nvar", []]
 
 # If you wish to stream the attach method, a block may be supplied.
-container = Docker::Container.create('Image' => 'base', 'Cmd' => ['find / -name *'])
+container = Docker::Container.create('Image' => 'debian:stable', 'Cmd' => ['find / -name *'])
 container.tap(&:start).attach { |stream, chunk| puts "#{stream}: #{chunk}" }
-stderr: 2013/10/30 17:16:24 Unable to locate find / -name *
+# stderr: 2013/10/30 17:16:24 Unable to locate find / -name *
 # => [[], ["2013/10/30 17:16:24 Unable to locate find / -name *\n"]]
 
 # If you want to attach to stdin of the container, supply an IO-like object:
-container = Docker::Container.create('Image' => 'base', 'Cmd' => ['cat'], 'OpenStdin' => true, 'StdinOnce' => true)
+container = Docker::Container.create('Image' => 'debian:stable', 'Cmd' => ['cat'], 'OpenStdin' => true, 'StdinOnce' => true)
 container.tap(&:start).attach(stdin: StringIO.new("foo\nbar\n"))
 # => [["foo\nbar\n"], []]
 
@@ -470,16 +470,16 @@ container.logs(stdout: true)
 
 # Streaming logs from non-TTY container removing multiplex prefix with a block printing out each line (block not possible with Container#logs)
 container.streaming_logs(stdout: true) { |stream, chunk| puts "#{stream}: #{chunk}" }
-stdout: 1
-stdout: 2
-stdout: 3
-stdout: 4
-stdout: 5
-stdout: 6
-stdout: 7
-stdout: 8
-stdout: 9
-stdout: 10
+# stdout: 1
+# stdout: 2
+# stdout: 3
+# stdout: 4
+# stdout: 5
+# stdout: 6
+# stdout: 7
+# stdout: 8
+# stdout: 9
+# stdout: 10
 # => "1\n\n2\n\n3\n\n4\n\n5\n\n6\n\n7\n\n8\n\n9\n\n10\n"
 
 # If the container has TTY enabled, set `tty => true` to get the raw stream:
@@ -499,7 +499,7 @@ container.commit
 # Commit the Container and run a new command. The second argument is the number
 # of seconds the Container should wait before stopping its current command.
 container.run('pwd', 10)
-# => Docker::Image { :id => 4427be4199ac, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
+# => Docker::Container { :id => 4427be4199ac, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
 # Run an Exec instance inside the container and capture its output and exit status
 container.exec(['date'])
@@ -511,12 +511,13 @@ container.exec(['./my_service'], detach: true)
 
 # Parse the output of an Exec instance
 container.exec(['find', '/', '-name *']) { |stream, chunk| puts "#{stream}: #{chunk}" }
-stderr: 2013/10/30 17:16:24 Unable to locate find / -name *
+# stderr: 2013/10/30 17:16:24 Unable to locate find / -name *
 # => [[], ["2013/10/30 17:16:24 Unable to locate find / -name *\n"], 1]
 
-# Run an Exec instance by grab only the STDOUT output
-container.exec(['date'], stderr: false)
-# => [["Wed Nov 26 11:10:30 CST 2014\n"], [], 0]
+# The return value is [stdout_lines, stderr_lines, exit_code], so destructure
+# it if you only care about one stream.
+stdout, _stderr, _exit_code = container.exec(['date'])
+# stdout => ["Wed Nov 26 11:10:30 CST 2014\n"]
 
 # Pass input to an Exec instance command via Stdin
 container.exec(['cat'], stdin: StringIO.new("foo\nbar\n"))
@@ -529,7 +530,7 @@ container.exec(command, tty: true)
 
 # Wait for the current command to finish executing. If an argument is given,
 # will timeout after that number of seconds. The default is one minute.
-command = ["bash", "-c", "if [ -t 1 ]; then echo -n \"Set max seconds for exec!!\"; fi"]
+command = ["bash", "-c", "if [ -t 1 ]; then echo -n \"Set max seconds for exec!\"; fi"]
 container.exec(command, wait: 120)
 # => [["Set max seconds for exec!"], [], 0]
 
@@ -538,7 +539,7 @@ container.delete(:force => true)
 # => nil
 
 # Update the container.
-container.update("CpuShares" => 50000")
+container.update("CpuShares" => 50000)
 
 # Request a Container by ID or name.
 Docker::Container.get('500f53b25e6e')
@@ -578,17 +579,37 @@ require 'docker'
 
 # Action on a stream of events as they come in
 Docker::Event.stream { |event| puts event; break }
-Docker::Event { :status => create, :id => aeb8b55726df63bdd69d41e1b2650131d7ce32ca0d2fa5cbc75f24d0df34c7b0, :from => base:latest, :time => 1416958554 }
+# Docker::Event { :status => create, :id => aeb8b55726df63bdd69d41e1b2650131d7ce32ca0d2fa5cbc75f24d0df34c7b0, :from => debian:stable, :time => 1416958554 }
 # => nil
 
 # Action on all events after a given time (will execute the block for all events up till the current time, and wait to execute on any new events after)
 Docker::Event.since(1416958763) { |event| puts event; puts Time.now.to_i; break }
-Docker::Event { :status => die, :id => 663005cdeb56f50177c395a817dbc8bdcfbdfbdaef329043b409ecb97fb68d7e, :from => base:latest, :time => 1416958764 }
-1416959041
+# Docker::Event { :status => die, :id => 663005cdeb56f50177c395a817dbc8bdcfbdfbdaef329043b409ecb97fb68d7e, :from => debian:stable, :time => 1416958764 }
+# 1416959041
 # => nil
 ```
 
-These methods are prone to read timeouts.  `Docker.options[:read_timeout]` will need to be made higher than 60 seconds if expecting a long time between events.
+These methods are prone to read timeouts. Note that the first argument to
+`Docker::Event.stream` and `Docker::Event.since` is a hash of **query parameters**
+for the `/events` endpoint, not Excon options. Passing `read_timeout` there sends
+it to Docker as a query parameter and has no effect on the timeout. Set it on the
+connection instead:
+
+```ruby
+# Disable timeouts completely, for this call only
+conn = Docker::Connection.new(Docker.url, Docker.options.merge(read_timeout: 0))
+Docker::Event.stream({}, conn) { |event| puts event }
+
+# Timeout if no events are received in 24h
+conn = Docker::Connection.new(Docker.url, Docker.options.merge(read_timeout: 60 * 60 * 24))
+Docker::Event.stream({}, conn) { |event| puts event }
+
+# Or set a high timeout globally. Be warned that you probably don't want this
+# for other methods. This has to happen before the default connection is first
+# used, since `Docker.connection` is memoized.
+Docker.options[:read_timeout] = 60 * 60 * 24
+Docker::Event.stream { |event| puts event }
+```
 
 ## Connecting to Multiple Servers
 
@@ -624,8 +645,8 @@ end
 
 ## Not supported (yet)
 
-*   Generating a tarball of images and metadata for a repository specified by a name: https://docs.docker.com/engine/reference/api/docker_remote_api_v1.14/#get-a-tarball-containing-all-images-and-tags-in-a-repository
-*   Load a tarball generated from docker that contains all the images and metadata of a repository: https://docs.docker.com/engine/reference/api/docker_remote_api_v1.14/#load-a-tarball-with-a-set-of-images-and-tags-into-docker
+*   Generating a tarball of images and metadata for a repository specified by a name
+*   Load a tarball generated from docker that contains all the images and metadata of a repository
 
 License
 -----

data/lib/docker/connection.rb

@@ -129,7 +129,12 @@ class Docker::Connection
   end
 
   def rootless?
-    @rootless ||= (info['Rootless'] == true)
+    # `||=` cannot cache a false result, so this has to test for the ivar
+    # itself. #info is not memoized, so re-evaluating means another /info
+    # request on every call against a non-rootless daemon.
+    return @rootless if defined?(@rootless)
+
+    @rootless = (info['Rootless'] == true)
   end
 
   def version

data/lib/docker/container.rb

@@ -60,8 +60,11 @@ class Docker::Container
     detach = options.delete(:detach) || false
     user = options.delete(:user)
     stdin = options.delete(:stdin)
-    stdout = options.delete(:stdout) || !detach
-    stderr = options.delete(:stderr) || !detach
+    # `options.delete(:stdout) || !detach` turns an explicit false back into
+    # true, so these have to be tested for presence rather than truthiness.
+    # They default to the inverse of :detach when the caller says nothing.
+    stdout = options.key?(:stdout) ? options.delete(:stdout) : !detach
+    stderr = options.key?(:stderr) ? options.delete(:stderr) : !detach
     wait = options.delete(:wait)
 
     opts = {
@@ -118,6 +121,16 @@ class Docker::Container
       opts[:stdin] = true
       excon_params[:hijack_block] = Docker::Util.hijack_for(stdin, block,
         msgs, tty)
+      # Hijacking means asking the daemon to upgrade the connection. Without
+      # these headers Docker answers 200 and leaves the payload on Excon's
+      # buffered socket, which the raw hijacked read never looks at, so the
+      # attach blocks forever. With them the daemon replies 101 and hands the
+      # socket over, so 101 has to be an accepted status.
+      excon_params[:headers] = {
+        'Connection' => 'Upgrade',
+        'Upgrade' => 'tcp'
+      }.merge(excon_params[:headers] || {})
+      excon_params[:expects] ||= (200..204).to_a + [101, 301, 304]
     else
       excon_params[:response_block] = Docker::Util.attach_for(block, msgs, tty)
     end
@@ -137,7 +150,7 @@ class Docker::Container
     # Based on the link, the config passed as run, needs to be passed as the
     # body of the post so capture it, remove from the options, and pass it via
     # the post body
-    config = MultiJson.dump(options.delete('run'))
+    config = JSON.generate(options.delete('run'))
     hash = Docker::Util.parse_json(
       connection.post('/commit', options, body: config)
     )
@@ -187,7 +200,7 @@ class Docker::Container
   end
 
   def update(opts)
-    connection.post(path_for(:update), {}, body: MultiJson.dump(opts))
+    connection.post(path_for(:update), {}, body: JSON.generate(opts))
   end
 
   def streaming_logs(opts = {}, &block)
@@ -201,7 +214,7 @@ class Docker::Container
   end
 
   def start!(opts = {})
-    connection.post(path_for(:start), {}, body: MultiJson.dump(opts))
+    connection.post(path_for(:start), {}, body: JSON.generate(opts))
     self
   end
 
@@ -227,7 +240,7 @@ class Docker::Container
       timeout = opts.delete('timeout')
       query = {}
       request_options = {
-        :body => MultiJson.dump(opts)
+        :body => JSON.generate(opts)
       }
       if timeout
         query['t'] = timeout
@@ -324,11 +337,16 @@ class Docker::Container
     archive_in_stream("/", overwrite: true) { output_io.read }
   end
 
+  # Keys that /containers/create takes as query parameters rather than in the
+  # request body. The daemon silently ignores them if they are sent in the
+  # body, so a misplaced key means the option has no effect at all.
+  CREATE_QUERY_KEYS = %w[name platform].freeze
+
   # Create a new Container.
   def self.create(opts = {}, conn = Docker.connection)
-    query = opts.select {|key| ['name', :name].include?(key) }
-    clean_opts = opts.reject {|key| ['name', :name].include?(key) }
-    resp = conn.post('/containers/create', query, :body => MultiJson.dump(clean_opts))
+    query = opts.select { |key| CREATE_QUERY_KEYS.include?(key.to_s) }
+    clean_opts = opts.reject { |key| CREATE_QUERY_KEYS.include?(key.to_s) }
+    resp = conn.post('/containers/create', query, :body => JSON.generate(clean_opts))
     hash = Docker::Util.parse_json(resp) || {}
     new(conn, hash)
   end

data/lib/docker/exec.rb

@@ -29,7 +29,7 @@ class Docker::Exec
     end
 
     resp = conn.post("/containers/#{container}/exec", {},
-      body: MultiJson.dump(options))
+      body: JSON.generate(options))
     hash = Docker::Util.parse_json(resp) || {}
     new(conn, hash)
   end
@@ -60,7 +60,7 @@ class Docker::Exec
     read_timeout = options[:wait]
 
     # Create API Request Body
-    body = MultiJson.dump(
+    body = JSON.generate(
       'Tty' => tty,
       'Detach' => detached
     )

data/lib/docker/image.rb

@@ -119,7 +119,7 @@ class Docker::Image
 
     # Create a new Image.
     def create(opts = {}, creds = nil, conn = Docker.connection, &block)
-      credentials = creds.nil? ? Docker.creds : MultiJson.dump(creds)
+      credentials = creds.nil? ? Docker.creds : JSON.generate(creds)
       headers = credentials && Docker::Util.build_auth_header(credentials) || {}
       body = +''
       conn.post(

data/lib/docker/network.rb

@@ -5,7 +5,7 @@ class Docker::Network
   include Docker::Base
 
   def connect(container, opts = {}, body_opts = {})
-    body = MultiJson.dump({ container: container }.merge(body_opts))
+    body = JSON.generate({ container: container }.merge(body_opts))
     Docker::Util.parse_json(
       connection.post(path_for('connect'), opts, body: body)
     )
@@ -13,7 +13,7 @@ class Docker::Network
   end
 
   def disconnect(container, opts = {})
-    body = MultiJson.dump(container: container)
+    body = JSON.generate(container: container)
     Docker::Util.parse_json(
       connection.post(path_for('disconnect'), opts, body: body)
     )
@@ -43,7 +43,7 @@ class Docker::Network
 
   class << self
     def create(name, opts = {}, conn = Docker.connection)
-      default_opts = MultiJson.dump({
+      default_opts = JSON.generate({
         'Name' => name,
         'CheckDuplicate' => true
       }.merge(opts))

data/lib/docker/util.rb

@@ -106,8 +106,8 @@ module Docker::Util
   end
 
   def parse_json(body)
-    MultiJson.load(body) unless body.nil? || body.empty? || (body == 'null')
-  rescue MultiJson::ParseError => ex
+    JSON.parse(body) unless body.nil? || body.empty? || (body == 'null')
+  rescue JSON::ParserError => ex
     raise UnexpectedResponseError, ex.message
   end
 
@@ -173,14 +173,25 @@ module Docker::Util
   end
 
   def create_relative_dir_tar(directory, output)
+    root = File.realpath(directory)
+
     Gem::Package::TarWriter.new(output) do |tar|
       files = docker_context(directory)
 
       files.each do |prefixed_file_name|
-        stat = File.stat(prefixed_file_name)
+        stat = File.lstat(prefixed_file_name)
+        unprefixed_file_name = prefixed_file_name[directory.length..-1]
+
+        if stat.symlink?
+          tar.add_symlink(
+            unprefixed_file_name, File.readlink(prefixed_file_name), stat.mode
+          )
+          next
+        end
         next unless stat.file?
 
-        unprefixed_file_name = prefixed_file_name[directory.length..-1]
+        next unless contained?(prefixed_file_name, root)
+
         add_file_to_tar(
           tar, unprefixed_file_name, stat.mode, stat.size, stat.mtime
         ) do |tar_file|
@@ -190,6 +201,14 @@ module Docker::Util
     end
   end
 
+  # True when path resolves, with every symlink and '..' expanded, to
+  # something underneath root.
+  def contained?(path, root)
+    File.realpath(path).start_with?(root + File::SEPARATOR)
+  rescue SystemCallError
+    false
+  end
+
   def add_file_to_tar(tar, name, mode, size, mtime)
     tar.check_closed
 
@@ -261,7 +280,7 @@ module Docker::Util
   end
 
   def build_auth_header(credentials)
-    credentials = MultiJson.dump(credentials) if credentials.is_a?(Hash)
+    credentials = JSON.generate(credentials) if credentials.is_a?(Hash)
     encoded_creds = Base64.urlsafe_encode64(credentials)
     {
       'X-Registry-Auth' => encoded_creds
@@ -270,10 +289,10 @@ module Docker::Util
 
   def build_config_header(credentials)
     if credentials.is_a?(String)
-      credentials = MultiJson.load(credentials, symbolize_keys: true)
+      credentials = JSON.parse(credentials, symbolize_names: true)
     end
 
-    header = MultiJson.dump(
+    header = JSON.generate(
       credentials[:serveraddress].to_s => {
         'username' => credentials[:username].to_s,
         'password' => credentials[:password].to_s,

data/lib/docker/version.rb

@@ -2,5 +2,5 @@
 
 module Docker
   # The version of the docker-api gem.
-  VERSION = '2.4.0'
+  VERSION = '2.5.0'
 end

data/lib/docker/volume.rb

@@ -33,7 +33,7 @@ class Docker::Volume
     # creates a volume with an arbitrary name
     def create(name, opts = {}, conn = Docker.connection)
       opts['Name'] = name
-      resp = conn.post('/volumes/create', {}, body: MultiJson.dump(opts))
+      resp = conn.post('/volumes/create', {}, body: JSON.generate(opts))
       hash = Docker::Util.parse_json(resp) || {}
       new(conn, hash)
     end

data/lib/docker.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'cgi'
-require 'multi_json'
+require 'json'
 require 'excon'
 require 'tempfile'
 require 'base64'
@@ -133,7 +133,7 @@ module Docker
 
   # Login to the Docker registry.
   def authenticate!(options = {}, connection = self.connection)
-    creds = MultiJson.dump(options)
+    creds = JSON.generate(options)
     connection.post('/auth', {}, body: creds)
     @creds = creds
     true

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docker-api
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Swipely, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2026-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.64.0
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -164,7 +164,10 @@ files:
 homepage: https://github.com/upserve/docker-api
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/upserve/docker-api/issues
+  source_code_uri: https://github.com/upserve/docker-api
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -180,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.34
 signing_key: 
 specification_version: 4
 summary: A simple REST client for the Docker Remote API