fog-maestrodev 1.7.0.20121114190951

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,250 @@
+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 ssl_termination
+          requires :identity
+          ssl_termination = connection.get_ssl_termination(identity).body['sslTermination']
+        rescue Fog::Rackspace::LoadBalancers::NotFound
+          nil
+        end
+
+        def enable_ssl_termination(securePort, privatekey, certificate, options = {})
+          requires :identity
+          connection.set_ssl_termination(identity, securePort, privatekey, certificate, options)
+        end
+
+        def disable_ssl_termination
+          requires :identity
+          connection.remove_ssl_termination(identity)
+        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 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
+
+        def error_page
+          requires :identity
+          connection.get_error_page(identity).body['errorpage']['content']
+        end
+
+        def error_page=(content)
+          requires :identity
+          connection.set_error_page identity, content
+        end
+
+        def reset_error_page
+          requires :identity
+          connection.remove_error_page identity
+        end
+
+        private
+        def create
+          requires :name, :protocol, :port, :virtual_ips, :nodes
+
+          if algorithm
+            options = { :algorithm => algorithm }
+          else
+            options = {}
+          end
+
+          data = connection.create_load_balancer(name, protocol, port, virtual_ips_hash, nodes_hash, options)
+          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'
+                                                true
+                                              when false,'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

data/lib/fog/rackspace/models/storage/directories.rb

@@ -0,0 +1,43 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/storage/directory'
+
+module Fog
+  module Storage
+    class Rackspace
+
+      class Directories < Fog::Collection
+
+        model Fog::Storage::Rackspace::Directory
+
+        def all
+          data = connection.get_containers.body
+          load(data)
+        end
+
+        # Supply the :cdn_cname option to use the Rackspace CDN CNAME functionality on the public_url.
+        #
+        # > fog.directories.get('video', :cdn_cname => 'http://cdn.lunenburg.org').files.first.public_url
+        # => 'http://cdn.lunenburg.org/hayley-dancing.mov'
+        def get(key, options = {})
+          data = connection.get_container(key, options)
+          directory = new(:key => key, :cdn_cname => options[:cdn_cname])
+          for key, value in data.headers
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)
+              directory.merge_attributes(key => value)
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.instance_variable_set(:@loaded, true)
+          data.body.each do |file|
+            directory.files << directory.files.new(file)
+          end
+          directory
+        rescue Fog::Storage::Rackspace::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/storage/directory.rb

@@ -0,0 +1,80 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/storage/files'
+
+module Fog
+  module Storage
+    class Rackspace
+
+      class Directory < Fog::Model
+
+        identity  :key, :aliases => 'name'
+
+        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
+        attribute :count, :aliases => 'X-Container-Object-Count'
+        attribute :cdn_cname
+
+        def destroy
+          requires :key
+          connection.delete_container(key)
+          connection.cdn.post_container(key, 'X-CDN-Enabled' => 'False')
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Storage::Rackspace::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def public=(new_public)
+          @public = new_public
+        end
+
+        def public_url
+          requires :key
+          @public_url ||= begin
+            begin response = connection.cdn.head_container(key)
+              if response.headers['X-Cdn-Enabled'] == 'True'
+                if connection.rackspace_cdn_ssl == true
+                  response.headers['X-Cdn-Ssl-Uri']
+                else
+                  cdn_cname || response.headers['X-Cdn-Uri']
+                end
+              end
+            rescue Fog::Service::NotFound
+              nil
+            end
+          end
+        end
+
+        def save
+          requires :key
+          connection.put_container(key)
+
+          if @connection.cdn && @public
+            # if public and CDN connection then update cdn to public
+            uri_header = 'X-CDN-URI'
+            if connection.rackspace_cdn_ssl == true
+              uri_header = 'X-CDN-SSL-URI'
+            end
+            @public_url = connection.cdn.put_container(key, 'X-CDN-Enabled' => 'True').headers[uri_header]
+          elsif @connection.cdn && !@public
+            connection.cdn.put_container(key, 'X-CDN-Enabled' => 'False')
+            @public_url = nil
+          elsif !@connection.cdn && @public
+            # if public but no CDN connection then error
+            raise(Fog::Storage::Rackspace::Error.new("Directory can not be set as :public without a CDN provided"))
+          end
+          true
+        end
+
+      end
+
+    end
+  end
+end