Class: ComputeInstances

Inherits:
Object
  • Object
show all
Defined in:
lib/danarchy_sys/openstack/compute/instances.rb

Overview

OpenStack Instance Management

Instance Method Summary collapse

Constructor Details

#initialize(compute, instances, settings) ⇒ ComputeInstances

Returns a new instance of ComputeInstances.



4
5
6
7
8
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 4

def initialize(compute, instances, settings)
  @compute = compute
  @instances = instances
  @settings = settings
end

Instance Method Details

#all_instances(*filter) ⇒ Object 



10
11
12
13
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 10

def all_instances(*filter)
  filter = filter.shift || {}
  @instances = @compute.servers(filters: filter)
end

#check_instance(instance_name) ⇒ Object 



25
26
27
28
29
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 25

def check_instance(instance_name)
  return false if instance_name == nil || instance_name.empty? == true
  return true if get_instance(instance_name)
  false
end

#create_instance(instance_name, image_id, flavor_id, keypair_name, *userdata) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 94

def create_instance(instance_name, image_id, flavor_id, keypair_name, *userdata)
  user_data = userdata ? userdata.first : nil

  instance = @compute.servers.create(name: instance_name,
                                    image_ref: image_id,
                                    flavor_ref: flavor_id,
                                    key_name: keypair_name,
                                    user_data: user_data)
  
  # add security_group
  # add volumes
  # handle user_data with base64 encoding

  # Put error handling from instance_prompts here
  
  instance.wait_for { ready? }
  instance
end

#delete_instance(instance) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 113

def delete_instance(instance)
  instance = get_instance(instance) if instance.class == String    
  return 1 if instance == false

  instance_name = instance.name
  @compute.delete_server(instance.id)

  attempt = 1
  until check_instance(instance_name) == false
    return false if attempt == 5
    sleep(5)
    attempt += 1
  end

  addrs = [get_public_addresses(instance),
           get_private_addresses(instance)].flatten.compact!
  addrs.each { |addr| system("ssh-keygen -R #{addr} &>/dev/null") }

  return true
end

#get_instance(instance_name) ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 31

def get_instance(instance_name)
  instance = all_instances({ 'name' => [instance_name] })
  return false if !instance.first
  return false if !instance.collect{ |i| i.name }.include?(instance_name)
  instance.first
end

#get_private_addresses(instance) ⇒ Object 



45
46
47
48
49
50
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 45

def get_private_addresses(instance)
  instance = get_instance(instance) if instance.class == String
  addrs = instance.addresses
  return nil if !addrs['private']
  addrs['public'].map{|a| a['addr']}
end

#get_public_addresses(instance) ⇒ Object 



38
39
40
41
42
43
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 38

def get_public_addresses(instance)
  instance = get_instance(instance) if instance.class == String
  addrs = instance.addresses
  return nil if !addrs['public']
  addrs['public'].map{|a| a['addr']}
end

#list_active_instances ⇒ Object 



19
20
21
22
23
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 19

def list_active_instances
  @instances.collect do |i|
    i.name if i.state == 'ACTIVE'
  end.compact!
end

#list_all_instances ⇒ Object 



15
16
17
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 15

def list_all_instances
  @instances.collect { |i| i.name }
end

#pause(instance) ⇒ Object 



52
53
54
55
56
57
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 52

def pause(instance)
  instance = get_instance(instance) if instance.class == String

  return false unless instance.state == 'ACTIVE'
  instance.pause
end

#rebuild_instance(instance, image) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 134

def rebuild_instance(instance, image)
  instance = get_instance(instance) if instance.class == String

  instance.rebuild(image.id, instance.name)
  addrs = [get_public_addresses(instance),
           get_private_addresses(instance)].flatten.compact!
  addrs.each { |addr| system("ssh-keygen -R #{addr} &>/dev/null") }

  # instance.wait_for { ready? }
  get_instance(instance.name)
end

#resume(instance) ⇒ Object 



73
74
75
76
77
78
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 73

def resume(instance)
  instance = get_instance(instance) if instance.class == String

  return false unless instance.state == 'SUSPENDED'
  instance.start
end

#ssh_connector(instance) ⇒ Object 



146
147
148
149
150
151
152
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 146

def ssh_connector(instance)
  addrs = get_public_addresses(instance.name)
  { ipv4: addrs.grep(/\./).first,
    ipv6: addrs.grep(/:/).first,
    ssh_user: user,
    ssh_key: pemfile }
end

#start(instance) ⇒ Object 



80
81
82
83
84
85
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 80

def start(instance)
  instance = get_instance(instance) if instance.class == String

  return false unless instance.state == 'SHUTOFF'
  instance.start
end

#stop(instance) ⇒ Object 



87
88
89
90
91
92
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 87

def stop(instance)
  instance = get_instance(instance) if instance.class == String

  return false unless instance.state == 'ACTIVE'
  instance.stop
end

#suspend(instance) ⇒ Object 



66
67
68
69
70
71
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 66

def suspend(instance)
  instance = get_instance(instance) if instance.class == String

  return false unless instance.state == 'ACTIVE'
  instance.suspend
end

#unpause(instance) ⇒ Object 



59
60
61
62
63
64
 
# File 'lib/danarchy_sys/openstack/compute/instances.rb', line 59

def unpause(instance)
  instance = get_instance(instance) if instance.class == String

  return false unless instance.state == 'PAUSED'
  instance.start
end