fog-azure-rm-temp 0.0.1

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

@@ -0,0 +1,183 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of listing blobs.
+      class Files < Fog::Collection
+        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'
+
+        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
+        end
+
+        # 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
+  end
+end

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

@@ -0,0 +1,12 @@
+module Fog
+  module ARM
+    module Storage
+      module Models
+        module Kind
+          Storage = 'Storage'.freeze
+          BlobStorage = 'BlobStorage'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Recovery Vault.
+      class RecoveryVault < Fog::Model
+        attribute :id
+        identity :name
+        attribute :resource_group
+        attribute :location
+        attribute :type
+        attribute :sku_name
+
+        def self.parse(recovery_vault)
+          {
+            id: recovery_vault['id'],
+            name: recovery_vault['name'],
+            resource_group: get_resource_group_from_id(recovery_vault['id']),
+            location: recovery_vault['location'],
+            type: recovery_vault['type'],
+            sku_name: recovery_vault['sku']['name']
+          }
+        end
+
+        def save
+          requires :name, :location, :resource_group
+          recovery_vault = service.create_or_update_recovery_vault(resource_group, location, name)
+          merge_attributes(Fog::Storage::AzureRM::RecoveryVault.parse(recovery_vault))
+        end
+
+        def enable_backup_protection(vm_name, vm_resource_group)
+          requires :name, :resource_group
+          service.enable_backup_protection(name, resource_group, vm_name, vm_resource_group)
+        end
+
+        def start_backup(vm_name, vm_resource_group)
+          service.start_backup(resource_group, name, vm_name, vm_resource_group)
+        end
+
+        def disable_backup_protection(vm_name, vm_resource_group)
+          service.disable_backup_protection(name, resource_group, vm_name, vm_resource_group)
+        end
+
+        def destroy
+          service.delete_recovery_vault(resource_group, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of all/get for Recovery Vaults
+      class RecoveryVaults < Fog::Collection
+        model Fog::Storage::AzureRM::RecoveryVault
+        attribute :resource_group
+        attribute :name
+
+        def all
+          requires :resource_group
+          recovery_vaults = []
+          service.list_recovery_vaults(resource_group).each do |recovery_vault|
+            recovery_vaults << Fog::Storage::AzureRM::RecoveryVault.parse(recovery_vault)
+          end
+          load(recovery_vaults)
+        end
+
+        def get(resource_group, name)
+          recovery_vault = service.get_recovery_vault(resource_group, name)
+          recovery_vault_fog = Fog::Storage::AzureRM::RecoveryVault.new(service: service)
+          recovery_vault_fog.merge_attributes(Fog::Storage::AzureRM::RecoveryVault.parse(recovery_vault))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Fog
+  module ARM
+    module Storage
+      module Models
+        module SkuName
+          StandardLRS = 'Standard_LRS'.freeze
+          StandardGRS = 'Standard_GRS'.freeze
+          StandardRAGRS = 'Standard_RAGRS'.freeze
+          StandardZRS = 'Standard_ZRS'.freeze
+          PremiumLRS = 'Premium_LRS'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Fog
+  module ARM
+    module Storage
+      module Models
+        module SkuTier
+          Standard = 'Standard'.freeze
+          Premium = 'Premium'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for storage account.
+      class StorageAccount < Fog::Model
+        identity  :name
+        attribute :id
+        attribute :location
+        attribute :resource_group
+        attribute :sku_name
+        attribute :replication
+        attribute :encryption
+
+        def self.parse(storage_account)
+          hash = {}
+          hash['id'] = storage_account.id
+          hash['name'] = storage_account.name
+          hash['location'] = storage_account.location
+          hash['resource_group'] = get_resource_group_from_id(storage_account.id)
+          hash['sku_name'] = storage_account.sku.name.split('_').first
+          hash['replication'] = storage_account.sku.name.split('_').last
+          hash['encryption'] = storage_account.encryption.services.blob.enabled unless storage_account.encryption.nil?
+          hash
+        end
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          # Create a model for new storage account.
+          self.sku_name = STANDARD_STORAGE if sku_name.nil?
+          self.replication = ALLOWED_STANDARD_REPLICATION.first if replication.nil?
+          validate_sku_name!
+          storage_account = service.create_storage_account(storage_account_params)
+          merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def storage_account_params
+          {
+            resource_group: resource_group,
+            name: name,
+            sku_name: sku_name,
+            location: location,
+            replication: replication,
+            encryption: encryption
+          }
+        end
+
+        def update(storage_account_params)
+          validate_input(storage_account_params)
+          storage_account_params = merge_attributes(storage_account_params).all_attributes
+
+          storage_account = service.update_storage_account(storage_account_params)
+          merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def validate_sku_name!
+          case sku_name
+          when STANDARD_STORAGE
+            raise 'Standard Replications can only be LRS, ZRS, GRS or RAGRS.' unless ALLOWED_STANDARD_REPLICATION.include?(replication)
+          when PREMIUM_STORAGE
+            raise 'Premium Replication can only be LRS.' if replication != 'LRS'
+          else
+            raise 'Account Type can only be Standard or Premium'
+          end
+        end
+
+        def get_access_keys(options = {})
+          service.get_storage_access_keys(resource_group, name, options)
+        end
+
+        def destroy
+          service.delete_storage_account(resource_group, name)
+        end
+
+        private
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :location, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+
+        private :storage_account_params, :validate_sku_name!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module Storage
+    class AzureRM
+      # This class is giving implementation of all/list, get and
+      # check name availability for storage account.
+      class StorageAccounts < Fog::Collection
+        model Fog::Storage::AzureRM::StorageAccount
+        attribute :resource_group
+
+        def all
+          accounts = []
+          if !resource_group.nil?
+            requires :resource_group
+            hash_of_storage_accounts = service.list_storage_account_for_rg(resource_group)
+          else
+            hash_of_storage_accounts = service.list_storage_accounts
+          end
+          hash_of_storage_accounts.each do |account|
+            accounts << Fog::Storage::AzureRM::StorageAccount.parse(account)
+          end
+          load(accounts)
+        end
+
+        def get(resource_group_name, storage_account_name)
+          storage_account = service.get_storage_account(resource_group_name, storage_account_name)
+          storage_account_fog = Fog::Storage::AzureRM::StorageAccount.new(service: service)
+          storage_account_fog.merge_attributes(Fog::Storage::AzureRM::StorageAccount.parse(storage_account))
+        end
+
+        def check_name_availability(name, type = 'Microsoft.Storage/storageAccounts')
+          service.check_storage_account_name_availability(name, type)
+        end
+
+        def check_storage_account_exists(resource_group_name, storage_account_name)
+          service.check_storage_account_exists(resource_group_name, storage_account_name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/traffic_manager/traffic_manager_end_point.rb

@@ -0,0 +1,82 @@
+module Fog
+  module TrafficManager
+    class AzureRM
+      # Traffic Manager End Point model for Traffic Manager Service
+      class TrafficManagerEndPoint < Fog::Model
+        identity :name
+        attribute :traffic_manager_profile_name
+        attribute :id
+        attribute :resource_group
+        attribute :type
+        attribute :target_resource_id
+        attribute :target
+        attribute :endpoint_status
+        attribute :endpoint_monitor_status
+        attribute :weight
+        attribute :priority
+        attribute :endpoint_location
+        attribute :min_child_endpoints
+
+        def self.parse(endpoint)
+          traffic_manager_endpoint = get_hash_from_object(endpoint)
+          traffic_manager_endpoint['type'] = get_end_point_type(endpoint.type)
+          traffic_manager_endpoint['resource_group'] = get_resource_group_from_id(endpoint.id)
+          traffic_manager_endpoint['traffic_manager_profile_name'] = get_traffic_manager_profile_name_from_endpoint_id(endpoint.id)
+          traffic_manager_endpoint
+        end
+
+        def save
+          requires :name, :traffic_manager_profile_name, :resource_group, :type
+          requires :target_resource_id if type.eql?(AZURE_ENDPOINTS)
+          requires :target, :endpoint_location if type.eql?(EXTERNAL_ENDPOINTS)
+          requires :target_resource_id, :endpoint_location, :min_child_endpoints if type.eql?(NESTED_ENDPOINTS)
+
+          create_or_update
+        end
+
+        def destroy
+          service.delete_traffic_manager_endpoint(resource_group, name, traffic_manager_profile_name, type)
+        end
+
+        def update(endpoint_params)
+          validate_input(endpoint_params)
+          merge_attributes(endpoint_params)
+
+          create_or_update
+        end
+
+        private
+
+        def create_or_update
+          if %w(azureEndpoints externalEndpoints nestedEndpoints).select { |type| type if type.eql?(type) }.any?
+            traffic_manager_endpoint = service.create_or_update_traffic_manager_endpoint(traffic_manager_endpoint_hash)
+            merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(traffic_manager_endpoint))
+          else
+            raise(ArgumentError, ":type should be '#{AZURE_ENDPOINTS}', '#{EXTERNAL_ENDPOINTS}' or '#{NESTED_ENDPOINTS}'")
+          end
+        end
+
+        def traffic_manager_endpoint_hash
+          {
+            resource_group: resource_group,
+            name: name,
+            traffic_manager_profile_name: traffic_manager_profile_name,
+            type: type,
+            target_resource_id: target_resource_id,
+            target: target,
+            weight: weight,
+            priority: priority,
+            endpoint_location: endpoint_location,
+            min_child_endpoints: min_child_endpoints
+          }
+        end
+
+        def validate_input(attr_hash)
+          invalid_attr = [:resource_group, :name, :traffic_manager_profile_name, :id]
+          result = invalid_attr & attr_hash.keys
+          raise 'Cannot modify the given attribute' unless result.empty?
+        end
+      end
+    end
+  end
+end