Class: Fog::HP::LB::Real

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/hp/requests/lb/list_limits.rb,
lib/fog/hp/lb.rb,
lib/fog/hp/requests/lb/list_versions.rb,
lib/fog/hp/requests/lb/list_protocols.rb,
lib/fog/hp/requests/lb/list_algorithms.rb,
lib/fog/hp/requests/lb/get_load_balancer.rb,
lib/fog/hp/requests/lb/list_load_balancers.rb,
lib/fog/hp/requests/lb/create_load_balancer.rb,
lib/fog/hp/requests/lb/delete_load_balancer.rb,
lib/fog/hp/requests/lb/update_load_balancer.rb,
lib/fog/hp/requests/lb/get_load_balancer_node.rb,
lib/fog/hp/requests/lb/list_load_balancer_nodes.rb,
lib/fog/hp/requests/lb/create_load_balancer_node.rb,
lib/fog/hp/requests/lb/delete_load_balancer_node.rb,
lib/fog/hp/requests/lb/update_load_balancer_node.rb,
lib/fog/hp/requests/lb/list_load_balancer_virtual_ips.rb

Overview

List virtual IPs for an existing load balancer

Parameters

  • ‘load_balancer_id’<~String> - UUId of the load balancer to get virtual IPs for

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘virtualIps’<~Array>:

        • ‘id’<~String> - UUId for the virtual IP

        • ‘address’<~String> - Address for the virtual IP

        • ‘type’<~String> - Type for the virtual IP e.g. ‘PUBLIC’

        • ‘ipVersion’<~String> - Version for virtual IP e.g. ‘IPV4’, ‘IPV6’

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Real

Returns a new instance of Real.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/fog/hp/lb.rb', line 96

def initialize(options={})
  @hp_access_key = options[:hp_access_key]
  @hp_secret_key      = options[:hp_secret_key]
  @hp_auth_uri        = options[:hp_auth_uri]
  @connection_options = options[:connection_options] || {}
  ### Set an option to use the style of authentication desired; :v1 or :v2 (default)
  auth_version        = options[:hp_auth_version] || :v2
  ### Pass the service name for object storage to the authentication call
  options[:hp_service_type] ||= "hpext:lbaas"
  @hp_tenant_id       = options[:hp_tenant_id]
  @hp_avl_zone        = options[:hp_avl_zone]

  ### Make the authentication call
  if (auth_version == :v2)
    # Call the control services authentication
    credentials = Fog::HP.authenticate_v2(options, @connection_options)
    # the CS service catalog returns the block storage endpoint
    @hp_block_uri = credentials[:endpoint_url]
  else
    # Call the legacy v1.0/v1.1 authentication
    credentials = Fog::HP.authenticate_v1(options, @connection_options)
    # the user sends in the block storage endpoint
    @hp_block_uri = options[:hp_auth_uri]
  end

  @auth_token = credentials[:auth_token]
  @persistent = options[:persistent] || false

  uri = URI.parse(@hp_block_uri)
  @host   = uri.host
  @path   = uri.path
  @port   = uri.port
  @scheme = uri.scheme

  @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
end

Instance Attribute Details

#credentials ⇒ Object (readonly)

Returns the value of attribute credentials.



94
95
96
 
# File 'lib/fog/hp/lb.rb', line 94

def credentials
  @credentials
end

Instance Method Details

#create_load_balancer(name, nodes, options = {}) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/fog/hp/requests/lb/create_load_balancer.rb', line 41

def create_load_balancer(name, nodes, options={})
  ### Inconsistent behavior. Should be passing in as a 'loadbalancer' => {'name', 'nodes'}
  data = {
    'name'  => name,
    'nodes' => nodes
  }
  l_options = ['port', 'protocol', 'algorithm']
  l_options.select{|o| options[o]}.each do |key|
    data[key] = options[key]
  end

  if options['virtualIps']
    data['virtualIps'] = []
    for vip in options['virtualIps']
      data['virtualIps'] << vip
    end
  end

  response = request(
    :body    => Fog::JSON.encode(data),
    :expects => 202,
    :method  => 'POST',
    :path    => 'loadbalancers'
  )
  response
end

#create_load_balancer_node(load_balancer_id, address, port, options = {}) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/fog/hp/requests/lb/create_load_balancer_node.rb', line 23

def create_load_balancer_node(load_balancer_id, address, port, options={})
  data = {
    'nodes' => [
        {
            'address' => address,
            'port'    => port
        }
    ]
  }
  if options['condition']
    data['nodes'][0]['condition'] = options['condition']
  end

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 202,
    :method  => 'POST',
    :path    => "loadbalancers/#{load_balancer_id}/nodes"
  )
end

#delete_load_balancer(load_balancer_id) ⇒ Object 



10
11
12
13
14
15
16
 
# File 'lib/fog/hp/requests/lb/delete_load_balancer.rb', line 10

def delete_load_balancer(load_balancer_id)
  request(
      :expects => 202,
      :method  => 'DELETE',
      :path    => "loadbalancers/#{load_balancer_id}"
  )
end

#delete_load_balancer_node(load_balancer_id, node_id) ⇒ Object 



11
12
13
14
15
16
17
 
# File 'lib/fog/hp/requests/lb/delete_load_balancer_node.rb', line 11

def delete_load_balancer_node(load_balancer_id, node_id)
  request(
    :expects => 202,
    :method  => 'DELETE',
    :path    => "loadbalancers/#{load_balancer_id}/nodes/#{node_id}"
  )
end

#get_load_balancer(load_balancer_id) ⇒ Object 



35
36
37
38
39
40
41
 
# File 'lib/fog/hp/requests/lb/get_load_balancer.rb', line 35

def get_load_balancer(load_balancer_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "loadbalancers/#{load_balancer_id}"
  )
end

#get_load_balancer_node(load_balancer_id, node_id) ⇒ Object

Get details for an existing load balancer node

Parameters

  • ‘load_balancer_id’<~String> - UUId of the load balancer to get

  • ‘node_id’<~String> - UUId of node to get

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘id’<~String> - UUId for the node

      • ‘address’<~String> - Address for the node

      • ‘port’<~String> - Port for the node

      • ‘condition’<~String> - Condition for the node e.g. ‘ENABLED’

      • ‘status’<~String> - Status for the node e.g. ‘ONLINE’



19
20
21
22
23
24
25
 
# File 'lib/fog/hp/requests/lb/get_load_balancer_node.rb', line 19

def get_load_balancer_node(load_balancer_id, node_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "loadbalancers/#{load_balancer_id}/nodes/#{node_id}"
  )
end

#list_algorithms ⇒ Object 



12
13
14
15
16
17
18
 
# File 'lib/fog/hp/requests/lb/list_algorithms.rb', line 12

def list_algorithms
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'algorithms'
  )
end

#list_limits ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/fog/hp/requests/lb/list_limits.rb', line 17

def list_limits
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'limits'
  )
end

#list_load_balancer_nodes(load_balancer_id) ⇒ Object 



16
17
18
19
20
21
22
23
 
# File 'lib/fog/hp/requests/lb/list_load_balancer_nodes.rb', line 16

def list_load_balancer_nodes(load_balancer_id)
  response = request(
    :expects => 200,
    :method  => 'GET',
    :path    => "loadbalancers/#{load_balancer_id}/nodes"
  )
  response
end

#list_load_balancer_virtual_ips(load_balancer_id) ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/fog/hp/requests/lb/list_load_balancer_virtual_ips.rb', line 18

def list_load_balancer_virtual_ips(load_balancer_id)
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => "loadbalancers/#{load_balancer_id}/virtualips"
  )
end

#list_load_balancers ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/fog/hp/requests/lb/list_load_balancers.rb', line 20

def list_load_balancers
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'loadbalancers'
  )
end

#list_protocols ⇒ Object 



13
14
15
16
17
18
19
20
 
# File 'lib/fog/hp/requests/lb/list_protocols.rb', line 13

def list_protocols
  response = request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'protocols'
  )
  response
end

#list_versions ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/hp/requests/lb/list_versions.rb', line 5

def list_versions
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => ''
  )
end

#reload ⇒ Object 



133
134
135
 
# File 'lib/fog/hp/lb.rb', line 133

def reload
  @connection.reset
end

#request(params, parse_json = true, &block) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/fog/hp/lb.rb', line 137

def request(params, parse_json = true, &block)
  begin
    response = @connection.request(params.merge!({
       :headers => {
         'Content-Type' => 'application/json',
         'Accept'       => 'application/json',
         'X-Auth-Token' => @auth_token
       }.merge!(params[:headers] || {}),
       :path    => "#{@path}/#{params[:path]}",
   }), &block)
  rescue Excon::Errors::HTTPStatusError => error
    raise case error
    when Excon::Errors::NotFound
      Fog::HP::LB::NotFound.slurp(error)
    else
      error
    end
  end
  if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
    response.body = Fog::JSON.decode(response.body)
  end
  response
end

#update_load_balancer(load_balancer_id, options = {}) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/fog/hp/requests/lb/update_load_balancer.rb', line 12

def update_load_balancer(load_balancer_id, options={})
  data = {}
  l_options = ['name', 'algorithm']
  l_options.select{|o| options[o]}.each do |key|
    data[key] = options[key]
  end

  request(
    :body    => Fog::JSON.encode(data),
    :expects => 202,
    :method  => 'PUT',
    :path    => "loadbalancers/#{load_balancer_id}"
  )
end

#update_load_balancer_node(load_balancer_id, node_id, condition) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/fog/hp/requests/lb/update_load_balancer_node.rb', line 12

def update_load_balancer_node(load_balancer_id, node_id, condition)
  data = {
    'condition' => condition
  }
  request(
    :body    => Fog::JSON.encode(data),
    :expects => 202,
    :method  => 'PUT',
    :path    => "loadbalancers/#{load_balancer_id}/nodes/#{node_id}"
  )
end