Class: Minke::Docker::DockerRunner

Inherits:
Object
  • Object
show all
Defined in:
lib/minke/docker/docker_runner.rb

Instance Method Summary collapse

Constructor Details

#initialize(network = nil) ⇒ DockerRunner

Returns a new instance of DockerRunner.



4
5
6
 
# File 'lib/minke/docker/docker_runner.rb', line 4

def initialize network = nil
  @network = network ||= 'bridge'
end

Instance Method Details

#build_image(dockerfile_dir, name) ⇒ Object

build_image creates a new image from the given Dockerfile and name



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/minke/docker/docker_runner.rb', line 109

def build_image dockerfile_dir, name
  puts dockerfile_dir
  puts name
  ::Docker.options = {:read_timeout => 6200}
  begin
    ::Docker::Image.build_from_dir(dockerfile_dir, {:t => name}) do |v|
      data = /{"stream.*:"(.*)".*/.match(v)
      data = data[1].encode(Encoding.find('UTF-8'), {invalid: :replace, undef: :replace, replace: ''}) unless data == nil || data.length < 1
      $stdout.puts data unless data == nil
    end
  rescue => e
    puts e
    message = /.*{"message":"(.*?)"}/.match(e.to_s)
    puts "Error: #{message[1]}" unless message == nil || message.length < 1
  end
end

#create_and_run_container(args) ⇒ Object

create_and_run_container starts a conatainer of the given image name and executes a command

Returns:

  • Docker::Container

  • sucess (true if command succeded without error)



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/minke/docker/docker_runner.rb', line 67

def create_and_run_container args
  # update the timeout for the Excon Http Client
  # set the chunk size to enable streaming of log files
  ::Docker.options = {:chunk_size => 1, :read_timeout => 3600}
  container = ::Docker::Container.create(
    'Image'           => args[:image],
    'Cmd'             => args[:command],
    "Binds"           => args[:volumes],
    "Env"             => args[:environment],
    'WorkingDir'      => args[:working_directory],
    'NetworkMode'     => @network,
    'name'        => args[:name],
    'PublishAllPorts' => true
  )

  success = true

  unless args[:deamon] == true
    thread = Thread.new do
      container.attach(:stream => true, :stdin => nil, :stdout => true, :stderr => true, :logs => false, :tty => false) do
        |stream, chunk|
          stream.to_s == 'stdout' ? color = :green : color  = :red
          puts "#{chunk.strip}".colorize(color)

          if stream.to_s == "stderr"
            success = false
          else
            success = true
          end
      end
    end
  end

  container.start

  thread.join unless args[:deamon] == true

  return container, success
end

#delete_container(container) ⇒ Object 



130
131
132
133
134
135
136
137
138
 
# File 'lib/minke/docker/docker_runner.rb', line 130

def delete_container container
  if container != nil
    begin
      container.delete()
    rescue => e
      puts "Error: Unable to delete container: #{e}"
    end
  end
end

#docker_version ⇒ Object 



160
161
162
 
# File 'lib/minke/docker/docker_runner.rb', line 160

def docker_version
  ::Docker.version['Version']
end

#find_image(image_name) ⇒ Object

find_image finds a docker image in the local registry Returns

Docker::Image



33
34
35
36
37
38
39
40
41
 
# File 'lib/minke/docker/docker_runner.rb', line 33

def find_image image_name
  found = nil

  ::Docker::Image.all.each do | image |
    found = image if image.info["RepoTags"] != nil && image.info["RepoTags"].include?(image_name)
  end

  return found
end

#get_docker_ip_address ⇒ Object

returns the ip address that docker is running on



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/minke/docker/docker_runner.rb', line 10

def get_docker_ip_address
  # first try to get the ip from docker-ip env
  if !ENV['DOCKER_IP'].to_s.empty?
    return ENV['DOCKER_IP']
  end

  if !ENV['DOCKER_HOST'].to_s.empty?
    # dockerhost set
    host = ENV['DOCKER_HOST'].dup
    host.gsub!(/tcp:\/\//, '')
    host.gsub!(/:\d+/,'')

    return host
  else
    return '127.0.0.1'
  end
end

#login_registry(url, user, password, email) ⇒ Object 



140
141
142
143
144
145
146
147
148
 
# File 'lib/minke/docker/docker_runner.rb', line 140

def  url, user, password, email
  if docker_version.start_with? '1.11'
    # email is removed for login in docker 1.11
    system("docker login -u #{user} -p #{password} #{url}")
  else
    system("docker login -u #{user} -p #{password} -e #{email} #{url}")
  end
  $?.exitstatus
end

#pull_image(image_name) ⇒ Object

pull_image pulls a new copy of the given image from the registry



45
46
47
48
49
 
# File 'lib/minke/docker/docker_runner.rb', line 45

def pull_image image_name
  puts "Pulling Image: #{image_name}"
  ::Docker.options = {:chunk_size => 1, :read_timeout => 3600}
  ::Docker::Image.create('fromImage' => image_name)
end

#push_image(image_name) ⇒ Object 



155
156
157
158
 
# File 'lib/minke/docker/docker_runner.rb', line 155

def push_image image_name
  system("docker push #{image_name}:latest")
  $?.exitstatus ==  0
end

#running_containers ⇒ Object

running_images returns a list of running containers Returns

Array of Docker::Image



56
57
58
59
 
# File 'lib/minke/docker/docker_runner.rb', line 56

def running_containers
  containers = ::Docker::Container.all(all: true, filters: { status: ["running"] }.to_json)
  return containers
end

#stop_container(container) ⇒ Object 



126
127
128
 
# File 'lib/minke/docker/docker_runner.rb', line 126

def stop_container container
  container.stop()
end

#tag_image(image_name, tag) ⇒ Object 



150
151
152
153
 
# File 'lib/minke/docker/docker_runner.rb', line 150

def tag_image image_name, tag
  image =  self.find_image "#{image_name}:latest"
  image.tag('repo' => tag, 'force' => true) unless image.info["RepoTags"].include? "#{tag}:latest"
end