Class: Fog::Rackspace::LoadBalancers::LoadBalancer

Inherits:
Model
  • Object
show all
Defined in:
lib/fog/rackspace/models/load_balancers/load_balancer.rb

Constant Summary collapse

ACTIVE =

States

'ACTIVE'
ERROR = 
'ERROR'
PENDING_UPDATE = 
'PENDING_UPDATE'
PENDING_DELTE = 
'PENDING_DELETE'
SUSPENDED = 
'SUSPENDED'
DELETED = 
'DELETED'
BUILD = 
'BUILD'

Instance Attribute Summary

Attributes inherited from Model

#collection, #connection

Instance Method Summary collapse

Methods inherited from Model

#inspect, #reload, #to_json, #wait_for

Methods included from Attributes::ClassMethods

#_load, #aliases, #attribute, #attributes, #identity, #ignore_attributes, #ignored_attributes

Methods included from Attributes::InstanceMethods

#_dump, #attributes, #dup, #identity, #identity=, #merge_attributes, #new_record?, #requires, #requires_one

Constructor Details

#initialize(attributes) ⇒ LoadBalancer

Returns a new instance of LoadBalancer.



31
32
33
34
35
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 31

def initialize(attributes)
  #HACK - Since we are hacking how sub-collections work, we have to make sure the connection is valid first.
  @connection = attributes[:connection]
  super
end

Instance Method Details

#access_rules ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 37

def access_rules
  @access_rules ||= begin
    Fog::Rackspace::LoadBalancers::AccessRules.new({
      :connection => connection,
      :load_balancer => self})
  end
end

#access_rules=(new_access_rules = []) ⇒ Object 



45
46
47
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 45

def access_rules=(new_access_rules=[])
  access_rules.load(new_access_rules)
end

#connection_logging ⇒ Object 



73
74
75
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 73

def connection_logging
  attributes[:connection_logging]
end

#connection_throttling ⇒ Object 



107
108
109
110
111
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 107

def connection_throttling
  requires :identity
  throttle = connection.get_connection_throttling(identity).body['connectionThrottle']
  throttle.count == 0 ? nil : throttle
end

#destroy ⇒ Object 



143
144
145
146
147
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 143

def destroy
  requires :identity
  connection.delete_load_balancer(identity)
  true
end

#disable_connection_logging ⇒ Object 



83
84
85
86
87
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 83

def disable_connection_logging
  requires :identity
  connection.set_connection_logging identity, false
  attributes[:connection_logging] = false
end

#disable_connection_throttling ⇒ Object 



119
120
121
122
123
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 119

def disable_connection_throttling
  requires :identity
  connection.remove_connection_throttling(identity)
  true
end

#disable_health_monitor ⇒ Object 



101
102
103
104
105
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 101

def disable_health_monitor
  requires :identity
  connection.remove_monitor(identity)
  true
end

#disable_session_persistence ⇒ Object 



137
138
139
140
141
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 137

def disable_session_persistence
  requires :identity
  connection.remove_session_persistence(identity)
  true
end

#enable_connection_logging ⇒ Object 



77
78
79
80
81
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 77

def enable_connection_logging
  requires :identity
  connection.set_connection_logging identity, true
  attributes[:connection_logging] = true
end

#enable_connection_throttling(max_connections, min_connections, max_connection_rate, rate_interval) ⇒ Object 



113
114
115
116
117
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 113

def enable_connection_throttling(max_connections, min_connections, max_connection_rate, rate_interval)
  requires :identity
  connection.set_connection_throttling(identity, max_connections, min_connections, max_connection_rate, rate_interval)
  true
end

#enable_health_monitor(type, delay, timeout, attempsBeforeDeactivation, options = {}) ⇒ Object 



95
96
97
98
99
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 95

def enable_health_monitor(type, delay, timeout, attempsBeforeDeactivation, options = {})
  requires :identity
  connection.set_monitor(identity, type, delay, timeout, attempsBeforeDeactivation, options = {})
  true
end

#enable_session_persistence(type) ⇒ Object 



131
132
133
134
135
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 131

def enable_session_persistence(type)
  requires :identity
  connection.set_session_persistence(identity, type)
  true
end

#health_monitor ⇒ Object 



89
90
91
92
93
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 89

def health_monitor
  requires :identity
  monitor = connection.get_monitor(identity).body['healthMonitor']
  monitor.count == 0 ? nil : monitor
end

#nodes ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 49

def nodes
  @nodes ||= begin
    Fog::Rackspace::LoadBalancers::Nodes.new({
      :connection => connection,
      :load_balancer => self})
  end
end

#nodes=(new_nodes = []) ⇒ Object 



57
58
59
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 57

def nodes=(new_nodes=[])
  nodes.load(new_nodes)
end

#ready? ⇒ Boolean

Returns:

  • (Boolean) 


149
150
151
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 149

def ready?
  state == ACTIVE
end

#save ⇒ Object 



153
154
155
156
157
158
159
160
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 153

def save
  if identity
    update
  else
    create
  end
  true
end

#session_persistence ⇒ Object 



125
126
127
128
129
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 125

def session_persistence
  requires :identity
  persistence = connection.get_session_persistence(identity).body['sessionPersistence']
  persistence.count == 0 ? nil : persistence
end

#usage(options = {}) ⇒ Object 



162
163
164
165
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 162

def usage(options = {})
  requires :identity
  connection.get_load_balancer_usage(identity, options).body
end

#virtual_ips ⇒ Object 



61
62
63
64
65
66
67
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 61

def virtual_ips
  @virtual_ips ||= begin
    Fog::Rackspace::LoadBalancers::VirtualIps.new({
      :connection => connection,
      :load_balancer => self})
  end
end

#virtual_ips=(new_virtual_ips = []) ⇒ Object 



69
70
71
 
# File 'lib/fog/rackspace/models/load_balancers/load_balancer.rb', line 69

def virtual_ips=(new_virtual_ips=[])
  virtual_ips.load(new_virtual_ips)
end