fog-azure-rm-temp 0.0.1

data/lib/fog/azurerm/models/sql/sql_servers.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Server Collection for Server Service
+      class SqlServers < Fog::Collection
+        attribute :resource_group
+        model Fog::Sql::AzureRM::SqlServer
+
+        def all
+          requires :resource_group
+
+          servers = []
+          service.list_sql_servers(resource_group).each do |server|
+            servers << Fog::Sql::AzureRM::SqlServer.parse(server)
+          end
+          load(servers)
+        end
+
+        def get(resource_group, server_name)
+          server = service.get_sql_server(resource_group, server_name)
+          server_fog = Fog::Sql::AzureRM::SqlServer.new(service: service)
+          server_fog.merge_attributes(Fog::Sql::AzureRM::SqlServer.parse(server))
+        end
+
+        def check_sql_server_exists(resource_group, server_name)
+          service.check_sql_server_exists(resource_group, server_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Storage
+    class AzureRM
+      # DataDisk Model for Storage Service
+      class DataDisk < Fog::Model
+        identity  :name
+        attribute :disk_size_gb
+        attribute :lun
+        attribute :vhd_uri
+        attribute :caching
+        attribute :create_option
+        attribute :file_path
+
+        def self.parse(disk)
+          hash = {}
+          hash['name'] = disk.name
+          hash['disk_size_gb'] = disk.disk_size_gb
+          hash['lun'] = disk.lun
+          hash['vhd_uri'] = disk.vhd.uri
+          hash['caching'] = disk.caching unless disk.caching.nil?
+          hash['create_option'] = disk.create_option
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of listing containers.
+      class Directories < Fog::Collection
+        model Fog::Storage::AzureRM::Directory
+
+        # List all directories(containers) in the storage account.
+        #
+        # @return [Fog::Storage::AzureRM::Directories]
+        #
+        def all
+          containers = service.list_containers
+          data = []
+          containers.each do |container|
+            c = parse_storage_object(container)
+            c[:acl] = 'unknown'
+            data << c
+          end
+          load(data)
+        end
+
+        # Get a directory with files(blobs) under this directory.
+        # You can set max_keys to 1 if you do not want to return all files under this directory.
+        #
+        # @param identity [String] Name of 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::Directory] A directory. Return nil if the directory does not exist.
+        #
+        def get(identity, options = {})
+          remap_attributes(options, max_keys: :max_results)
+
+          container = service.get_container_properties(identity)
+          data = parse_storage_object(container)
+          data[:acl] = 'unknown'
+
+          directory = new(key: identity, is_persisted: true)
+          directory.merge_attributes(data)
+
+          data = service.list_blobs(identity, options)
+
+          new_options = options.merge(next_marker: data[:next_marker])
+          directory.files.merge_attributes(new_options)
+
+          blobs = []
+          data[:blobs].each do |blob|
+            blobs << parse_storage_object(blob)
+          end
+          directory.files.load(blobs)
+          directory
+        rescue => error
+          return nil if error.message == 'NotFound'
+          raise error
+        end
+
+        def check_container_exists(name)
+          service.check_container_exists(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create and delete a container.
+      class Directory < Fog::Model
+        VALID_ACLS = ['container', 'blob', 'unknown', nil].freeze
+
+        attr_writer :acl
+
+        identity  :key,                 aliases: %w(Name name)
+        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 :metadata
+
+        # Set the the permission
+        #
+        # @param new_acl [String] permission. Options: container, blob or nil. unknown is for internal usage.
+        #                                     container: Full public read access. Container and blob data can be read via anonymous request.
+        #                                                Clients can enumerate blobs within the container via anonymous request, but cannot
+        #                                                enumerate containers within the storage account.
+        #                                     blob: Public read access for blobs only. Blob data within this container can be read via
+        #                                           anonymous request, but container data is not available. Clients cannot enumerate blobs
+        #                                           within the container via anonymous request.
+        #                                     nil: No public read access. Container and blob data can be read by the account owner only.
+        #                                     unknown: Internal usage in fog-azure-rm.
+        #
+        # @return [String] Permission.
+        #
+        # @exception ArgumentError Raised when new_acl is not 'container', 'blob', nil or 'unknown'.
+        #
+        # Reference: https://msdn.microsoft.com/en-us/library/azure/dd179391.aspx
+        #
+        def acl=(new_acl)
+          raise ArgumentError.new("acl must be one of [#{VALID_ACLS.join(', ')}nil]") unless VALID_ACLS.include?(new_acl)
+
+          attributes[:acl] = new_acl
+        end
+
+        # Get the the permission
+        #
+        #     required attributes: key
+        #
+        # @return [String] Permission.
+        #
+        def acl
+          requires :key
+
+          return attributes[:acl] if attributes[:acl] != 'unknown' || !persisted?
+
+          data = service.get_container_acl(key)
+          attributes[:acl] = data[0]
+        end
+
+        # Destroy directory.
+        #
+        #     required attributes: key
+        #
+        # @return [Boolean] True if successful
+        #
+        def destroy
+          requires :key
+
+          service.delete_container(key)
+        end
+
+        # Get files under this directory.
+        # If you have set max_results or max_keys when getting this directory by directories.get,
+        # files may be incomplete. You need to use files.all to get all files under this directory.
+        #
+        # @return [Fog::Storage::AzureRM::Files] Files.
+        #
+        def files
+          @files ||= Fog::Storage::AzureRM::Files.new(directory: self, service: service)
+        end
+
+        # Set the container permission to public or private
+        #
+        # @param [Boolean] True: public(container); False: private(nil)
+        #
+        # @return [Boolean] True if public; Otherwise return false.
+        #
+        def public=(new_public)
+          attributes[:acl] = new_public ? 'container' : nil
+          new_public
+        end
+
+        # Get the public URL of the directory
+        #
+        #     required attributes: 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 :key
+
+          service.get_container_url(key, options) if acl == 'container'
+        end
+
+        # Create/Update the directory
+        #
+        #     required attributes: key
+        #
+        # @param options [Hash]
+        # @option options [Boolean] is_create Sets whether to create or update the directory. Default is true(create).
+        #                                     Will update metadata and acl when is_create is set to false.
+        #
+        # @return [Boolean] True if successful.
+        #
+        def save(options = {})
+          requires :key
+
+          is_create = options.delete(:is_create)
+          if is_create.nil? || is_create
+            options = {}
+            options[:public_access_level] = acl if acl != 'unknown'
+            options[:metadata] = metadata if metadata
+
+            container = service.create_container(key, options)
+          else
+            service.put_container_acl(key, acl) if acl != 'unknown'
+            service.put_container_metadata(key, metadata) if metadata
+            container = service.get_container_properties(key)
+          end
+
+          attributes[:is_persisted] = true
+          data = parse_storage_object(container)
+          merge_attributes(data)
+
+          true
+        end
+
+        # Check whether the directory is created.
+        #
+        # @return [Boolean] True if the file is created. Otherwise return false.
+        #
+        def persisted?
+          # is_persisted is true in case of directories.get or after #save
+          # last_modified is set in case of directories.all
+          attributes[:is_persisted] || !attributes[:last_modified].nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Blob.
+      class File < Fog::Model
+        identity :key, aliases: %w(Name name Key)
+
+        attr_writer :body
+        attribute :directory
+        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
+
+        # 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 = {})
+          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
+
+        # Get file's body if exists, else ''.
+        #
+        # @return [File || String]
+        #
+        def body
+          return attributes[:body] if attributes[:body]
+          return '' unless last_modified
+
+          file = collection.get(identity)
+          if file.nil?
+            attributes[:body] = ''
+            return ''
+          end
+
+          attributes[:body] = file.body
+        end
+
+        # Set body attribute.
+        #
+        # @param new_body [File || String]
+        #
+        # @return [File || String]
+        #
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        # 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
+
+        # 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
+
+        # Destroy file.
+        #
+        #     required attributes: directory, key
+        #
+        # @param options [Hash]
+        # @option options versionId []
+        #
+        # @return [Boolean] true if successful
+        #
+        def destroy(options = {})
+          requires :key
+          requires :directory
+          attributes[:body] = nil
+          service.delete_blob(directory.key, key, options)
+
+          true
+        end
+
+        # Get whether the file can be accessed by anonymous.
+        #
+        # @return [Boolean]
+        #
+        def public?
+          requires :directory
+
+          # 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
+
+        # 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
+
+        # 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
+
+        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
+  end
+end