fog-azure-rm-temp 0.0.4 → 0.0.5

data/lib/fog/azurerm/docs/traffic_manager.md

@@ -1,6 +1,6 @@
 # Traffic Manager
 
-This document explains how to get started using Azure Traffic Manager Service with Fog. With this gem you can create/update/list/delete Traffic Manager Profiles and End Points.
+This document explains how to get started using Azure Traffic Manager Service with Fog. With this gem you can create, update, list or delete Traffic Manager Profiles and End Points.
 
 ## Usage
 
@@ -14,19 +14,19 @@ require 'fog/azurerm'
 Next, create a connection to the Traffic Manager Service:
 
 ```ruby
-    azure_traffic_manager_service = Fog::TrafficManager::AzureRM.new(
-        tenant_id: '<Tenantid>',                                                            # Tenant id of Azure Active Directory Application
-        client_id:    '<Clientid>',                                                         # Client id of Azure Active Directory Application
-        client_secret: '<ClientSecret>',                                                    # Client Secret of Azure Active Directory Application
-        subscription_id: '<Subscriptionid>',                                                # Subscription id of an Azure Account
-        :environment => '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'   # Azure cloud environment. Default is AzureCloud.
+fog_traffic_manager_service = Fog::TrafficManager::AzureRM.new(
+      tenant_id:        '<Tenant Id>',                                                          # Tenant Id of Azure Active Directory Application
+      client_id:        '<Client Id>',                                                          # Client Id of Azure Active Directory Application
+      client_secret:    '<Client Secret>',                                                      # Client Secret of Azure Active Directory Application
+      subscription_id:  '<Subscription Id>',                                                    # Subscription Id of an Azure Account
+      environment:      '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'       # Azure cloud environment. Default is AzureCloud.
 )
 ```
 
 ## Check Traffic Manager Profile Existence
 
 ```ruby
-azure_traffic_manager_service.traffic_manager_profiles.check_traffic_manager_profile_exists(<Resource Group Name>, <Profile Name>)
+fog_traffic_manager_service.traffic_manager_profiles.check_traffic_manager_profile_exists('<Resource Group Name>', '<Profile Name>')
 ```
 
 ## Create Traffic Manager Profile
@@ -34,16 +34,17 @@ azure_traffic_manager_service.traffic_manager_profiles.check_traffic_manager_pro
 Create a new Traffic Manager Profile. The parameter 'traffic_routing_method' can be 'Performance', 'Weighted' or 'Priority'.
 
 ```ruby
-      profile = azure_traffic_manager_service.traffic_manager_profiles.create(
+profile = fog_traffic_manager_service.traffic_manager_profiles.create(
         name: '<Profile Name>',
         resource_group: '<Resource Group Name>',
-        traffic_routing_method: 'Performance',
+        traffic_routing_method: '<Routing Method Name>',
         relative_name: '<Profile Relative Name>',
-        ttl: '30',
-        protocol: 'http',
-        port: '80',
-        path: '/monitorpage.aspx'
-      )
+        ttl: '<TTL>',
+        protocol: '<Protocol Name>',
+        port: '<Port Number>',
+        path: '<Path>',
+        tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' }                          # [Optional]
+)
 ```
 
 ## List Traffic Manager Profiles
@@ -51,10 +52,10 @@ Create a new Traffic Manager Profile. The parameter 'traffic_routing_method' can
 List Traffic Manager Profiles in a resource group
 
 ```ruby
-    profiles  = azure_traffic_manager_service.traffic_manager_profiles(resource_group: '<Resource Group name>')
-    profiles.each do |profile|
-      puts "#{profile.name}"
-    end
+profiles  = fog_traffic_manager_service.traffic_manager_profiles(resource_group: '<Resource Group Name>')
+profiles.each do |profile|
+    puts "#{profile.name}"
+end
 ```
 
 ## Retrieve a single Traffic Manager Profile
@@ -62,10 +63,10 @@ List Traffic Manager Profiles in a resource group
 Get a single record of Traffic Manager Profile
 
 ```ruby
-     profile = azure_traffic_manager_service
-               .traffic_manager_profiles
-                .get('<Resource Group name>', '<Profile name>')
-     puts "#{profile.name}"
+profile = fog_traffic_manager_service
+             .traffic_manager_profiles
+             .get('<Resource Group Name>', '<Profile Name>')
+puts "#{profile.name}"
 ```
 
 ## Update a Traffic Manager Profile
@@ -73,13 +74,13 @@ Get a single record of Traffic Manager Profile
 Get a Traffic Manager Profile object from the get method and then update that Traffic Manager Profile. You can update the Traffic Manager Profile by passing the modifiable attributes in the form of a hash.
 
 ```ruby
-    profile.update(
-              traffic_routing_method: 'Weighted',
-              ttl: '35',
-              protocol: 'https',
-              port: '90',
-              path: '/monitorpage1.aspx'
-    )
+profile.update(
+              traffic_routing_method: '<Routing Method Name>',
+              ttl: '<TTL>',
+              protocol: '<Protocol Name>',
+              port: '<Port Number>',
+              path: '<Path>'
+)
 ```
 
 ## Destroy a single Traffic Manager Profile
@@ -87,18 +88,18 @@ Get a Traffic Manager Profile object from the get method and then update that Tr
 Get a Traffic Manager Profile object from the get method and then destroy that Traffic Manager Profile.
 
 ```ruby
-     profile.destroy
+profile.destroy
 ```
 
 ## Check Traffic Manager Endpoint Existence
 
 ```ruby
- azure_network_service.traffic_manager_end_points.check_traffic_manager_endpoint_exists(
-   <Resource Group Name>,
-   <Profile Name>,
-   <Endpoint Name>,
-   <Type(externalEndpoints)>
-   )
+azure_network_service.traffic_manager_end_points.check_traffic_manager_endpoint_exists(
+        '<Resource Group Name>',
+        '<Profile Name>',
+        '<Endpoint Name>',
+        '<Type(<Endpoint Type>)>'
+)
 ```
 
 ## Create Traffic Manager Endpoint
@@ -106,14 +107,14 @@ Get a Traffic Manager Profile object from the get method and then destroy that T
 Traffic Manager Profile is pre-requisite of Traffic Manager Endpoint. Create a new Traffic Manager Endpoint. The parameter 'type' can be 'externalEndpoints, 'azureEndpoints' or 'nestedEndpoints'.
 
 ```ruby
-      endpoint = azure_network_service.traffic_manager_end_points.create(
+endpoint = azure_network_service.traffic_manager_end_points.create(
         name: '<Endpoint Name>',
         traffic_manager_profile_name: '<Profile Name>',
         resource_group: '<Resource Group Name>',
-        type: 'externalEndpoints',
-        target: 'test.com',
-        endpoint_location: 'West US'
-      )
+        type: '<Endpoint Type>',
+        target: '<Target URL>',
+        endpoint_location: '<Location>'
+)
 ```
 
 ## List Traffic Manager Endpoints
@@ -121,10 +122,10 @@ Traffic Manager Profile is pre-requisite of Traffic Manager Endpoint. Create a n
 List Traffic Manager Endpoints in a resource group.
 
 ```ruby
-    endpoints  = azure_traffic_manager_service.traffic_manager_end_points(resource_group: '<Resource Group name>', traffic_manager_profile_name: '<Profile Name>')
-    endpoints.each do |endpoint|
-      puts "#{endpoint.name}"
-    end
+endpoints  = fog_traffic_manager_service.traffic_manager_end_points(resource_group: '<Resource Group Name>', traffic_manager_profile_name: '<Profile Name>')
+endpoints.each do |endpoint|
+   puts "#{endpoint.name}"
+end
 ```
 
 ## Retrieve a single Traffic Manager Endpoint
@@ -132,19 +133,20 @@ List Traffic Manager Endpoints in a resource group.
 Get a single Traffic Manager Endpoint.
 
 ```ruby
-      endpoint = azure_traffic_manager_service
+endpoint = fog_traffic_manager_service
                  .traffic_manager_end_points
-                 .get('<Resource Group name>', '<Profile Name>', '<Endpoint name>', '<Endpoint type>')
-      puts "#{endpoint.name}"
+                 .get('<Resource Group Name>', '<Profile Name>', '<Endpoint name>', '<Endpoint Type>')
+puts "#{endpoint.name}"
 ```
 ## Update a Traffic Manager Endpoint
 
 Get a Traffic Manager Endpoint object from the get method and then update that Traffic Manager Endpoint. You can update the Traffic Manager Endpoint by passing the modifiable attributes in the form of a hash.
 
 ```ruby
-      endpoint.update(type: 'externalEndpoints',
-                      target: 'test1.com',
-                      endpoint_location: 'Central US')
+endpoint.update(type: '<Endpoint Type>',
+                target: '<Target URL>',
+                endpoint_location: '<Location>'
+)
 ```
 
 ## Destroy a single Traffic Manager Endpoint
@@ -152,7 +154,7 @@ Get a Traffic Manager Endpoint object from the get method and then update that T
 Get a Traffic Manager Endpoint object from the get method and then destroy that Traffic Manager Endpoint.
 
 ```ruby
-     endpoint.destroy
+endpoint.destroy
 ```
 
 ## Support and Feedback

data/lib/fog/azurerm/models/application_gateway/gateway.rb

@@ -22,6 +22,7 @@ module Fog
         attribute :http_listeners
         attribute :url_path_maps
         attribute :request_routing_rules
+        attribute :tags
 
         def self.parse(gateway)
           hash = {}
@@ -96,6 +97,8 @@ module Fog
             request_routing_rule = Fog::ApplicationGateway::AzureRM::RequestRoutingRule.new
             hash['request_routing_rules'] << request_routing_rule.merge_attributes(Fog::ApplicationGateway::AzureRM::RequestRoutingRule.parse(rule))
           end unless gateway.request_routing_rules.nil?
+
+          hash['tags'] = gateway.tags
           hash
         end
 
@@ -133,7 +136,8 @@ module Fog
             backend_http_settings_list: backend_http_settings_list,
             http_listeners: http_listeners,
             url_path_maps: url_path_maps,
-            request_routing_rules: request_routing_rules
+            request_routing_rules: request_routing_rules,
+            tags: tags
           }
         end
 

data/lib/fog/azurerm/models/compute/availability_set.rb

@@ -13,6 +13,7 @@ module Fog
         attribute :platform_fault_domain_count
         attribute :use_managed_disk
         attribute :sku_name
+        attribute :tags
 
         def self.parse(availability_set)
           hash = {}
@@ -29,6 +30,7 @@ module Fog
             hash['use_managed_disk'] = availability_set.sku.name.eql?(AS_SKU_ALIGNED)
           end
 
+          hash['tags'] = availability_set.tags
           hash
         end
 
@@ -55,7 +57,8 @@ module Fog
             resource_group: resource_group,
             platform_fault_domain_count: platform_fault_domain_count,
             platform_update_domain_count: platform_update_domain_count,
-            use_managed_disk: use_managed_disk
+            use_managed_disk: use_managed_disk,
+            tags: tags
           }
         end
       end

data/lib/fog/azurerm/models/compute/managed_disk.rb

@@ -16,7 +16,6 @@ module Fog
         attribute :tags
         attribute :time_created
         attribute :creation_data
-        
         attribute :os_type
         attribute :encryption_settings
 

data/lib/fog/azurerm/models/compute/server.rb

@@ -31,6 +31,11 @@ module Fog
         attribute :custom_data
         attribute :vhd_path
         attribute :managed_disk_storage_type
+        attribute :os_disk_size
+        attribute :tags
+        attribute :platform_update_domain
+        attribute :platform_fault_domain
+        attribute :image_ref
 
         def self.parse(vm)
           hash = {}
@@ -41,7 +46,7 @@ module Fog
           hash['vm_size'] = vm.hardware_profile.vm_size unless vm.hardware_profile.vm_size.nil?
           unless vm.storage_profile.nil?
             hash['os_disk_name'] = vm.storage_profile.os_disk.name
-
+            hash['os_disk_size'] = vm.storage_profile.os_disk.disk_size_gb
             if vm.storage_profile.os_disk.vhd.nil?
               hash['managed_disk_storage_type'] = vm.storage_profile.os_disk.managed_disk.storage_account_type
             else
@@ -76,14 +81,21 @@ module Fog
           end
           hash['network_interface_card_ids'] = vm.network_profile.network_interfaces.map(&:id)
           hash['availability_set_id'] = vm.availability_set.id unless vm.availability_set.nil?
+          hash['tags'] = vm.tags
+
+          unless vm.instance_view.nil?
+            hash['platform_update_domain'] = vm.instance_view.platform_update_domain
+            hash['platform_fault_domain'] = vm.instance_view.platform_fault_domain
+          end
 
           hash
         end
 
         def save(async = false)
-          requires :name, :location, :resource_group, :vm_size, :storage_account_name,
-                   :username, :network_interface_card_ids
-          requires :publisher, :offer, :sku, :version if vhd_path.nil? && managed_disk_storage_type.nil?
+          requires :name, :location, :resource_group, :vm_size, :username, :network_interface_card_ids
+          requires :publisher, :offer, :sku, :version if vhd_path.nil? && image_ref.nil?
+          requires :storage_account_name if managed_disk_storage_type.nil?
+          requires :managed_disk_storage_type if storage_account_name.nil?
 
           if platform_is_linux?(platform)
             requires :disable_password_authentication
@@ -97,6 +109,7 @@ module Fog
             service.create_virtual_machine(virtual_machine_params(ssh_key_path), true)
           else
             vm = service.create_virtual_machine(virtual_machine_params(ssh_key_path))
+            vm = service.get_virtual_machine(resource_group, name, false)
             merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
           end
         end
@@ -155,25 +168,37 @@ module Fog
           async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
-        def attach_managed_disk(disk_name, disk_resource_group, async=false)
+        def attach_managed_disk(disk_name, disk_resource_group, async = false)
           response = service.attach_data_disk_to_vm(data_disk_params(disk_name, nil, nil, disk_resource_group), async)
           async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
-        def detach_managed_disk(disk_name, async=false)
+        def detach_managed_disk(disk_name, async = false)
           response = service.detach_data_disk_from_vm(resource_group, name, disk_name, async)
           async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
+        def delete_extra_resources
+          unless vhd_path.nil? || !managed_disk_storage_type.nil?
+            service.delete_image(resource_group, name)
+            delete_storage_account_or_container(resource_group, storage_account_name, name)
+          end
+        end
+
+        def update_attributes
+          vm = service.get_virtual_machine(resource_group, name, false)
+          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+        end
+
         private
 
         def platform_is_linux?(platform)
           platform.strip.casecmp(PLATFORM_LINUX).zero?
         end
 
-        def create_fog_async_response(response)
+        def create_fog_async_response(response, delete_extra_resource = false)
           server = Fog::Compute::AzureRM::Server.new(service: service)
-          Fog::AzureRM::AsyncResponse.new(server, response)
+          Fog::AzureRM::AsyncResponse.new(server, response, delete_extra_resource)
         end
 
         def virtual_machine_params(ssh_key_path)
@@ -200,11 +225,16 @@ module Fog
             custom_data: custom_data,
             vhd_path: vhd_path,
             os_disk_caching: os_disk_caching,
-            managed_disk_storage_type: managed_disk_storage_type
+            managed_disk_storage_type: managed_disk_storage_type,
+            os_disk_size: os_disk_size,
+            tags: tags,
+            image_ref: image_ref,
+            os_disk_name: os_disk_name,
+            os_disk_vhd_uri: os_disk_vhd_uri
           }
         end
-        
-        def data_disk_params(disk_name, disk_size=nil, storage_account=nil, disk_resource_group=nil)
+
+        def data_disk_params(disk_name, disk_size = nil, storage_account = nil, disk_resource_group = nil)
           {
             vm_name: name,
             vm_resource_group: resource_group,
@@ -214,6 +244,26 @@ module Fog
             disk_resource_group: disk_resource_group
           }
         end
+
+        def delete_storage_account_or_container(resource_group, storage_account_name, vm_name)
+          if storage_account_name.nil?
+            delete_storage_account(resource_group)
+          else
+            delete_storage_container(resource_group, storage_account_name, vm_name)
+          end
+        end
+
+        def delete_storage_container(resource_group, storage_account_name, vm_name)
+          @storage_service = service.instance_variable_get(:@storage_service)
+          access_key = @storage_service.get_storage_access_keys(resource_group, storage_account_name).first.value
+          container_name = "customvhd-#{vm_name.downcase}-os-image"
+          @storage_service.directories.delete_temporary_container(storage_account_name, access_key, container_name)
+        end
+
+        def delete_storage_account(resource_group)
+          @storage_service = service.instance_variable_get(:@storage_service)
+          @storage_service.storage_accounts.delete_storage_account_from_tag(resource_group, TEMPORARY_STORAGE_ACCOUNT_TAG_KEY, TEMPORARY_STORAGE_ACCOUNT_TAG_VALUE)
+        end
       end
     end
   end

data/lib/fog/azurerm/models/compute/servers.rb

@@ -18,8 +18,8 @@ module Fog
 
         def create_async(attributes = {})
           server = new(attributes)
-          async_response = server.save(true)
-          Fog::AzureRM::AsyncResponse.new(server, async_response)
+          promise = server.save(true)
+          Fog::AzureRM::AsyncResponse.new(server, promise, true, 'update_attributes')
         end
 
         def get(resource_group_name, virtual_machine_name, async = false)

data/lib/fog/azurerm/models/dns/a_record.rb

@@ -0,0 +1,15 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving an implementation of 'A' RecordSet type
+      class ARecord < Fog::Model
+        attribute :ipv4address
+
+        def self.parse(arecord)
+          hash = get_hash_from_object(arecord)
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/dns/cname_record.rb

@@ -0,0 +1,15 @@
+module Fog
+  module DNS
+    class AzureRM
+      # This class is giving an implementation of 'CNAME' RecordSet type
+      class CnameRecord < Fog::Model
+        attribute :cname
+
+        def self.parse(cnamerecord)
+          hash = get_hash_from_object(cnamerecord)
+          hash
+        end
+      end
+    end
+  end
+end