Class: Dockage::Docker::Shell

Inherits:
Object
  • Object
show all
Defined in:
lib/dockage/docker/shell.rb

Constant Summary collapse

DOCKER_DEFAULT_HOST = 
'unix:///var/run/docker.sock'

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Shell

Returns a new instance of Shell.



7
8
9
 
# File 'lib/dockage/docker/shell.rb', line 7

def initialize
  @env = "export DOCKER_HOST=#{Dockage.settings[:docker_host] || DOCKER_DEFAULT_HOST}"
end

Instance Method Details

#build ⇒ Object 



51
52
53
 
# File 'lib/dockage/docker/shell.rb', line 51

def build
  invoke('build', attach_std: true)
end

#container_exists?(name) ⇒ Boolean

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/dockage/docker/shell.rb', line 114

def container_exists?(name)
  ps(name, true).any?
end

#container_running?(name) ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/dockage/docker/shell.rb', line 110

def container_running?(name)
  ps(name).any?
end

#destroy(name) ⇒ Object 



32
33
34
35
36
37
38
39
 
# File 'lib/dockage/docker/shell.rb', line 32

def destroy(name)
  unless container_exists?(name)
    Dockage.logger("Container #{name.bold.yellow} not found")
    return
  end
  Dockage.logger("Destroying container #{name.bold.yellow}")
  invoke("rm #{name}", catch_errors: false)
end

#provide(container) ⇒ Object

Raises:



41
42
43
44
45
46
47
48
49
 
# File 'lib/dockage/docker/shell.rb', line 41

def provide(container)
  raise SSHOptionsError unless container[:ssh]
  unless container_running?(container[:name])
    Dockage.error("Container #{container[:name].bold.yellow} is not running")
  end
  container[:provision].each do |provision|
    SSH.execute(provision, container[:ssh])
  end
end

#ps(name = nil, all = false) ⇒ Object 



55
56
57
58
59
60
 
# File 'lib/dockage/docker/shell.rb', line 55

def ps(name = nil, all = false)
  ps_output = invoke("ps --no-trunc #{all && '-a '}", attach_std: false).split(/\n/)
  containers = Parse.parse_docker_ps(ps_output)
  containers.reject! { |con| con[:name] != name } if name
  containers
end

#pull(image) ⇒ Object 



11
12
13
 
# File 'lib/dockage/docker/shell.rb', line 11

def pull(image)
  invoke("pull #{image}", attach_std: true)
end

#reload(container) ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/dockage/docker/shell.rb', line 74

def reload(container)
  return unless dependences_satisfied?(container)
  stop(container[:name]) if container_running?(container[:name])
  destroy(container[:name]) if container_exists?(container[:name])
  up(container)
end

#run(image, opts = {}) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/dockage/docker/shell.rb', line 118

def run(image, opts = {})
  command = "run" \
    "#{opts[:detach]  == false || ' -d'}" \
    "#{opts[:links]   && opts[:links].map { |link| " --link #{link}" }.join}" \
    "#{opts[:volumes] && opts[:volumes].map { |volume| " -v #{volume}" }.join}" \
    "#{opts[:ports]   && opts[:ports].map { |port| " -p #{port}" }.join}" \
    "#{opts[:name]    && " --name #{opts[:name]}"}" \
    " #{image}" \
    "#{opts[:cmd]     && " /bin/sh -c '#{opts[:cmd]}'"}"
  invoke(command)
end

#shellinit ⇒ Object 



106
107
108
 
# File 'lib/dockage/docker/shell.rb', line 106

def shellinit
  "export #{@env}"
end

#start(name) ⇒ Object 



15
16
17
18
19
20
21
 
# File 'lib/dockage/docker/shell.rb', line 15

def start(name)
  if container_running?(name)
    Dockage.logger("Container #{name.bold.yellow} is already running")
    return
  end
  invoke("start #{name}", catch_errors: true)
end

#status(name = nil) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/dockage/docker/shell.rb', line 81

def status(name = nil)
  output = ''

  containers = Dockage.settings[:containers]
  containers = containers.select { |con| con[:name] == name } if name

  active_containers = ps(name, true)
  containers.each do |container|
    output += "#{container[:name].to_s.bold.yellow} is "
    docker_container = active_containers.select { |con| con[:name] == container[:name] }.first
    if docker_container
      output += docker_container[:running] ? 'running'.green : 'not running'.red
    else
      output += 'not exists'.red
    end
    output += "\n"
  end

  output
end

#stop(name) ⇒ Object 



23
24
25
26
27
28
29
30
 
# File 'lib/dockage/docker/shell.rb', line 23

def stop(name)
  unless container_running?(name)
    Dockage.logger("Container #{name.bold.yellow} is not running. Nothing to do")
    return
  end
  Dockage.logger("Stopping container #{name.bold.yellow}")
  invoke("stop #{name}", catch_errors: true)
end

#up(container) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/dockage/docker/shell.rb', line 62

def up(container)
  Dockage.logger("Bringing up #{container[:name].yellow.bold}")
  return reload(container) if should_be_reload?(container)
  if container_running?(container[:name])
    Dockage.logger("Container #{container[:name].bold} is already up. Nothing to do")
    return
  end
  return start(container[:name]) if container_exists?(container[:name])
  pull(container[:image]) if container[:keep_fresh]
  run(container[:image], container)
end

#version ⇒ Object 



102
103
104
 
# File 'lib/dockage/docker/shell.rb', line 102

def version
  invoke('version')
end