Class: VagrantPlugins::Openstack::NovaClient

Inherits:
Object
  • Object
show all
Includes:
Singleton, Domain, HttpUtils
Defined in:
lib/vagrant-openstack-provider/client/nova.rb

Instance Method Summary collapse

Methods included from HttpUtils

#delete, #get, #get_api_version_list, #post

Methods included from HttpUtils::RequestLogger

#log_request, #log_response

Constructor Details

#initialize ⇒ NovaClient

Returns a new instance of NovaClient.



14
15
16
17
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 14

def initialize
  @logger = Log4r::Logger.new('vagrant_openstack::nova')
  @session = VagrantPlugins::Openstack.session
end

Instance Method Details

#add_floating_ip(env, server_id, floating_ip) ⇒ Object 



109
110
111
112
113
114
115
116
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 109

def add_floating_ip(env, server_id, floating_ip)
  instance_exists do
    check_floating_ip(env, floating_ip)

    post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
         { addFloatingIp: { address: floating_ip } }.to_json)
  end
end

#allocate_floating_ip(env, pool) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 33

def allocate_floating_ip(env, pool)
  ips_json = post(env, "#{@session.endpoints[:compute]}/os-floating-ips",
                  {
                    pool: pool
                  }.to_json,
                  'X-Auth-Token' => @session.token,
                  :accept => :json,
                  :content_type => :json)
  floating_ip = JSON.parse(ips_json)['floating_ip']
  FloatingIP.new(floating_ip['ip'], floating_ip['pool'], floating_ip['instance_id'])
end

#attach_volume(env, server_id, volume_id, device = nil) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 154

def attach_volume(env, server_id, volume_id, device = nil)
  instance_exists do
    attachment = post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/os-volume_attachments",
                      {
                        volumeAttachment: {
                          volumeId: volume_id,
                          device: device
                        }
                      }.to_json)
    JSON.parse(attachment)['volumeAttachment']
  end
end

#create_server(env, options) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 50

def create_server(env, options)
  server = {}.tap do |s|
    s['name'] = options[:name]
    if options[:image_ref].nil?
      s['block_device_mapping'] = [{ volume_id: options[:volume_boot][:id], device_name: options[:volume_boot][:device] }]
    else
      s['imageRef'] = options[:image_ref]
    end
    s['flavorRef'] = options[:flavor_ref]
    s['key_name'] = options[:keypair]
    s['availability_zone'] = options[:availability_zone] unless options[:availability_zone].nil?
    s['security_groups'] = options[:security_groups] unless options[:security_groups].nil?
    s['user_data'] = Base64.encode64(options[:user_data]) unless options[:user_data].nil?
    s['metadata'] = options[:metadata] unless options[:metadata].nil?
    s['networks'] = options[:networks] unless options[:networks].nil? || options[:networks].empty?
  end
  object = { server: server }
  object[:scheduler_hints] = options[:scheduler_hints] unless options[:scheduler_hints].nil?
  server = post(env, "#{@session.endpoints[:compute]}/servers", object.to_json)
  JSON.parse(server)['server']['id']
end

#delete_keypair_if_vagrant(env, server_id) ⇒ Object 



137
138
139
140
141
142
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 137

def delete_keypair_if_vagrant(env, server_id)
  instance_exists do
    keyname = get_server_details(env, server_id)['key_name']
    delete(env, "#{@session.endpoints[:compute]}/os-keypairs/#{keyname}") if keyname.start_with?('vagrant-generated-')
  end
end

#delete_server(env, server_id) ⇒ Object 



72
73
74
75
76
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 72

def delete_server(env, server_id)
  instance_exists do
    delete(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
  end
end

#get_all_flavors(env) ⇒ Object 



19
20
21
22
23
24
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 19

def get_all_flavors(env)
  flavors_json = get(env, "#{@session.endpoints[:compute]}/flavors/detail")
  JSON.parse(flavors_json)['flavors'].map do |fl|
    Flavor.new(fl['id'], fl['name'], fl['vcpus'], fl['ram'], fl['disk'])
  end
end

#get_all_floating_ips(env) ⇒ Object 



26
27
28
29
30
31
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 26

def get_all_floating_ips(env)
  ips_json = get(env, "#{@session.endpoints[:compute]}/os-floating-ips",
                 'X-Auth-Token' => @session.token,
                 :accept => :json)
  JSON.parse(ips_json)['floating_ips'].map { |n| FloatingIP.new(n['ip'], n['pool'], n['instance_id']) }
end

#get_all_images(env) ⇒ Object 



45
46
47
48
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 45

def get_all_images(env)
  images_json = get(env, "#{@session.endpoints[:compute]}/images")
  JSON.parse(images_json)['images'].map { |fl| Image.new(fl['id'], fl['name'], 'unknown') }
end

#get_floating_ip_pools(env) ⇒ Object 



144
145
146
147
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 144

def get_floating_ip_pools(env)
  floating_ips = get(env, "#{@session.endpoints[:compute]}/os-floating-ip-pools")
  JSON.parse(floating_ips)['floating_ip_pools']
end

#get_floating_ips(env) ⇒ Object 



149
150
151
152
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 149

def get_floating_ips(env)
  floating_ips = get(env, "#{@session.endpoints[:compute]}/os-floating-ips")
  JSON.parse(floating_ips)['floating_ips']
end

#get_server_details(env, server_id) ⇒ Object 



102
103
104
105
106
107
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 102

def get_server_details(env, server_id)
  instance_exists do
    server_details = get(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
    JSON.parse(server_details)['server']
  end
end

#import_keypair(env, public_key) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 118

def import_keypair(env, public_key)
  keyname = "vagrant-generated-#{Kernel.rand(36**8).to_s(36)}"

  key_details = post(env, "#{@session.endpoints[:compute]}/os-keypairs",
                     { keypair:
                       {
                         name: keyname,
                         public_key: public_key
                       }
                     }.to_json)
  JSON.parse(key_details)['keypair']['name']
end

#import_keypair_from_file(env, public_key_path) ⇒ Object 



131
132
133
134
135
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 131

def import_keypair_from_file(env, public_key_path)
  fail "File specified in public_key_path #{public_key_path} doesn't exist" unless File.exist?(public_key_path)
  file = File.open(public_key_path)
  import_keypair(env, file.read)
end

#resume_server(env, server_id) ⇒ Object 



84
85
86
87
88
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 84

def resume_server(env, server_id)
  instance_exists do
    change_server_state(env, server_id, :resume)
  end
end

#start_server(env, server_id) ⇒ Object 



96
97
98
99
100
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 96

def start_server(env, server_id)
  instance_exists do
    change_server_state(env, server_id, :start)
  end
end

#stop_server(env, server_id) ⇒ Object 



90
91
92
93
94
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 90

def stop_server(env, server_id)
  instance_exists do
    change_server_state(env, server_id, :stop)
  end
end

#suspend_server(env, server_id) ⇒ Object 



78
79
80
81
82
 
# File 'lib/vagrant-openstack-provider/client/nova.rb', line 78

def suspend_server(env, server_id)
  instance_exists do
    change_server_state(env, server_id, :suspend)
  end
end