fog-rackspace 0.1.0

data/lib/fog/rackspace/models/identity/roles.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/identity/role'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Roles < Fog::Collection
+        model Fog::Rackspace::Identity::Role
+
+        attr_accessor :user
+
+        def all
+          requires :user
+          load(retrieve_roles)
+        end
+
+        def get(id)
+          requires :user
+          data = retrieve_roles.find{ |role| role['id'] == id }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_roles
+          data = service.list_user_roles(user.identity).body['roles']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/service_catalog.rb

@@ -0,0 +1,84 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Identity
+      class ServiceCatalog < Fog::Model
+        attr_reader :catalog
+
+        def initialize(attributes)
+          @service = attributes.delete(:service)
+          @catalog = attributes.delete(:catalog) || {}
+        end
+
+        def services
+          catalog.map {|s| s["name"]}
+        end
+
+        def get_endpoints(service_name, service_net=false)
+          h = catalog.find {|service| service["name"] == service_name.to_s}
+          return {} unless h
+          key = network_type_key(service_net)
+          h["endpoints"].select {|e| e[key]}
+        end
+
+        def display_service_regions(service_name, service_net=false)
+          endpoints = get_endpoints(service_name, service_net)
+          regions = endpoints.map do |e|
+            e["region"] ? ":#{e["region"].downcase}" : ":global"
+          end
+          regions.join(", ")
+        end
+
+        def get_endpoint(service_name, region=nil, service_net=false)
+          service_region = region_key(region)
+
+          network_type = network_type_key(service_net)
+
+          endpoints = get_endpoints(service_name, service_net)
+          raise "Unable to locate endpoint for service #{service_name}" if endpoints.empty?
+
+          if endpoints.size > 1 && region.nil?
+            raise "There are multiple endpoints available for #{service_name}. Please specify one of the following regions: #{display_service_regions(service_name)}."
+          end
+
+          # select multiple endpoints
+          endpoint = endpoints.find {|e| matching_region?(e, service_region) }
+          return endpoint[network_type] if endpoint && endpoint[network_type]
+
+          # endpoint doesnt have region
+          if endpoints.size == 1 && matching_region?(endpoints[0], "GLOBAL")
+            return endpoints[0][network_type]
+          end
+
+          raise "Unknown region :#{region} for service #{service_name}. Please use one of the following regions: #{display_service_regions(service_name)}"
+        end
+
+        def reload
+          @service.authenticate
+          @catalog = @service.service_catalog.catalog
+          self
+        end
+
+        def self.from_response(service, hash)
+          ServiceCatalog.new :service => service, :catalog => hash["access"]["serviceCatalog"]
+        end
+
+        private
+
+        def network_type_key(service_net)
+          service_net ? "internalURL" : "publicURL"
+        end
+
+        def matching_region?(h, region)
+          region_key(h["region"]) == region
+        end
+
+        def region_key(region)
+          return region.to_s.upcase if region.is_a? Symbol
+          (region.nil? || region.empty?) ? "GLOBAL" : region.to_s.upcase
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/tenant.rb

@@ -0,0 +1,15 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Tenant < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :enabled
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/tenants.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/identity/tenant'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Tenants < Fog::Collection
+        model Fog::Rackspace::Identity::Tenant
+
+        def all
+          load(retrieve_tenants)
+        end
+
+        def get(id)
+          data = retrieve_tenants.find{ |tenant| tenant['id'] == id }
+          data && new(data)
+        end
+
+        private
+
+        def retrieve_tenants
+          data = service.list_tenants.body['tenants']
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/user.rb

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Identity
+      class User < Fog::Model
+        identity :id
+
+        attribute :username
+        attribute :password, :alias => 'OS-KSADM:password'
+        attribute :email
+        attribute :enabled
+        attribute :created
+        attribute :updated
+
+        def save
+          requires :username, :email, :enabled
+          unless persisted?
+            data = service.create_user(username, email, enabled, :password => password)
+          else
+            data = service.update_user(identity, username, email, enabled, :password => password)
+          end
+          merge_attributes(data.body['user'])
+          true
+        end
+
+        def destroy
+          requires :identity
+          service.delete_user(identity)
+          true
+        end
+
+        def roles
+          @roles ||= begin
+            Fog::Rackspace::Identity::Roles.new({
+              :service => service,
+              :user => self
+            })
+          end
+        end
+
+        def credentials
+          @credentials ||= begin
+            Fog::Rackspace::Identity::Credentials.new({
+              :service => service,
+              :user => self
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/identity/users.rb

@@ -0,0 +1,35 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/identity/user'
+
+module Fog
+  module Rackspace
+    class Identity
+      class Users < Fog::Collection
+        model Fog::Rackspace::Identity::User
+
+        def all
+          data = service.list_users.body['users']
+          load(data)
+        end
+
+        def get(user_id)
+          data = service.get_user_by_id(user_id).body['user']
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        rescue Excon::Errors::Unauthorized
+          nil
+        end
+
+        def get_by_name(user_name)
+          data = service.get_user_by_name(user_name).body['user']
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        rescue Excon::Errors::Unauthorized
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+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
+          service.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 persisted?
+          requires :load_balancer, :address, :type
+          service.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 = service.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 = service.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,286 @@
+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 :timeout
+        attribute :nodes
+        attribute :https_redirect,      :aliases => 'httpsRedirect'
+
+        def initialize(attributes)
+          #HACK - Since we are hacking how sub-collections work, we have to make sure the service is valid first.
+          # Old 'connection' is renamed as service and should be used instead
+          @service = attributes[:service] || attributes[:connection]
+          super
+        end
+
+        def access_rules
+          unless @access_rules
+            @access_rules = Fog::Rackspace::LoadBalancers::AccessRules.new({
+              :service => service,
+              :load_balancer => self})
+
+             # prevents loading access rules from non-existent load balancers
+            @access_rules.clear unless persisted?
+          end
+          @access_rules
+        end
+
+        def access_rules=(new_access_rules=[])
+          access_rules.load(new_access_rules)
+        end
+
+        def nodes
+          if @nodes.nil?
+            @nodes = Fog::Rackspace::LoadBalancers::Nodes.new({
+                :service => service,
+                :load_balancer => self})
+
+            # prevents loading nodes from non-existent load balancers
+            @nodes.clear unless persisted?
+          end
+          @nodes
+        end
+
+        def nodes=(new_nodes=[])
+          nodes.load(new_nodes)
+        end
+
+        def https_redirect
+          if @https_redirect.nil?
+            requires :identity
+            @https_redirect = begin
+              service.get_load_balancer(identity).body['loadBalancer']['httpsRedirect']
+            rescue => e
+              nil
+            end
+          end
+          @https_redirect
+        end
+
+        def ssl_termination
+          requires :identity
+          ssl_termination = service.get_ssl_termination(identity).body['sslTermination']
+        rescue Fog::Rackspace::LoadBalancers::NotFound
+          nil
+        end
+
+        def enable_ssl_termination(securePort, privatekey, certificate, options = {})
+          requires :identity
+          service.set_ssl_termination(identity, securePort, privatekey, certificate, options)
+        end
+
+        def disable_ssl_termination
+          requires :identity
+          service.remove_ssl_termination(identity)
+        end
+
+        def virtual_ips
+          if @virtual_ips.nil?
+            @virtual_ips = Fog::Rackspace::LoadBalancers::VirtualIps.new({
+              :service => service,
+              :load_balancer => self})
+            @virtual_ips.clear unless persisted?
+          end
+          @virtual_ips
+        end
+
+        def virtual_ips=(new_virtual_ips=[])
+          virtual_ips.load(new_virtual_ips)
+        end
+
+        def enable_content_caching
+          requires :identity
+          service.set_content_caching identity, true
+          true
+        end
+
+        def disable_content_caching
+          requires :identity
+          service.set_content_caching identity, false
+          true
+        end
+
+        def content_caching
+          requires :identity
+          service.get_content_caching(identity).body['contentCaching']['enabled']
+        end
+
+        def enable_connection_logging
+          requires :identity
+          service.set_connection_logging identity, true
+          attributes[:connection_logging] = true
+        end
+
+        def disable_connection_logging
+          requires :identity
+          service.set_connection_logging identity, false
+          attributes[:connection_logging] = false
+        end
+
+        def health_monitor
+          requires :identity
+          monitor = service.get_monitor(identity).body['healthMonitor']
+          monitor.count == 0 ? nil : monitor
+        end
+
+        def enable_health_monitor(type, delay, timeout, attempsBeforeDeactivation, options = {})
+          requires :identity
+          service.set_monitor(identity, type, delay, timeout, attempsBeforeDeactivation, options)
+          true
+        end
+
+        def disable_health_monitor
+          requires :identity
+          service.remove_monitor(identity)
+          true
+        end
+
+        def connection_throttling
+          requires :identity
+          throttle = service.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
+          service.set_connection_throttling(identity, max_connections, min_connections, max_connection_rate, rate_interval)
+          true
+        end
+
+        def disable_connection_throttling
+          requires :identity
+          service.remove_connection_throttling(identity)
+          true
+        end
+
+        def session_persistence
+          requires :identity
+          persistence = service.get_session_persistence(identity).body['sessionPersistence']
+          persistence.count == 0 ? nil : persistence
+        end
+
+        def enable_session_persistence(type)
+          requires :identity
+          service.set_session_persistence(identity, type)
+          true
+        end
+
+        def disable_session_persistence
+          requires :identity
+          service.remove_session_persistence(identity)
+          true
+        end
+
+        def destroy
+          requires :identity
+          service.delete_load_balancer(identity)
+          true
+        end
+
+        def ready?
+          state == ACTIVE
+        end
+
+        def save
+          if persisted?
+            update
+          else
+            create
+          end
+          true
+        end
+
+        def usage(options = {})
+          requires :identity
+          service.get_load_balancer_usage(identity, options).body
+        end
+
+        def stats
+          requires :identity
+          service.get_stats(identity).body
+        end
+
+        def error_page
+          requires :identity
+          service.get_error_page(identity).body['errorpage']['content']
+        end
+
+        def error_page=(content)
+          requires :identity
+          service.set_error_page identity, content
+        end
+
+        def reset_error_page
+          requires :identity
+          service.remove_error_page identity
+        end
+
+        private
+
+        def create
+          requires :name, :protocol, :virtual_ips
+
+          options = {}
+          options[:algorithm] = algorithm if algorithm
+          options[:timeout] = timeout if timeout
+
+          data = service.create_load_balancer(name, protocol, port, virtual_ips, nodes, options)
+          merge_attributes(data.body['loadBalancer'])
+        end
+
+        def update
+          requires :name, :protocol, :port, :algorithm, :timeout, :https_redirect
+          options = {
+            :name => name,
+            :algorithm => algorithm,
+            :protocol => protocol,
+            :port => port,
+            :timeout => timeout,
+            :https_redirect => !!https_redirect
+          }
+
+          service.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 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