fog-azure-rm 0.1.2 → 0.2.0

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

@@ -0,0 +1,88 @@
+# Key Vault
+
+This document explains how to get started using Azure Key Vault Service with Fog to manage Vault. With this gem you can create/list/delete Vault.
+
+## 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 Key Vault Service:
+
+```ruby
+    azure_key_vault_service = Fog::KeyVault::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
+)
+```
+
+## Check Vault Existence
+
+```ruby
+ azure_key_vault_service.vaults.check_vault_exists(<Resource Group name>, <Vault Name>)
+```
+
+## Create Vault
+
+Create a new Vault.
+
+```ruby
+    vault = azure_key_vault_service.vaults.create(
+        name: '<Vault Name>',
+        location: 'eastus',
+        resource_group: '<Resource Group name>',
+        tenant_id: <Tenantid>,
+        sku_family: 'A',
+        sku_name: 'standard',
+        access_policies: [
+                           {
+                             tenant_id: <Tenantid>,
+                             object_id: <Tenantid>,
+                             permissions: {
+                               keys: ['all'],
+                               secrets: ['all']
+                             }
+                           }
+                         ]
+
+    )
+```
+
+## List Vaults
+
+List all vaults in a resource group
+
+```ruby
+    vaults = azure_key_vault_service.vaults(resource_group: '<Resource Group Name>')
+    vaults.each do |vault|
+        puts "#{vault.name}"
+    end
+```
+
+## Retrieve a single Vault
+
+Get a single record of Vault
+
+```ruby
+    vault = azure_key_vault_service
+                            .vaults
+                            .get('<Resource Group name>', '<Vault Name>')
+    puts "#{vault.name}"
+```
+
+## Destroy a single Vault
+
+Get a vault object from the get method and then destroy that vault.
+
+```ruby
+    vault.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/network.md

@@ -15,12 +15,20 @@ Next, create a connection to the Network Service:
 
 ```ruby
     azure_network_service = Fog::Network::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
+        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.
 )
 ```
+
+## Check Virtual Network Existence
+
+```ruby
+ azure_network_service.virtual_networks.check_virtual_network_exists(<Resource Group name>, <Virtual Network Name>)
+```
+
 ## Create Virtual Network
 
 Create a new virtual network
@@ -44,20 +52,24 @@ Optional parameters for Subnet: network_security_group_id, route_table_id & addr
     )
 ```
 
-## Check for Virtual Network
+## List Virtual Networks in Resource Group
 
-Checks if the Virtual Network already exists or not.
+List all virtual networks in a resource group
 
 ```ruby
-    azure_network_service.virtual_networks.check_if_exists('<Virtual Network name>', '<Resource Group name>')
+    vnets  = azure_network_service.virtual_networks(resource_group: '<Resource Group Name>')
+    vnets.each do |vnet|
+      puts "#{vnet.name}"
+      puts "#{vnet.location}"
+    end
 ```
 
-## List Virtual Networks
+## List Virtual Networks in Subscription
 
 List all virtual networks in a subscription
 
 ```ruby
-    vnets  = azure_network_service.virtual_networks(resource_group: '<Resource Group Name>')
+    vnets  = azure_network_service.virtual_networks
     vnets.each do |vnet|
       puts "#{vnet.name}"
       puts "#{vnet.location}"
@@ -126,6 +138,12 @@ Get virtual network object from the get method and then destroy that virtual net
     vnet.destroy
 ```
 
+## Check Subnet Existence
+
+```ruby
+ azure_network_service.subnets.check_subnet_exists(<Resource Group name>, <Virtual Network Name>, <Subnet Name>)
+```
+
 ## Create Subnet
 
 Create a new Subnet
@@ -217,6 +235,12 @@ Get a subnet object from the get method and then destroy that subnet.
     subnet.destroy
 ```
 
+## Check Network Interface Card Existence
+
+```ruby
+ azure_network_service.network_interfaces.check_network_interface_exists(<Resource Group name>, <Network Interface name>)
+```
+
 ## Create Network Interface Card
 
 Create a new network interface. Skip public_ip_address_id parameter to create network interface without PublicIP. The parameter, private_ip_allocation_method can be Dynamic or Static.
@@ -294,6 +318,12 @@ Get a network interface object from the get method and then destroy that network
      nic.destroy
 ```
 
+## Check Public IP Existence
+
+```ruby
+ azure_network_service.public_ips.check_public_ip_exists(<Resource Group name>, <Public IP name>>)
+```
+
 ## Create Public IP
 
 Create a new public IP. The parameter, type can be Dynamic or Static.
@@ -357,6 +387,12 @@ Get a Public IP object from the get method and then destroy that public IP.
     pubip.destroy
 ```
 
+## Check Network Security Group Existence
+
+```ruby
+ azure_network_service.network_security_groups.check_net_sec_group_exists(<Resource Group name>, <Network Security Group name>)
+```
+
 ## Create Network Security Group
 
 Network security group requires a resource group to create. 
@@ -462,6 +498,12 @@ Get a network security group object from the get method and then destroy that ne
     nsg.destroy
 ```
 
+## Check Network Security Rule Existence
+
+```ruby
+ azure_network_service.network_security_rules.check_net_sec_rule_exists(<Resource Group name>, <Network Security Group name>, <Security Rule name>)
+```
+
 ## Create Network Security Rule
 
 Network security rule requires a resource group and network security group to create. 
@@ -513,6 +555,12 @@ Get a network security rule object from the get method and then destroy that net
     network_security_rule.destroy
 ```
 
+## Check External Load Balancer Existence
+
+```ruby
+ azure_network_service.load_balancers.check_load_balancer_exists(<Resource Group name>, <Load Balancer name>)
+```
+
 ## Create External Load Balancer
 
 Create a new load balancer.
@@ -637,6 +685,17 @@ List all load balancers in a resource group
     end
 ```
 
+## List Load Balancers in subscription
+
+List all load balancers in a subscription
+
+```ruby
+    lbs = azure_network_service.load_balancers
+    lbs.each do |lb|
+      puts "#{lb.name}"
+    end
+```
+
 ## Retrieve a single Load Balancer
 
 Get a single record of Load Balancer
@@ -656,6 +715,12 @@ Get a load balancer object from the get method and then destroy that load balanc
     lb.destroy
 ```
 
+## Check Virtual Network Gateway Existence
+
+```ruby
+ azure_network_service.virtual_network_gateways.check_vnet_gateway_exists(<Resource Group name>, <Virtual Network Gateway Name>)
+```
+
 ## Create Virtual Network Gateway
 
 Create a new Virtual Network Gateway.
@@ -737,6 +802,12 @@ Get a virtual network gateway object from the get method and then destroy that v
 	network_gateway.destroy
 ```
 
+## Check Local Network Gateway Existence
+
+```ruby
+ azure_network_service.local_network_gateways.check_local_net_gateway_exists(<Resource Group name>, <Local Network Gateway Name>)
+```
+
 ## Create Local Network Gateway
 
 Create a new Local Network Gateway.
@@ -795,6 +866,12 @@ For more details about express route [click here](https://azure.microsoft.com/en
 
 The Circuit represents the entity created by customer to register with an express route service provider with intent to connect to Microsoft.
 
+## Check Express Route Circuit Existence
+
+```ruby
+ azure_network_service.express_route_circuits.check_express_route_circuit_exists(<Resource Group name>, <Circuit Name>)
+```
+
 ## Create an Express Route Circuit
 
 Create a new Express Route Circuit.
@@ -858,6 +935,12 @@ Get an express route circuit object from the get method and then destroy that ex
 
 Authorization is part of Express Route circuit.
 
+## Check Express Route Circuit Authorization Existence
+
+```ruby
+ azure_network_service.express_route_circuit_authorizations.check_express_route_cir_auth_exists(<Resource Group name>, <Circuit Name>, <Authorization-Name>)
+```
+
 ## Create an Express Route Circuit Authorization
 
 Create a new Express Route Circuit Authorization. Parameter 'authorization_status' can be 'Available' or 'InUse'.
@@ -963,6 +1046,12 @@ List all express route service providers
 	puts service_providers
 ```
 
+## Check Virtual Network Gateway Connection Existence
+
+```ruby
+ azure_network_service.virtual_network_gateway_connections.check_vnet_gateway_connection_exists(<Resource Group name>, <Virtual Network Gateway Connection Name>)
+```
+
 ## Create Virtual Network Gateway Connection
 
 Create a new Virtual Network Gateway Connection.

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

@@ -16,12 +16,20 @@ 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
+        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.
 )
 ```
+
+## Check Resource Group Existence
+
+```ruby
+ azure_resources_service.resource_groups.check_resource_group_exists(<Resource Group name>)
+```
+
 ## Create Resource Group
 
 Create a new resource group
@@ -110,6 +118,18 @@ Remove tag from a resource as following:
         )
 ```
 
+## Check Resource Existence
+
+```ruby
+ azure_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>)
+```
+
 ## Create Deployment
 
 Create a Deployment

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

@@ -16,10 +16,11 @@ 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
+        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.
     )
 ```
 
@@ -89,8 +90,6 @@ If parameter {edition} is set to DataWarehouse, the acceptable values for parame
         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.
         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]
-        restore_point_in_time: '<String>',            # Conditional. Specifies the point in time for the restore. If createMode is set to PointInTimeRestore, then this value must be specified. 
-        source_database_deletion_date: '<Date>',      # Conditional. Specifies the deletion date of the source database. If createMode is set to Restore, then this value must be specified
         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.   
     )

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

@@ -59,6 +59,12 @@ Check Storage Account Name Availability.This operation checks that account name
 azure_storage_service.storage_accounts.check_name_availability('<Storage Account name>')
 ```
 
+## Check Storage Account Existence
+
+```ruby
+azure_storage_service.storage_accounts.check_storage_account_exists(<Resource Group name>, <StorageAccountName>)
+```
+
 ## Create Storage Account
 
 Create a new storage account. Replication attribute for Standard and Premium account types are as follows 
@@ -161,6 +167,12 @@ By default the disk will be deleted from the container 'vhds'. You can specify o
 azure_storage_service.delete_disk('<Data Disk Name>', options = {})
 ```
 
+## Check Storage Container Existence
+
+```ruby
+azure_storage_service.directories.check_container_exists(<container name>)
+```
+
 ## Create a storage container
 
 Create a storage container in the current storage account.

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

@@ -15,13 +15,20 @@ 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
+        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.
 )
 ```
 
+## Check Traffic Manager Profile Existence
+
+```ruby
+azure_traffic_manager_service.traffic_manager_profiles.check_traffic_manager_profile_exists(<Resource Group Name>, <Profile Name>)
+```
+
 ## Create Traffic Manager Profile
 
 Create a new Traffic Manager Profile. The parameter 'traffic_routing_method' can be 'Performance', 'Weighted' or 'Priority'.
@@ -83,6 +90,17 @@ Get a Traffic Manager Profile object from the get method and then destroy that T
      profile.destroy
 ```
 
+## Check Traffic Manager Endpoint Existence
+
+```ruby
+ azure_network_service.traffic_manager_end_points.check_traffic_manager_endpoint_exists(
+   <Resource Group Name>,
+   <Profile Name>,
+   <Endpoint Name>,
+   <Type(externalEndpoints)>
+   )
+```
+
 ## 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'.

data/lib/fog/azurerm/key_vault.rb

@@ -0,0 +1,51 @@
+module Fog
+  module KeyVault
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+
+      request_path 'fog/azurerm/requests/key_vault'
+      request :get_vault
+      request :list_vaults
+      request :create_or_update_vault
+      request :delete_vault
+      request :check_vault_exists
+
+      model_path 'fog/azurerm/models/key_vault'
+      model :vault
+      model :access_policy_entry
+      collection :vaults
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_key_vault'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+
+      # This class provides the actual implementation for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_key_vault'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+
+          credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret])
+          @key_vault_client = ::Azure::ARM::KeyVault::KeyVaultManagementClient.new(credentials)
+          @key_vault_client.subscription_id = options[:subscription_id]
+        end
+      end
+    end
+  end
+end