far-gem 0.5.1

data/lib/fog/azurerm/config.rb

@@ -0,0 +1 @@
+LOCATION = 'eastus'.freeze

data/lib/fog/azurerm/constants.rb

@@ -0,0 +1,71 @@
+AZURE_RESOURCE = 'https://management.azure.com'.freeze
+DEFAULT_ADDRESS_PREFIXES = ['10.2.0.0/16'].freeze
+SUBNET = 'Subnet'.freeze
+PUBLIC_IP = 'Public-IP-Address'.freeze
+NETWORK_SECURITY_GROUP = 'Network-Security-Group'.freeze
+STANDARD_STORAGE = 'Standard'.freeze
+PREMIUM_STORAGE = 'Premium'.freeze
+ALLOWED_STANDARD_REPLICATION = %w[LRS ZRS GRS RAGRS].freeze
+API_VERSION = '2016-06-01'.freeze
+FAULT_DOMAIN_COUNT = 2
+UPDATE_DOMAIN_COUNT = 5
+WINDOWS = 'windows'.freeze
+VPN = 'Vpn'.freeze
+MICROSOFT_PEERING = 'MicrosoftPeering'.freeze
+RESOURCE_GROUP_NAME = 4
+RESOURCE_PROVIDER_NAMESPACE = 6
+RESOURCE_TYPE = 7
+RESOURCE_NAME = 8
+ENDPOINT_PREFIX = 'Microsoft.Network/trafficManagerProfiles'.freeze
+DISK_PREFIX = 'Microsoft.Compute/disks'.freeze
+AZURE_ENDPOINTS = 'azureEndpoints'.freeze
+EXTERNAL_ENDPOINTS = 'externalEndpoints'.freeze
+NESTED_ENDPOINTS = 'nestedEndpoints'.freeze
+GLOBAL = 'global'.freeze
+UPLOAD_BLOB_WORKER_THREAD_COUNT = 8
+VM_NAME_POSITION = 8
+PRIMARY_NIC_INDEX = 0
+
+ENVIRONMENT_AZURE_CLOUD = 'AzureCloud'.freeze
+ENVIRONMENT_AZURE_CHINA_CLOUD = 'AzureChinaCloud'.freeze
+ENVIRONMENT_AZURE_US_GOVERNMENT = 'AzureUSGovernment'.freeze
+ENVIRONMENT_AZURE_GERMAN_CLOUD = 'AzureGermanCloud'.freeze
+
+# MsRestAzure::AzureOperationError class Error Codes
+ERROR_CODE_RESOURCE_NOT_FOUND = 'ResourceNotFound'.freeze
+ERROR_CODE_NOT_FOUND = 'NotFound'.freeze
+ERROR_CODE_RESOURCE_GROUP_NOT_FOUND = 'ResourceGroupNotFound'.freeze
+ERROR_CODE_PARENT_RESOURCE_NOT_FOUND = 'ParentResourceNotFound'.freeze
+
+PLATFORM_LINUX = 'linux'.freeze
+
+# State of the copy operation
+COPY_STATUS =
+  {
+    # The copy completed successfully.
+    SUCCESS: 'success',
+    # The copy is in progress
+    PENDING: 'pending'
+  }.freeze
+
+# https://msdn.microsoft.com/en-us/library/azure/dd179451.aspx
+# The maximum size for a block blob created via Put Blob is 64 MB. But for better performance, this size should be 32 MB.
+# If your blob is larger than 32 MB, you must upload it as a set of blocks.
+SINGLE_BLOB_PUT_THRESHOLD = 32 * 1024 * 1024
+
+# Block blob: https://msdn.microsoft.com/en-us/library/azure/dd135726.aspx
+# Page blob: https://msdn.microsoft.com/en-us/library/azure/ee691975.aspx
+# Each block/page can be a different size, up to a maximum of 4 MB
+MAXIMUM_CHUNK_SIZE = 4 * 1024 * 1024
+
+# The hash value of 4MB empty content
+HASH_OF_4MB_EMPTY_CONTENT = 'b5cfa9d6c8febd618f91ac2843d50a1c'.freeze
+REST_CLIENT_API_VERSION = %w[2014-04-01-preview 2016-05-01].freeze
+AS_SKU_CLASSIC = 'Classic'.freeze
+AS_SKU_ALIGNED = 'Aligned'.freeze
+
+# The tag key and tag value for creating a temporary storage account for generalized image
+TEMPORARY_STORAGE_ACCOUNT_TAG_KEY = 'generalized_image'.freeze
+TEMPORARY_STORAGE_ACCOUNT_TAG_VALUE = 'delete'.freeze
+
+HTTP_NOT_FOUND = 404

data/lib/fog/azurerm/credentials.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Credentials
+    # This class is managing credentials token
+    class AzureRM
+      def self.get_credentials(tenant_id, client_id, client_secret, environment = ENVIRONMENT_AZURE_CLOUD)
+        if @credentials.nil? || new_management_credential?(tenant_id, client_id, client_secret, environment)
+          get_new_credentials(tenant_id, client_id, client_secret, environment)
+        else
+          @credentials
+        end
+      end
+
+      def self.get_token(tenant_id, client_id, client_secret, environment = ENVIRONMENT_AZURE_CLOUD)
+        get_credentials(tenant_id, client_id, client_secret, environment) if @credentials.nil?
+        @token_provider.get_authentication_header
+      end
+
+      def self.get_new_credentials(tenant_id, client_id, client_secret, environment)
+        @tenant_id = tenant_id
+        @client_id = client_id
+        @client_secret = client_secret
+        @environment = environment
+        return if @tenant_id.nil? || @client_id.nil? || @client_secret.nil?
+        @token_provider = MsRestAzure::ApplicationTokenProvider.new(@tenant_id, @client_id, @client_secret, active_directory_service_settings(environment))
+        @credentials = MsRest::TokenCredentials.new(@token_provider)
+        @credentials
+      end
+
+      def self.new_management_credential?(tenant_id, client_id, client_secret, environment)
+        @tenant_id != tenant_id ||
+          @client_id != client_id ||
+          @client_secret != client_secret ||
+          @environment != environment
+      end
+
+      private_class_method :get_new_credentials
+      private_class_method :new_management_credential?
+    end
+  end
+end

data/lib/fog/azurerm/dns.rb

@@ -0,0 +1,70 @@
+module Fog
+  module DNS
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+      recognizes :environment
+
+      request_path 'fog/azurerm/requests/dns'
+      request :create_or_update_zone
+      request :delete_zone
+      request :check_zone_exists
+      request :list_zones
+      request :get_zone
+      request :create_or_update_record_set
+      request :delete_record_set
+      request :list_record_sets
+      request :get_records_from_record_set
+      request :get_record_set
+      request :check_record_set_exists
+
+      model_path 'fog/azurerm/models/dns'
+      model :zone
+      collection :zones
+      model :record_set
+      collection :record_sets
+      model :a_record
+      model :cname_record
+      
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+        end
+      end
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_dns'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          options[:environment] = 'AzureCloud' if options[:environment].nil?
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret], options[:environment])
+          telemetry = "fog-azure-rm/#{Fog::AzureRM::VERSION}"
+          @dns_client = ::Azure::ARM::Dns::DnsManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
+          @dns_client.subscription_id = options[:subscription_id]
+          @dns_client.add_user_agent_information(telemetry)
+          @tenant_id = options[:tenant_id]
+          @client_id = options[:client_id]
+          @client_secret = options[:client_secret]
+          @environment = options[:environment]
+          @resources = Fog::Resources::AzureRM.new(
+            tenant_id: options[:tenant_id],
+            client_id: options[:client_id],
+            client_secret: options[:client_secret],
+            subscription_id: options[:subscription_id],
+            environment: options[:environment]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,245 @@
+# 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
+
+First of all, you need to require the Fog library by executing:
+
+```ruby
+require 'fog/azurerm'
+```
+## Create Connection
+
+Next, create a connection to the Application Gateway Service:
+
+```ruby
+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
+fog_application_gateway_service.gateways.check_application_gateway_exists('<Resource Group Name>', '<Gateway Name>')
+
+```
+
+## Create Application Gateway
+
+Create a new Application Gateway.
+
+```ruby
+gateway = fog_application_gateway_service.gateways.create(
+
+        name: '<Gateway Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group name>',
+        sku_name: '<SKU Name>',
+        sku_tier: '<SKU Tier>',
+        sku_capacity: '<SKU Capacity>',
+        gateway_ip_configurations:
+            [
+                {
+                    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: '<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: '<Frontend Port Name>',
+                    port: <Port Number>
+                }
+            ],
+        backend_address_pools:
+            [
+                {
+                    name: '<Backend Address Pool Name>',
+                    ip_addresses: [
+                        {
+                            ipAddress: '<IP Address>'
+                        }
+                    ]
+                }
+            ],
+        backend_http_settings_list:
+            [
+                {
+                    name: '<Gateway Settings Name>',
+                    port: <Port Number>,
+                    protocol: '<Protocol Name>',
+                    cookie_based_affinity: '<Enabled/Disabled>',
+                    request_timeout: '<Timeout Time>'
+                }
+            ],
+        http_listeners:
+            [
+                {
+                    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: '<True/False>'
+                }
+            ],
+        request_routing_rules:
+            [
+                {
+                    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
+
+	```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
+
+	```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 = fog_application_gateway_service.gateways(resource_group: '<Resource Group Name>')
+gateways.each do |gateway|
+	puts "#{gateway.name}"
+end
+```
+
+## Retrieve a single Application Gateway
+
+Get a single record of Application Gateway
+
+```ruby
+gateway = fog_application_gateway_service
+                            .gateways
+                            .get('<Resource Group Name>', '<Application Gateway Name>')
+puts "#{gateway.name}"
+```
+
+
+## Update SKU attributes (Name and Capacity)                
+
+```ruby
+ag.update_sku('<SKU Name>', '<SKU Capacity>')
+```
+
+## 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>')
+```
+
+## Add/ Remove SSL Certificates 
+
+```ruby
+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: '<SSL Certificate Data>',
+       password: '<Password>',
+       public_cert_data: '<Public Certificate Data>'
+	}
+)
+```
+
+## Add/ Remove Frontend ports    
+
+```ruby
+ag.add_frontend_port({name: '<Frontend Port Name>', port: <Port Number>})
+    
+ag.remove_frontend_port({name: '<Frontend Port Name>', port: <Port Number>})
+```
+
+## Add/ Remove Probes    
+
+```ruby
+ag.add_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: '<Protocol Name>',
+    host: '<Protocol Name>',
+    path: '<Probe Path>',
+    interval: <Interval Time>, 
+    timeout: <Timeout Time>,
+    unhealthy_threshold: <Threshold Value>
+  }
+)
+```
+
+## Destroy a single Application Gateway
+
+Get a application gateway object from the get method and then destroy that application gateway.
+
+```ruby
+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.

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

@@ -0,0 +1,499 @@
+# Compute
+
+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 
+
+First of all, you need to require the Fog library by executing:
+
+```ruby
+require 'fog/azurerm'
+```
+
+## Create Connection
+
+Next, create a connection to the Compute Service:
+
+```ruby
+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
+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.
+- 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
+fog_compute_service.servers.create(
+        name: '<VM Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group Name>',
+	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)
+)
+```
+
+**Info:**
+
+- To create VM from Image, pass in the Image ID in `image_ref` attribute
+
+**Limitation:**
+
+- Image should be in the same region
+- ONLY managed VM can be created from image
+
+### Virtual Machine (Managed OS Disk from Image)
+
+```ruby
+fog_compute_service.servers.create(
+        name: '<VM Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group Name>',
+	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'.
+        image_ref: '<Image ID>',                                # [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
+fog_compute_service.servers.create(
+        name: '<VM Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group Name>',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
+        storage_account_name: '<Storage Account Name>',
+        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
+
+Create a new linux server asynchronously
+
+```ruby
+async_response = fog_compute_service.servers.create_async(
+        name: '<VM Name>',
+        location: '<Location>',
+        resource_group: '<Resource Group Name>',
+	tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },
+        vm_size: '<Virtual Machine Size>',
+        storage_account_name: '<Storage Account Name>',
+        username: '<Username for VM>',
+        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
+- pending?
+- rejected?
+- reason
+- fulfilled?
+- value
+
+An example of handling async response is given below:
+
+```ruby
+while 1
+    puts async_response.state
+    
+    if async_response.pending?
+      sleep(2)
+    end
+
+    if async_response.fulfilled?
+      puts async_response.value.inspect
+      break
+    end
+
+    if async_response.rejected?
+      puts async_response.reason.inspect
+      break
+    end
+ end
+```
+ 
+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  = fog_compute_service.servers(resource_group: '<Resource Group Name>')
+servers.each do |server|
+        puts "#{server.name}"
+        puts "#{server.location}"
+end
+```
+
+## Retrieve a single Server
+
+Get a single record of Server
+
+```ruby
+server = fog_compute_service
+                  .servers(resource_group: '<Resource Group Name>')
+                  .get('<Resource Group Name>', 'Server Name>')
+puts "#{server.name}"
+```
+
+## Get a Server's status
+
+Check the status of a Server
+
+```ruby 
+status = fog_compute_service
+                      .servers
+                      .get('<Resource Group Name>', '<Server Name>')
+                      .vm_status
+puts status
+```
+
+## Start a Server
+```ruby
+server.start
+```
+
+## Power Off a Server
+```ruby
+server.power_off
+```
+
+## Restart a Server
+```ruby
+server.restart
+```
+
+## Deallocate a Server
+```ruby
+server.deallocate
+```
+
+## Redeploy a Server
+```ruby
+server.redeploy
+```
+
+## Destroy a single Server
+
+Get a server object from the get method (described above) and then destroy that server.
+
+```ruby
+server.destroy
+```
+
+## Attach a Data Disk to Server
+
+Get the server object and attach a Data Disk to it. The data disk attached is blob based.
+
+```ruby
+server.attach_data_disk('<Disk Name>', <Size in GBs>, '<Storage Account Name>')
+```
+
+## Detach a Data Disk from Server
+
+Get the server object and detach a Data Disk from it.
+
+```ruby
+server.detach_data_disk('<Disk Name>')
+```
+
+## Create Managed Disk
+
+Create a new Premium Managed Disk
+
+```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>'
+        }
+)
+```
+
+Create a new Standard Managed Disk
+
+```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>'
+        }
+)
+```
+
+## Attach a Managed Data Disk to Server
+
+Get the server object and attach a Data Disk to it.
+
+```ruby
+server.attach_managed_disk('<Disk Name>', '<Disk Resource Group Name>')
+```
+
+## Detach a Managed Data Disk from Server
+
+Get the server object and detach a Data Disk from it.
+
+```ruby
+server.detach_managed_disk('<Disk Name>')
+```
+
+## List Managed Disks in a Resource Group
+
+List managed disks in a resource group
+
+```ruby
+managed_disks  = fog_compute_service.managed_disks(resource_group: '<Resource Group Name>')
+mnaged_disks.each do |disk|
+      puts "#{disk.name}"
+      puts "#{disk.location}"
+end
+```
+
+## List Managed Disks in a Subscription
+
+List managed disks in a subscription
+
+```ruby
+fog_compute_service.managed_disks.each do |disk|
+     puts "#{disk.name}"
+     puts "#{disk.location}"
+end
+```
+
+## Grant Access to a Managed Disk
+
+Grant access to a managed disk
+
+```ruby
+access_sas = fog_compute_service.managed_disks.grant_access('<Resource Group Name>', '<Disk Name>', '<Access Type>', <Duration in Seconds>)
+puts "Access SAS: #{access_sas}"
+```
+
+## Revoke Access from a Managed Disk
+
+Revoke access from a managed disk
+
+```ruby
+response = fog_compute_service.managed_disks.revoke_access('<Resource Group Name>', '<Disk Name>')
+puts "Revoke Access response status: #{response.status}"
+```
+
+## Check Managed Disk Existence
+
+```ruby
+fog_compute_service.managed_disks.check_managed_disk_exists('<Resource Group Name>', '<Disk Name>')
+```
+
+## Retrieve a single Managed Disk
+
+Get a single record of managed disks
+
+```ruby
+managed_disk = fog_compute_service
+                       .managed_disks
+                       .get('<Resource Group Name>', '<Disk Name>')
+puts "#{managed_disk.name}"
+```
+
+## Destroy a single Managed Disk
+
+Get an managed disk object from the get method and then destroy that managed disk.
+
+```ruby
+managed_disk.destroy
+```
+
+## Check Availability Set Existence
+
+```ruby
+fog_compute_service.availability_sets.check_availability_set_exists('<Resource Group Name>', '<Availability Set Name>')
+```
+
+## Create Availability Set
+
+Create a new availability set
+
+```ruby
+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 
+
+List availability sets in a resource group
+
+```ruby
+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
+```
+
+## Retrieve a single Availability Set
+
+Get a single record of Availability Set
+
+```ruby
+availability_set = fog_compute_service
+                        .availability_sets
+                        .get('<Resource Group Name>','<Availability Set Name>')
+puts "#{availability_set.name}"
+```
+
+## Destroy a single Availability Set
+
+Get an availability set object from the get method and then destroy that availability set.
+
+```ruby
+availability_set.destroy
+```
+
+## Check Virtual Machine Extension Existence
+
+```ruby
+fog_compute_service.virtual_machine_extensions.check_vm_extension_exists('<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>')
+```
+
+## Create Virtual Machine Extension
+
+Installs an extension to the specified virtual machine.
+
+```ruby
+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
+)
+```
+
+## Get Extension from Virtual Machine
+
+Retrieves the given extension from the virtual machine
+
+```ruby
+vm_extension = fog_compute_service.virtual_machine_extensions.get(
+        '<Resource Group Name>', '<Virtual Machine Name>', '<Extension Name>'
+)
+```
+
+## Update Extension
+
+Update the given extension. The attributes that can be modified are
+- auto_upgrade_minor_version
+- settings
+- protected_settings
+
+```ruby
+vm_extension.update(
+        auto_upgrade_minor_version: <True/False>,
+        settings: {JSON object},
+        protected_settings: {JSON object}
+)
+```
+
+## Destroy Extension
+
+Destroy the given extension from the virtual machine
+
+```ruby
+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.