Module: Mcrain::Boot2docker

Defined in:
lib/mcrain/boot2docker.rb

Constant Summary collapse

BOOT2DOCKER_DOCKER_HOME = 
'/home/docker'.freeze

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.certs_dir ⇒ Object

Returns the value of attribute certs_dir.



16
17
18
 
# File 'lib/mcrain/boot2docker.rb', line 16

def certs_dir
  @certs_dir
end

Class Method Details

.build_docker_options(uri) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/mcrain/boot2docker.rb', line 46

def build_docker_options(uri)
  d = Boot2docker.certs_dir
  cert_path = File.join(d, "cert.pem")
  key_path = File.join(d, "key.pem")
  files = {
    ".docker/cert.pem" => cert_path,
    ".docker/key.pem" => key_path,
  }
  download_files_from_vm(uri.host, files)
  return {
    client_cert: cert_path,
    client_key: key_path,
    scheme: 'https',
  }
end

.cp_r(src, dest) ⇒ Object 



143
144
145
 
# File 'lib/mcrain/boot2docker.rb', line 143

def cp_r(src, dest)
  used? ? cp_r_remote(src, dest) : cp_r_local(src, dest)
end

.cp_r_local(src, dest) ⇒ Object 



164
165
166
 
# File 'lib/mcrain/boot2docker.rb', line 164

def cp_r_local(src, dest)
  FileUtils.cp_r(src, dest)
end

.cp_r_remote(src, dest) ⇒ Object 



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/mcrain/boot2docker.rb', line 147

def cp_r_remote(src, dest)
  Dir.mktmpdir("for_tarball") do |dir|
    tarball_name = "#{File.basename(src)}.tar.gz"
    FileUtils.chdir(dir) do
      FileUtils.cp_r(src, ".")
      unless system("tar zcf #{tarball_name} #{File.basename(src)}")
        raise "failed to create tarball of #{src} to #{dir}"
      end
    end
    host = URI.parse(ENV["DOCKER_HOST"]).host
    scp_connect(host) do |scp|
      scp.upload!(File.join(dir, tarball_name), dest)
      scp.session.exec!("cd #{dest} && tar zxf #{tarball_name}")
    end
  end
end

.download_files_from_vm(host, files) ⇒ Object

docs.docker.com/reference/api/docker_remote_api/ github.com/boot2docker/boot2docker#ssh-into-vm



64
65
66
67
68
69
70
71
72
 
# File 'lib/mcrain/boot2docker.rb', line 64

def download_files_from_vm(host, files)
  return if files.values.all?{|f| File.readable?(f)}
  files.values.each{|f| FileUtils.mkdir_p(File.dirname(f))}
  scp_connect(host) do |scp|
    files.each do |src, dest|
      scp.download(src, dest)
    end
  end
end

.mktmpdir(&block) ⇒ Object 



93
94
95
 
# File 'lib/mcrain/boot2docker.rb', line 93

def mktmpdir(&block)
  used? ? mktmpdir_ssh(&block) : mktmpdir_local(&block)
end

.mktmpdir_local(*args) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/mcrain/boot2docker.rb', line 126

def mktmpdir_local(*args)
  r = Dir.mktmpdir(*args)
  if block_given?
    begin
      yield(r)
    ensure
      Mcrain.logger.debug("removing #{r}")
      begin
        FileUtils.remove_entry_secure(r, true)
      rescue => e
        Mcrain.logger.warn("[#{e.class}] #{e.message}")
      end
    end
  end
  return r
end

.mktmpdir_remote(ssh, &block) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/mcrain/boot2docker.rb', line 103

def mktmpdir_remote(ssh, &block)
  Dir.mktmpdir do |orig_dir|
    dir = File.join(BOOT2DOCKER_DOCKER_HOME, 'tmp', orig_dir)
    cmd1 = "mkdir -p #{dir}"
    Mcrain.logger.debug(cmd1)
    ssh.exec! cmd1
    if block_given?
      begin
        yield(dir)
      ensure
        begin
          cmd2 = "rm -rf #{dir}"
          Mcrain.logger.debug(cmd2)
          ssh.exec! cmd2
        rescue => e
          Mcrain.logger.warn("[#{e.class}] #{e.message}")
        end
      end
    end
    return dir
  end
end

.mktmpdir_ssh(&block) ⇒ Object 



97
98
99
100
101
 
# File 'lib/mcrain/boot2docker.rb', line 97

def mktmpdir_ssh(&block)
  ssh_to_vm do |ssh|
    return mktmpdir_remote(ssh, &block)
  end
end

.preparing_command ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/mcrain/boot2docker.rb', line 26

def preparing_command
  return "" unless used?
  unless `boot2docker status`.strip == "running"
    raise "boot2docker is not running. Please `boot2docker start`"
  end
  exports = `boot2docker shellinit 2>/dev/null`.strip.split(/\n/)
  exports.empty? ? '' : "%s && " % exports.join(" && ")
end

.scp_connect(host, &block) ⇒ Object 



74
75
76
 
# File 'lib/mcrain/boot2docker.rb', line 74

def scp_connect(host, &block)
  Net::SCP.start(host, "docker", :password => "tcuser", &block)
end

.setup_docker_options ⇒ Object 



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/mcrain/boot2docker.rb', line 35

def setup_docker_options
  if used?
    require 'docker'
    uri = URI.parse(ENV["DOCKER_HOST"])
    Excon.defaults[:ssl_verify_peer] = false
    Docker.options = build_docker_options(uri)
  elsif ENV["DOCKER_HOST"].nil?
    ENV["DOCKER_HOST"] = "http://localhost:2375"
  end
end

.ssh_to_vm(&block) ⇒ Object 



85
86
87
88
89
90
91
 
# File 'lib/mcrain/boot2docker.rb', line 85

def ssh_to_vm(&block)
  host = used? ? URI.parse(ENV["DOCKER_HOST"]).host : "localhost"
  Mcrain.logger.debug("connection STARTING to #{host} by SSH")
  r = Net::SSH.start(host, "docker", :password => "tcuser", &block)
  Mcrain.logger.debug("connection SUCCESS  to #{host} by SSH")
  return r
end

.tmpdir ⇒ Object

return temporary dire for 2nd argument of Dir.mktmpdir



81
82
83
 
# File 'lib/mcrain/boot2docker.rb', line 81

def tmpdir
  used? ? File.join(BOOT2DOCKER_DOCKER_HOME, 'tmp', Dir.tmpdir) : Dir.tmpdir
end

.used? ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/mcrain/boot2docker.rb', line 22

def used?
  RbConfig::CONFIG["host_os"] =~ /darwin/
end