ey-vendored-backup 3.0.27

data/vendor/gems/fog/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/vendor/gems/fog/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/vendor/gems/fog/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/vendor/gems/fog/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/vendor/gems/fog/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/vendor/gems/fog/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/vendor/gems/fog/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

data/vendor/gems/fog/lib/fog/rackspace/models/storage/file.rb

@@ -0,0 +1,150 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Rackspace
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => 'name'
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+        attribute :access_control_allow_origin, :aliases => ['Access-Control-Allow-Origin']
+        attribute :origin,          :aliases => ['Origin']
+
+        def body
+          attributes[:body] ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def copy(target_directory_key, target_file_key, options={})
+          requires :directory, :key
+          options['Content-Type'] ||= content_type if content_type
+          options['Access-Control-Allow-Origin'] ||= access_control_allow_origin if access_control_allow_origin
+          options['Origin'] ||= origin if origin
+          connection.copy_object(directory.key, key, target_directory_key, target_file_key, options)
+          target_directory = connection.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          connection.delete_object(directory.key, key)
+          true
+        end
+
+        def metadata
+          @metadata ||= headers_to_metadata
+        end
+
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        def public_url
+          requires :key
+          self.collection.get_url(self.key)
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          options['Content-Type'] = content_type if content_type
+          options['Access-Control-Allow-Origin'] = access_control_allow_origin if access_control_allow_origin
+          options['Origin'] = origin if origin
+          options.merge!(metadata_to_headers)
+
+          data = connection.put_object(directory.key, key, body, options)          
+          update_attributes_from(data)
+          refresh_metadata
+
+          self.content_length = Fog::Storage.get_body_size(body)
+          self.content_type ||= Fog::Storage.get_content_type(body)
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+        def refresh_metadata
+          metadata.reject! {|k, v| v.nil? }
+        end
+
+        def headers_to_metadata
+          key_map = key_mapping
+          Hash[metadata_attributes.map {|k, v| [key_map[k], v] }]
+        end
+
+        def key_mapping
+          key_map = metadata_attributes
+          key_map.each_pair {|k, v| key_map[k] = header_to_key(k)}
+        end
+
+        def header_to_key(opt)
+          opt.gsub(metadata_prefix, '').split('-').map {|k| k[0, 1].downcase + k[1..-1]}.join('_').to_sym
+        end
+
+        def metadata_to_headers
+          header_map = header_mapping
+          Hash[metadata.map {|k, v| [header_map[k], v] }]
+        end
+
+        def header_mapping
+          header_map = metadata.dup
+          header_map.each_pair {|k, v| header_map[k] = key_to_header(k)}
+        end
+
+        def key_to_header(key)
+          metadata_prefix + key.to_s.split(/[-_]/).map(&:capitalize).join('-')
+        end
+
+        def metadata_attributes
+          if etag
+            headers = connection.head_object(directory.key, self.key).headers
+            headers.reject! {|k, v| !metadata_attribute?(k)}
+          else
+            {}
+          end
+        end
+
+        def metadata_attribute?(key)
+          key.to_s =~ /^#{metadata_prefix}/
+        end
+
+        def metadata_prefix
+          "X-Object-Meta-"
+        end
+
+        def update_attributes_from(data)
+          merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+        end
+      end
+
+    end
+  end
+end