ey-vendored-backup 3.0.27

data/vendor/gems/fog/lib/fog/aws/models/rds/snapshots.rb

@@ -0,0 +1,48 @@
+require 'fog/core/collection'
+require 'fog/aws/models/rds/snapshot'
+
+module Fog
+  module AWS
+    class RDS
+
+      class Snapshots < Fog::Collection
+        attribute :server
+        attribute :filters
+        model Fog::AWS::RDS::Snapshot
+
+        def initialize(attributes)
+          self.filters ||= {}
+          if attributes[:server]
+            filters[:identifier] = attributes[:server].id
+          end
+          if attributes[:type]
+            filters[:type] = attributes[:type]
+          end
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          data = connection.describe_db_snapshots(filters).body['DescribeDBSnapshotsResult']['DBSnapshots']
+          load(data) # data is an array of attribute hashes
+        end
+
+        def get(identity)
+          data = connection.describe_db_snapshots(:snapshot_id => identity).body['DescribeDBSnapshotsResult']['DBSnapshots'].first
+          new(data) # data is an attribute hash
+        rescue Fog::AWS::RDS::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          if server
+            super({ :instance_id => server.id }.merge!(attributes))
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/gems/fog/lib/fog/aws/models/rds/subnet_group.rb

@@ -0,0 +1,20 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+
+      class SubnetGroup < Fog::Model
+
+        identity   :id, :aliases => ['DBSubnetGroupName', :name]
+        attribute  :description, :aliases => 'DBSubnetGroupDescription'
+        attribute  :status, :aliases => 'SubnetGroupStatus'
+        attribute  :vpc_id, :aliases => 'VpcId'
+        attribute  :subnet_ids, :aliases => 'Subnets'
+
+        # TODO: ready?, save, destroy
+
+      end
+    end
+  end
+end

data/vendor/gems/fog/lib/fog/aws/models/rds/subnet_groups.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/aws/models/rds/subnet_group'
+
+module Fog
+  module AWS
+    class RDS
+
+      class SubnetGroups < Fog::Collection
+
+        model Fog::AWS::RDS::SubnetGroup
+
+        def all
+          data = connection.describe_db_subnet_groups.body['DescribeDBSubnetGroupsResult']['DBSubnetGroups']
+          load(data) # data is an array of attribute hashes
+        end
+
+        def get(identity)
+          data = connection.describe_db_subnet_groups(identity).body['DescribeDBSubnetGroupsResult']['DBSubnetGroups'].first
+          new(data) # data is an attribute hash
+        rescue Fog::AWS::RDS::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/vendor/gems/fog/lib/fog/aws/models/storage/directories.rb

@@ -0,0 +1,43 @@
+require 'fog/core/collection'
+require 'fog/aws/models/storage/directory'
+
+module Fog
+  module Storage
+    class AWS
+
+      class Directories < Fog::Collection
+
+        model Fog::Storage::AWS::Directory
+
+        def all
+          data = connection.get_service.body['Buckets']
+          load(data)
+        end
+
+        def get(key, options = {})
+          remap_attributes(options, {
+            :delimiter  => 'delimiter',
+            :marker     => 'marker',
+            :max_keys   => 'max-keys',
+            :prefix     => 'prefix'
+          })
+          data = connection.get_bucket(key, options).body
+          directory = new(:key => data['Name'])
+          options = {}
+          for k, v in data
+            if ['CommonPrefixes', 'Delimiter', 'IsTruncated', 'Marker', 'MaxKeys', 'Prefix'].include?(k)
+              options[k] = v
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.load(data['Contents'])
+          directory
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/vendor/gems/fog/lib/fog/aws/models/storage/directory.rb

@@ -0,0 +1,126 @@
+require 'fog/core/model'
+require 'fog/aws/models/storage/files'
+require 'fog/aws/models/storage/versions'
+
+module Fog
+  module Storage
+    class AWS
+
+      class Directory < Fog::Model
+        VALID_ACLS = ['private', 'public-read', 'public-read-write', 'authenticated-read']
+
+        # See http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUT.html
+        INVALID_LOCATIONS = ['us-east-1']
+
+        attr_reader :acl
+
+        identity  :key,           :aliases => ['Name', 'name']
+
+        attribute :creation_date, :aliases => 'CreationDate'
+
+        def acl=(new_acl)
+          unless VALID_ACLS.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{VALID_ACLS.join(', ')}]")
+          else
+            @acl = new_acl
+          end
+        end
+
+        def destroy
+          requires :key
+          connection.delete_bucket(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def location
+          requires :key
+          attributes[:location] || bucket_location || self.connection.region
+        end
+
+        def location=(new_location)
+          if INVALID_LOCATIONS.include?(new_location)
+            raise ArgumentError, "location must not include any of #{INVALID_LOCATIONS.join(', ')}. See http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUT.html"
+          else
+            merge_attributes(:location => new_location)
+          end
+        end
+
+        def files
+          @files ||= Fog::Storage::AWS::Files.new(:directory => self, :connection => connection)
+        end
+
+        def payer
+          requires :key
+          data = connection.get_request_payment(key)
+          data.body['Payer']
+        end
+
+        def payer=(new_payer)
+          requires :key
+          connection.put_request_payment(key, new_payer)
+          @payer = new_payer
+        end
+
+        def versioning?
+          requires :key
+          data = connection.get_bucket_versioning(key)
+          data.body['VersioningConfiguration']['Status'] == 'Enabled'
+        end
+
+        def versioning=(new_versioning)
+          requires :key
+          connection.put_bucket_versioning(key, new_versioning ? 'Enabled' : 'Suspended')
+        end
+
+        def versions
+          @versions ||= Fog::Storage::AWS::Versions.new(:directory => self, :connection => connection)
+        end
+
+        def public=(new_public)
+          self.acl = new_public ? 'public-read' : 'private'
+          new_public
+        end
+
+        def public_url
+          requires :key
+          if connection.get_bucket_acl(key).body['AccessControlList'].detect {|grant| grant['Grantee']['URI'] == 'http://acs.amazonaws.com/groups/global/AllUsers' && grant['Permission'] == 'READ'}
+            if key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\-(?![\.])){1,61}[a-z0-9]$/
+              "https://#{key}.s3.amazonaws.com"
+            else
+              "https://s3.amazonaws.com/#{key}"
+            end
+          else
+            nil
+          end
+        end
+
+        def save
+          requires :key
+
+          options = {}
+
+          options['x-amz-acl'] = acl if acl
+
+          if location = attributes[:location] || (self.connection.region != 'us-east-1' && self.connection.region)
+            options['LocationConstraint'] = location
+          end
+
+          connection.put_bucket(key, options)
+
+          true
+        end
+
+        private
+
+        def bucket_location
+          data = connection.get_bucket_location(key)
+          data.body['LocationConstraint']
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require 'fog/core/model'
+require 'fog/aws/models/storage/versions'
+
+module Fog
+  module Storage
+    class AWS
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => 'Key'
+
+        attr_writer :body
+        attribute :cache_control,       :aliases => 'Cache-Control'
+        attribute :content_disposition, :aliases => 'Content-Disposition'
+        attribute :content_encoding,    :aliases => 'Content-Encoding'
+        attribute :content_length,      :aliases => ['Content-Length', 'Size'], :type => :integer
+        attribute :content_md5,         :aliases => 'Content-MD5'
+        attribute :content_type,        :aliases => 'Content-Type'
+        attribute :etag,                :aliases => ['Etag', 'ETag']
+        attribute :expires,             :aliases => 'Expires'
+        attribute :last_modified,       :aliases => ['Last-Modified', 'LastModified']
+        attribute :metadata
+        attribute :owner,               :aliases => 'Owner'
+        attribute :storage_class,       :aliases => ['x-amz-storage-class', 'StorageClass']
+        attribute :encryption,          :aliases => 'x-amz-server-side-encryption'
+        attribute :version,             :aliases => 'x-amz-version-id'
+
+        # Chunk size to use for multipart uploads
+        # Use small chunk sizes to minimize memory
+        # E.g. 5242880 = 5mb
+        attr_accessor :multipart_chunk_size
+
+        def acl=(new_acl)
+          valid_acls = ['private', 'public-read', 'public-read-write', 'authenticated-read']
+          unless valid_acls.include?(new_acl)
+            raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
+          end
+          @acl = new_acl
+        end
+
+        def body
+          attributes[:body] ||= if last_modified && (file = collection.get(identity))
+            file.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
+          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.head(target_file_key)
+        end
+
+        def destroy(options = {})
+          requires :directory, :key
+          attributes[:body] = nil if options['versionId'] == version
+          connection.delete_object(directory.key, key, options)
+          true
+        end
+
+        remove_method :metadata
+        def metadata
+          attributes.reject {|key, value| !(key.to_s =~ /^x-amz-/)}
+        end
+
+        remove_method :metadata=
+        def metadata=(new_metadata)
+          merge_attributes(new_metadata)
+        end
+
+        remove_method :owner=
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = 'public-read'
+          else
+            @acl = 'private'
+          end
+          new_public
+        end
+
+        def public_url
+          requires :directory, :key
+          if connection.get_object_acl(directory.key, key).body['AccessControlList'].detect {|grant| grant['Grantee']['URI'] == 'http://acs.amazonaws.com/groups/global/AllUsers' && grant['Permission'] == 'READ'}
+            if directory.key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\-(?![\.])){1,61}[a-z0-9]$/
+              "https://#{directory.key}.s3.amazonaws.com/#{Fog::AWS.escape(key)}".gsub('%2F','/')
+            else
+              "https://s3.amazonaws.com/#{directory.key}/#{Fog::AWS.escape(key)}".gsub('%2F','/')
+            end
+          else
+            nil
+          end
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          if options != {}
+            Fog::Logger.deprecation("options param is deprecated, use acl= instead [light_black](#{caller.first})[/]")
+          end
+          options['x-amz-acl'] ||= @acl if @acl
+          options['Cache-Control'] = cache_control if cache_control
+          options['Content-Disposition'] = content_disposition if content_disposition
+          options['Content-Encoding'] = content_encoding if content_encoding
+          options['Content-MD5'] = content_md5 if content_md5
+          options['Content-Type'] = content_type if content_type
+          options['Expires'] = expires if expires
+          options.merge!(metadata)
+          options['x-amz-storage-class'] = storage_class if storage_class
+          options['x-amz-server-side-encryption'] = encryption if encryption
+
+          if multipart_chunk_size && body.respond_to?(:read)
+            data = multipart_save(options)
+            merge_attributes(data.body)
+          else
+            data = connection.put_object(directory.key, key, body, options)
+            merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+          end
+          self.etag.gsub!('"','')
+          self.content_length = Fog::Storage.get_body_size(body)
+          self.content_type ||= Fog::Storage.get_content_type(body)
+          true
+        end
+
+        def url(expires, options = {})
+          requires :key
+          collection.get_url(key, expires, options)
+        end
+
+        def versions
+          @versions ||= begin
+            Fog::Storage::AWS::Versions.new(
+              :file         => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+        def multipart_save(options)
+          # Initiate the upload
+          res = connection.initiate_multipart_upload(directory.key, key, options)
+          upload_id = res.body["UploadId"]
+
+          # Store ETags of upload parts
+          part_tags = []
+
+          # Upload each part
+          # TODO: optionally upload chunks in parallel using threads
+          # (may cause network performance problems with many small chunks)
+          # TODO: Support large chunk sizes without reading the chunk into memory
+          body.rewind if body.respond_to?(:rewind)
+          while (chunk = body.read(multipart_chunk_size)) do
+            md5 = Base64.encode64(Digest::MD5.digest(chunk)).strip
+            part_upload = connection.upload_part(directory.key, key, upload_id, part_tags.size + 1, chunk, 'Content-MD5' => md5 )
+            part_tags << part_upload.headers["ETag"]
+          end
+
+        rescue
+          # Abort the upload & reraise
+          connection.abort_multipart_upload(directory.key, key, upload_id) if upload_id
+          raise
+        else
+          # Complete the upload
+          connection.complete_multipart_upload(directory.key, key, upload_id, part_tags)
+        end
+
+      end
+
+    end
+  end
+end