fog-azure-rm 0.0.4 → 0.0.5

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

@@ -585,210 +585,218 @@ Get a load balancer object from the get method and then destroy that load balanc
     lb.destroy
 ```
 
-## Create Traffic Manager Profile
+## Create Virtual Network Gateway
 
-Create a new Traffic Manager Profile. The parameter, traffic_routing_method can be Performance, Weighted or Priority.
+Create a new Virtual Network Gateway.
 
 ```ruby
-      profile = azure_network_service.traffic_manager_profiles.create(
-        name: '<Profile Name>',
-        resource_group: '<Resource Group Name>',
-        traffic_routing_method: 'Performance',
-        relative_name: '<Profile Relative Name>',
-        ttl: '30',
-        protocol: 'http',
-        port: '80',
-        path: '/monitorpage.aspx'
-      )
+    network_gateway = network.virtual_network_gateways.create(
+      name: '<Virtual Network Gateway Name>',
+      location: 'eastus',
+      tags: {
+        key1: 'value1',
+        key2: 'value2'
+      },
+      ip_configurations: [
+        {
+          name: 'default',
+          private_ipallocation_method: 'Dynamic',
+          public_ipaddress_id: '/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Network/publicIPAddresses/{public_ip_name}',
+          subnet_id: '/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Network/virtualNetworks/{virtual_network_name}/subnets/{subnet_name}',
+          private_ipaddress: nil
+        }
+      ],
+      resource_group: 'learn_fog',
+      sku_name: 'Standard',
+      sku_tier: 'Standard',
+      sku_capacity: 2,
+      gateway_type: 'ExpressRoute',
+      enable_bgp: true,
+      gateway_size: nil,
+      asn: 100,
+      bgp_peering_address: nil,
+      peer_weight: 3,
+      vpn_type: 'RouteBased',
+      vpn_client_address_pool: [],
+      gateway_default_site: '/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Network/localNetworkGateways/{local_network_gateway_name}',
+      default_sites: [],
+      vpn_client_configuration: {
+        address_pool: ['192.168.0.4', '192.168.0.5'],
+        root_certificates: [
+          {
+            name: 'root',
+            public_cert_data: 'certificate data'
+          }
+        ],
+        revoked_certificates: [
+          {
+            name: 'revoked',
+            thumbprint: 'thumb print detail'
+          }
+        ]
+      }
+    )
 ```
 
-## List Traffic Manager Profiles
+## List Virtual Network Gateways
 
-List Traffic Manager Profiles in a resource group
+List all virtual network gateways in a resource group
 
 ```ruby
-    profiles  = azure_network_service.traffic_manager_profiles(resource_group: '<Resource Group name>')
-    profiles.each do |profile|
-      puts "#{profile.name}"
-    end
+    network_gateways = network.virtual_network_gateways(resource_group: '<Resource Group Name>')
+	network_gateways.each do |gateway|
+    	puts "#{gateway.name}"
+	end
 ```
 
-## Retrieve a single Traffic Manager Profile
+## Retrieve single Virtual Network Gateway
 
-Get a single record of Traffic Manager Profile
+Get single record of Virtual Network Gateway
 
 ```ruby
-     profile = azure_network_service
-               .traffic_manager_profiles(resource_group: '<Resource Group name>')
-                .get('<Profile name>')
-     puts "#{profile.name}"
+    network_gateway = network.virtual_network_gateways.get('<Resource Group Name>', '<Virtual Network Gateway Name>')
+	puts "#{network_gateway.name}"
 ```
 
-## Destroy a single Traffic Manager Profile
+## Destroy single Virtual Network Gateway
 
-Get a Traffic Manager Profile object from the get method and then destroy that Traffic Manager Profile.
+Get a virtual network gateway object from the get method and then destroy that virtual network gateway.
 
 ```ruby
-     profile.destroy
+	network_gateway.destroy
 ```
 
-## Create Traffic Manager Endpoint
+## Express Route
+
+Microsoft Azure ExpressRoute lets you extend your on-premises networks into the Microsoft cloud over a dedicated private connection facilitated by a connectivity provider.
+For more details about express route [click here](https://azure.microsoft.com/en-us/documentation/articles/expressroute-introduction/).
+
+# Express Route Circuit
+
+The Circuit represents the entity created by customer to register with an express route service provider with intent to connect to Microsoft.
+
+## Create an Express Route Circuit
 
-Create a new Traffic Manager Endpoint. The parameter, type can be external, azure or nested.
+Create a new Express Route Circuit.
 
 ```ruby
-      profile = azure_network_service.traffic_manager_end_points.create(
-        name: '<Endpoint Name>',
-        traffic_manager_profile_name: '<Profile Name>',
-        resource_group: '<Resource Group Name>',
-        type: 'external',
-        target: 'test.com',
-        endpoint_location: 'West US'
-      )
+    circuit = network.express_route_circuits.create(
+    	"name": "<Circuit Name>",
+    	"location": "eastus",
+    	"resource_group": "<Resource Group Name>",
+    	"tags": {
+    		"key1": 'value1',
+    		"key2": 'value2'
+  		},
+    	"sku_name": "Standard_MeteredData",
+    	"sku_tier": "Standard",
+    	"sku_family": "MeteredData",
+    	"service_provider_name": "Telenor",
+    	"peering_location": "London",
+    	"bandwidth_in_mbps": 100,
+    	"peerings": [
+        	{
+            	"name": "AzurePublicPeering",
+            	"peering_type": "AzurePublicPeering",
+            	"peer_asn": 100,
+            	"primary_peer_address_prefix": "192.168.1.0/30",
+            	"secondary_peer_address_prefix": "192.168.2.0/30",
+            	"vlan_id": 200
+        	}
+    	]
+	)
 ```
 
-## List Traffic Manager Endpoints
+## List Express Route Circuits
 
-List Traffic Manager Endpoints in a resource group
+List all express route circuits in a resource group
 
 ```ruby
-    endpoints  = azure_network_service.traffic_manager_end_points(resource_group: '<Resource Group name>', traffic_manager_profile_name: '<Profile Name>')
-    endpoints.each do |endpoint|
-      puts "#{endpoint.name}"
-    end
+    circuits  = network.express_route_circuits(resource_group: '<Resource Group Name>')
+	circuits.each do |circuit|
+    	puts "#{circuit.name}"
+	end
 ```
 
-## Retrieve a single Traffic Manager Endpoint
+## Retrieve a single Express Route Circuit
 
-Get a single record of Traffic Manager Endpoint
+Get a single record of Express Route Circuit
 
 ```ruby
-      endpoint = azure_network_service
-                 .traffic_manager_end_points(resource_group: '<Resource Group name>', traffic_manager_profile_name: '<Profile Name>')
-                 .get('<Endpoint name>')
-      puts "#{endpoint.name}"
+    circuit = network.express_route_circuits.get("<Resource Group Name>", "<Circuit Name>")
+	puts "#{circuit.name}"
 ```
 
-## Destroy a single Traffic Manager Endpoint
+## Destroy a single Express Route Circuit
 
-Get a Traffic Manager Endpoint object from the get method and then destroy that Traffic Manager Endpoint.
+Get an express route circuit object from the get method and then destroy that express route circuit.
 
 ```ruby
-     endpoint.destroy
+    circuit.destroy
 ```
 
-## Create Application Gateway
+# Express Route Peering
+
+BGP Peering is part of Express Route circuit and defines the type of connectivity needed with Microsoft.
 
-Create a new Application Gateway.
+## Create an Express Route Circuit Peering
+
+Create a new Express Route Circuit Peering.
 
 ```ruby
-    gateway = azure_network_service.application_gateways.create(
-        name: '<Gateway Name>',
-        location: 'eastus',
-        resource_group: '<Resource Group name>',
-        sku_name: 'Standard_Medium',
-        sku_tier: 'Standard',
-        sku_capacity: '2',
-        gateway_ip_configurations:
-            [
-                {
-                    name: 'gatewayIpConfigName',
-                    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: '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'
-                }
-            ],
-        frontend_ports:
-            [
-                {
-                    name: 'frontendPort',
-                    port: 443
-                }
-            ],
-        backend_address_pools:
-            [
-                {
-                    name: 'backendAddressPool',
-                    ip_addresses: [
-                        {
-                            ipAddress: '10.0.1.6'
-                        }
-                    ]
-                }
-            ],
-        backend_http_settings_list:
-            [
-                {
-                    name: 'gateway_settings',
-                    port: 80,
-                    protocol: 'Http',
-                    cookie_based_affinity: 'Enabled',
-                    request_timeout: '30'
-                }
-            ],
-        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',
-                    host_name: '',
-                    require_server_name_indication: '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',
-                    url_path_map: ''
-                }
-            ]
+    peering = network.express_route_circuit_peerings.create(
+    	"name": "AzurePrivatePeering",
+    	"circuit_name": "<Circuit Name>",
+    	"resource_group": "<Resourse Group Name>",
+    	"peering_type": "AzurePrivatePeering",
+    	"peer_asn": 100,
+    	"primary_peer_address_prefix": "192.168.3.0/30",
+    	"secondary_peer_address_prefix": "192.168.4.0/30",
+    	"vlan_id": 200
+	)
+```
 
+## List Express Route Circuit Peerings
 
-    )
+List all express route circuit peerings in a resource group
+
+```ruby
+    peerings  = network.express_route_circuit_peerings(resource_group: '<Resource Group Name>', circuit_name: '<Circuit Name>')
+	peerings.each do |peering|
+    	puts "#{peering.name}"
+	end
 ```
 
-## List Application Gateways
+## Retrieve single Express Route Circuit Peering
 
-List all application gateways in a resource group
+Get a single record of Express Route Circuit Peering
 
 ```ruby
-    gateways = azure_network_service.application_gateways(resource_group: '<Resource Group Name>')
-    gateways.each do |gateway|
-        puts "#{gateway.name}"
-    end
+    peering = network.express_route_circuit_peerings.get("<Resource Group Name>", "<Peering Name>", "Circuit Name")
+	puts "#{peering.peering_type}"
 ```
 
-## Retrieve a single Application Gateway
+## Destroy single Express Route Circuit Peering
 
-Get a single record of Application Gateway
+Get an express route circuit peering object from the get method and then destroy that express route circuit peering.
 
 ```ruby
-    gateway = azure_network_service
-                            .application_gateways(resource_group: '<Resource Group name>')
-                            .get('<Application Gateway Name>')
-    puts "#{gateway.name}"
+    peering.destroy
 ```
 
-## Destroy a single Application Gateway
+# Express Route Service Provider
+
+Express Route Service Providers are telcos and exchange providers who are approved in the system to provide Express Route connectivity.
 
-Get a application gateway object from the get method and then destroy that application gateway.
+## List Express Route Service Providers
+
+List all express route service providers
 
 ```ruby
-    gateway.destroy
+    service_providers = network.express_route_service_providers
+	puts service_providers
 ```
 
+
 ## 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/resources.md

@@ -74,7 +74,7 @@ You can tag a Resource as following:
 ## List Tagged Resources in a Subscription
 
 ```ruby
-    azure_resources_service.resources(tag_name: '<Tag-Key>', tag_value: '<Tag-Value>').each do |resource|
+    azure_resources_service.azure_resources(tag_name: '<Tag-Key>', tag_value: '<Tag-Value>').each do |resource|
         puts "#{resource.name}"
         puts "#{resource.location}"
         puts "#{resource.type}"        
@@ -82,7 +82,7 @@ You can tag a Resource as following:
 ```
 OR
 ```ruby
-    azure_resources_service.resources(tag_name: '<Tag-Key>').each do |resource|
+    azure_resources_service.azure_resources(tag_name: '<Tag-Key>').each do |resource|
         puts "#{resource.name}"
         puts "#{resource.location}"
         puts "#{resource.type}"        
@@ -94,7 +94,7 @@ Get a single record of Tagged Resources
 
 ```ruby
     resource = azure_resources_service
-                          .resources(tag_name: '<Tag-Key>')
+                          .azure_resources(tag_name: '<Tag-Key>')
                           .get('<Resource-ID>')
     puts "#{resource.name}"
 ```

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

@@ -60,15 +60,25 @@ Check Storage Account Name Availability.This operation checks that account name
 
 ## Create Storage Account
 
-Create a new 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)
 
 ```ruby
 azure_storage_service.storage_accounts.create(
   :name => '<Storage Account name>',
   :location => 'West US',
-  :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' 
 )
 ```
+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/).
+
 ## List storage accounts
 
 ##### List storage accounts in a subscription
@@ -106,7 +116,9 @@ Get access keys of a storage account
 
 ```ruby
 keys_hash = storage_acc.get_access_keys
-puts "#{keys_hash['key1']} #{keys_hash['key2']}"
+keys_hash.each do |keys|
+  puts "#{keys.key_name}:  #{keys.value}"
+end
 ```
 
 ## Destroy a single Storage Account

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

@@ -0,0 +1,118 @@
+# Traffic Manager
+
+This document explains how to get started using Azure Traffic Manager Service with Fog. With this gem you can create/update/list/delete Traffic Manager Profiles and End Points.
+
+## 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 Traffic Manager Service:
+
+```ruby
+    azure_traffic_manager_service = Fog::TrafficManager::AzureRM.new(
+        tenant_id: '<Tenantid>',                  # Tenant id of Azure Active Directory Application
+        client_id:    '<Clientid>',               # Client id of Azure Active Directory Application
+        client_secret: '<ClientSecret>',          # Client Secret of Azure Active Directory Application
+        subscription_id: '<Subscriptionid>'       # Subscription id of an Azure Account
+)
+```
+
+## Create Traffic Manager Profile
+
+Create a new Traffic Manager Profile. The parameter 'traffic_routing_method' can be 'Performance', 'Weighted' or 'Priority'.
+
+```ruby
+      profile = azure_traffic_manager_service.traffic_manager_profiles.create(
+        name: '<Profile Name>',
+        resource_group: '<Resource Group Name>',
+        traffic_routing_method: 'Performance',
+        relative_name: '<Profile Relative Name>',
+        ttl: '30',
+        protocol: 'http',
+        port: '80',
+        path: '/monitorpage.aspx'
+      )
+```
+
+## List Traffic Manager Profiles
+
+List Traffic Manager Profiles in a resource group
+
+```ruby
+    profiles  = azure_traffic_manager_service.traffic_manager_profiles(resource_group: '<Resource Group name>')
+    profiles.each do |profile|
+      puts "#{profile.name}"
+    end
+```
+
+## Retrieve a single Traffic Manager Profile
+
+Get a single record of Traffic Manager Profile
+
+```ruby
+     profile = azure_traffic_manager_service
+               .traffic_manager_profiles
+                .get('<Resource Group name>', '<Profile name>')
+     puts "#{profile.name}"
+```
+
+## Destroy a single Traffic Manager Profile
+
+Get a Traffic Manager Profile object from the get method and then destroy that Traffic Manager Profile.
+
+```ruby
+     profile.destroy
+```
+
+## Create Traffic Manager Endpoint
+
+Traffic Manager Profile is pre-requisite of Traffic Manager Endpoint. Create a new Traffic Manager Endpoint. The parameter 'type' can be 'externalEndpoints, 'azureEndpoints' or 'nestedEndpoints'.
+
+```ruby
+      endpoint = azure_network_service.traffic_manager_end_points.create(
+        name: '<Endpoint Name>',
+        traffic_manager_profile_name: '<Profile Name>',
+        resource_group: '<Resource Group Name>',
+        type: 'externalEndpoints',
+        target: 'test.com',
+        endpoint_location: 'West US'
+      )
+```
+
+## List Traffic Manager Endpoints
+
+List Traffic Manager Endpoints in a resource group.
+
+```ruby
+    endpoints  = azure_traffic_manager_service.traffic_manager_end_points(resource_group: '<Resource Group name>', traffic_manager_profile_name: '<Profile Name>')
+    endpoints.each do |endpoint|
+      puts "#{endpoint.name}"
+    end
+```
+
+## Retrieve a single Traffic Manager Endpoint
+
+Get a single Traffic Manager Endpoint.
+
+```ruby
+      endpoint = azure_traffic_manager_service
+                 .traffic_manager_end_points
+                 .get('<Resource Group name>', '<Profile Name>', '<Endpoint name>', '<Endpoint type>')
+      puts "#{endpoint.name}"
+```
+
+## Destroy a single Traffic Manager Endpoint
+
+Get a Traffic Manager Endpoint object from the get method and then destroy that Traffic Manager Endpoint.
+
+```ruby
+     endpoint.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.