gitlab-fog-azure-rm 0.6.0

data/lib/fog/azurerm/models/resources/azure_resource.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for resources.
+      class AzureResource < Fog::Model
+        attribute :id
+        attribute :name
+        attribute :type
+        attribute :location
+        attribute :tags
+
+        def self.parse(resource)
+          hash = {}
+          hash['id'] = resource.id
+          hash['name'] = resource.name
+          hash['type'] = resource.type
+          hash['location'] = resource.location
+          hash['tags'] = resource.tags
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/azure_resources.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of all/list and get.
+      class AzureResources < Fog::Collection
+        attribute :tag_name
+        attribute :tag_value
+        model Fog::Resources::AzureRM::AzureResource
+
+        def all
+          unless tag_name.nil? && tag_value.nil?
+            resources = []
+            service.list_tagged_resources(tag_name, tag_value).each do |resource|
+              resources << Fog::Resources::AzureRM::AzureResource.parse(resource)
+            end
+            resources.inspect
+            return load(resources)
+          end
+          nil
+        end
+
+        def get(resource_id)
+          all.find { |f| f.id == resource_id }
+        end
+
+        def check_azure_resource_exists(resource_id, api_version)
+          service.check_azure_resource_exists(resource_id, api_version)
+        end
+
+        def list_resources_in_resource_group(resource_group_name)
+          resources = []
+          service.list_resources_in_resource_group(resource_group_name).each do |resource|
+            resources.push(Fog::Resources::AzureRM::AzureResource.parse(resource))
+          end
+          load(resources)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/dependency.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Resources
+    class AzureRM
+      # Dependency model class
+      class Dependency < Fog::Model
+        attribute :id
+        attribute :resource_name
+        attribute :resource_type
+        attribute :depends_on
+
+        def self.parse(dependency)
+          hash = {}
+          hash['id'] = dependency.id
+          hash['resource_name'] = dependency.resource_name
+          hash['resource_type'] = dependency.resource_type
+
+          hash['depends_on'] = []
+          dependency.depends_on.each do |sub_dependency|
+            dependency_obj = Fog::Resources::AzureRM::Dependency.new
+            hash['depends_on'] << dependency_obj.merge_attributes(Fog::Resources::AzureRM::Dependency.parse(sub_dependency))
+          end if dependency.respond_to?('depends_on')
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/deployment.rb

@@ -0,0 +1,65 @@
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Deployment model.
+      class Deployment < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :correlation_id
+        attribute :timestamp
+        attribute :outputs
+        attribute :providers
+        attribute :dependencies
+        attribute :template_link
+        attribute :parameters_link
+        attribute :mode
+        attribute :debug_setting
+        attribute :content_version
+        attribute :provisioning_state
+
+        def self.parse(deployment)
+          hash = {}
+          hash['name'] = deployment.name
+          hash['id'] = deployment.id
+          hash['resource_group'] = get_resource_from_resource_id(deployment.id, RESOURCE_GROUP_NAME)
+          hash['correlation_id'] = deployment.properties.correlation_id
+          hash['timestamp'] = deployment.properties.timestamp
+          hash['outputs'] = deployment.properties.outputs
+
+          hash['providers'] = []
+          deployment.properties.providers.each do |provider|
+            provider_obj = Fog::Resources::AzureRM::Provider.new
+            hash['providers'] << provider_obj.merge_attributes(Fog::Resources::AzureRM::Provider.parse(provider))
+          end
+
+          hash['dependencies'] = []
+          deployment.properties.dependencies.each do |dependency|
+            dependency_obj = Fog::Resources::AzureRM::Dependency.new
+            hash['dependencies'] << dependency_obj.merge_attributes(Fog::Resources::AzureRM::Dependency.parse(dependency))
+          end
+
+          hash['template_link'] = deployment.properties.template_link.uri
+          hash['parameters_link'] = deployment.properties.parameters_link.uri
+          hash['content_version'] = deployment.properties.template_link.content_version
+          hash['mode'] = deployment.properties.mode
+          hash['debug_setting'] = deployment.properties.debug_setting.detail_level unless deployment.properties.debug_setting.nil?
+          hash['provisioning_state'] = deployment.properties.provisioning_state
+          hash
+        end
+
+        def save
+          requires :name, :resource_group, :template_link, :parameters_link
+
+          deployment = service.create_deployment(resource_group, name, template_link, parameters_link)
+          merge_attributes(Fog::Resources::AzureRM::Deployment.parse(deployment))
+        end
+
+        def destroy
+          service.delete_deployment(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/deployments.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Resources
+    class AzureRM
+      # Deployments collection class
+      class Deployments < Fog::Collection
+        attribute :resource_group
+        model Fog::Resources::AzureRM::Deployment
+
+        def all
+          requires :resource_group
+          deployments = []
+          service.list_deployments(resource_group).each do |deployment|
+            deployments << Fog::Resources::AzureRM::Deployment.parse(deployment)
+          end
+          load(deployments)
+        end
+
+        def get(resource_group_name, deployment_name)
+          deployment = service.get_deployment(resource_group_name, deployment_name)
+          deployment_fog = Fog::Resources::AzureRM::Deployment.new(service: service)
+          deployment_fog.merge_attributes(Fog::Resources::AzureRM::Deployment.parse(deployment))
+        end
+
+        def check_deployment_exists(resource_group_name, deployment_name)
+          service.check_deployment_exists(resource_group_name, deployment_name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/provider.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Resources
+    class AzureRM
+      # Provider model class
+      class Provider < Fog::Model
+        attribute :id
+        attribute :namespace
+        attribute :registration_state
+        attribute :resource_types
+
+        def self.parse(provider)
+          hash = {}
+          hash['id'] = provider.id
+          hash['namespace'] = provider.namespace
+          hash['registration_state'] = provider.registration_state if provider.respond_to?('registration_state')
+
+          hash['resource_types'] = []
+          provider.resource_types.each do |provider_resource_type|
+            provider_resource_type_obj = Fog::Resources::AzureRM::ProviderResourceType.new
+            hash['resource_types'] << provider_resource_type_obj.merge_attributes(Fog::Resources::AzureRM::ProviderResourceType.parse(provider_resource_type))
+          end
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/provider_resource_type.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Resources
+    class AzureRM
+      # ProviderResourceType model class
+      class ProviderResourceType < Fog::Model
+        attribute :resource_type
+        attribute :locations
+        attribute :api_versions
+        attribute :properties
+
+        def self.parse(provider_resource_type)
+          hash = {}
+          hash['resource_type'] = provider_resource_type.resource_type
+          hash['locations'] = provider_resource_type.locations
+          hash['api_versions'] = provider_resource_type.api_versions if provider_resource_type.respond_to?('api_versions')
+          hash['properties'] = provider_resource_type.properties if provider_resource_type.respond_to?('properties')
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/resource_group.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for resource group.
+      class ResourceGroup < Fog::Model
+        identity :name
+        attribute :id
+        attribute :location
+        attribute :tags
+
+        def self.parse(resource_group)
+          hash = {}
+          hash['id'] = resource_group.id
+          hash['name'] = resource_group.name
+          hash['location'] = resource_group.location
+          hash['tags'] = resource_group.tags
+          hash
+        end
+
+        def save
+          requires :name
+          requires :location
+          resource_group = service.create_resource_group(name, location, tags)
+          merge_attributes(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
+        end
+
+        def destroy
+          service.delete_resource_group(name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/resources/resource_groups.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Resources
+    class AzureRM
+      # This class is giving implementation of all/list, get and
+      # check name availability for resource groups.
+      class ResourceGroups < Fog::Collection
+        model Fog::Resources::AzureRM::ResourceGroup
+
+        def all
+          resource_groups = []
+          service.list_resource_groups.each do |resource_group|
+            resource_groups.push(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
+          end
+          load(resource_groups)
+        end
+
+        def get(resource_group_name)
+          resource_group = service.get_resource_group(resource_group_name)
+          resource_group_fog = Fog::Resources::AzureRM::ResourceGroup.new(service: service)
+          resource_group_fog.merge_attributes(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
+        end
+
+        def check_resource_group_exists(resource_group_name)
+          service.check_resource_group_exists(resource_group_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+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 Exception => error
+          return nil if error.message == 'NotFound'
+          raise error
+        end
+
+        def delete_temporary_container(storage_account_name, access_key, container_name)
+          storage_data = Fog::Storage::AzureRM.new(azure_storage_account_name: storage_account_name, azure_storage_access_key: access_key)
+          storage_data.delete_container(container_name)
+        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