Module: VCAP::Services::Base::Warden::InstanceUtils

Included in:
Service
Defined in:
lib/base/warden/instance_utils.rb

Defined Under Namespace

Modules: ClassMethods

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object 



21
22
23
 
# File 'lib/base/warden/instance_utils.rb', line 21

def self.included(base)
  base.extend(ClassMethods)
end

Instance Method Details

#bind_mount_request(bind_dir) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/base/warden/instance_utils.rb', line 150

def bind_mount_request(bind_dir)
  bind = Warden::Protocol::CreateRequest::BindMount.new
  bind.src_path = bind_dir[:src]
  bind.dst_path = bind_dir[:dst] || bind_dir[:src]
  if bind_dir[:read_only]
    bind.mode = Warden::Protocol::CreateRequest::BindMount::Mode::RO
  else
    bind.mode = Warden::Protocol::CreateRequest::BindMount::Mode::RW
  end
  bind
end

#container_destroy(handle) ⇒ Object 



62
63
64
65
66
67
68
69
70
 
# File 'lib/base/warden/instance_utils.rb', line 62

def container_destroy(handle)
  warden = self.class.warden_connect
  req = Warden::Protocol::DestroyRequest.new
  req.handle = handle
  warden.call(req)
  true
ensure
  warden.disconnect if warden
end

#container_info(handle) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/base/warden/instance_utils.rb', line 104

def container_info(handle)
  warden = self.class.warden_connect
  req = Warden::Protocol::InfoRequest.new
  req.handle = handle
  warden.call(req)
rescue => e
  nil
ensure
  warden.disconnect if warden
end

#container_run_command(handle, cmd, is_privileged = false) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/base/warden/instance_utils.rb', line 76

def container_run_command(handle, cmd, is_privileged=false)
  warden = self.class.warden_connect
  req = Warden::Protocol::RunRequest.new
  req.handle = handle
  req.script = cmd
  req.privileged = is_privileged
  res = warden.call(req)
  if res.exit_status == 0
    res
  else
    raise VCAP::Services::Base::Error::ServiceError::new(VCAP::Services::Base::Error::ServiceError::WARDEN_RUN_COMMAND_FAILURE, cmd, handle, res.exit_status, res.stdout, res.stderr)
  end
ensure
  warden.disconnect if warden
end

#container_running?(handle) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/base/warden/instance_utils.rb', line 72

def container_running?(handle)
  handle != "" && container_info(handle) != nil
end

#container_spawn_command(handle, cmd, is_privileged = false) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/base/warden/instance_utils.rb', line 92

def container_spawn_command(handle, cmd, is_privileged=false)
  warden = self.class.warden_connect
  req = Warden::Protocol::SpawnRequest.new
  req.handle = handle
  req.script = cmd
  req.privileged = is_privileged
  res = warden.call(req)
  res
ensure
  warden.disconnect if warden
end

#container_start(bind_mounts = []) ⇒ Object

warden container operation helper



38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/base/warden/instance_utils.rb', line 38

def container_start(bind_mounts=[])
  warden = self.class.warden_connect
  req = Warden::Protocol::CreateRequest.new
  unless bind_mounts.empty?
    req.bind_mounts = bind_mounts
  end
  rsp = warden.call(req)
  handle = rsp.handle
  handle
ensure
  warden.disconnect if warden
end

#container_stop(handle, force = true) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/base/warden/instance_utils.rb', line 51

def container_stop(handle, force=true)
  warden = self.class.warden_connect
  req = Warden::Protocol::StopRequest.new
  req.handle = handle
  req.background = !force
  warden.call(req)
  true
ensure
  warden.disconnect if warden
end

#limit_bandwidth(handle, rate) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/base/warden/instance_utils.rb', line 126

def limit_bandwidth(handle, rate)
  warden = self.class.warden_connect
  req = Warden::Protocol::LimitBandwidthRequest.new
  req.handle = handle
  req.rate = (rate * 1024 * 1024).to_i
  req.burst = (rate * 1 * 1024 * 1024).to_i # Set burst the same size as rate
  warden.call(req)
  true
ensure
  warden.disconnect if warden
end

#limit_memory(handle, limit) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/base/warden/instance_utils.rb', line 115

def limit_memory(handle, limit)
  warden = self.class.warden_connect
  req = Warden::Protocol::LimitMemoryRequest.new
  req.handle = handle
  req.limit_in_bytes = limit * 1024 * 1024
  warden.call(req)
  true
ensure
  warden.disconnect if warden
end

#map_port(handle, src_port, dest_port) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/base/warden/instance_utils.rb', line 138

def map_port(handle, src_port, dest_port)
  warden = self.class.warden_connect
  req = Warden::Protocol::NetInRequest.new
  req.handle = handle
  req.host_port = src_port
  req.container_port = dest_port
  res = warden.call(req)
  res
ensure
  warden.disconnect if warden
end