fog-azure-rm 0.1.0 → 0.1.1

data/lib/fog/azurerm/models/network/virtual_network_gateways.rb

@@ -3,22 +3,22 @@ module Fog
     class AzureRM
       # VirtualNetworkGateways collection class for Network Service
       class VirtualNetworkGateways < Fog::Collection
-        model VirtualNetworkGateway
+        model Fog::Network::AzureRM::VirtualNetworkGateway
         attribute :resource_group
 
         def all
           requires :resource_group
           network_gateways = []
           service.list_virtual_network_gateways(resource_group).each do |gateway|
-            network_gateways << VirtualNetworkGateway.parse(gateway)
+            network_gateways << Fog::Network::AzureRM::VirtualNetworkGateway.parse(gateway)
           end
           load(network_gateways)
         end
 
         def get(resource_group_name, name)
           network_gateway = service.get_virtual_network_gateway(resource_group_name, name)
-          virtual_network_gateway = VirtualNetworkGateway.new(service: service)
-          virtual_network_gateway.merge_attributes(VirtualNetworkGateway.parse(network_gateway))
+          virtual_network_gateway = Fog::Network::AzureRM::VirtualNetworkGateway.new(service: service)
+          virtual_network_gateway.merge_attributes(Fog::Network::AzureRM::VirtualNetworkGateway.parse(network_gateway))
         end
       end
     end

data/lib/fog/azurerm/models/network/virtual_networks.rb

@@ -4,22 +4,22 @@ module Fog
       # This class is giving implementation of all/list, get and
       # check name availability for virtual network.
       class VirtualNetworks < Fog::Collection
-        model VirtualNetwork
+        model Fog::Network::AzureRM::VirtualNetwork
         attribute :resource_group
 
         def all
           requires :resource_group
           virtual_networks = []
           service.list_virtual_networks(resource_group).each do |vnet|
-            virtual_networks << VirtualNetwork.parse(vnet)
+            virtual_networks << Fog::Network::AzureRM::VirtualNetwork.parse(vnet)
           end
           load(virtual_networks)
         end
 
         def get(resource_group_name, virtual_network_name)
           virtual_network = service.get_virtual_network(resource_group_name, virtual_network_name)
-          virtual_network_object = VirtualNetwork.new(service: service)
-          virtual_network_object.merge_attributes(VirtualNetwork.parse(virtual_network))
+          virtual_network_fog = Fog::Network::AzureRM::VirtualNetwork.new(service: service)
+          virtual_network_fog.merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
         end
 
         def check_if_exists(resource_group, name)

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

@@ -5,13 +5,13 @@ module Fog
       class AzureResources < Fog::Collection
         attribute :tag_name
         attribute :tag_value
-        model AzureResource
+        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 << AzureResource.parse(resource)
+              resources << Fog::Resources::AzureRM::AzureResource.parse(resource)
             end
             resources.inspect
             return load(resources)

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

@@ -4,21 +4,21 @@ module Fog
       # Deployments collection class
       class Deployments < Fog::Collection
         attribute :resource_group
-        model Deployment
+        model Fog::Resources::AzureRM::Deployment
 
         def all
           requires :resource_group
           deployments = []
           service.list_deployments(resource_group).each do |deployment|
-            deployments << Deployment.parse(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_object = Deployment.new(service: service)
-          deployment_object.merge_attributes(Deployment.parse(deployment))
+          deployment_fog = Fog::Resources::AzureRM::Deployment.new(service: service)
+          deployment_fog.merge_attributes(Fog::Resources::AzureRM::Deployment.parse(deployment))
         end
       end
     end

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

@@ -4,20 +4,20 @@ module Fog
       # This class is giving implementation of all/list, get and
       # check name availability for resource groups.
       class ResourceGroups < Fog::Collection
-        model ResourceGroup
+        model Fog::Resources::AzureRM::ResourceGroup
 
         def all
           resource_groups = []
           service.list_resource_groups.each do |resource_group|
-            resource_groups.push(ResourceGroup.parse(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_object = ResourceGroup.new(service: service)
-          resource_group_object.merge_attributes(ResourceGroup.parse(resource_group))
+          resource_group_fog = Fog::Resources::AzureRM::ResourceGroup.new(service: service)
+          resource_group_fog.merge_attributes(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
         end
       end
     end

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

@@ -28,7 +28,7 @@ module Fog
         def save
           requires :resource_group, :server_name, :name, :start_ip, :end_ip
           firewall_rule = service.create_or_update_firewall_rule(firewall_params)
-          merge_attributes(FirewallRule.parse(firewall_rule))
+          merge_attributes(Fog::Sql::AzureRM::FirewallRule.parse(firewall_rule))
         end
 
         def destroy

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

@@ -5,22 +5,22 @@ module Fog
       class FirewallRules < Fog::Collection
         attribute :resource_group
         attribute :server_name
-        model FirewallRule
+        model Fog::Sql::AzureRM::FirewallRule
 
         def all
           requires :resource_group, :server_name
 
           firewall_rules = []
           service.list_firewall_rules(resource_group, server_name).each do |firewall_rule|
-            firewall_rules << FirewallRule.parse(firewall_rule)
+            firewall_rules << Fog::Sql::AzureRM::FirewallRule.parse(firewall_rule)
           end
           load(firewall_rules)
         end
 
         def get(resource_group, server_name, rule_name)
           firewall_rule = service.get_firewall_rule(resource_group, server_name, rule_name)
-          firewall_rule_obj = FirewallRule.new(service: service)
-          firewall_rule_obj.merge_attributes(FirewallRule.parse(firewall_rule))
+          firewall_rule_fog = Fog::Sql::AzureRM::FirewallRule.new(service: service)
+          firewall_rule_fog.merge_attributes(Fog::Sql::AzureRM::FirewallRule.parse(firewall_rule))
         end
       end
     end

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

@@ -27,30 +27,34 @@ module Fog
         attribute :source_database_deletion_date
 
         def self.parse(database)
-          {
-            id: database['id'],
-            type: database['type'],
-            name: database['name'],
-            location: database['location'],
-            edition: database['properties']['edition'],
-            elastic_pool_name: database['elasticPoolName'],
-            collation: database['properties']['collation'],
-            create_mode: database['properties']['createMode'],
-            database_id: database['properties']['databaseId'],
-            server_name: get_server_name_from_id(database['id']),
-            creation_date: database['properties']['creationDate'],
-            max_size_bytes: database['properties']['maxSizeBytes'],
-            resource_group: get_resource_group_from_id(database['id']),
-            source_database_id: database['properties']['sourceDatabaseId'],
-            restore_point_in_time: database['properties']['restorePointInTime'],
-            earliest_restore_date: database['properties']['earliestRestoreDate'],
-            service_level_objective: database['properties']['serviceLevelObjective'],
-            default_secondary_location: database['properties']['defaultSecondaryLocation'],
-            source_database_deletion_date: database['properties']['sourceDatabaseDeletionDate'],
-            requested_service_objective_id: database['properties']['requestedServiceObjectiveId'],
-            requested_service_objective_name: database['properties']['requestedServiceObjectiveName'],
-            current_service_level_objective_id: database['properties']['currentServiceLevelObjectiveId'],
-          }
+          sql_database = {}
+          sql_database['id'] = database['id'] unless database['id'].nil?
+          sql_database['type'] = database['type'] unless database['type'].nil?
+          sql_database['name'] = database['name'] unless database['name'].nil?
+          sql_database['location'] = database['location'] unless database['location'].nil?
+          sql_database['elastic_pool_name'] = database['elasticPoolName'] unless database['elasticPoolName'].nil?
+          unless database['id'].nil?
+            sql_database['server_name'] = get_server_name_from_id(database['id'])
+            sql_database['resource_group'] = get_resource_group_from_id(database['id'])
+          end
+          unless database['properties'].nil?
+            sql_database['edition'] = database['properties']['edition']
+            sql_database['collation'] = database['properties']['collation']
+            sql_database['create_mode'] = database['properties']['createMode']
+            sql_database['database_id'] = database['properties']['databaseId']
+            sql_database['creation_date'] = database['properties']['creationDate']
+            sql_database['max_size_bytes'] = database['properties']['maxSizeBytes']
+            sql_database['source_database_id'] = database['properties']['sourceDatabaseId']
+            sql_database['restore_point_in_time'] = database['properties']['restorePointInTime']
+            sql_database['earliest_restore_date'] = database['properties']['earliestRestoreDate']
+            sql_database['service_level_objective'] = database['properties']['serviceLevelObjective']
+            sql_database['default_secondary_location'] = database['properties']['defaultSecondaryLocation']
+            sql_database['source_database_deletion_date'] = database['properties']['sourceDatabaseDeletionDate']
+            sql_database['requested_service_objective_id'] = database['properties']['requestedServiceObjectiveId']
+            sql_database['requested_service_objective_name'] = database['properties']['requestedServiceObjectiveName']
+            sql_database['current_service_level_objective_id'] = database['properties']['currentServiceLevelObjectiveId']
+          end
+          sql_database
         end
 
         def save

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

@@ -5,23 +5,22 @@ module Fog
       class SqlDatabases < Fog::Collection
         attribute :resource_group
         attribute :server_name
-        model SqlDatabase
+        model Fog::Sql::AzureRM::SqlDatabase
 
         def all
-          requires :resource_group
-          requires :server_name
+          requires :resource_group, :server_name
 
           databases = []
           service.list_databases(resource_group, server_name).each do |database|
-            databases << SqlDatabase.parse(database)
+            databases << Fog::Sql::AzureRM::SqlDatabase.parse(database)
           end
           load(databases)
         end
 
         def get(resource_group, server_name, name)
           database = service.get_database(resource_group, server_name, name)
-          database_obj = SqlDatabase.new(service: service)
-          database_obj.merge_attributes(SqlDatabase.parse(database))
+          database_fog = Fog::Sql::AzureRM::SqlDatabase.new(service: service)
+          database_fog.merge_attributes(Fog::Sql::AzureRM::SqlDatabase.parse(database))
         end
       end
     end

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

@@ -4,22 +4,22 @@ module Fog
       # Sql Server Collection for Server Service
       class SqlServers < Fog::Collection
         attribute :resource_group
-        model SqlServer
+        model Fog::Sql::AzureRM::SqlServer
 
         def all
           requires :resource_group
 
           servers = []
           service.list_sql_servers(resource_group).each do |server|
-            servers << SqlServer.parse(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_obj = SqlServer.new(service: service)
-          server_obj.merge_attributes(SqlServer.parse(server))
+          server_fog = Fog::Sql::AzureRM::SqlServer.new(service: service)
+          server_fog.merge_attributes(Fog::Sql::AzureRM::SqlServer.parse(server))
         end
       end
     end

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

@@ -3,37 +3,62 @@ module Fog
     class AzureRM
       # This class is giving implementation of listing containers.
       class Directories < Fog::Collection
-        model Directory
+        model Fog::Storage::AzureRM::Directory
 
-        def all(options = { metadata: true })
-          containers = []
-          service.list_containers(options).each do |container|
-            hash = Directory.parse container
-            hash['public_access_level'] = 'unknown'
-            containers << hash
+        # 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 containers
+          load(data)
         end
 
-        def get(identity)
-          container = all(prefix: identity, metadata: true).find { |item| item.key == identity }
-          return if container.nil?
+        # 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)
 
-          access_control_list = service.get_container_access_control_list(identity)[0]
-          container.public_access_level = if access_control_list.is_a? Hash
-                                            access_control_list['public_access_level']
-                                          else
-                                            access_control_list.public_access_level
-                                          end
-          container
-        end
+          container = service.get_container_properties(identity)
+          data = parse_storage_object(container)
+          data[:acl] = 'unknown'
 
-        def get_metadata(name, options = {})
-          service.get_container_metadata(name, options)
-        end
+          directory = new(key: identity, is_persisted: true)
+          directory.merge_attributes(data)
+
+          data = service.list_blobs(identity, options)
 
-        def set_metadata(name, metadata, options = {})
-          service.set_container_metadata(name, metadata, 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
       end
     end

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

@@ -3,61 +3,147 @@ module Fog
     class AzureRM
       # This class is giving implementation of create and delete a container.
       class Directory < Fog::Model
-        identity  :key, aliases: %w(Name name)
-        attribute :etag
-        attribute :last_modified
-        attribute :lease_duration
-        attribute :lease_state
-        attribute :lease_status
+        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
-        attribute :public_access_level
 
-        def create(options = {})
-          requires :key
-          merge_attributes(Directory.parse(service.create_container(key, options)))
-        end
+        # 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)
 
-        alias save create
+          attributes[:acl] = new_acl
+        end
 
-        def get_properties(options = { metadata: true })
+        # Get the the permission
+        #
+        #     required attributes: key
+        #
+        # @return [String] Permission.
+        #
+        def acl
           requires :key
-          merge_attributes(Directory.parse(service.get_container_properties(key, options)))
+
+          return attributes[:acl] if attributes[:acl] != 'unknown' || !persisted?
+
+          data = service.get_container_acl(key)
+          attributes[:acl] = data[0]
         end
 
-        def access_control_list(options = {})
+        # Destroy directory.
+        #
+        #     required attributes: key
+        #
+        # @return [Boolean] True if successful
+        #
+        def destroy
           requires :key
-          merge_attributes(Directory.parse(service.get_container_access_control_list(key, options)[0]))
+
+          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
 
-        def destroy(options = {})
+        # 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.delete_container key, options
+
+          service.get_container_url(key, options) if acl == 'container'
         end
 
-        def self.parse(container)
-          hash = {}
-          if container.is_a? Hash
-            hash['key'] = container['name']
-            hash['metadata'] = container['metadata']
-            return hash unless container.key?('properties')
-
-            hash['last_modified'] = container['properties']['last_modified']
-            hash['etag'] = container['properties']['etag']
-            hash['lease_duration'] = container['properties']['lease_duration']
-            hash['lease_status'] = container['properties']['lease_status']
-            hash['lease_state'] = container['properties']['lease_state']
+        # 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
-            hash['key'] = container.name
-            hash['metadata'] = container.metadata
-            return hash unless container.respond_to?('properties')
-
-            hash['last_modified'] = container.properties[:last_modified]
-            hash['etag'] = container.properties[:etag]
-            hash['lease_duration'] = container.properties[:lease_duration]
-            hash['lease_status'] = container.properties[:lease_status]
-            hash['lease_state'] = container.properties[:lease_state]
+            service.put_container_acl(key, acl) if acl != 'unknown'
+            service.put_container_metadata(key, metadata) if metadata
+            container = service.get_container_properties(key)
           end
-          hash
+
+          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