fog-azure-rm 0.3.7 → 0.3.8

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

@@ -1,6 +1,6 @@
-#Resources
+# Resources
 
-This document explains how to get started using Azure Resources Service with Fog. With this gem you can create/update/list/delete resource groups.
+This document explains how to get started using Azure Resources Service with Fog. With this gem you can create, update, list or delete resource groups.
 
 ## Usage
 
@@ -15,19 +15,19 @@ require 'fog/azurerm'
 Next, create a connection to the Resources Service:
 
 ```ruby
-    azure_resources_service = Fog::Resources::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_resources_service = Fog::Resources::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 Resource Group Existence
 
 ```ruby
- azure_resources_service.resource_groups.check_resource_group_exists(<Resource Group name>)
+fog_resources_service.resource_groups.check_resource_group_exists('<Resource Group Name>')
 ```
 
 ## Create Resource Group
@@ -35,19 +35,19 @@ Next, create a connection to the Resources Service:
 Create a new resource group
 
 ```ruby
-    azure_resources_service.resource_groups.create(
+fog_resources_service.resource_groups.create(
         name:     '<Resource Group name>',
         location: '<Location>',
-        tags: { key1: "value1", key2: "value2", keyN: "valueN" }                        # [Optional]
- )
+        tags:     { key1: 'value1', key2: 'value2', keyN: 'valueN' }                        # [Optional]
+)
 ```
 ## List Resource Groups
 
 ```ruby
-    azure_resources_service.resource_groups.each do |resource_group|
+fog_resources_service.resource_groups.each do |resource_group|
         puts "#{resource_group.name}"
         puts "#{resource_group.location}"
-    end
+end
 ```
 
 ## Retrieve a single Resource Group
@@ -55,10 +55,10 @@ Create a new resource group
 Get a single record of Resource Group
 
 ```ruby
-      resource_group = azure_resources_service
+resource_group = fog_resources_service
                           .resource_groups
-                          .get('<Resource Group name>')
-      puts "#{resource_group.name}"
+                          .get('<Resource Group Name>')
+puts "#{resource_group.name}"
 ```
 
 ## Destroy a single Resource Group
@@ -66,71 +66,71 @@ Get a single record of Resource Group
 Get resource group object from the get method(described above) and then destroy that resource group.
 
 ```ruby
-      resource_group.destroy
+resource_group.destroy
 ```
 ## Tagging a Resource
 
 You can tag a Resource as following:
 
 ```ruby
-    azure_resources_service.tag_resource(
-        '<Resource-ID>',
-        '<Tag-Key>',
-        '<Tag-Value>',
-        '<API-Version>'
-    )
+fog_resources_service.tag_resource(
+        '<Resource Id>',
+        '<Tag Key>',
+        '<Tag Value>',
+        '<API Version>'
+)
 ```
 
 ## List Tagged Resources in a Subscription
 
 ```ruby
-    azure_resources_service.azure_resources(tag_name: '<Tag-Key>', tag_value: '<Tag-Value>').each do |resource|
+fog_resources_service.azure_resources(tag_name: '<Tag Key>', tag_value: '<Tag Value>').each do |resource|
         puts "#{resource.name}"
         puts "#{resource.location}"
         puts "#{resource.type}"        
-    end
+end
 ```
 OR
 ```ruby
-    azure_resources_service.azure_resources(tag_name: '<Tag-Key>').each do |resource|
+fog_resources_service.azure_resources(tag_name: '<Tag Key>').each do |resource|
         puts "#{resource.name}"
         puts "#{resource.location}"
         puts "#{resource.type}"        
-    end
+end
 ```
 ## Retrieve a single Resource
 
 Get a single record of Tagged Resources
 
 ```ruby
-    resource = azure_resources_service
-                          .azure_resources(tag_name: '<Tag-Key>')
-                          .get('<Resource-ID>')
-    puts "#{resource.name}"
+resource = fog_resources_service
+                          .azure_resources(tag_name: '<Tag Key>')
+                          .get('<Resource Id>')
+puts "#{resource.name}"
 ```
 ## Remove tag from a Resource
 
 Remove tag from a resource as following:
 
 ```ruby
-    azure_resources_service.delete_resource_tag(
-        '<Resource-ID>',
-        '<Tag-Key>',
-        '<Tag-Value>',
-        '<API-Version>'
-        )
+fog_resources_service.delete_resource_tag(
+        '<Resource Id>',
+        '<Tag Key>',
+        '<Tag Value>',
+        '<API Version>'
+)
 ```
 
 ## Check Resource Existence
 
 ```ruby
- azure_resources_service.azure_resources.check_azure_resource_exists(<Resource-ID>, <API-Version>)
+fog_resources_service.azure_resources.check_azure_resource_exists('<Resource Id>', '<API Version>')
 ```
 
 ## Check Deployment Existence
 
 ```ruby
- azure_resources_service.deployments.check_deployment_exists(<Resource Group Name>, <Deployment name>)
+fog_resources_service.deployments.check_deployment_exists('<Resource Group Name>', '<Deployment Name>')
 ```
 
 ## Create Deployment
@@ -138,21 +138,21 @@ Remove tag from a resource as following:
 Create a Deployment
 
 ```ruby
-    azure_resources_service.deployments.create(
-        name:            '<Deployment name>',
-        resource_group:  '<Resource Group name>',
+fog_resources_service.deployments.create(
+        name:            '<Deployment Name>',
+        resource_group:  '<Resource Group Name>',
         template_link:   '<Template Link>',
         parameters_link: '<Parameters Link>'
- )
+)
 ```
 ## List Deployments
 
 List Deployments in a resource group
 
 ```ruby
-    azure_resources_service.deployments(resource_group: '<Resource Group Name>').each do |deployment|
+fog_resources_service.deployments(resource_group: '<Resource Group Name>').each do |deployment|
         puts "#{deployment.name}"
-    end
+end
 ```
 
 ## Retrieve a single Deployment
@@ -160,10 +160,10 @@ List Deployments in a resource group
 Get a single record of Deployment
 
 ```ruby
-      deployment = azure_resources_service
-                          .deployments
-                          .get('<Resource Group name>', '<Deployment name>')
-      puts "#{deployment.name}"
+deployment = fog_resources_service
+                       .deployments
+                       .get('<Resource Group Name>', '<Deployment Name>')
+puts "#{deployment.name}"
 ```
 
 ## Destroy a single Deployment
@@ -171,7 +171,7 @@ Get a single record of Deployment
 Get Deployment object from the get method(described above) and then destroy that Deployment.
 
 ```ruby
-      deployment.destroy
+deployment.destroy
 ```
 
 ## Support and Feedback

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

@@ -1,4 +1,4 @@
-#Azure SQL
+# Azure SQL
 
 This document explains how to get started using Azure SQL Services with Fog.
 
@@ -15,16 +15,16 @@ require 'fog/azurerm'
 Next, create a connection to the SQL Service:
 
 ```ruby
-    azure_sql_service = Fog::Sql::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_sql_service = Fog::Sql::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.
+)
 ```
 
-The {server-name} and {database-name} value must be set using all lowercase ANSI letters , hyphen, and the numbers 1 through 9. Do not use a hyphen as the leading or trailing character.
+The _server-name_ and _database-name_ value must be set using all lowercase ANSI letters , hyphen, and the numbers 1 through 9. Do not use a hyphen as the leading or trailing character.
 
 
 ## Create SQL Server
@@ -32,25 +32,25 @@ The {server-name} and {database-name} value must be set using all lowercase ANSI
 Create a new Server
 
 ```ruby
-    azure_sql_service.sql_servers.create(
+fog_sql_service.sql_servers.create(
         name: '<Unique Server Name>',
         resource_group: '<Resource Group Name>',
-        location: 'East US',
-        version: '2.0',                                                                     # Specifies the version of the Azure server. The acceptable value are: '2.0' or '12.0'
-        administrator_login: 'testserveradmin',                                             # Specifies the name of the SQL administrator.
-        administrator_login_password: 'svr@admin123',                                       # Specifies the password of the SQL administrator.
-        tags: { key1: "value1", key2: "value2", keyN: "valueN" }                            # [Optional]
-    )
+        location: '<Location>',
+        version: '<Version Number>',                                                        # Specifies the version of the Azure server. The acceptable value are: '2.0' or '12.0'
+        administrator_login: '<Admin Username>',                                            # Specifies the name of the SQL administrator.
+        administrator_login_password: '<Admin Password>',                                   # Specifies the password of the SQL administrator.
+        tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' }                            # [Optional]
+)
 ```
 For more information, see link: https://msdn.microsoft.com/en-us/library/azure/mt297738.aspx
 
 ## List SQL Servers
 Get a list of servers in given resource group
 ```ruby
-    servers  = azure_sql_service.sql_servers(resource_group: '<Resource Group Name>')
-    servers.each do |server|
-      puts "Listing : #{server.name}"
-    end
+servers  = fog_sql_service.sql_servers(resource_group: '<Resource Group Name>')
+servers.each do |server|
+    puts "Listing : #{server.name}"
+end
 ```
 
 ## Retrieve a single SQL Server
@@ -58,9 +58,9 @@ Get a list of servers in given resource group
 Get a single record of SQL Server
 
 ```ruby
-     server = azure_sql_service.sql_servers
-                   .get('<Resource Group Name>', '<Server Name>')
-     puts "Server Name: #{server.name}"
+server = fog_sql_service.sql_servers
+              .get('<Resource Group Name>', '<Server Name>')
+puts "Server Name: #{server.name}"
 ```
 
 ## Destroy a SQL Server
@@ -68,33 +68,33 @@ Get a single record of SQL Server
 Get SQL Server object from the get method(described above) and destroy that Server.
 
 ```ruby
-      server.destroy
+server.destroy
 ```
 
 ## Create SQL Database
 
 Creates a new Sql Database
 
-In parameter {create_mode}: 'Copy', 'NonReadableSecondary', and 'OnlineSecondary' are not supported by SQL Data Warehouse.
+In parameter _create_mode_: 'Copy', 'NonReadableSecondary', and 'OnlineSecondary' are not supported by SQL Data Warehouse.
 
-If parameter {edition} is set to DataWarehouse, the acceptable values for parameter {requested_service_objective_name} are: ['DW100', 'DW200', 'DW300', 'DW400', 'DW500', 'DW600', 'DW1000', 'DW1200', 'DW1500', 'DW2000', 'DW3000', 'DW6000'] 
+If parameter _edition_ is set to DataWarehouse, the acceptable values for parameter _requested_service_objective_name_ are: ['DW100', 'DW200', 'DW300', 'DW400', 'DW500', 'DW600', 'DW1000', 'DW1200', 'DW1500', 'DW2000', 'DW3000', 'DW6000'] 
 
 ```ruby
-    azure_sql_service.sql_databases.create(
+fog_sql_service.sql_databases.create(
         resource_group: '<Resource Group Name>',
-        location: 'East US',
+        location: '<Location>',
         server_name: '<Server Name>',
         name: '<Database Name>',
-        create_mode: '<Create Mode>',                                                       # Optional. Specifies the type of database to create. The default value is Default. The acceptable values are: [Copy, Default, NonReadableSecondary, OnlineSecondary, PointInTimeRestore, PointInTimeRestore, Restore]
-        edition: '<Edition>',                                                               # Conditional. Specifies the edition of the database. If createMode is set to Default, then this value must be specified. The acceptable value are: [Basic, Standard, Premium, DataWarehouse]
+        edition: '<Edition Type>',                                                          # Conditional. Specifies the edition of the database. If createMode is set to Default, then this value must be specified. The acceptable value are: [Basic, Standard, Premium, DataWarehouse]
         source_database_id: '<URI>',                                                        # Conditional. Specifies the URI of the source database. If createMode is not set to Default, then this value must be specified.
         collation: '<Collation>',                                                           # Conditional. Specifies the name of the collation. If createMode is set to Default, then this value must be specified. 
-        max_size_bytes: '<Size>',                                                           # Conditional. Specifies the maximum size to which the database may grow. If createMode is set to Default, then this value must be specified.
+        max_size_bytes: '<Size in Bytes>',                                                  # Conditional. Specifies the maximum size to which the database may grow. If createMode is set to Default, then this value must be specified.
         requested_service_objective_name: '<Name>',                                         # Conditional. Specifies the requested service level of the database. If requestedServiceObjectiveId is specified, then this value must not be specified. The acceptable value are: [Basic, S0, S1, S2, S3, P1, P2, P4, P6, P11, ElasticPool]
         elastic_pool_name: '<Pool Name>',                                                   # Conditional. Specifies the name of the elastic database pool. If requestedServiceObjectiveId or requestedServiceObjectiveName is set to ElasticPool, then this value must be specified.
         requested_service_objective_id: '<GUID>',                                           # Conditional. Specifies the identifier of the requested service level. If requestedServiceObjectiveName is specified, then this value must not be specified.
-        tags: { key1: "value1", key2: "value2", keyN: "valueN" }                            # [Optional]
-    )
+        tags: { key1: 'value1', key2: 'value2', keyN: 'valueN' },                           # [Optional]
+        create_mode: '<Create Mode Type>'                                                   # [Optional]. Specifies the type of database to create. The default value is Default. The acceptable values are: [Copy, Default, NonReadableSecondary, OnlineSecondary, PointInTimeRestore, PointInTimeRestore, Restore]
+)
 ```
 For more information see link: https://msdn.microsoft.com/en-us/library/azure/mt163685.aspx  
 
@@ -102,10 +102,10 @@ For more information see link: https://msdn.microsoft.com/en-us/library/azure/mt
 Get a list of databases in given resource group
 
 ```ruby
-    databases  = azure_sql_service.sql_databases(resource_group: '<Resource Group Name>', server_name: '<Server Name>')
-    databases.each do |database|
-      puts "Listing : #{database.name}"
-    end
+databases  = fog_sql_service.sql_databases(resource_group: '<Resource Group Name>', server_name: '<Server Name>')
+databases.each do |database|
+   puts "Listing : #{database.name}"
+end
 ```
 
 ## Retrieve a single SQL Database
@@ -113,17 +113,17 @@ Get a list of databases in given resource group
 Get a single record of SQL Database
 
 ```ruby
-     database = azure_sql_service.sql_databases
-                   .get('<Resource Group Name>', '<Server Name>', '<Database Name>')
-     puts "Database Name: #{database.name}"
+database = fog_sql_service.sql_databases
+                .get('<Resource Group Name>', '<Server Name>', '<Database Name>')
+puts "Database Name: #{database.name}"
 ```
 
-## Destroy a SQL Database
+## Destroy a single SQL Database
 
 Get SQL Database object from the get method(described above) and destroy that Database.
 
 ```ruby
-      database.destroy
+database.destroy
 ```
 
 ## Create Firewall Rule
@@ -131,38 +131,38 @@ Get SQL Database object from the get method(described above) and destroy that Da
 Create a new Firewall Rule
 
 ```ruby
-    azure_sql_service.firewall_rules.create(
+fog_sql_service.firewall_rules.create(
         name: '<Firewall Rule Name>',
         resource_group: '<Resource Group Name>',
         server_location: '<Server Name>',
         start_ip: '<Start IP Address>',           # Specifies the starting IP address to allow through the firewall.
         end_ip: '<End IP Address>',               # Specifies the ending IP address to allow through the firewall.
         
-    )
+)
 ```
 
 ## List Firewall Rules
 Get a list of Firewall Rules on a SQL Server in given resource group
 ```ruby
-    firewall_rules  = azure_sql_service.firewall_rules(resource_group: '<Resource Group Name>', server_name: '<Server Name>')
-    firewall_rules.each do |firewall_rule|
-      puts "Listing : #{firewall_rule.name}"
-    end
+firewall_rules  = fog_sql_service.firewall_rules(resource_group: '<Resource Group Name>', server_name: '<Server Name>')
+firewall_rules.each do |firewall_rule|
+    puts "Listing : #{firewall_rule.name}"
+end
 ```
 
 ## Retrieve a single Firewall Rule
 Get a single record of Firewall rule on SQL Server
 ```ruby
-     firewall_rule = azure_sql_service.firewall_rules
+firewall_rule = fog_sql_service.firewall_rules
                    .get('<Resource Group Name>', '<Server Name>', '<Firewall Rule Name>')
-     puts "Get: Firewall Rule Name: #{firewall_rule.name}"
+puts "Get: Firewall Rule Name: #{firewall_rule.name}"
 ```
 
 ## Destroy a Firewall Rule
 Get Firewall Rule object from the get method(described above) and destroy that Firewall Rule.
 
 ```ruby
-      firewall_rule.destroy
+firewall_rule.destroy
 ```
 
 

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

@@ -1,6 +1,6 @@
-#Storage
+# Storage
 
-This document explains how to get started using Azure Storage Service with Fog. With this gem you can create/update/list/delete storage accounts.
+This document explains how to get started using Azure Storage Service with Fog. With this gem you can create, update, list or delete storage accounts.
 
 ## Usage
 
@@ -15,75 +15,76 @@ require 'fog/azurerm'
 Next, create a connection to the Storage Service:
 
 ```ruby
-azure_storage_service = Fog::Storage::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
-  azure_storage_account_name: '<StorageAccountName>',                            # Name of an Azure Storage Account
-  azure_storage_access_key: '<StorageAccountKey>',                               # Key of an Azure Storage Account
-  environment: '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>' # Azure cloud environment. Default is AzureCloud.
+fog_storage_service = Fog::Storage::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
+  azure_storage_account_name: '<Storage Account Name>',                              # Name of an Azure Storage Account
+  azure_storage_access_key: '<Storage Account Key>',                                 # Key of an Azure Storage Account
+  environment: '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'     # Azure cloud environment. Default is AzureCloud.
 )
 ```
 
 If you only want to manage the storage accounts, you can create the connection without the storage account information:
 
 ```ruby
-azure_storage_service = Fog::Storage.new(
-  provider:         'AzureRM',
-  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_storage_service = Fog::Storage::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.
 )
 ```
 
 If you only want to manage the storage data, you can create the connection without the Azure subscription information:
 
 ```ruby
-azure_storage_service = Fog::Storage.new(
-  :provider => 'AzureRM',
-  :azure_storage_account_name => '<StorageAccountName>',                            # Name of an Azure Storage Account
-  :azure_storage_access_key => '<StorageAccountKey>',                               # Key of an Azure Storage Account
-  :environment => '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>' # Azure cloud environment. Default is AzureCloud.
+fog_storage_service = Fog::Storage::AzureRM.new(
+  azure_storage_account_name:   '<Storage Account Name>',                                             # Name of an Azure Storage Account
+  azure_storage_access_key:     '<Storage Account Key>',                                              # Key of an Azure Storage Account
+  environment:                  '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'     # Azure cloud environment. Default is AzureCloud.
 )
 ```
 
 ## Check Name Availability 
 
-Check Storage Account Name Availability.This operation checks that account name is valid and is not already in use.
-_Storage Account Type_ is an optional parameter
+This operation checks that account name is valid and is not already in use. _Storage Account Type_ is an optional parameter
 
 ```ruby
-azure_storage_service.storage_accounts.check_name_availability(<Storage Account name>, <Storage Account Type>)
+fog_storage_service.storage_accounts.check_name_availability('<Storage Account Name>', '<Storage Account Type>')
 ```
 
 ## Check Storage Account Existence
 
 ```ruby
-azure_storage_service.storage_accounts.check_storage_account_exists(<Resource Group name>, <StorageAccountName>)
+fog_storage_service.storage_accounts.check_storage_account_exists('<Resource Group Name>', '<Storage Account Name>')
 ```
 
 ## Create Storage Account
 
 Create a new storage account. Replication attribute for Standard and Premium account types are as follows 
 
-Standard: LRS (Standard Locally-redundant storage)
-          ZRS (Standard Zone-redundant storage)
-          GRS (Standard Geo-redundant storage)
-          RAGRS (Standard Read access geo-redundant storage)
-Premium:  LRS (Premium Locally-redundant storage)
+##### Standard 
+
+1. LRS (Standard Locally-redundant storage)
+2. ZRS (Standard Zone-redundant storage)
+3. GRS (Standard Geo-redundant storage)
+4. RAGRS (Standard Read access geo-redundant storage)
+
+##### Premium
+1. LRS (Premium Locally-redundant storage)
 
 ```ruby
-azure_storage_service.storage_accounts.create(
+fog_storage_service.storage_accounts.create(
   name:           '<Storage Account name>',
   location:       '<Location>',
-  resource_group: '<Resource Group name>',
+  resource_group: '<Resource Group Name>',
   account_type:   '<Standard/Premium>',                                   # [Optional] Default value 'Standard'. Allowed values can only be Standard or Premium
-  replication:    'LRS',                                                  # [Optional] Default value 'LRS'
-  encryption:     true,                                                   # [Optional] Enables encryption. Default is false.
-  tags:           { key1: "value1", key2: "value2", keyN: "valueN" }      # [Optional]
+  replication:    '<Replication Type>',                                    # [Optional] Default value 'LRS'
+  encryption:     <True/False>,                                           # [Optional] Enables encryption. Default is false.
+  tags:           { key1: 'value1', key2: 'value2', keyN: 'valueN' }       # [Optional]
 )
 ```
 Premium Storage account store data on solid state drives (SSDs). For more details on standard and premium storage accounts, see [Introduction to Microsoft Azure Storage](https://azure.microsoft.com/en-us/documentation/articles/storage-introduction/) and [Premium Storage: High-Performance Storage for Azure Virtual Machine Workloads](https://azure.microsoft.com/en-us/documentation/articles/storage-premium-storage/).
@@ -93,7 +94,7 @@ Premium Storage account store data on solid state drives (SSDs). For more detail
 ##### List storage accounts in a subscription
 
 ```ruby
-azure_storage_service.storage_accounts.each do |storage_acc|
+fog_storage_service.storage_accounts.each do |storage_acc|
   puts "#{storage_acc.name}"
   puts "#{storage_acc.location}"
 end
@@ -101,7 +102,7 @@ end
 ##### List storage accounts in a resource group
 
 ```ruby
-storage_accounts  = azure_storage_service.storage_accounts(resource_group: '<Resource Group name>')
+storage_accounts  = fog_storage_service.storage_accounts(resource_group: '<Resource Group Name>')
 storage_accounts.each do |storage_acc|
   puts "#{storage_acc.name}"
   puts "#{storage_acc.location}"
@@ -113,9 +114,9 @@ end
 Get a single record of Storage Account
 
 ```ruby
-storage_acc = azure_storage_service
+storage_acc = fog_storage_service
                 .storage_accounts
-                .get('<Resource Group name>', '<Storage Account name>')
+                .get('<Resource Group Name>', '<Storage Account Name>')
 puts "#{storage_acc.name}"
 ```
 
@@ -124,9 +125,9 @@ puts "#{storage_acc.name}"
 Get a single record of Storage Account and enable encryption on that Storage Account
 
 ```ruby
-storage_acc = azure_storage_service
+storage_acc = fog_storage_service
                 .storage_accounts
-                .get('<Resource Group name>', '<Storage Account name>')
+                .get('<Resource Group Name>', '<Storage Account Name>')
 
 storage_acc.update(encryption: true)
 ```
@@ -152,26 +153,26 @@ storage_acc.destroy
 
 ## Create a Disk
 
-Create a Disk in storage account. disk_size_in_gb must be an integer and the range is [1, 1023].
+Create a Disk in storage account. _disk_size_in_gb_ must be an integer and the range is [1, 1023].
 By default the disk will be created in the container 'vhds'. You can specify other container by set options[:container_name].
 
 ```ruby
-azure_storage_service.create_disk('<Data Disk Name>', disk_size_in_gb, options = {})
+fog_storage_service.create_disk('<Data Disk Name>', disk_size_in_gb, options = {})
 ```
 
 ## Delete a Disk
 
-Delete a Disk from a storage account. Disk must be in unlocked state i.e detached from server(virtual machine) to successfully perform this action.
+Delete a Disk from a storage account. Disk must be in unlocked state i.e detached from server (virtual machine) to successfully perform this action.
 By default the disk will be deleted from the container 'vhds'. You can specify other container by set options[:container_name].
 
 ```ruby
-azure_storage_service.delete_disk('<Data Disk Name>', options = {})
+fog_storage_service.delete_disk('<Data Disk Name>', options = {})
 ```
 
 ## Check Storage Container Existence
 
 ```ruby
-azure_storage_service.directories.check_container_exists(<container name>)
+fog_storage_service.directories.check_container_exists('<Container Name>')
 ```
 
 ## Create a storage container
@@ -179,9 +180,9 @@ azure_storage_service.directories.check_container_exists(<container name>)
 Create a storage container in the current storage account.
 
 ```ruby
-directory = azure_storage_service.directories.create(
-  key: '<container name>',
-  public: true
+directory = fog_storage_service.directories.create(
+   key: '<Container Name>',
+   public: <True/False>
 )
 puts directory.key
 ```
@@ -191,7 +192,7 @@ puts directory.key
 List all the storage containers in the current storage accounts.
 
 ```ruby
-azure_storage_service.directories.each do |directory|
+fog_storage_service.directories.each do |directory|
   puts directory.key
 end
 ```
@@ -201,7 +202,7 @@ end
 Get the permissions for the specified container. The permissions indicate whether container data may be accessed publicly.
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 puts directory.acl
 ```
 
@@ -209,22 +210,22 @@ puts directory.acl
 
 Set the permissions for the specified container. The permissions indicate whether container data may be accessed publicly. The container permissions provide the following options for managing container access:
 
-  - container
+  - ###### Container
 
     Full public read access. Container and blob data can be read via anonymous request. Clients can enumerate blobs within the container via anonymous request, but cannot enumerate containers within the storage account.
 
-  - blob
+  - ###### Blob
 
     Public read access for blobs only. Blob data within this container can be read via anonymous request, but container data is not available. Clients cannot enumerate blobs within the container via anonymous request.
 
-  - nil
+  - ###### Nil
 
     No public read access. Container and blob data can be read by the account owner only.
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
-directory.acl = 'container'
-directory.save(is_create: false)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
+directory.acl = '<Container Name>'
+directory.save(is_create: <True/False>)
 ```
 
 ## Delete the storage container
@@ -232,13 +233,13 @@ directory.save(is_create: false)
 Mark the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection.
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 puts directory.destroy
 ```
 
 ## Upload data as a block blob
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 options = {
   key: '<Blob Name>',
   body: '<Blob Content>'
@@ -249,7 +250,7 @@ puts new_block_blob.inspect
 
 ## Upload a local file as a block blob
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 File.open('<File Path>') do |file|
   options = {
     key: '<Blob Name>',
@@ -262,11 +263,11 @@ end
 
 ## Upload VHD data as a page blob
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 options = {
   key: '<Blob Name>',
   body: '<Blob Content>',
-  blob_type: 'PageBlob'
+  blob_type: '<Blob Type>'
 }
 new_page_blob = directory.files.create(options)
 puts new_page_blob.inspect
@@ -274,12 +275,12 @@ puts new_page_blob.inspect
 
 ## Upload a local VHD as a page blob
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 File.open('<File Path>') do |file|
   options = {
     key: '<Blob Name>',
     body: file,
-    blob_type: 'PageBlob'
+    blob_type: '<Blob Type>'
   }
   new_page_blob = directory.files.create(options)
   puts new_page_blob.inspect
@@ -288,14 +289,14 @@ end
 
 ## Copy Blob from one container to another
 ```ruby
-directory = azure_storage_service.directories.get('<Source Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Source Container Name>', max_keys: <Maximum No. of Keys Value>)
 copied_blob = directory.files.head('<Source Blob Name>').copy('<Destination Container Name>', '<Destination Blob Name>')
 puts copied_blob.inspect
 ```
 
 ## Copy Blob from one uri to self
 ```ruby
-directory = azure_storage_service.directories.get('<Destination Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Destination Container Name>', max_keys: <Maximum No. of Keys Value>)
 copied_blob = directory.files.new(key: '<Destination Blob Name>')
 copied_blob.copy_from_uri('<Source Blob Uri>')
 puts copied_blob.inspect
@@ -303,7 +304,7 @@ puts copied_blob.inspect
 
 ## Download a small blob to a local file
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 blob = directory.files.get('<Blob Name>')
 File.open('<File Path>', 'wb') do |file|
   file.write(blob.body)
@@ -313,7 +314,7 @@ puts "File Size: #{::File.size <File Path>}"
 
 ## Download a large blob to a local file
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 File.open('<File Path>', 'wb') do |file|
   directory.files.get('<Blob Name>') do |chunk, remaining_bytes, total_bytes|
     puts "remaining_bytes: #{remaining_bytes}, total_bytes: #{total_bytes}"
@@ -328,21 +329,21 @@ puts "File Size: #{::File.size <File Path>}"
 Mark the specified blob for deletion. The blob is later deleted during garbage collection.
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 blob = directory.files.head('<Blob Name>')
 puts blob.destroy
 ```
 
-### Set storage blob properties
+## Set storage blob properties
 
 Set the storage blob properties.
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 blob = directory.files.head('<Blob Name>')
-blob.content_language = "English"
-blob.content_disposition = "attachment"
-blob.save(update_body: false)
+blob.content_language = '<Language>'
+blob.content_disposition = '<Content Disposition Type>'
+blob.save(update_body: <True/False>)
 ```
 
 ## Metadata
@@ -352,7 +353,7 @@ Metadata allows us to provide descriptive information about specific containers
 ### Get Blob Metadata
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 blob = directory.files.head('<Blob Name>')
 puts blob.metadata
 ```
@@ -360,33 +361,33 @@ puts blob.metadata
 ### Set Blob Metadata
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 blob = directory.files.head('<Blob Name>')
 blob.metadata = {
-  "Category" => "Images",
-  "Resolution" => "High"
+  Category: '<Category Value>',
+  Resolution: '<Resolution Value>'
 }
-blob.save(update_body: false)
+blob.save(update_body: <True/False>)
 ```
 
 ### Get Container Metadata
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 puts directory.metadata
 ```
 
 ### Set Container Metadata
 
 ```ruby
-directory = azure_storage_service.directories.get('<Container Name>', max_keys: 1)
+directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
 directory.metadata = {
-  "CreatedBy" => "User",
-  "SourceMachine" => "Mymachine",
-  "category" => "guidance",
-  "docType" => "textDocuments"
-  }
-directory.save(is_create: false)
+  CreatedBy: '<Username>',
+  SourceMachine: '<Machine Name>',
+  category: '<Category Value>',
+  docType: '<Document Type>'
+}
+directory.save(is_create: <True/False>)
 ```
 
 ## Support and Feedback