fog-azure-rm 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 13f17ed03ff7536e9b9d9b71bb865dc543b59e1b
-  data.tar.gz: 963f1baac6eedbe81e483f495dcbd46eb64af2ff
+SHA256:
+  metadata.gz: 34ee4dc155b1227329c3833c1bf6c3a0603f6f91ffaf06702a82c649b5588c7b
+  data.tar.gz: cea157198db03ed7f9aba2af3ef1cea364db7b1109d3d98aa9c937af76fb8e95
 SHA512:
-  metadata.gz: db73728f0b7b18d6299fb323764ab33366094142bf878b90cd569664313a906b059675dba5ade8a4fb31b0bcf071400357e72bbc956e15e4f497dd4b701636b4
-  data.tar.gz: dbce127ba78e5657f9f6d5ef0ff3ce312f82a2bb21a35a8489eb0caf10c63edb5e5c13b51702a0398b919123024f27669fa6e05b16503223094496b66197a016
+  metadata.gz: 85c0c89befd15482cc097393860ded6df9b49b764e3f9cc5047b4c84f33d2c743eed347c81ba12566c11cc50900a4532f66cc60f86a81b3c7edf595cb4c4fd3c
+  data.tar.gz: b5a0704f2f32bc8f8d1cd4ad51384b4d10aedabc10a67dc6a90c747a4ede66870fa3f55b88c951f59cd5bbc5c7558704a2d738ec6fa7e34be71f0b005a1a7187

data/.travis.yml

@@ -4,8 +4,9 @@ sudo: false
 before_install:
   - gem install bundler
   - gem update bundler
+  - gem uninstall -aIx nokogiri -i /home/travis/.rvm/gems/ruby-2.4.1@global nokogiri
 
-script: sh rake-script.sh
+script: bash ./rake-script.sh
 
 matrix:
   fast_finish: true

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.3.8
+
+**Changed:**
+- Updated documentation
+
+**Fixed:**
+- Compute Service - Fixed issue with fault/update domain not populating
+
 ## 0.3.7
 
 **Fixed:**

data/lib/fog/azurerm/async_response.rb

@@ -2,16 +2,21 @@ module Fog
   module AzureRM
     # class for Async Response
     class AsyncResponse
-      def initialize(model, promise, delete_extra_resource = false)
+      def initialize(model, promise, delete_extra_resource = false, post_method_execute = nil)
         @fog_model = model
         @promise = promise
         @delete_extra_resource = delete_extra_resource
+        @post_method_execute = post_method_execute
       end
 
       def value
         response = @promise.value.body
         @fog_model.merge_attributes(@fog_model.class.parse(response))
         @fog_model.delete_extra_resources if @delete_extra_resource
+        # This code block will execute the method mentioned in post_method_execute after getting the response
+        unless @post_method_execute.nil?
+          @fog_model.public_send(@post_method_execute) if @fog_model.respond_to? @post_method_execute
+        end
         @fog_model
       end
 

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

@@ -1,6 +1,6 @@
 # Application Gateway
 
-This document explains how to get started using Azure Network Service with Fog to manage Application Gateway. With this gem you can create/update/list/delete Application Gateway.
+This document explains how to get started using Azure Network Service with Fog to manage Application Gateway. With this gem you can create, update, list or delete Application Gateway.
 
 ## Usage
 
@@ -14,19 +14,20 @@ require 'fog/azurerm'
 Next, create a connection to the Application Gateway Service:
 
 ```ruby
-    azure_application_gateway_service = Fog::ApplicationGateway::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_application_gateway_service = Fog::ApplicationGateway::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 Application Gateway Existence
 
 ```ruby
-azure_application_gateway_service.gateways.check_application_gateway_exists(<Resource Group name>, <Gateway Name>)
+fog_application_gateway_service.gateways.check_application_gateway_exists('<Resource Group Name>', '<Gateway Name>')
+
 ```
 
 ## Create Application Gateway
@@ -34,44 +35,44 @@ azure_application_gateway_service.gateways.check_application_gateway_exists(<Res
 Create a new Application Gateway.
 
 ```ruby
-    gateway = azure_application_gateway_service.gateways.create(
+gateway = fog_application_gateway_service.gateways.create(
+
         name: '<Gateway Name>',
-        location: 'eastus',
+        location: '<Location>',
         resource_group: '<Resource Group name>',
-        tags: { key1: "value1", key2: "value2", keyN: "valueN" },                         # [Optional]
-        sku_name: 'Standard_Medium',
-        sku_tier: 'Standard',
-        sku_capacity: '2',
+        sku_name: '<SKU Name>',
+        sku_tier: '<SKU Tier>',
+        sku_capacity: '<SKU Capacity>',
         gateway_ip_configurations:
             [
                 {
-                    name: 'gatewayIpConfigName',
-                    subnet_id: '/subscriptions/<Subscription_id>/resourcegroups/<Resource Group name>/providers/Microsoft.Network/virtualNetworks/<Virtual Network Name>/subnets/<Subnet Name>'
+                    name: '<Gateway IP Config Name>',
+                    subnet_id: '/subscriptions/<Subscription Id>/resourcegroups/<Resource Group Name>/providers/Microsoft.Network/virtualNetworks/<Virtual Network Name>/subnets/<Subnet Name>'
                 }
             ],
         frontend_ip_configurations:
             [
                 {
-                    name: 'frontendIpConfig',
-                    private_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic,
-                    public_ip_address_id: '/subscriptions/<Subscription_id>/resourcegroups/<Resource Group name>/providers/Microsoft.Network/publicIPAddresses/<Public IP Address Name>',
-                    private_ip_address: '10.0.1.5'
+                    name: '<Frontend IP Config Name>',
+                    private_ip_allocation_method: '<IP Allocation Method>',
+                    public_ip_address_id: '/subscriptions/<Subscription Id>/resourcegroups/<Resource Group Name>/providers/Microsoft.Network/publicIPAddresses/<Public IP Address Name>',
+                    private_ip_address: '<IP Address>'
                 }
             ],
         frontend_ports:
             [
                 {
-                    name: 'frontendPort',
-                    port: 443
+                    name: '<Frontend Port Name>',
+                    port: <Port Number>
                 }
             ],
         backend_address_pools:
             [
                 {
-                    name: 'backendAddressPool',
+                    name: '<Backend Address Pool Name>',
                     ip_addresses: [
                         {
-                            ipAddress: '10.0.1.6'
+                            ipAddress: '<IP Address>'
                         }
                     ]
                 }
@@ -79,74 +80,74 @@ Create a new Application Gateway.
         backend_http_settings_list:
             [
                 {
-                    name: 'gateway_settings',
-                    port: 80,
-                    protocol: 'Http',
-                    cookie_based_affinity: 'Enabled',
-                    request_timeout: '30'
+                    name: '<Gateway Settings Name>',
+                    port: <Port Number>,
+                    protocol: '<Protocol Name>',
+                    cookie_based_affinity: '<Enabled/Disabled>',
+                    request_timeout: '<Timeout Time>'
                 }
             ],
         http_listeners:
             [
                 {
-                    name: 'gateway_listener',
-                    frontend_ip_config_id: '/subscriptions/<Subscription_id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/frontendIPConfigurations/frontendIpConfig',
-                    frontend_port_id: '/subscriptions/<Subscription_id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/frontendPorts/frontendPort',
-                    protocol: 'Http',
+                    name: '<Gateway Listener Name>',
+                    frontend_ip_config_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/frontendIPConfigurations/<Frontend IP Config Name>',
+                    frontend_port_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/frontendPorts/<Frontend Port Name>',
+                    protocol: '<Protocol Name>',
                     host_name: '',
-                    require_server_name_indication: 'false'
+                    require_server_name_indication: '<True/False>'
                 }
             ],
         request_routing_rules:
             [
                 {
-                    name: 'gateway_request_route_rule',
-                    type: 'Basic',
-                    http_listener_id: '/subscriptions/<Subscription_id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/httpListeners/gateway_listener',
-                    backend_address_pool_id: '/subscriptions/<Subscription_id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/backendAddressPools/backendAddressPool',
-                    backend_http_settings_id: '/subscriptions/<Subscription_id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/backendHttpSettingsCollection/gateway_settings',
+                    name: '<Gateway Request Route Rule Name>',
+                    type: '<Type>',
+                    http_listener_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/httpListeners/<Gateway Listener Name>',
+                    backend_address_pool_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/backendAddressPools/<Backend Address Pool Name>',
+                    backend_http_settings_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/applicationGateways/<Gateway Name>/backendHttpSettingsCollection/<Gateway Settings Name>',
                     url_path_map: ''
                 }
-            ]
-    )
+            ],
+	 tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' }                          # [Optional]
+)
 ```
 
 There can be two ways of giving `frontend_ip_configurations` while creating application gateway
 
-1. When giving public ip, then we need to provide `public_ip_address_id` as follows
-
-`frontend_ip_configurations:
-    [
-        {
-            name: 'frontendIpConfig',
-            private_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic,
-            public_ip_address_id: '/subscriptions/<Subscription_id>/resourcegroups/<Resource Group name>/providers/Microsoft.Network/publicIPAddresses/<Public IP Address Name>',
-            private_ip_address: '10.0.1.5'
-        }
-]`
-
+1. When giving public IP, then we need to provide `public_ip_address_id` as follows
+
+	```ruby
+	frontend_ip_configurations:
+	[
+		{
+			name: '<Frontend IP Config Name>',
+			private_ip_allocation_method: '<IP Allocation Method>',
+			public_ip_address_id: '/subscriptions/<Subscription Id>/resourcegroups/<Resource Group Name>/providers/Microsoft.Network/publicIPAddresses/<Public IP Address Name>',
+			private_ip_address: '<IP Address>'
+		}
+	]
 2. When giving subnet id, then we need to provide `subnet_id` as follows
 
-`frontend_ip_configurations:
-    [
-        {
-            name: 'frontendIpConfig',
-            private_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic,
-            subnet_id: '<Subnet ID',
-            private_ip_address: '10.0.1.5'
-        }
-]`
-
-
+	```ruby
+	frontend_ip_configurations:
+	[
+		{
+			name: '<Frontend IP Config Name>',
+			private_ip_allocation_method: '<IP Allocation Method>',
+			subnet_id: '<Subnet ID>',
+			private_ip_address: '<IP Address>'
+		}
+	]
 ## List Application Gateways
 
 List all application gateways in a resource group
 
 ```ruby
-    gateways = azure_application_gateway_service.gateways(resource_group: '<Resource Group Name>')
-    gateways.each do |gateway|
-        puts "#{gateway.name}"
-    end
+gateways = fog_application_gateway_service.gateways(resource_group: '<Resource Group Name>')
+gateways.each do |gateway|
+	puts "#{gateway.name}"
+end
 ```
 
 ## Retrieve a single Application Gateway
@@ -154,79 +155,81 @@ List all application gateways in a resource group
 Get a single record of Application Gateway
 
 ```ruby
-    gateway = azure_application_gateway_service
+gateway = fog_application_gateway_service
                             .gateways
-                            .get('<Resource Group name>', '<Application Gateway Name>')
-    puts "#{gateway.name}"
+                            .get('<Resource Group Name>', '<Application Gateway Name>')
+puts "#{gateway.name}"
 ```
 
 
-## Update sku attributes (Name and Capacity)                
+## Update SKU attributes (Name and Capacity)                
 
 ```ruby
-    ag.update_sku('Standard_Small', '1')
+ag.update_sku('<SKU Name>', '<SKU Capacity>')
 ```
 
-## Update gateway ip configuration (Subnet id) 
+## Update gateway IP configuration (Subnet Id) 
+
 
 ```ruby
-    ag.update_gateway_ip_configuration("/subscriptions/<Subscription_id>/<Resource Group name>/<Gateway Name>/providers/Microsoft.Network/virtualNetworks/<Virtual Network Name>/subnets/<Subnet Name>")
+ag.update_gateway_ip_configuration('/subscriptions/<Subscription Id>/<Resource Group Name>/<Gateway Name>/providers/Microsoft.Network/virtualNetworks/<Virtual Network Name>/subnets/<Subnet Name>')
 ```
 
-## Add/Remove SSL Certificates 
+## Add/ Remove SSL Certificates 
 
 ```ruby
-    ag.add_ssl_certificate(
-      {
-        name: '<SSL Certificate name>',
-        data: 'Base-64 encoded pfx certificate',
-        password: 'azure',
-        public_cert_data: 'Base-64 encoded Public cert data corresponding to pfx specified in data.'
-      }
-    )
+ag.add_ssl_certificate(
+	{
+       name: '<SSL Certificate Name>',
+       data: '<SSL Certificate Data>',
+       password: '<Password>',
+       public_cert_data: '<Public Certificate Data>'
+	}
+)
     
-    ag.remove_ssl_certificate(
-      {
-       name: '<SSL Certificate name>',
-       data: 'Base-64 encoded pfx certificate',
-       password: 'azure',
-       public_cert_data: 'Base-64 encoded Public cert data corresponding to pfx specified in data.'
-     }
-    )
+ag.remove_ssl_certificate(
+	{
+       name: '<SSL Certificate Name>',
+       data: '<SSL Certificate Data>',
+       password: '<Password>',
+       public_cert_data: '<Public Certificate Data>'
+	}
+)
 ```
 
-## Add/Remove Frontend ports    
+## Add/ Remove Frontend ports    
 
 ```ruby
-    ag.add_frontend_port({name: '<Frontend port name>', port: 80})
+ag.add_frontend_port({name: '<Frontend Port Name>', port: <Port Number>})
     
-    ag.remove_frontend_port({name: '<Frontend port name>', port: 80})
+ag.remove_frontend_port({name: '<Frontend Port Name>', port: <Port Number>})
 ```
 
-## Add/Remove Probes    
+## Add/ Remove Probes    
 
 ```ruby
- ag.add_probe(
+ag.add_probe(
   {
-    name: '<Probe name>',
-    protocol: 'http',
-    host: 'localhost',
-    path: '/fog-test',
-    interval: 60, 
-    timeout: 300,
-    unhealthy_threshold: 5
-   }
- )
-    ag.remove__probe(
+    name: '<Probe Name>',
+    protocol: '<Protocol Name>',
+    host: '<Host Name>',
+    path: '<Probe Path>',
+    interval: <Interval Time>, 
+    timeout: <Timeout Time>,
+    unhealthy_threshold: <Threshold Value>
+  }
+)
+
+ag.remove__probe(
   {
     name: '<Probe name>',
-    protocol: 'http',
-    host: 'localhost',
-    path: '/fog-test',
-    interval: 60, 
-    timeout: 300,
-    unhealthy_threshold: 5
-   }
+    protocol: '<Protocol Name>',
+    host: '<Protocol Name>',
+    path: '<Probe Path>',
+    interval: <Interval Time>, 
+    timeout: <Timeout Time>,
+    unhealthy_threshold: <Threshold Value>
+  }
 )
 ```
 
@@ -235,8 +238,8 @@ Get a single record of Application Gateway
 Get a application gateway object from the get method and then destroy that application gateway.
 
 ```ruby
-    gateway.destroy
+gateway.destroy
 ```
 
 ## Support and Feedback
-Your feedback is highly appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.
+Your feedback is highly appreciated! If you have specific issues with the Fog ARM, you should file an issue via Github.

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

@@ -1,6 +1,6 @@
 # Compute
 
-This document explains how to get started using Azure Compute Service with Fog. With this gem you can create/update/list/delete availability sets and virtual machines.
+This document explains how to get started using Azure Compute Service with Fog. With this gem you can create, update, list or delete availability sets and virtual machines.
 
 ## Usage 
 
@@ -15,78 +15,81 @@ require 'fog/azurerm'
 Next, create a connection to the Compute Service:
 
 ```ruby
-    azure_compute_service = Fog::Compute::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_compute_service = Fog::Compute::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 Server Existence
 
 ```ruby
-azure_compute_service.servers.check_vm_exists(<Resource Group name>, <VM Name>)
+fog_compute_service.servers.check_vm_exists('<Resource Group Name>', '<VM Name>')
 ```
 
 ## Create Server
 
 **Info:**
 
-- Attribute **network_interface_card_ids** is an array of NICs ids. The NIC id at index zero will become primary NIC of this server(virtual machine) by default.
+- Attribute **network_interface_card_ids** is an array of NICs Ids. The NIC Id at index zero will become primary NIC of this server (virtual machine) by default.
 - To create VM with managed OS disk, use the _managed_disk_storage_type_ argument
 - To create VM with unmanaged OS disk, use the _storage_account_name_ argument
 
+
 ### Virtual Machine (Managed OS Disk)
 
 ```ruby
-    azure_compute_service.servers.create(
+fog_compute_service.servers.create(
         name: '<VM Name>',
-        location: 'West US',
+        location: '<Location>',
         resource_group: '<Resource Group Name>',
-        vm_size: 'Basic_A0',
-        username: '<Username for VM>',
-        password: '<Password for VM>',             # Optional, if 'platform' partameter is 'Linux'.
-        disable_password_authentication: false,
-        network_interface_card_ids: ['/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}'],
-        availability_set_id: '<availability_set_id>', # Optional
-        publisher: 'Canonical',                    # Not required if custom image is being used 
-        offer: 'UbuntuServer',                     # Not required if custom image is being used
-        sku: '14.04.2-LTS',                        # Not required if custom image is being used
-        version: 'latest',                         # Not required if custom image is being used
-        platform: 'Linux',
-        vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
-        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None, # Optional, can be one of None, ReadOnly, ReadWrite
-        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS, # Optional if storage_account_name is passed, can be StandardLRS or PremiumLRS
-        os_disk_size: <Disk Size>                  # Optional, size of the os disk in GB (upto 1023)
-    )
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
+        username: '<Username>',
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                          # Not required if custom image is being used 
+        offer: '<Offer Name>',                                  # Not required if custom image is being used
+        sku: '<SKU Name>',                                      # Not required if custom image is being used
+        version: '<Version>',                                   # Not required if custom image is being used
+        platform: '<OS Type>',
+        availability_set_id: '<Availability Set Id>',           # [Optional]
+        password: '<Password>',                                 # [Optional], if 'platform' partameter is 'Linux'.
+        vhd_path: '<Path of VHD>',                              # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',                     # [Optional], if you want to add custom data in this VM.
+        os_disk_caching: '<Caching Type>',                      # [Optional], can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: '<Storage Account Type>',    # [Optional], if storage_account_name is passed, can be StandardLRS or PremiumLRS
+        os_disk_size: <Disk Size>                               # [Optional], size of the os disk in GB (upto 1023)
+)
 ```
 
 ### Virtual Machine (Unmanaged OS Disk)
 
 ```ruby
-    azure_compute_service.servers.create(
+fog_compute_service.servers.create(
         name: '<VM Name>',
-        location: 'West US',
+        location: '<Location>',
         resource_group: '<Resource Group Name>',
-        vm_size: 'Basic_A0',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
         storage_account_name: '<Storage Account Name>',
-        username: '<Username for VM>',
-        password: '<Password for VM>',
-        disable_password_authentication: false,
-        network_interface_card_ids: ['/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}'],
-        availability_set_id: '<availability_set_id>', # Optional
-        publisher: 'MicrosoftWindowsServerEssentials',   # Not required if custom image is being used
-        offer: 'WindowsServerEssentials',                # Not required if custom image is being used  
-        sku: 'WindowsServerEssentials',                  # Not required if custom image is being used
-        version: 'latest',                               # Not required if custom image is being used
-        platform: 'Windows',
-        vhd_path: '<Path of VHD>',                       # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData',                  # Optional, if you want to add custom data in this VM.
-        os_disk_size: <Disk Size>                        # Optional, size of the os disk in GB (upto 1023)
-    )
+        username: '<Username>',
+        password: '<Password>',
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                    # Not required if custom image is being used
+        offer: '<Offer Name>',                            # Not required if custom image is being used  
+        sku: '<SKU Name>',                                # Not required if custom image is being used
+        version: '<Version>',                             # Not required if custom image is being used
+        platform: '<OS Type>',
+        availability_set_id: '<Availability Set Id>',     # [Optional]
+        vhd_path: '<Path of VHD>',                        # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',               # [Optional], if you want to add custom data in this VM.
+        os_disk_size: <Disk Size>                         # [Optional], size of the os disk in GB (upto 1023)
+)
 ```
 
 ## Create Server Asynchronously
@@ -94,28 +97,29 @@ azure_compute_service.servers.check_vm_exists(<Resource Group name>, <VM Name>)
 Create a new linux server asynchronously
 
 ```ruby
-    async_response = azure_compute_service.servers.create_async(
+async_response = fog_compute_service.servers.create_async(
         name: '<VM Name>',
-        location: 'West US',
+        location: '<Location>',
         resource_group: '<Resource Group Name>',
-        vm_size: 'Basic_A0',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
         storage_account_name: '<Storage Account Name>',
         username: '<Username for VM>',
-        password: '<Password for VM>',             # Optional, if 'platform' partameter is 'Linux'.
-        disable_password_authentication: false,
-        network_interface_card_ids: ['/subscriptions/{Subscription-Id}/resourceGroups/{Resource-Group-Name}/providers/Microsoft.Network/networkInterfaces/{Network-Interface-Id}'],
-        availability_set_id: '<availability_set_id>', # Optional
-        publisher: 'Canonical',                    # Not required if custom image is being used 
-        offer: 'UbuntuServer',                     # Not required if custom image is being used
-        sku: '14.04.2-LTS',                        # Not required if custom image is being used
-        version: 'latest',                         # Not required if custom image is being used
-        platform: 'Linux',
-        vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
-        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None, # Optional, can be one of None, ReadOnly, ReadWrite
-        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS, # Optional, can be StandardLRS or PremiumLRS
-        os_disk_size: <Disk Size>                  # Optional, size of the os disk in GB (upto 1023)
-    )
+        disable_password_authentication: <True/False>,
+        network_interface_card_ids: ['/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkInterfaces/<Network Interface Id>'],
+        publisher: '<Publisher Name>',                       # Not required if custom image is being used 
+        offer: '<Offer Name>',                               # Not required if custom image is being used
+        sku: '<SKU Name>',                                   # Not required if custom image is being used
+        version: '<Version>' ,                               # Not required if custom image is being used
+        platform: '<OS Type>', 
+        availability_set_id: '<Availability Set Id>',        # [Optional]
+        password: '<Password>',                              # [Optional], if 'platform' partameter is 'Linux'.
+        vhd_path: '<Path of VHD>',                           # [Optional], if you want to create the VM from a custom image.
+        custom_data: '<Custom Data Value>',                  # [Optional], if you want to add custom data in this VM.
+        os_disk_caching: '<Caching Type>',                   # [Optional], can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: '<Storage Account Type>', # [Optional], can be StandardLRS or PremiumLRS
+        os_disk_size: <Disk Size>                            # [Optional], size of the os disk in GB (upto 1023)
+)
 ```
 Following methods are available to handle async respoonse:
 - state
@@ -147,18 +151,18 @@ while 1
  end
 ```
  
-For more information about custom_data; see link: https://msdn.microsoft.com/en-us/library/azure/mt163591.aspx
+For more information about custom_data, see link: https://msdn.microsoft.com/en-us/library/azure/mt163591.aspx
 
 ## List Servers
 
 List servers in a resource group
 
 ```ruby
-    servers  = azure_compute_service.servers(resource_group: '<Resource Group name>')
-    servers.each do |server|
+servers  = fog_compute_service.servers(resource_group: '<Resource Group Name>')
+servers.each do |server|
         puts "#{server.name}"
         puts "#{server.location}"
-    end
+end
 ```
 
 ## Retrieve a single Server
@@ -166,272 +170,270 @@ List servers in a resource group
 Get a single record of Server
 
 ```ruby
-      server = azure_compute_service
-                          .servers(resource_group: '<Resource Group name>')
-                          .get('<Resource Group name>', 'Server name>')
-      puts "#{server.name}"
+server = fog_compute_service
+                  .servers(resource_group: '<Resource Group Name>')
+                  .get('<Resource Group Name>', 'Server Name>')
+puts "#{server.name}"
 ```
 
-## Attach a Data Disk to Server
+## Get a Server's status
 
-Get the server object and attach a Data Disk to it.
+Check the status of a Server
 
-```ruby
-      server.attach_data_disk('<Disk Name>', <Size in GB>, '<Storage Account Name>')
+```ruby 
+status = fog_compute_service
+                      .servers
+                      .get('<Resource Group Name>', '<Server Name>')
+                      .vm_status
+puts status
 ```
 
-## Detach a Data Disk from Server
+## Destroy a single Server
 
-Get the server object and detach a Data Disk from it.
+Get a server object from the get method (described above) and then destroy that server.
 
 ```ruby
-      server.detach_data_disk('<Disk Name>')
+server.destroy
 ```
 
-## Attach a Managed Data Disk to Server
+## Attach a Data Disk to Server
 
-Get the server object and attach a Data Disk to it.
+Get the server object and attach a Data Disk to it. The data disk attached is blob based.
 
 ```ruby
-      server.attach_managed_disk('<Disk Name>', '<Disk Resource Group Name>')
+server.attach_data_disk('<Disk Name>', <Size in GBs>, '<Storage Account Name>')
 ```
 
-## Detach a Managed Data Disk from Server
+## Detach a Data Disk from Server
 
 Get the server object and detach a Data Disk from it.
 
 ```ruby
-      server.detach_managed_disk('<Disk Name>')
+server.detach_data_disk('<Disk Name>')
 ```
 
-## Get a Server's status
+## Create Managed Disk
 
-Check the status of a Server
+Create a new Premium Managed Disk
 
-```ruby 
-      status = azure_compute_service
-                          .servers
-                          .get('<Resource Group name>', '<Server name>')
-                          .vm_status
-      puts status
+```ruby
+fog_compute_service.managed_disks.create(
+        name: '<Disk Name>',
+        location: '<Location>',
+        resource_group_name: '<Resource Group Name>',
+        account_type: '<Storage Account Type>',
+        disk_size_gb: <Disk Size in GBs>,
+        creation_data: {
+            create_option: '<Create Option Value>'
+        }
+)
 ```
 
-## Destroy a single Server
-
-Get a server object from the get method(described above) and then destroy that server.
+Create a new Standard Managed Disk
 
 ```ruby
-      server.destroy
+fog_compute_service.managed_disks.create(
+        name: '<Disk Name>',
+        location: '<Location>',
+        resource_group_name: '<Resource Group Name>',
+        account_type: '<Storage Account Type>',
+        disk_size_gb: <Disk Size in GBs>,
+        creation_data: {
+            create_option: '<Create Option Value>'
+        }
+)
 ```
 
-## Check Availability Set Existence
+## Attach a Managed Data Disk to Server
+
+Get the server object and attach a Data Disk to it.
 
 ```ruby
-azure_compute_service.availability_sets.check_availability_set_exists(<Resource Group name>, <Availability Set name>)
+server.attach_managed_disk('<Disk Name>', '<Disk Resource Group Name>')
 ```
 
-## Create Availability Set
+## Detach a Managed Data Disk from Server
 
-Create a new availability set
+Get the server object and detach a Data Disk from it.
 
 ```ruby
-azure_compute_service.availability_sets.create(
-    name: '<Availability Set name>',
-    location: '<Location>',
-    resource_group: '<Resource Group name>'
-    platform_fault_domain_count: <No of Fault Domains>,     # [Optional] Default => 2
-    platform_update_domain_count: <No of Update Domains>,   # [Optional] Default => 5
-    use_managed_disk: true                                  # [Optional] Possible values true or false
-)
+server.detach_managed_disk('<Disk Name>')
 ```
-## List Availability Sets 
 
-List availability sets in a resource group
+## List Managed Disks in a Resource Group
+
+List managed disks in a resource group
 
 ```ruby
-    availability_sets  = azure_compute_service.availability_sets(resource_group: '<Resource Group name>')
-    availability_sets.each do |availability_set|
-        puts "#{availability_set.name}"
-        puts "#{availability_set.location}"
-    end
+managed_disks  = fog_compute_service.managed_disks(resource_group: '<Resource Group Name>')
+mnaged_disks.each do |disk|
+      puts "#{disk.name}"
+      puts "#{disk.location}"
+end
 ```
 
-## Retrieve a single Availability Set
+## List Managed Disks in a Subscription
 
-Get a single record of Availability Set
+List managed disks in a subscription
 
 ```ruby
-      availability_set = azure_compute_service
-                          .availability_sets
-                          .get('<Resource Group name>','<Availability Set name>')
-        puts "#{availability_set.name}"
+fog_compute_service.managed_disks.each do |disk|
+     puts "#{disk.name}"
+     puts "#{disk.location}"
+end
 ```
 
-## Destroy a single Availability Set
+## Grant Access to a Managed Disk
 
-Get an availability set object from the get method and then destroy that availability set.
+Grant access to a managed disk
 
 ```ruby
-      availability_set.destroy
+access_sas = fog_compute_service.managed_disks.grant_access('<Resource Group Name>', '<Disk Name>', '<Access Type>', <Duration in Seconds>)
+puts "Access SAS: #{access_sas}"
 ```
 
-## Check Virtual Machine Extension Existence
+## Revoke Access from a Managed Disk
+
+Revoke access from a managed disk
 
 ```ruby
-azure_compute_service.virtual_machine_extensions.check_vm_extension_exists(<Resource Group name>, <Virtual Machine Name>, <Extension Name>)
+response = fog_compute_service.managed_disks.revoke_access('<Resource Group Name>', '<Disk Name>')
+puts "Revoke Access response status: #{response.status}"
 ```
 
-## Create Virtual Machine Extension
-
-Installs an extension to the specified virtual machine.
+## Check Managed Disk Existence
 
 ```ruby
-    azure_compute_service.virtual_machine_extensions.create(
-        name: <Extension Name>,
-        resource_group: <Resource Group>,
-        location: <Location>,
-        vm_name: <Virtual Machine Name>, # Extension will be installed on this VM
-        publisher: <Extension publisher>,
-        type: <Extension type>,
-        type_handler_version: <Extension version>,
-        auto_upgrade_minor_version: <true|false>, # Optional
-        settings: {JSON object}, # Format: {"key": "value", "key": {"key": "value"}}
-        protected_settings: {JSON object}
-    )
+fog_compute_service.managed_disks.check_managed_disk_exists('<Resource Group Name>', '<Disk Name>')
 ```
 
-## Get Extension from Virtual Machine
+## Retrieve a single Managed Disk
 
-Retrieves the given extension from the virtual machine
+Get a single record of managed disks
 
 ```ruby
-    vm_extension = azure_compute_service.virtual_machine_extensions.get(
-        '<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>'
-    )
+managed_disk = fog_compute_service
+                       .managed_disks
+                       .get('<Resource Group Name>', '<Disk Name>')
+puts "#{managed_disk.name}"
 ```
 
-## Update Extension
+## Destroy a single Managed Disk
 
-Update the given extension. The attributes that can be modified are
-- auto_upgrade_minor_version
-- settings
-- protected_settings
+Get an managed disk object from the get method and then destroy that managed disk.
 
 ```ruby
-    vm_extension.update(
-        auto_upgrade_minor_version: <true|false>,
-        settings: {JSON object},
-        protected_settings: {JSON object}
-    )
+managed_disk.destroy
 ```
 
-## Destroy Extension
-
-Destroy the given extension from the virtual machine
+## Check Availability Set Existence
 
 ```ruby
-    vm_extension.destroy
+fog_compute_service.availability_sets.check_availability_set_exists('<Resource Group Name>', '<Availability Set Name>')
 ```
 
+## Create Availability Set
 
-## Create Managed Disk
-
-Create a new Premium Managed Disk
+Create a new availability set
 
 ```ruby
-    azure_compute_service.managed_disks.create(
-        name: 'disk_name',
-        location: 'east us',
-        resource_group_name: 'resource_group_name',
-        account_type: 'Premium_LRS',
-        disk_size_gb: 1023,
-        creation_data: {
-          create_option: 'Empty'
-        }
-    )
+fog_compute_service.availability_sets.create(
+    name: '<Availability Set Name>',
+    location: '<Location>',
+    resource_group: '<Resource Group Name>'
+    platform_fault_domain_count: <No of Fault Domains>,     # [Optional] Default => 2
+    platform_update_domain_count: <No of Update Domains>,   # [Optional] Default => 5
+    use_managed_disk: true                                  # [Optional] Possible values true or false
+)
 ```
+## List Availability Sets 
 
-Create a new Standard Managed Disk
+List availability sets in a resource group
 
 ```ruby
-    azure_compute_service.managed_disks.create(
-        name: 'disk_name',
-        location: 'east us',
-        resource_group_name: 'resource_group_name',
-        account_type: 'Standard_LRS',
-        disk_size_gb: 1023,
-        creation_data: {
-          create_option: 'Empty'
-        }
-    )
+availability_sets  = fog_compute_service.availability_sets(resource_group: '<Resource Group Name>')
+availability_sets.each do |availability_set|
+     puts "#{availability_set.name}"
+     puts "#{availability_set.location}"
+end
 ```
 
-## List Managed Disks in a Resource Group
+## Retrieve a single Availability Set
 
-List managed disks in a resource group
+Get a single record of Availability Set
 
 ```ruby
-    managed_disks  = azure_compute_service.managed_disks(resource_group: '<Resource Group name>')
-    mnaged_disks.each do |disk|
-        puts "#{disk.name}"
-        puts "#{disk.location}"
-    end
+availability_set = fog_compute_service
+                        .availability_sets
+                        .get('<Resource Group Name>','<Availability Set Name>')
+puts "#{availability_set.name}"
 ```
 
-## List Managed Disks in a Subscription
+## Destroy a single Availability Set
 
-List managed disks in a subscription
+Get an availability set object from the get method and then destroy that availability set.
 
 ```ruby
-    azure_compute_service.managed_disks.each do |disk|
-        puts "#{disk.name}"
-        puts "#{disk.location}"
-    end
+availability_set.destroy
 ```
 
-## Grant Access to a Managed Disk
-
-Grant access to a managed disk
+## Check Virtual Machine Extension Existence
 
 ```ruby
-    access_sas = azure_compute_service.managed_disks.grant_access('<resource_group_name>', '<disk_name>', 'Read', 1000)
-    puts "Access SAS: #{access_sas}"
+fog_compute_service.virtual_machine_extensions.check_vm_extension_exists('<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>')
 ```
 
-## Revoke Access from a Managed Disk
+## Create Virtual Machine Extension
 
-Revoke access from a managed disk
+Installs an extension to the specified virtual machine.
 
 ```ruby
-    response = azure_compute_service.managed_disks.revoke_access('<resource_group_name>', '<disk_name>')
-    puts "Revoke Access response status: #{response.status}"
+fog_compute_service.virtual_machine_extensions.create(
+        name: '<Extension Name>',
+        resource_group: '<Resource Group Name>',
+        location: '<Location>',
+        vm_name: '<Virtual Machine Name>',            # Extension will be installed on this VM
+        publisher: '<Extension Publisher>',
+        type: '<Extension Type>',
+        type_handler_version: '<Extension Version>',
+        settings: {JSON object},                      # Format: {"key": "value", "key": {"key": "value"}}
+        protected_settings: {JSON object},
+        auto_upgrade_minor_version: <True/False> ,   # Optional
+)
 ```
 
-## Check Managed Disk Existence
+## Get Extension from Virtual Machine
+
+Retrieves the given extension from the virtual machine
 
 ```ruby
-    azure_compute_service.managed_disks.check_managed_disk_exists(<Resource Group name>, <Disk name>)
+vm_extension = fog_compute_service.virtual_machine_extensions.get(
+        '<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>'
+)
 ```
 
-## Retrieve a single Managed Disk
+## Update Extension
 
-Get a single record of managed disks
+Update the given extension. The attributes that can be modified are
+- auto_upgrade_minor_version
+- settings
+- protected_settings
 
 ```ruby
-      managed_disk = azure_compute_service
-                          .managed_disks
-                          .get('<Resource Group name>','<Disk name>')
-      puts "#{managed_disk.name}"
+vm_extension.update(
+        auto_upgrade_minor_version: <True/False>,
+        settings: {JSON object},
+        protected_settings: {JSON object}
+)
 ```
 
-## Destroy a single Managed Disk
+## Destroy Extension
 
-Get an managed disk object from the get method and then destroy that managed disk.
+Destroy the given extension from the virtual machine
 
 ```ruby
-      managed_disk.destroy
+vm_extension.destroy
 ```
 
-
 ## Support and Feedback
 Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.