Class: Docker::Container

Inherits:
Object
  • Object
show all
Includes:
Error
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 collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(connection, id = nil) ⇒ Container

The private new method accepts a connection and optional id.



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

def initialize(connection, id = nil)
  if connection.is_a?(Docker::Connection)
    @connection, @id = connection, id
  else
    raise ArgumentError, "Expected a Docker::Connection, got: #{connection}."
  end
end

Instance Attribute Details

#connection ⇒ Object

Returns the value of attribute connection.



6
7
8
 
# File 'lib/docker/container.rb', line 6

def connection
  @connection
end

#id ⇒ Object

Returns the value of attribute id.



6
7
8
 
# File 'lib/docker/container.rb', line 6

def id
  @id
end

Class Method Details

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

Return all of the Containers.



144
145
146
147
 
# File 'lib/docker/container.rb', line 144

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

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

Create a new Container.



123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/docker/container.rb', line 123

def self.create(opts = {}, conn = Docker.connection)
  instance = new(conn)
  name = opts.delete('name')
  query = {}
  query['name'] = name if name
  resp = conn.post('/containers/create', query, :body => opts.to_json)
  if (instance.id = Docker::Util.parse_json(resp)['Id']).nil?
    raise UnexpectedResponseError, 'Create response did not contain an Id'
  else
    instance
  end
end

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

Return the container with specified ID



137
138
139
140
141
 
# File 'lib/docker/container.rb', line 137

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['ID'])
end

Instance Method Details

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

Attach to a container’s standard streams / logs.



52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/docker/container.rb', line 52

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



67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/docker/container.rb', line 67

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['Id'])
end

#copy(path, &block) ⇒ Object 



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

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

#delete(options = {}) ⇒ Object

delete container



109
110
111
112
 
# File 'lib/docker/container.rb', line 109

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

#export(&block) ⇒ Object

Export the Container as a tar.



46
47
48
49
 
# File 'lib/docker/container.rb', line 46

def export(&block)
  connection.get(path_for(:export), {}, :response_block => block)
  self
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.



37
38
39
40
41
42
43
 
# File 'lib/docker/container.rb', line 37

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 represntation of the Container.



82
83
84
 
# File 'lib/docker/container.rb', line 82

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.



18
19
20
21
22
23
24
25
 
# File 'lib/docker/container.rb', line 18

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.



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

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