Class: Cyoi::Providers::Clients::OpenStackProviderClient

Inherits:
FogProviderClient show all
Defined in:
lib/cyoi/providers/clients/openstack_provider_client.rb

Instance Attribute Summary

Attributes inherited from FogProviderClient

#attributes, #fog_compute

Instance Method Summary collapse

Methods inherited from FogProviderClient

#cleanup_unused_ip_addresses, #create_blobstore, #create_key_pair, #create_security_group, #delete_key_pair_if_exists, #delete_servers_with_name, #delete_volumes_with_name, #extract_port_definition, #find_unused_public_ip_address, #initialize, #provision_or_reuse_public_ip_address, #set_resource_name, #supports_blobstore_service?, #valid_key_pair_fingerprint?

Constructor Details

This class inherits a constructor from Cyoi::Providers::Clients::FogProviderClient

Instance Method Details

#associate_ip_address_with_server(ip_address, server) ⇒ Object 



32
33
34
35
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 32

def associate_ip_address_with_server(ip_address, server)
  address = fog_compute.addresses.find { |a| a.ip == ip_address }
  address.server = server
end

#authorize_port_range(sg, port_range, protocol, ip_range) ⇒ Object

Hook method for FogProviderClient#create_security_group



82
83
84
85
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 82

def authorize_port_range(sg, port_range, protocol, ip_range)
  rules = ip_permissions(sg)
  rules.create(parent_group_id: sg.id, from_port: port_range.min, to_port: port_range.max, ip_range: {"cidr" => ip_range}, ip_protocol: protocol)
end

#configuration ⇒ Object 



106
107
108
109
110
111
112
113
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 106

def configuration
  configuration = Fog.symbolize_credentials(attributes.credentials)
  configuration[:provider] = "OpenStack"
  if attributes.credentials.openstack_region && attributes.credentials.openstack_region.empty?
    configuration.delete(:openstack_region)
  end
  configuration
end

#create_and_attach_volume(name, disk_size, server, device) ⇒ Object 



92
93
94
95
96
97
98
99
100
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 92

def create_and_attach_volume(name, disk_size, server, device)
  volume = fog_compute.volumes.create(:name => name,
                                      :description => "",
                                      :size => disk_size,
                                      :availability_zone => server.availability_zone)
  volume.wait_for { volume.status == 'available' }
  volume.attach(server.id, device)
  volume.wait_for { volume.status == 'in-use' }
end

#delete_security_group_and_servers(sg_name) ⇒ Object 



102
103
104
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 102

def delete_security_group_and_servers(sg_name)
  raise "not implemented yet"
end

#find_server_device(server, device) ⇒ Object 



87
88
89
90
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 87

def find_server_device(server, device)
  va = fog_compute.get_server_volumes(server.id).body['volumeAttachments']
  va.find { |v| v["device"] == device }
end

#fog_network ⇒ Object 



127
128
129
130
131
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 127

def fog_network
  @fog_network ||= Fog::Network.new(configuration)
rescue Fog::Errors::NotFound
  nil
end

#fog_storage ⇒ Object

May throw odd exception if OpenStack doesn’t support Swift, like:

NoMethodError: undefined method `join' for "object-store":String



117
118
119
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 117

def fog_storage
  @fog_storage ||= Fog::Storage.new(configuration)
end

#ip_addresses_assigned_to_servers ⇒ Object 



63
64
65
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 63

def ip_addresses_assigned_to_servers
  fog_compute.servers.map {|s| s.addresses}.map {|address_hash| address_hash.map {|name, addrs| addrs}}.flatten.map {|addr| addr["addr"]}
end

#ip_permissions(sg) ⇒ Object

Hook method for FogProviderClient#create_security_group



68
69
70
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 68

def ip_permissions(sg)
  sg.security_group_rules
end

#networks? ⇒ boolean

Returns true if target OpenStack running Neutron networks.

Returns:

  • (boolean) —

    true if target OpenStack running Neutron networks



11
12
13
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 11

def networks?
  fog_network
end

#next_available_ip_in_subnet(subnet) ⇒ String

allocation_pools look like: “allocation_pools” => [“end”=>“192.168.101.254”]

Returns:

  • (String) —

    IP that is available for a new VM to use



54
55
56
57
58
59
60
61
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 54

def next_available_ip_in_subnet(subnet)
  ip = IPAddr.new(subnet.allocation_pools.first["start"])
  skip_ips = ip_addresses_assigned_to_servers
  while skip_ips.include?(ip.to_s)
    ip = ip.succ
  end
  ip.to_s
end

#openstack_constants ⇒ Object 



133
134
135
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 133

def openstack_constants
  Cyoi::Providers::Constants::OpenStackConstants
end

#port_open?(ip_permissions, port_range, protocol, ip_range) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
75
76
77
78
79
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 72

def port_open?(ip_permissions, port_range, protocol, ip_range)
  ip_permissions && ip_permissions.find do |ip|
    ip.ip_protocol == protocol \
    && ip.ip_range["cidr"] == ip_range \
    && ip.from_port <= port_range.min \
    && ip.to_port >= port_range.max
  end
end

#provision_public_ip_address(options = {}) ⇒ String

Returns provisions a new public IP address in target region.

Returns:

  • (String) —

    provisions a new public IP address in target region



20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 20

def provision_public_ip_address(options={})
  pool_name = options.delete("pool_name")
  pool_name ||= begin
    pool = fog_compute.addresses.get_address_pools.first
    pool["name"]
  end
  address = fog_compute.addresses.create(:pool => pool_name)
  address.ip
rescue NoMethodError
  print "No Public IP Found"
end

#setup_fog_connection ⇒ Object

Construct a Fog::Compute object Uses attributes which normally originates from settings.provider



123
124
125
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 123

def setup_fog_connection
  @fog_compute = Fog::Compute.new(configuration)
end

#subnets ⇒ Object 



15
16
17
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 15

def subnets
  fog_network.subnets
end

#unallocated_floating_ip_addresses(options = {}) ⇒ Array

Defaults to the first address pool unless “pool_name” is provided in options

Returns:

  • (Array) —

    of IPs that are not allocated to a server



40
41
42
43
44
45
46
47
48
49
 
# File 'lib/cyoi/providers/clients/openstack_provider_client.rb', line 40

def unallocated_floating_ip_addresses(options={})
  pool_name = options.delete("pool_name")
  pool_name ||= begin
    pool = fog_compute.addresses.get_address_pools.first
    pool["name"]
  end
  fog_compute.addresses.
    select { |a| a.pool == pool_name && a.instance_id.nil? }.
    map(&:ip)
end