Module: Mccloud::Provider::Libvirt::VmCommand

Included in:
Vm
Defined in:
lib/mccloud/provider/libvirt/vm/up.rb,
lib/mccloud/provider/libvirt/vm/scp.rb,
lib/mccloud/provider/libvirt/vm/ssh.rb,
lib/mccloud/provider/libvirt/vm/halt.rb,
lib/mccloud/provider/libvirt/vm/rsync.rb,
lib/mccloud/provider/libvirt/vm/reload.rb,
lib/mccloud/provider/libvirt/vm/destroy.rb,
lib/mccloud/provider/libvirt/vm/forward.rb,
lib/mccloud/provider/libvirt/vm/bootstrap.rb,
lib/mccloud/provider/libvirt/vm/provision.rb

Instance Method Summary collapse

Instance Method Details

#_bootstrap(command, options = nil) ⇒ Object 



7
8
9
10
11
12
13
 
# File 'lib/mccloud/provider/libvirt/vm/bootstrap.rb', line 7

def _bootstrap(command,options=nil)
  if raw.ready?
    env.ui.info "[#{@name}] - Waiting for an ip-address "
    raw.wait_for {   printf "."; STDOUT.flush; !public_ip_address.nil? }
  end
  ssh_bootstrap(command,options)
end

#_provision(options) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/mccloud/provider/libvirt/vm/provision.rb', line 5

def _provision(options)

  unless raw.nil?

    if raw.ready?
      @provisioners.each do |provisioner|
        env.ui.info "[#{@name}] - starting provisioning with #{provisioner.name} as provisioner"
        provisioner.run(self)
      end
    else
      env.ui.info "[#{@name}] - machine is not running, skipping provisioning"
    end
  else
    env.ui.info "[#{@name}] - machine doesn't exit yet"
  end

end

#destroy(options) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/mccloud/provider/libvirt/vm/destroy.rb', line 5

def destroy(options)
  fullname="#{@provider.filter}#{@name}"
  server=@provider.raw.servers.all(:name => fullname)
  volname="#{fullname}.img"
  #TODO use the creation options
  volume=@provider.raw.volumes.all(:name => volname)

  unless server.nil?
    env.ui.info "[#{@name}] - Destroying machine #{@provider.namespace}::#{@name}"

    server.first.destroy
  else
    env.ui.info "[#{@name}] - Server #{@provider.namespace}::#{@name} does not exist"
  end

  unless volume.nil?
    env.ui.info "[#{@name}] - Destroying volume #{@provider.namespace}::#{@name}.img"

    volume.first.destroy
  else
    env.ui.info "[#{@name}] - Volume #{@provider.namespace}::#{@name}.img does not exist"

  end

end

#forward(command, options = {}) ⇒ Object 



5
6
7
8
 
# File 'lib/mccloud/provider/libvirt/vm/forward.rb', line 5

def forward(command,options={})
  @forward_threads=Array.new
  return self.ssh_forward(options)
end

#halt(options) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/mccloud/provider/libvirt/vm/halt.rb', line 5

def halt(options)

  if self.running?
    env.ui.info "Halting machine #{@name}(#{@raw.id})"
    raw.shutdown
    raw.wait_for { printf "."; STDOUT.flush; state=="stopped"||state=="crashed"}
    env.ui.info ""
  else
    env.ui.info "#{@name}(#{raw.id}) is already halted."
  end

end

#reload(options) ⇒ Object 



4
5
6
7
8
9
10
 
# File 'lib/mccloud/provider/libvirt/vm/reload.rb', line 4

def reload(options)
   env.logger.info "Checking if #{@name} is running: #{self.running?}"
  if self.running?
    self.halt(options)
  end
  self.up(options)
end

#rsync(path, options) ⇒ Object 



5
6
7
 
# File 'lib/mccloud/provider/libvirt/vm/rsync.rb', line 5

def rsync(path,options)
  super(path,options)
end

#scp(src, dest, options = {}) ⇒ Object 



9
10
11
 
# File 'lib/mccloud/provider/libvirt/vm/scp.rb', line 9

def scp(src,dest, options = {})
   raw.scp(src,dest,options)
end

#ssh(command, options = {}) ⇒ Object 



5
6
7
 
# File 'lib/mccloud/provider/libvirt/vm/ssh.rb', line 5

def ssh(command,options={})
  super(command,options)
end

#transfer(src, dest, options = {}) ⇒ Object 



5
6
7
 
# File 'lib/mccloud/provider/libvirt/vm/scp.rb', line 5

def transfer(src,dest,options = {})
  scp(src,dest,options)
end

#up(options) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/mccloud/provider/libvirt/vm/up.rb', line 5

def up(options)

  env.ui.info "Upping of libvirt vm #{@name}"

  # There is no existing machine yet, so we create it
  if raw.nil?
    enhanced_create_options=@create_options
    enhanced_create_options[:name]="#{@provider.filter}#{@name}"
    env.ui.info "[#{@name}] - Creating machine #{@provider.namespace}::#{@name}"
    @raw=@provider.raw.servers.create(enhanced_create_options)
    raw.start

    env.ui.info "[#{@name}] - Waiting for the machine to become accessible"
    raw.wait_for { printf "."; STDOUT.flush;  ready?}

    # Wait for ssh to become available ...
    env.ui.info "[#{@name}] - Waiting for ip address"
    #env.ui.info instance.console_output.body["output"]
    raw.wait_for { printf "."; STDOUT.flush;  !public_ip_address.nil?}

    env.ui.info "[#{@name}] - Waiting for ssh on #{self.ip_address} to become available"
    Mccloud::Util::Ssh.execute_when_tcp_available(self.ip_address, { :port => @port, :timeout => 6000 }) do
      env.ui.info "[#{@name}] - Ssh is available , proceeding with bootstrap"
    end

    # Because it's a new machine we bootstrap it to
    self._bootstrap(nil,options)

  else
    state=raw.state
    if state !="running"
      env.ui.info "Booting up machine #{@name}"
      raw.start
      raw.wait_for { printf ".";STDOUT.flush;  ready?}
      env.ui.info ""
    else
      unless raw.state == "shutting-down"
        env.ui.info "[#{@name}] - already running."
      else
        env.ui.info "[#{@name}] - can't start machine because it is in state #{raw.state}"
        return
      end
    end

  end

  unless options["noprovision"]
    env.ui.info "[#{@name}] - Waiting for ssh to become available"
    Mccloud::Util::Ssh.execute_when_tcp_available(self.ip_address, { :port => @port, :timeout => 6000 }) do
      env.ui.info "[#{@name}] - Ssh is available , proceeding with provisioning"
    end

    env.ui.info "[#{@name}] - provision step #{@name}"
    self._provision(options)
  end

end