fog-azure-rm 0.0.8 → 0.0.9

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

@@ -0,0 +1,89 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Database model for Database Service
+      class SqlDatabase < Fog::Model
+        identity :name
+        attribute :id
+        attribute :resource_group
+        attribute :server_name
+        attribute :type
+        attribute :collation
+        attribute :create_mode
+        attribute :creation_date
+        attribute :current_service_level_objective_id
+        attribute :database_id
+        attribute :default_secondary_location
+        attribute :edition
+        attribute :earliest_restore_date
+        attribute :elastic_pool_name
+        attribute :location
+        attribute :max_size_bytes
+        attribute :requested_service_objective_id
+        attribute :requested_service_objective_name
+        attribute :restore_point_in_time
+        attribute :service_level_objective
+        attribute :source_database_id
+        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'],
+          }
+        end
+
+        def save
+          requires :resource_group, :server_name, :name, :location
+          sql_database = service.create_or_update_database(database_params)
+          merge_attributes(Fog::Sql::AzureRM::SqlDatabase.parse(sql_database))
+        end
+
+        def destroy
+          service.delete_database(resource_group, server_name, name)
+        end
+
+        private
+
+        def database_params
+          {
+            resource_group: resource_group,
+            server_name: server_name,
+            name: name,
+            location: location,
+            create_mode: create_mode,
+            edition: edition,
+            source_database_id: source_database_id,
+            collation: collation,
+            max_size_bytes: max_size_bytes,
+            requested_service_objective_name: requested_service_objective_name,
+            restore_point_in_time: restore_point_in_time,
+            source_database_deletion_date: source_database_deletion_date,
+            elastic_pool_name: elastic_pool_name,
+            requested_service_objective_id: requested_service_objective_id
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Server Collection for Database Service
+      class SqlDatabases < Fog::Collection
+        attribute :resource_group
+        attribute :server_name
+        model SqlDatabase
+
+        def all
+          requires :resource_group
+          requires :server_name
+
+          databases = []
+          service.list_databases(resource_group, server_name).each do |database|
+            databases << 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))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Server model for Server Service
+      class SqlServer < Fog::Model
+        identity :name
+        attribute :id
+        attribute :type
+        attribute :resource_group
+        attribute :location
+        attribute :version
+        attribute :state
+        attribute :administrator_login
+        attribute :administrator_login_password
+        attribute :fully_qualified_domain_name
+
+        def self.parse(server)
+          {
+            id: server['id'],
+            type: server['type'],
+            name: server['name'],
+            location: server['location'],
+            state: server['properties']['state'],
+            version: server['properties']['version'],
+            resource_group: get_resource_group_from_id(server['id']),
+            administrator_login: server['properties']['administratorLogin'],
+            administrator_login_password: server['properties']['administratorLoginPassword'],
+            fully_qualified_domain_name: server['properties']['fullyQualifiedDomainName']
+          }
+        end
+
+        def save
+          requires :name, :resource_group, :location, :version, :administrator_login, :administrator_login_password
+          sql_server = service.create_or_update_sql_server(database_params)
+          merge_attributes(Fog::Sql::AzureRM::SqlServer.parse(sql_server))
+        end
+
+        def destroy
+          service.delete_sql_server(resource_group, name)
+        end
+
+        private
+
+        def database_params
+          {
+            resource_group: resource_group,
+            name: name,
+            version: version,
+            location: location,
+            administrator_login: administrator_login,
+            administrator_login_password: administrator_login_password
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Server Collection for Server Service
+      class SqlServers < Fog::Collection
+        attribute :resource_group
+        model SqlServer
+
+        def all
+          requires :resource_group
+
+          servers = []
+          service.list_sql_servers(resource_group).each do |server|
+            servers << 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))
+        end
+      end
+    end
+  end
+end

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

@@ -18,21 +18,11 @@ module Fog
         attribute :min_child_endpoints
 
         def self.parse(endpoint)
-          hash = {}
-          hash['id'] = endpoint.id
-          hash['name'] = endpoint.name
-          hash['resource_group'] = get_resource_group_from_id(endpoint.id)
-          hash['type'] = get_end_point_type(endpoint.type)
-          hash['target_resource_id'] = endpoint.target_resource_id
-          hash['target'] = endpoint.target
-          hash['endpoint_status'] = endpoint.endpoint_status
-          hash['endpoint_monitor_status'] = endpoint.endpoint_monitor_status
-          hash['weight'] = endpoint.weight
-          hash['priority'] = endpoint.priority
-          hash['endpoint_location'] = endpoint.endpoint_location
-          hash['min_child_endpoints'] = endpoint.min_child_endpoints
-          hash['traffic_manager_profile_name'] = get_traffic_manager_profile_name_from_endpoint_id(endpoint.id)
-          hash
+          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
@@ -60,7 +50,7 @@ module Fog
         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))
+            merge_attributes(TrafficManagerEndPoint.parse(traffic_manager_endpoint))
           else
             raise(ArgumentError, ":type should be '#{AZURE_ENDPOINTS}', '#{EXTERNAL_ENDPOINTS}' or '#{NESTED_ENDPOINTS}'")
           end

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

@@ -5,25 +5,20 @@ module Fog
       class TrafficManagerEndPoints < Fog::Collection
         attribute :resource_group
         attribute :traffic_manager_profile_name
-        model Fog::TrafficManager::AzureRM::TrafficManagerEndPoint
+        model TrafficManagerEndPoint
 
         def all
-          requires :resource_group
-          requires :traffic_manager_profile_name
+          requires :resource_group, :traffic_manager_profile_name
 
-          traffic_manager_endpoints = []
-          profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
-          end_points = profile.endpoints
-          end_points.each do |endpoint|
-            traffic_manager_endpoints << Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint)
-          end
+          end_points = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name).endpoints
+          traffic_manager_endpoints = end_points.map { |endpoint| TrafficManagerEndPoint.parse(endpoint) }
           load(traffic_manager_endpoints)
         end
 
         def get(resource_group, traffic_manager_profile_name, end_point_name, type)
           endpoint = service.get_traffic_manager_end_point(resource_group, traffic_manager_profile_name, end_point_name, type)
-          endpoint_obj = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new(service: service)
-          endpoint_obj.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+          endpoint_obj = TrafficManagerEndPoint.new(service: service)
+          endpoint_obj.merge_attributes(TrafficManagerEndPoint.parse(endpoint))
         end
       end
     end

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

@@ -19,33 +19,34 @@ module Fog
         attribute :endpoints
 
         def self.parse(profile)
-          hash = {}
-          hash['id'] = profile.id
-          hash['name'] = profile.name
-          hash['resource_group'] = get_resource_group_from_id(profile.id)
-          hash['location'] = profile.location
-          hash['profile_status'] = profile.profile_status
-          hash['traffic_routing_method'] = profile.traffic_routing_method
-          hash['relative_name'] = profile.dns_config.relative_name
-          hash['fqdn'] = profile.dns_config.fqdn
-          hash['ttl'] = profile.dns_config.ttl
-          hash['profile_monitor_status'] = profile.monitor_config.profile_monitor_status
-          hash['protocol'] = profile.monitor_config.protocol
-          hash['port'] = profile.monitor_config.port
-          hash['path'] = profile.monitor_config.path
-          hash['endpoints'] = []
+          traffic_manager_profile = get_hash_from_object(profile)
+
+          if profile.dns_config
+            traffic_manager_profile['relative_name'] = profile.dns_config.relative_name
+            traffic_manager_profile['fqdn'] = profile.dns_config.fqdn
+            traffic_manager_profile['ttl'] = profile.dns_config.ttl
+          end
+
+          if profile.monitor_config
+            traffic_manager_profile['profile_monitor_status'] = profile.monitor_config.profile_monitor_status
+            traffic_manager_profile['protocol'] = profile.monitor_config.protocol
+            traffic_manager_profile['port'] = profile.monitor_config.port
+            traffic_manager_profile['path'] = profile.monitor_config.path
+          end
+          traffic_manager_profile['resource_group'] = get_resource_group_from_id(profile.id)
+          traffic_manager_profile['endpoints'] = []
           profile.endpoints.each do |endpoint|
-            end_point = Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.new
-            hash['endpoints'] << end_point.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerEndPoint.parse(endpoint))
+            end_point = TrafficManagerEndPoint.new
+            traffic_manager_profile['endpoints'] << end_point.merge_attributes(TrafficManagerEndPoint.parse(endpoint))
           end
-          hash
+          traffic_manager_profile
         end
 
         def save
           requires :name, :resource_group, :traffic_routing_method, :relative_name, :ttl,
                    :protocol, :port, :path
           traffic_manager_profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
-          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(traffic_manager_profile))
+          merge_attributes(TrafficManagerProfile.parse(traffic_manager_profile))
         end
 
         def destroy
@@ -56,7 +57,7 @@ module Fog
           validate_input(profile_params)
           merge_attributes(profile_params)
           profile = service.create_or_update_traffic_manager_profile(traffic_manager_profile_hash)
-          merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+          merge_attributes(TrafficManagerProfile.parse(profile))
         end
 
         private

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

@@ -4,21 +4,18 @@ module Fog
       # Traffic Manager Profile Collection for TrafficManager Service
       class TrafficManagerProfiles < Fog::Collection
         attribute :resource_group
-        model Fog::TrafficManager::AzureRM::TrafficManagerProfile
+        model TrafficManagerProfile
 
         def all
           requires :resource_group
-          traffic_manager_profiles = []
-          service.list_traffic_manager_profiles(resource_group).each do |profile|
-            traffic_manager_profiles << Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile)
-          end
+          traffic_manager_profiles = service.list_traffic_manager_profiles(resource_group).map { |profile| TrafficManagerProfile.parse(profile) }
           load(traffic_manager_profiles)
         end
 
         def get(resource_group, traffic_manager_profile_name)
           profile = service.get_traffic_manager_profile(resource_group, traffic_manager_profile_name)
-          profile_obj = Fog::TrafficManager::AzureRM::TrafficManagerProfile.new(service: service)
-          profile_obj.merge_attributes(Fog::TrafficManager::AzureRM::TrafficManagerProfile.parse(profile))
+          profile_obj = TrafficManagerProfile.new(service: service)
+          profile_obj.merge_attributes(TrafficManagerProfile.parse(profile))
         end
       end
     end

data/lib/fog/azurerm/network.rb

@@ -138,6 +138,7 @@ module Fog
         def initialize(options)
           begin
             require 'azure_mgmt_network'
+            require 'yaml'
           rescue LoadError => e
             retry if require('rubygems')
             raise e.message
@@ -150,6 +151,8 @@ module Fog
           @client_id = options[:client_id]
           @client_secret = options[:client_secret]
           @subscription_id = options[:subscription_id]
+          current_directory = File.dirname(__FILE__)
+          @logger_messages = YAML.load_file("#{current_directory}/utilities/logger_messages.yml")
         end
       end
     end

data/lib/fog/azurerm/requests/application_gateway/start_application_gateway.rb

@@ -0,0 +1,27 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      class Real
+        def start_application_gateway(resource_group, name)
+          msg = "Starting Application Gateway #{name} in Resource Group #{resource_group}"
+          Fog::Logger.debug msg
+
+          begin
+            @network_client.application_gateways.start(resource_group, name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Successfully started Application Gateway #{name} in Resource Group #{resource_group}"
+          true
+        end
+      end
+
+      class Mock
+        def start_application_gateway(*)
+          Fog::Logger.debug 'Successfully started Application Gateway {name} in Resource Group {resource_group}'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/application_gateway/stop_application_gateway.rb

@@ -0,0 +1,27 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      class Real
+        def stop_application_gateway(resource_group, name)
+          msg = "Stopping Application Gateway #{name} in Resource Group #{resource_group}"
+          Fog::Logger.debug msg
+
+          begin
+            @network_client.application_gateways.stop(resource_group, name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Successfully stopped Application Gateway #{name} in Resource Group #{resource_group}"
+          true
+        end
+      end
+
+      class Mock
+        def stop_application_gateway(*)
+          Fog::Logger.debug 'Successfully stopped Application Gateway {name} in Resource Group {resource_group}'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/dns/check_for_zone.rb

@@ -4,33 +4,21 @@ module Fog
       # Real class for DNS Request
       class Real
         def check_for_zone(resource_group, name)
-          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnsZones/#{name}?api-version=2015-05-04-preview"
+          msg = "Getting Zone #{name} from Resource Group #{resource_group}."
+          Fog::Logger.debug msg
           begin
-            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
-            RestClient.get(
-              resource_url,
-              accept: 'application/json',
-              content_type: 'application/json',
-              authorization: token
-            )
-            true
-          rescue RestClient::Exception => e
-            body = JSON.parse(e.response)
-            if (body['error']['code']) == 'ResourceNotFound'
-              false
-            else
-              Fog::Logger.warning "Exception checking if the zone exists in resource group #{resource_group}"
-              msg = "Exception checking if the zone exists: #{body['error']['code']}, #{body['error']['message']}"
-              raise msg
-            end
+            zone = @dns_client.zones.get(resource_group, name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
           end
+          !zone.nil?
         end
       end
 
       # Mock class for DNS Request
       class Mock
-        def check_for_zone(_resource_group, name)
-          Fog::Logger.debug "Zone name #{name} is available."
+        def check_for_zone(*)
+          Fog::Logger.debug 'Zone name name is available.'
           true
         end
       end

data/lib/fog/azurerm/requests/dns/create_or_update_record_set.rb

@@ -3,101 +3,67 @@ module Fog
     class AzureRM
       # Real class for DNS Request
       class Real
-        def create_or_update_record_set(resource_group, name, zone_name, records, record_type, ttl)
-          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnsZones/#{zone_name}/#{record_type}/#{name}?api-version=2015-05-04-preview"
-          Fog::Logger.debug "Creating/Updating RecordSet #{name} of type '#{record_type}' in zone #{zone_name}"
+        def create_or_update_record_set(record_set_params, type)
+          msg = "Creating/updating Recordset #{record_set_params[:name]} in Resource Group: #{record_set_params[:resource_group]}."
+          Fog::Logger.debug msg
+          recordset_object = get_record_set_object(record_set_params, type)
+          begin
+            record_set = @dns_client.record_sets.create_or_update(record_set_params[:resource_group], record_set_params[:zone_name], record_set_params[:name], type, recordset_object)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Record Set #{record_set_params[:name]} created/updated successfully."
+          record_set
+        end
 
-          case record_type
+        private
+
+        def get_record_set_object(record_set_params, type)
+          record_set = Azure::ARM::Dns::Models::RecordSet.new
+          record_set.name = record_set_params[:name]
+          record_set.type = type
+          record_set.ttl = record_set_params[:ttl]
+          record_set.etag = record_set_params[:etag]
+          case type
           when 'A'
             a_type_records_array = []
-            records.each do |ip|
-              a_type_records_array.push(ipv4Address: ip)
+            record_set_params[:records].each do |ip|
+              a_record = Azure::ARM::Dns::Models::ARecord.new
+              a_record.ipv4address = ip
+              a_type_records_array.push(a_record)
             end
-            body = {
-              location: 'global',
-              tags: '',
-              properties: {
-                TTL: ttl,
-                ARecords: a_type_records_array
-              }
-            }
+            record_set.arecords = a_type_records_array
           when 'CNAME'
-            body = {
-              location: 'global',
-              tags: '',
-              properties: {
-                TTL: ttl,
-                CNAMERecord: {
-                  cname: records.first # because cname only has 1 value and we know the object is an array passed in.
-                }
-              }
-            }
+            record_set.cname_record = record_set_params[:records].first # because cname only has 1 value and we know the object is an array passed in.
           end
 
-          begin
-            token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
-            response = RestClient.put(
-              resource_url,
-              body.to_json,
-              accept: 'application/json',
-              content_type: 'application/json',
-              authorization: token
-            )
-            Fog::Logger.debug "RecordSet #{name} Created/Updated Successfully!"
-            parsed_response = JSON.parse(response)
-            parsed_response
-          rescue Exception => e
-            Fog::Logger.warning "Exception creating recordset #{name} in zone #{zone_name}."
-            msg = "AzureDns::RecordSet - Exception is: #{e.message}"
-            raise msg
-          end
+          record_set
         end
       end
 
       # Mock class for DNS Request
       class Mock
-        def create_or_update_record_set(resource_group, name, zone_name, records, record_type, ttl)
-          if record_type == 'A'
-            {
-              'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnszones/#{zone_name}/#{record_type}/#{name}",
-              'name' => name,
-              'type' => "Microsoft.Network/dnszones/#{record_type}",
-              'etag' => '7f159cb1-653d-4920-bc03-153c700412a2',
-              'location' => 'global',
-              'tags' => {},
-              'properties' =>
-                {
-                  'metadata' => {},
-                  'fqdn' => "#{name}.#{zone_name}.",
-                  'TTL' => ttl,
-                  'ARecords' =>
-                    [
-                      {
-                        'ipv4Address' => records[0]
-                      }
-                    ]
-                }
-            }
-          elsif record_type == 'CNAME'
-            {
-              'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnszones/#{zone_name}/#{record_type}/#{name}",
-              'name' => name,
-              'type' => "Microsoft.Network/dnszones/#{record_type}",
-              'etag' => 'cc5ceb6e-16ad-4a5f-bbd7-9bc31c12d0cf',
-              'location' => 'global',
-              'tags' => {},
-              'properties' =>
-                {
-                  'metadata' => {},
-                  'fqdn' => "#{name}.#{zone_name}.",
-                  'TTL' => ttl,
-                  'CNAMERecord' =>
+        def create_or_update_record_set(*)
+          {
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/resource_group/providers/Microsoft.Network/dnszones/zone_name/record_type/name',
+            'name' => 'name',
+            'type' => 'Microsoft.Network/dnszones/record_type',
+            'etag' => '7f159cb1-653d-4920-bc03-153c700412a2',
+            'location' => 'global',
+            'tags' => {},
+            'properties' =>
+              {
+                'metadata' => {},
+                'fqdn' => 'name.zone_name',
+                'TTL' => 10,
+                'ARecords' =>
+                  [
                     {
-                      'cname' => records[0]
+                      'ipv4Address' => '10.1.2.0'
                     }
-                }
-            }
-          end
+                  ]
+              }
+          }
         end
       end
     end