fog 0.10.0 → 0.11.0

data/lib/fog/rackspace/models/load_balancers/access_rule.rb

@@ -0,0 +1,39 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class AccessRule < Fog::Model
+
+        identity :id
+
+        attribute :address
+        attribute :type
+
+        def destroy
+          requires :identity, :load_balancer
+          connection.delete_access_rule(load_balancer.identity, identity)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :load_balancer, :address, :type
+          connection.create_access_rule(load_balancer.id, address, type)
+
+          #Unfortunately, access rules creation doesn't return an ID, we require a subsequent list call and comparison
+          data = connection.list_access_rules(load_balancer.id).body['accessList'].select do |ar|
+            ar['address'] == address && ar['type'] == type
+          end.first
+          merge_attributes(data)
+          true
+        end
+
+        private
+        def load_balancer
+          collection.load_balancer
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/access_rules.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/load_balancers/access_rule'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class AccessRules < Fog::Collection
+        model Fog::Rackspace::LoadBalancers::AccessRule
+
+        attr_accessor :load_balancer
+
+        def all
+          load(all_raw)
+        end
+
+        def get(access_rule_id)
+          data = all_raw.select { |access_rule| access_rule['id'] == access_rule_id }.first
+          data && new(data)
+        end
+
+        private
+        def all_raw
+          requires :load_balancer
+          data = connection.list_access_rules(load_balancer.id).body['accessList']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/load_balancer.rb

@@ -0,0 +1,216 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class LoadBalancer < Fog::Model
+
+        #States
+        ACTIVE = 'ACTIVE'
+        ERROR = 'ERROR'
+        PENDING_UPDATE = 'PENDING_UPDATE'
+        PENDING_DELTE = 'PENDING_DELETE'
+        SUSPENDED = 'SUSPENDED'
+        DELETED = 'DELETED'
+        BUILD = 'BUILD'
+
+        identity :id
+
+        attribute :cluster
+        attribute :connection_logging,  :aliases => 'connectionLogging'
+        attribute :port
+        attribute :protocol
+        attribute :algorithm
+        attribute :virtual_ips,         :aliases => 'virtualIps'
+        attribute :created
+        attribute :updated
+        attribute :name
+        attribute :state,               :aliases => 'status'
+        attribute :nodes
+
+        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
+
+        def access_rules
+          @access_rules ||= begin
+            Fog::Rackspace::LoadBalancers::AccessRules.new({
+              :connection => connection,
+              :load_balancer => self})
+          end
+        end
+
+        def access_rules=(new_access_rules=[])
+          access_rules.load(new_access_rules)
+        end
+
+        def nodes
+          @nodes ||= begin
+            Fog::Rackspace::LoadBalancers::Nodes.new({
+              :connection => connection,
+              :load_balancer => self})
+          end
+        end
+
+        def nodes=(new_nodes=[])
+          nodes.load(new_nodes)
+        end
+
+        def virtual_ips
+          @virtual_ips ||= begin
+            Fog::Rackspace::LoadBalancers::VirtualIps.new({
+              :connection => connection,
+              :load_balancer => self})
+          end
+        end
+
+        def virtual_ips=(new_virtual_ips=[])
+          virtual_ips.load(new_virtual_ips)
+        end
+
+        def connection_logging
+          attributes[:connection_logging]
+        end
+
+        def enable_connection_logging
+          requires :identity
+          connection.set_connection_logging identity, true
+          attributes[:connection_logging] = true
+        end
+
+        def disable_connection_logging
+          requires :identity
+          connection.set_connection_logging identity, false
+          attributes[:connection_logging] = false
+        end
+
+        def health_monitor
+          requires :identity
+          monitor = connection.get_monitor(identity).body['healthMonitor']
+          monitor.count == 0 ? nil : monitor
+        end
+
+        def enable_health_monitor(type, delay, timeout, attempsBeforeDeactivation, options = {})
+          requires :identity
+          connection.set_monitor(identity, type, delay, timeout, attempsBeforeDeactivation, options = {})
+          true
+        end
+
+        def disable_health_monitor
+          requires :identity
+          connection.remove_monitor(identity)
+          true
+        end
+
+        def connection_throttling
+          requires :identity
+          throttle = connection.get_connection_throttling(identity).body['connectionThrottle']
+          throttle.count == 0 ? nil : throttle
+        end
+
+        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
+
+        def disable_connection_throttling
+          requires :identity
+          connection.remove_connection_throttling(identity)
+          true
+        end
+
+        def session_persistence
+          requires :identity
+          persistence = connection.get_session_persistence(identity).body['sessionPersistence']
+          persistence.count == 0 ? nil : persistence
+        end
+
+        def enable_session_persistence(type)
+          requires :identity
+          connection.set_session_persistence(identity, type)
+          true
+        end
+
+        def disable_session_persistence
+          requires :identity
+          connection.remove_session_persistence(identity)
+          true
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_load_balancer(identity)
+          true
+        end
+
+        def ready?
+          state == ACTIVE
+        end
+
+        def save
+          if identity
+            update
+          else
+            create
+          end
+          true
+        end
+
+        def usage(options = {})
+          requires :identity
+          connection.get_load_balancer_usage(identity, options).body
+        end
+
+        private
+        def create
+          requires :name, :protocol, :port, :virtual_ips, :nodes
+          data = connection.create_load_balancer(name, protocol, port, virtual_ips_hash, nodes_hash)
+          merge_attributes(data.body['loadBalancer'])
+        end
+
+        def update
+          requires :name, :protocol, :port, :algorithm
+          options = {
+            :name => name,
+            :algorithm => algorithm,
+            :protocol => protocol,
+            :port => port}
+          connection.update_load_balancer(identity, options)
+
+          #TODO - Should this bubble down to nodes? Without tracking changes this would be very inefficient.
+          # For now, individual nodes will have to be saved individually after saving an LB
+        end
+
+        def virtual_ips_hash
+          virtual_ips.collect do |virtual_ip|
+            { :type => virtual_ip.type }
+          end
+
+        end
+
+        def nodes_hash
+          nodes.collect do |node|
+            { :address => node.address, :port => node.port, :condition => node.condition, :weight => node.weight }
+          end
+        end
+
+        def connection_logging=(new_value)
+          if !new_value.nil? and new_value.is_a?(Hash)
+            attributes[:connection_logging] = case new_value['enabled']
+                                              when 'true'
+                                                true
+                                              when 'false'
+                                                false
+                                              end
+          else
+            attributes[:connection_logging] = new_value
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/load_balancers.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/load_balancers/load_balancer'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+
+      class LoadBalancers < Fog::Collection
+
+        model Fog::Rackspace::LoadBalancers::LoadBalancer
+
+        def all
+          data = connection.list_load_balancers.body['loadBalancers']
+          load(data)
+        end
+
+        def get(load_balancer_id)
+          if load_balancer = connection.get_load_balancer(load_balancer_id).body['loadBalancer']
+            new(load_balancer)
+          end
+        rescue Fog::Rackspace::LoadBalancers::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/node.rb

@@ -0,0 +1,58 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class Node < Fog::Model
+
+        identity :id
+
+        attribute :address
+        attribute :status
+        attribute :weight
+        attribute :port
+        attribute :condition
+
+        def destroy
+          requires :identity, :load_balancer
+          connection.delete_node(load_balancer.identity, identity)
+          true
+        end
+
+        def save
+          if identity
+            update
+          else
+            create
+          end
+          true
+        end
+
+        private
+        def load_balancer
+          collection.load_balancer
+        end
+        def create
+          requires :load_balancer, :address, :condition, :port
+          options = {}
+          unless weight.nil?
+            options[:weight] = weight
+          end
+          data = connection.create_node(load_balancer.id, address, port, condition, options)
+          merge_attributes(data.body['nodes'][0])
+        end
+
+        def update
+          requires :load_balancer, :identity
+          options = {
+            :condition => condition
+          }
+          unless weight.nil?
+            options[:weight] = weight
+          end
+          connection.update_node(load_balancer.id, identity, options)
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/nodes.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/load_balancers/node'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class Nodes < Fog::Collection
+        model Fog::Rackspace::LoadBalancers::Node
+
+        attr_accessor :load_balancer
+
+        def all
+          requires :load_balancer
+          data = connection.list_nodes(load_balancer.id).body['nodes']
+          load(data)
+        end
+
+        def get(node_id)
+          requires :load_balancer
+          if node = connection.get_node(load_balancer.id, node_id).body['node']
+            new(node)
+          end
+        rescue Fog::Rackspace::LoadBalancers::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/virtual_ip.rb

@@ -0,0 +1,35 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class VirtualIp < Fog::Model
+
+        identity :id
+
+        attribute :address
+        attribute :type
+        attribute :ip_version, :aliases => 'ipVersion'
+
+        def destroy
+          requires :identity, :load_balancer
+          connection.delete_virtual_ip(load_balancer.identity, identity)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :load_balancer, :type
+          data = connection.create_virtual_ip(load_balancer.id, type)
+          merge_attributes(data.body)
+          true
+        end
+
+        private
+        def load_balancer
+          collection.load_balancer
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/virtual_ips.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/load_balancers/virtual_ip'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class VirtualIps < Fog::Collection
+        model Fog::Rackspace::LoadBalancers::VirtualIp
+
+        attr_accessor :load_balancer
+
+        def all
+          data = all_raw
+          load(data)
+        end
+
+        #HACK - This method is somewhat hacky since there isn't a way to retrieve a single virtual IP.  Hopefully long term a method will
+        # be added that allows a single virtual IP to be returned
+        def get(virtual_ip_id)
+          data = all_raw.select { |virtual_ip| virtual_ip['id'] == virtual_ip_id }.first
+          data && new(data)
+        end
+
+        private
+        def all_raw
+          requires :load_balancer
+          connection.list_virtual_ips(load_balancer.id).body['virtualIps']
+        end
+      end
+    end
+  end
+end