fog-azure-rm 0.1.0 → 0.1.1

data/lib/fog/azurerm/models/storage/file.rb

@@ -4,146 +4,258 @@ module Fog
       # This class is giving implementation of create/save and
       # delete/destroy for Blob.
       class File < Fog::Model
-        identity  :key, aliases: %w(Name name)
-        attribute :accept_ranges
-        attribute :cache_control
-        attribute :committed_block_count
-        attribute :content_length
-        attribute :content_type
-        attribute :content_md5
-        attribute :content_encoding
-        attribute :content_language
-        attribute :content_disposition
-        attribute :copy_completion_time
-        attribute :copy_status
-        attribute :copy_status_description
-        attribute :copy_id
-        attribute :copy_progress
-        attribute :copy_source
+        identity :key, aliases: %w(Name name Key)
+
+        attr_writer :body
         attribute :directory
-        attribute :etag
-        attribute :file_path
-        attribute :last_modified
-        attribute :lease_duration
-        attribute :lease_state
-        attribute :lease_status
+        attribute :accept_ranges,           aliases: %w(Accept-Ranges AcceptRanges)
+        attribute :content_length,          aliases: %w(Content-Length Size), type: :integer
+        attribute :content_type,            aliases: %w(Content-Type ContentType)
+        attribute :content_md5,             aliases: %w(Content-MD5 ContentMD5)
+        attribute :content_encoding,        aliases: %w(Content-Encoding ContentEncoding)
+        attribute :content_language,        aliases: %w(Content-Language ContentLanguage)
+        attribute :cache_control,           aliases: %w(Cache-Control CacheControl)
+        attribute :content_disposition,     aliases: %w(Content-Disposition ContentDisposition)
+        attribute :copy_completion_time,    aliases: %w(Copy-Completion-Time CopyCompletionTime)
+        attribute :copy_status,             aliases: %w(Copy-Status CopyStatus)
+        attribute :copy_status_description, aliases: %w(Copy-Status-Description CopyStatusDescription)
+        attribute :copy_id,                 aliases: %w(Copy-Id CopyId)
+        attribute :copy_progress,           aliases: %w(Copy-Progress CopyProgress)
+        attribute :copy_source,             aliases: %w(Copy-Source CopySource)
+        attribute :etag,                    aliases: %w(Etag ETag)
+        attribute :last_modified,           aliases: %w(Last-Modified LastModified), type: 'time'
+        attribute :lease_duration,          aliases: %w(Lease-Duration LeaseDuration)
+        attribute :lease_state,             aliases: %w(Lease-State LeaseState)
+        attribute :lease_status,            aliases: %w(Lease-Status LeaseStatus)
+        attribute :sequence_number,         aliases: %w(Sequence-Number SequenceNumber)
+        attribute :blob_type,               aliases: %w(Blob-Type BlobType)
         attribute :metadata
-        attribute :sequence_number
-        attribute :blob_type
 
+        # Save the file to the directory in Azure storage.
+        # TODO: Support snapshots.
+        #
+        #     required attributes: body(Only if update_body is true), directory, key
+        #
+        # @param identity [String] Name of directory
+        # @param options  [Hash]
+        # @option options [Boolean] update_body        Sets whether to upload the body of the file. Default is true.
+        #                                              Will update metadata and properties when update_body is set to false.
+        # @option options [Integer] worker_thread_num  Sets how many threads will be used to upload the body. Default is 8.
+        # @option options [String] blob_type or
+        #                          Blob-Type           Sets blob type for the file. Options: 'BlockBlob' or 'PageBlob'. Default is 'BlockBlob'.
+        # @option options [String] content_type or
+        #                          Content-Type        Sets content type for the file. For example, 'text/plain'.
+        # @option options [String] content_md5 or
+        #                          Content-MD5         Sets content MD5 hash for the file. Only for store.
+        #                                              When a block file whose size <= 32 MB, Azure will verify the integrity of the blob during transport.
+        #                                              Please reference this issue: https://github.com/Azure/azure-storage-ruby/issues/64
+        # @option options [String] content_encoding or
+        #                          Content-Encoding    Sets content encoding for the file. For example, 'x-gzip'.
+        # @option options [String] content_language or
+        #                          Content-Language    Sets the natural languages used by the file.
+        # @option options [String] cache_control or
+        #                          Cache-Control       Sets content encoding for the file. For example, 'No-cache'.
+        # @option options [String] content_disposition or
+        #                          Content-Disposition Sets content disposition for the file. For exampple, 'attachment; filename=testing.txt'.
+        # @option options [Hash]   metadata            Sets custom metadata values to store with the file.
+        #
+        # @return [Boolean]
+        #
         def save(options = {})
-          requires :key
-          requires :directory
-          merge_attributes(File.parse(service.upload_block_blob_from_file(directory, key, file_path, options)))
+          update_body = options.delete(:update_body)
+          update_body = true if update_body.nil?
+          requires :directory, :key
+          raise ArgumentError.new('body is required when update_body is true') if update_body && attributes[:body].nil?
+
+          remap_attributes(
+            options,
+            'Blob-Type'           => :blob_type,
+            'Content-Type'        => :content_type,
+            'Content-MD5'         => :content_md5,
+            'Content-Encoding'    => :content_encoding,
+            'Content-Language'    => :content_language,
+            'Cache-Control'       => :cache_control,
+            'Content-Disposition' => :content_disposition
+          )
+          options = {
+            blob_type: blob_type,
+            content_type: content_type,
+            content_md5: content_md5,
+            content_encoding: content_encoding,
+            content_language: content_language,
+            cache_control: cache_control,
+            content_disposition: content_disposition,
+            metadata: metadata
+          }.merge!(options)
+          options = options.reject { |_key, value| value.nil? || value.to_s.empty? }
+
+          if update_body
+            blob = save_blob(options)
+
+            data = parse_storage_object(blob)
+            merge_attributes(data)
+            attributes[:content_length] = Fog::Storage.get_body_size(body)
+            attributes[:content_type] ||= Fog::Storage.get_content_type(body)
+          else
+            service.put_blob_metadata(directory.key, key, options[:metadata]) if options[:metadata]
+            options.delete(:metadata)
+            service.put_blob_properties(directory.key, key, options)
+
+            blob = service.get_blob_properties(directory.key, key)
+            data = parse_storage_object(blob)
+            merge_attributes(data)
+          end
+
+          true
         end
 
-        alias create save
+        # Get file's body if exists, else ''.
+        #
+        # @return [File || String]
+        #
+        def body
+          return attributes[:body] if attributes[:body]
+          return '' unless last_modified
 
-        def destroy(options = {})
-          requires :key
-          requires :directory
-          service.delete_blob directory, key, options
+          file = collection.get(identity)
+          if file.nil?
+            attributes[:body] = ''
+            return ''
+          end
+
+          attributes[:body] = file.body
         end
 
-        def save_to_file(file_path, options = {})
-          requires :key
-          requires :directory
-          merge_attributes(file_path: file_path)
-          merge_attributes(File.parse(service.download_blob_to_file(directory, key, file_path, options)))
+        # Set body attribute.
+        #
+        # @param new_body [File || String]
+        #
+        # @return [File || String]
+        #
+        def body=(new_body)
+          attributes[:body] = new_body
         end
 
-        def get_properties(options = {})
-          requires :key
-          requires :directory
-          merge_attributes(File.parse(service.get_blob_properties(directory, key, options)))
+        # Copy object from one container to other container.
+        #
+        #     required attributes: directory, key
+        #
+        # @param target_directory_key [String]
+        # @param target_file_key      [String]
+        # @param options              [Hash] options for copy_object method
+        # @option options [Integer] timeout Sets to raise a TimeoutError if the copy does not finish in timeout seconds.
+        #
+        # @return [Fog::Storage::AzureRM::File] New File.
+        #
+        def copy(target_directory_key, target_file_key, options = {})
+          requires :directory, :key
+
+          timeout = options.delete(:timeout)
+          copy_id, copy_status = service.copy_blob(target_directory_key, target_file_key, directory.key, key, options)
+          service.wait_blob_copy_operation_to_finish(target_directory_key, target_file_key, copy_id, copy_status, timeout)
+
+          target_directory = service.directories.new(key: target_directory_key)
+          target_directory.files.head(target_file_key)
         end
 
-        def set_properties(properties = {})
-          requires :key
-          requires :directory
-          service.set_blob_properties(directory, key, properties)
-          merge_attributes(properties)
+        # Copy object from a uri.
+        #
+        #     required attributes: directory, key
+        #
+        # @param source_uri [String]
+        # @param options    [Hash] options for copy_object method
+        # @option options [Integer] timeout Sets to raise a TimeoutError if the copy does not finish in timeout seconds.
+        #
+        # @return [Boolean]
+        #
+        def copy_from_uri(source_uri, options = {})
+          requires :directory, :key
+
+          timeout = options.delete(:timeout)
+          copy_id, copy_status = service.copy_blob_from_uri(directory.key, key, source_uri, options)
+          service.wait_blob_copy_operation_to_finish(directory.key, key, copy_id, copy_status, timeout)
+
+          blob = service.get_blob_properties(directory.key, key)
+          data = parse_storage_object(blob)
+          merge_attributes(data)
+
+          true
         end
 
-        def get_metadata(options = {})
+        # Destroy file.
+        #
+        #     required attributes: directory, key
+        #
+        # @param options [Hash]
+        # @option options versionId []
+        #
+        # @return [Boolean] true if successful
+        #
+        def destroy(options = {})
           requires :key
           requires :directory
-          merge_attributes(metadata: service.get_blob_metadata(directory, key, options))
+          attributes[:body] = nil
+          service.delete_blob(directory.key, key, options)
+
+          true
         end
 
-        def set_metadata(metadata, options = {})
-          requires :key
+        # Get whether the file can be accessed by anonymous.
+        #
+        # @return [Boolean]
+        #
+        def public?
           requires :directory
-          service.set_blob_metadata(directory, key, metadata, options)
-          merge_attributes(metadata: metadata)
+
+          # TBD: The blob can be accessed if read permision is set in one access policy of the container.
+          directory.acl == 'container' || directory.acl == 'blob'
         end
 
-        def self.parse(blob)
-          if blob.is_a? Hash
-            parse_hash blob
-          else
-            parse_object blob
-          end
+        # Get publicly accessible url.
+        #
+        #     required attributes: directory, key
+        #
+        # @param options [Hash]
+        # @option options [String] scheme Sets which URL to get, http or https. Options: https or http. Default is https.
+        #
+        # @return [String] A public url.
+        #
+        def public_url(options = {})
+          requires :directory, :key
+          options[:scheme] == 'https' if options[:scheme].nil?
+          @service.get_blob_url(directory.key, key, options) if public?
         end
 
-        def self.parse_hash(blob)
-          hash = {}
-          hash['key'] = blob['name']
-          hash['metadata'] = blob['metadata']
-          return hash unless blob.key?('properties')
-
-          hash['last_modified'] = blob['properties']['last_modified']
-          hash['etag'] = blob['properties']['etag']
-          hash['lease_duration'] = blob['properties']['lease_duration']
-          hash['lease_status'] = blob['properties']['lease_status']
-          hash['lease_state'] = blob['properties']['lease_state']
-          hash['content_length'] = blob['properties']['content_length']
-          hash['content_type'] = blob['properties']['content_type']
-          hash['content_encoding'] = blob['properties']['content_encoding']
-          hash['content_language'] = blob['properties']['content_language']
-          hash['content_disposition'] = blob['properties']['content_disposition']
-          hash['content_md5'] = blob['properties']['content_md5']
-          hash['cache_control'] = blob['properties']['cache_control']
-          hash['sequence_number'] = blob['properties']['sequence_number']
-          hash['blob_type'] = blob['properties']['blob_type']
-          hash['copy_id'] = blob['properties']['copy_id']
-          hash['copy_status'] = blob['properties']['copy_status']
-          hash['copy_source'] = blob['properties']['copy_source']
-          hash['copy_progress'] = blob['properties']['copy_progress']
-          hash['copy_completion_time'] = blob['properties']['copy_completion_time']
-          hash['copy_status_description'] = blob['properties']['copy_status_description']
-          hash['accept_ranges'] = blob['properties']['accept_ranges']
-          hash
+        # Get a url for file.
+        #
+        #     required attributes: key
+        #
+        # @param expires [Time] The time at which the shared access signature becomes invalid, in a UTC format.
+        # @param options [Hash]
+        # @option options [String] scheme Sets which URL to get, http or https. Options: https or http. Default is https.
+        #
+        # @return [String] A public url which will expire after the specified time.
+        #
+        def url(expires, options = {})
+          requires :key
+          collection.get_url(key, expires, options)
         end
 
-        def self.parse_object(blob)
-          hash = {}
-          hash['key'] = blob.name
-          hash['metadata'] = blob.metadata
-          return hash unless blob.respond_to?('properties')
-
-          hash['last_modified'] = blob.properties[:last_modified]
-          hash['etag'] = blob.properties[:etag]
-          hash['lease_duration'] = blob.properties[:lease_duration]
-          hash['lease_status'] = blob.properties[:lease_status]
-          hash['lease_state'] = blob.properties[:lease_state]
-          hash['content_length'] = blob.properties[:content_length]
-          hash['content_type'] = blob.properties[:content_type]
-          hash['content_encoding'] = blob.properties[:content_encoding]
-          hash['content_language'] = blob.properties[:content_language]
-          hash['content_disposition'] = blob.properties[:content_disposition]
-          hash['content_md5'] = blob.properties[:content_md5]
-          hash['cache_control'] = blob.properties[:cache_control]
-          hash['sequence_number'] = blob.properties[:sequence_number]
-          hash['blob_type'] = blob.properties[:blob_type]
-          hash['copy_id'] = blob.properties[:copy_id]
-          hash['copy_status'] = blob.properties[:copy_status]
-          hash['copy_source'] = blob.properties[:copy_source]
-          hash['copy_progress'] = blob.properties[:copy_progress]
-          hash['copy_completion_time'] = blob.properties[:copy_completion_time]
-          hash['copy_status_description'] = blob.properties[:copy_status_description]
-          hash['accept_ranges'] = blob.properties[:accept_ranges]
-          hash
+        private
+
+        # Upload blob
+        def save_blob(options)
+          if options[:blob_type].nil? || options[:blob_type] == 'BlockBlob'
+            if Fog::Storage.get_body_size(body) <= SINGLE_BLOB_PUT_THRESHOLD
+              service.create_block_blob(directory.key, key, body, options)
+            else
+              service.multipart_save_block_blob(directory.key, key, body, options)
+              service.get_blob_properties(directory.key, key)
+            end
+          else
+            service.save_page_blob(directory.key, key, body, options)
+            service.get_blob_properties(directory.key, key)
+          end
         end
       end
     end

data/lib/fog/azurerm/models/storage/files.rb

@@ -3,24 +3,179 @@ module Fog
     class AzureRM
       # This class is giving implementation of listing blobs.
       class Files < Fog::Collection
-        model File
         attribute :directory
+        attribute :delimiter,       aliases: 'Delimiter'
+        attribute :marker,          aliases: 'Marker'
+        attribute :max_results,     aliases: %w(max-results MaxResults max_keys MaxKeys max-keys)
+        attribute :next_marker,     aliases: %w(NextMarker next-marker)
+        attribute :prefix,          aliases: 'Prefix'
 
-        def all(options = { metadata: true })
-          files = []
-          service.list_blobs(directory, options).each do |blob|
-            hash = File.parse blob
-            hash['directory'] = directory
-            files << hash
+        model Fog::Storage::AzureRM::File
+
+        # List all files(blobs) under the directory.
+        #
+        #     required attributes: directory
+        #
+        # @param options [Hash]
+        # @option options [String]  max_keys or
+        #                           max_results Sets the maximum number of files to return.
+        # @option options [String]  delimiter   Sets to cause that the operation returns a BlobPrefix element in the response body that acts
+        #                                       as a placeholder for all files whose names begin with the same substring up to the appearance
+        #                                       of the delimiter character. The delimiter may be a single character or a string.
+        # @option options [String]  marker      Sets the identifier that specifies the portion of the list to be returned.
+        # @option options [String]  prefix      Sets filters the results to return only files whose name begins with the specified prefix.
+        #
+        # @return [Fog::Storage::AzureRM::Files] Return nil if the directory does not exist.
+        #
+        def all(options = {})
+          requires :directory
+
+          options = {
+            max_results: max_results,
+            delimiter: delimiter,
+            marker: marker,
+            prefix: prefix
+          }.merge!(options)
+          options = options.reject { |_key, value| value.nil? || value.to_s.empty? }
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          return nil unless parent
+
+          merge_attributes(parent.files.attributes)
+          load(parent.files.map(&:attributes))
+        end
+
+        # Enumerate every file under the directory if block_given?
+        #
+        # @return [Fog::Storage::AzureRM::Files]
+        #
+        alias each_file_this_page each
+        def each
+          if block_given?
+            subset = dup.all
+
+            subset.each_file_this_page { |f| yield f }
+            while subset.next_marker
+              subset = subset.all(marker: subset.next_marker)
+              subset.each_file_this_page { |f| yield f }
+            end
+          end
+
+          self
+        end
+
+        # Get the file(blob) with full content as :body with the given name.
+        #
+        #     required attributes: directory
+        #
+        # @param key     [String] Name of file
+        # @param options [Hash]
+        # @option options [String]  block_size Sets buffer size when block_given? is true. Default is 32 MB
+        #
+        # @return [Fog::Storage::AzureRM::File] A file. Return nil if the file does not exist.
+        #
+        def get(key, options = {}, &block)
+          requires :directory
+
+          blob, content = service.get_blob(directory.key, key, options, &block)
+          data = parse_storage_object(blob)
+          file_data = data.merge(
+            body: content,
+            key: key
+          )
+          new(file_data)
+        rescue => error
+          return nil if error.message == 'NotFound'
+          raise error
+        end
+
+        # Get the URL of the file(blob) with the given name.
+        #
+        #     required attributes: directory
+        #
+        # @param key     [String] Name of file
+        # @param expires [Time] The time at which the shared access signature becomes invalid, in a UTC format.
+        # @param options [Hash]
+        # @option options [String] scheme Sets which URL to get, http or https. Options: https or http. Default is https.
+        #
+        # @return [String] A URL.
+        #
+        def get_url(key, expires, options = {})
+          requires :directory
+
+          if options[:scheme] == 'http'
+            get_http_url(key, expires, options)
+          else
+            get_https_url(key, expires, options)
           end
-          load files
         end
 
-        def get(directory, name)
-          file = File.new(service: service)
-          file.directory = directory
-          file.key = name
-          file
+        # Get the http URL of the file(blob) with the given name.
+        #
+        #     required attributes: directory
+        #
+        # @param key     [String] Name of file
+        # @param expires [Time] The time at which the shared access signature becomes invalid, in a UTC format.
+        # @param options [Hash] Unused. To keep same interface as other providers.
+        #
+        # @return [String] A http URL.
+        #
+        def get_http_url(key, expires, _options = {})
+          requires :directory
+
+          service.get_blob_http_url(directory.key, key, expires)
+        end
+
+        # Get the https URL of the file(blob) with the given name.
+        #
+        #     required attributes: directory
+        #
+        # @param key     [String] Name of file
+        # @param expires [Time] The time at which the shared access signature becomes invalid, in a UTC format.
+        # @param options [Hash] Unused. To keep same interface as other providers.
+        #
+        # @return [String] A https URL.
+        #
+        def get_https_url(key, expires, _options = {})
+          requires :directory
+
+          service.get_blob_https_url(directory.key, key, expires)
+        end
+
+        # Get the file(blob) without content with the given name.
+        #
+        #     required attributes: directory
+        #
+        # @param key     [String] Name of file
+        # @param options [Hash]
+        #
+        # @return [Fog::Storage::AzureRM::File] A file. Return nil if the file does not exist.
+        #
+        def head(key, options = {})
+          requires :directory
+
+          blob = service.get_blob_properties(directory.key, key, options)
+          data = parse_storage_object(blob)
+          file_data = data.merge(key: key)
+          new(file_data)
+        rescue => error
+          return nil if error.message == 'NotFound'
+          raise error
+        end
+
+        # Create a new file.
+        #
+        #     required attributes: directory
+        #
+        # @return [Fog::Storage::AzureRM::File] A file. You need to use File.save to upload this new file.
+        #
+        def new(attributes = {})
+          requires :directory
+
+          super({ directory: directory }.merge!(attributes))
         end
       end
     end