Class: Docker::Container

Inherits:
Object
  • Object
show all
Includes:
Base
Defined in:
lib/docker/container.rb

Overview

This class represents a Docker Container. It’s important to note that nothing is cached so that the information is always up to date.

Instance Attribute Summary

Attributes included from Base

#connection, #id, #info

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Base

#initialize, #normalize_hash

Class Method Details

.all(opts = {}, conn = Docker.connection) ⇒ Object

Return all of the Containers.



146
147
148
149
 
# File 'lib/docker/container.rb', line 146

def self.all(opts = {}, conn = Docker.connection)
  hashes = Docker::Util.parse_json(conn.get('/containers/json', opts)) || []
  hashes.map { |hash| new(conn, hash) }
end

.create(opts = {}, conn = Docker.connection) ⇒ Object

Create a new Container.



129
130
131
132
133
134
135
136
 
# File 'lib/docker/container.rb', line 129

def self.create(opts = {}, conn = Docker.connection)
  name = opts.delete('name')
  query = {}
  query['name'] = name if name
  resp = conn.post('/containers/create', query, :body => opts.to_json)
  hash = Docker::Util.parse_json(resp) || {}
  new(conn, hash)
end

.get(id, opts = {}, conn = Docker.connection) ⇒ Object

Return the container with specified ID



139
140
141
142
143
 
# File 'lib/docker/container.rb', line 139

def self.get(id, opts = {}, conn = Docker.connection)
  container_json = conn.get("/containers/#{URI.encode(id)}/json", opts)
  hash = Docker::Util.parse_json(container_json) || {}
  new(conn, hash)
end

Instance Method Details

#attach(options = {}, &block) ⇒ Object

Attach to a container’s standard streams / logs.



41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/docker/container.rb', line 41

def attach(options = {}, &block)
  opts = {
    :stream => true, :stdout => true, :stderr => true
  }.merge(options)
  # Creates list to store stdout and stderr messages
  msgs = Docker::Messages.new
  connection.post(
    path_for(:attach),
    opts,
    :response_block => attach_for(block, msgs)
  )
  [msgs.stdout_messages, msgs.stderr_messages]
end

#commit(options = {}) ⇒ Object

Create an Image from a Container’s change.s



56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/docker/container.rb', line 56

def commit(options = {})
  options.merge!('container' => self.id[0..7])
  # [code](https://github.com/dotcloud/docker/blob/v0.6.3/commands.go#L1115)
  # 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 = options.delete('run')
  hash = Docker::Util.parse_json(connection.post('/commit',
                                                 options,
                                                 :body => config.to_json))
  Docker::Image.send(:new, self.connection, hash)
end

#copy(path, &block) ⇒ Object 



120
121
122
123
124
125
126
 
# File 'lib/docker/container.rb', line 120

def copy(path, &block)
  connection.post(path_for(:copy), {},
    :body => { "Resource" => path }.to_json,
    :response_block => block
  )
  self
end

#export(&block) ⇒ Object

Export the Container as a tar.



35
36
37
38
 
# File 'lib/docker/container.rb', line 35

def export(&block)
  connection.get(path_for(:export), {}, :response_block => block)
  self
end

#remove(options = {}) ⇒ Object Also known as: delete

remove container



114
115
116
117
 
# File 'lib/docker/container.rb', line 114

def remove(options = {})
  connection.delete("/containers/#{self.id}", options)
  nil
end

#run(cmd, time = 1000) ⇒ Object

Given a command and an optional number of seconds to wait for the currently executing command, creates a new Container to run the specified command. If the command that is currently executing does not return a 0 status code, an UnexpectedResponseError is raised.



26
27
28
29
30
31
32
 
# File 'lib/docker/container.rb', line 26

def run(cmd, time = 1000)
  if (code = tap(&:start).wait(time)['StatusCode']).zero?
    commit.run(cmd).tap(&:start)
  else
    raise UnexpectedResponseError, "Command returned status code #{code}."
  end
end

#to_s ⇒ Object

Return a String representation of the Container.



70
71
72
 
# File 'lib/docker/container.rb', line 70

def to_s
  "Docker::Container { :id => #{self.id}, :connection => #{self.connection} }"
end

#top(opts = {}) ⇒ Object

Return a List of Hashes that represents the top running processes.



7
8
9
10
11
12
13
14
 
# File 'lib/docker/container.rb', line 7

def top(opts = {})
  resp = Docker::Util.parse_json(connection.get(path_for(:top), opts))
  if resp['Processes'].nil?
    []
  else
    resp['Processes'].map { |ary| Hash[resp['Titles'].zip(ary)] }
  end
end

#wait(time = 60) ⇒ Object

Wait for the current command to finish executing.



17
18
19
20
 
# File 'lib/docker/container.rb', line 17

def wait(time = 60)
  resp = connection.post(path_for(:wait), nil, :read_timeout => time)
  Docker::Util.parse_json(resp)
end