fog-azure-rm 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d368c1c1b51e0a2ce92cc1791b88c7fc41c05ecc
-  data.tar.gz: 9d50a7b320080bc990a6e2e54cef9c5144c9e7c5
+  metadata.gz: fcef6aa93014d6ab06b64750d6ab060e209f8d68
+  data.tar.gz: 35bc5f202cb58139facb70944270721c96436ab1
 SHA512:
-  metadata.gz: b397f190098b56507d6cfae71f290c298282ef4de15e122ee59d38dcb3b3fae6759646824e91a25c78640237b18bb9f7bd61315f3a962c11c4f384653e1b8f36
-  data.tar.gz: 4503e9320364fa79d212cc5872052a5f72c32f4b96ad7cdfdaaf9260c47a524305c19bc5d2a87281c41cb6d01d7308459dd7fd4713969e22db51d7f37803ee32
+  metadata.gz: 360d9b598b28e2669f160425a05fd6996d764e52b943cc626ec6df995b2c3754cecc895d404bbade9af4cfa63bb674e6e430cf2b6e284309c4b5c89a407d511b
+  data.tar.gz: 67912e5342afef2657d176406f39a0239377f40d3240e04567641e3c88f5fefa2f513006ce05d9c82780692937ebf47f2c89e5f29b75d75b937b479083045f89

data/.travis.yml

@@ -5,6 +5,8 @@ before_install:
   - gem install bundler
   - gem update bundler
 
+script: sh rake-script.sh
+
 matrix:
   fast_finish: true
   include:

data/CHANGELOG.md

@@ -1,7 +1,16 @@
+## 0.1.0
+
+**Added:**
+- Azure SQL Service - Added support for SQL Server Firewall Rules.
+- Azure Recovery Vault - Added support for Azure Recovery Vault.
+- Azure Storage Service - Encryption support for storage account and Added support to create new data disk.
+
+
 ## 0.0.9
 
 **Added:**
 - Azure SQL Service - Added support for SQL Server, SQL Databases and Data warehouse.
+- Updated fog-azure-rm runtime gem dependencies to latest.
 
 **Changed:**
 - DNS Service - DNS Service moved from API calls to Azure latest SDK.

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

@@ -93,7 +93,7 @@ Get a single record of Server
 ```ruby
       server = azure_compute_service
                           .servers(resource_group: '<Resource Group name>')
-                          .get('Server name>')
+                          .get('<Resource Group name>', 'Server name>')
       puts "#{server.name}"
 ```
 

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

@@ -125,6 +125,45 @@ Get SQL Database object from the get method(described above) and destroy that Da
       database.destroy
 ```
 
+## Create Firewall Rule
+
+Create a new Firewall Rule
+
+```ruby
+    azure_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
+```
+
+## Retrieve a single Firewall Rule
+Get a single record of Firewall rule on SQL Server
+```ruby
+     firewall_rule = azure_sql_service.firewall_rules
+                   .get('<Resource Group Name>', '<Server 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
+```
+
 
 ## Support and Feedback
 Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.

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

@@ -74,7 +74,8 @@ azure_storage_service.storage_accounts.create(
   :location => 'West US',
   :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' 
+  :replication => 'LRS',                               # Optional. Default value 'LRS'
+  :encryption => true                                  # Optional. If you want to enable encryption. Default value is 'false'
 )
 ```
 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/).
@@ -110,6 +111,18 @@ storage_acc = azure_storage_service
 puts "#{storage_acc.name}"
 ```
 
+## Enable encryption on Storage Account
+
+Get a single record of Storage Account and enable encryption on that Storage Account
+
+```ruby
+storage_acc = azure_storage_service
+                .storage_accounts
+                .get('<Resource Group name>', '<Storage Account name>')
+
+storage_acc.update(encryption: true)
+```
+
 ## Get Access Keys
 
 Get access keys of a storage account
@@ -129,12 +142,20 @@ Get storage account object from the get method and then destroy that storage acc
 storage_acc.destroy
 ```
 
+## Create a Disk
+
+Create a Disk in storage account.
+
+```ruby
+azure_storage_service.create_disk('<Data Disk Name>', 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.
 
 ```ruby
-azure_storage_service.delete_disk('<Resource Group name>', '<Storage Account name>', '<Data Disk Name>')
+azure_storage_service.delete_disk('<Data Disk Name>')
 ```
 
 ## Create a storage container
@@ -298,6 +319,72 @@ metadata = {
 azure_storage_service.directories.set_metadata('<Container name>', metadata)
 ```
 
+### Create Recovery Vault
+
+Create a new Recovery Vault object
+
+```ruby
+azure_storage_service.recovery_vaults.create(
+  name: '<vault_name>',
+  location: '<location>',
+  resource_group: '<resource_group_name>'
+```
+
+### Get Recovery Vault
+
+Retrieves a Recovery Vault object
+
+```ruby
+recovery_vault = azure_storage_service.recovery_vaults.get(
+  'Vault Name',
+  'Vault Resource Group'
+)
+```
+
+### List Recovery Vaults
+
+List the Recovery Vaults in a resource group
+
+```ruby
+azure_storage_service.recovery_vaults('Resource Group Name').each do |recovery_vault|
+  puts recovery_vault.inspect
+end
+```
+
+### Enable Backup Protection
+
+Enables backup protection for a virtual machine in the recovery vault. Backup protection for a virtual machine must be enabled before running backup.
+
+```ruby
+recovery_vault.enable_backup_protection('Virtual Machine Name', 'Virtual Machine Resource Group')
+```
+
+### Disable Backup Protection
+
+Disables backup protection for a virtual machine in the recovery vault.
+
+```ruby
+recovery_vault.disable_backup_protection('Virtual Machine Name', 'Virtual Machine Resource Group')
+```
+
+### Start Backup
+
+Starts the backup process for a given virtual machine
+
+```ruby
+recovery_vault.start_backup('Virtual Machine Name', 'Virtual Machine Resource Group')
+```
+
+### Destroy Recovery Vault
+
+Destroys the Recovery Vault
+
+```ruby
+recovery_vault.destroy
+```
+
+Note that a Recovery Vault must not contain any backup protectable items or tasks running in order for you to delete it. If any item is present, it must be deleted from the portal first before running this command.
+
 ## Support and Feedback
 Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.
 

data/lib/fog/azurerm/models/application_gateway/gateways.rb

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/application_gateway/gateway'
-
 module Fog
   module ApplicationGateway
     class AzureRM
       # Application Gateway collection class for Application Gateway Service
       class Gateways < Fog::Collection
-        model Fog::ApplicationGateway::AzureRM::Gateway
+        model Gateway
         attribute :resource_group
 
         def all
           requires :resource_group
           application_gateways = []
           service.list_application_gateways(resource_group).each do |gateway|
-            application_gateways << Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway)
+            application_gateways << Gateway.parse(gateway)
           end
           load(application_gateways)
         end
 
         def get(resource_group_name, application_gateway_name)
           gateway = service.get_application_gateway(resource_group_name, application_gateway_name)
-          application_gateway = Fog::ApplicationGateway::AzureRM::Gateway.new(service: service)
-          application_gateway.merge_attributes(Fog::ApplicationGateway::AzureRM::Gateway.parse(gateway))
+          application_gateway = Gateway.new(service: service)
+          application_gateway.merge_attributes(Gateway.parse(gateway))
         end
       end
     end

data/lib/fog/azurerm/models/compute/availability_sets.rb

@@ -1,12 +1,10 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/compute/availability_set'
 module Fog
   module Compute
     class AzureRM
       # This class is giving implementation of all/list, get and
       # check name availability for storage account.
       class AvailabilitySets < Fog::Collection
-        model Fog::Compute::AzureRM::AvailabilitySet
+        model AvailabilitySet
         attribute :resource_group
         def all
           accounts = []
@@ -15,7 +13,7 @@ module Fog
             service.list_availability_sets(resource_group)
           unless list_of_availability_sets.nil?
             list_of_availability_sets.each do |account|
-              parse_response = Fog::Compute::AzureRM::AvailabilitySet.parse(account)
+              parse_response = AvailabilitySet.parse(account)
               accounts << parse_response
             end
           end
@@ -24,8 +22,8 @@ module Fog
 
         def get(resource_group, identity)
           availability_set = service.get_availability_set(resource_group, identity)
-          availability_set_obj = Fog::Compute::AzureRM::AvailabilitySet.new(service: service)
-          availability_set_obj.merge_attributes(Fog::Compute::AzureRM::AvailabilitySet.parse(availability_set))
+          availability_set_obj = AvailabilitySet.new(service: service)
+          availability_set_obj.merge_attributes(AvailabilitySet.parse(availability_set))
         end
       end
     end

data/lib/fog/azurerm/models/compute/servers.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/compute/server'
-
 module Fog
   module Compute
     class AzureRM
@@ -8,21 +5,21 @@ module Fog
       # for Server.
       class Servers < Fog::Collection
         attribute :resource_group
-        model Fog::Compute::AzureRM::Server
+        model Server
 
         def all
           requires :resource_group
           virtual_machines = []
           service.list_virtual_machines(resource_group).each do |vm|
-            virtual_machines << Fog::Compute::AzureRM::Server.parse(vm)
+            virtual_machines << Server.parse(vm)
           end
           load(virtual_machines)
         end
 
         def get(resource_group_name, virtual_machine_name)
-          storage_account = service.get_virtual_machine(resource_group_name, virtual_machine_name)
-          storage_account_obj = Fog::Compute::AzureRM::Server.new(service: service)
-          storage_account_obj.merge_attributes(Fog::Compute::AzureRM::Server.parse(storage_account))
+          virtual_machine = service.get_virtual_machine(resource_group_name, virtual_machine_name)
+          virtual_machine_obj = Server.new(service: service)
+          virtual_machine_obj.merge_attributes(Server.parse(virtual_machine))
         end
       end
     end

data/lib/fog/azurerm/models/compute/virtual_machine_extensions.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/compute/virtual_machine_extension'
-
 module Fog
   module Compute
     class AzureRM

data/lib/fog/azurerm/models/dns/record_sets.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/dns/record_set'
-
 module Fog
   module DNS
     class AzureRM
@@ -11,22 +8,21 @@ module Fog
         attribute :zone_name
         attribute :type
 
-        model Fog::DNS::AzureRM::RecordSet
+        model RecordSet
 
         def all
-          requires :resource_group
-          requires :zone_name
+          requires :resource_group, :zone_name
           record_sets = []
           service.list_record_sets(resource_group, zone_name).each do |r|
-            record_sets << Fog::DNS::AzureRM::RecordSet.parse(r)
+            record_sets << RecordSet.parse(r)
           end
           load(record_sets)
         end
 
         def get(resource_group, name, zone_name, record_type)
           record_set = service.get_record_set(resource_group, name, zone_name, record_type)
-          record_set_obj = Fog::DNS::AzureRM::RecordSet.new(service: service)
-          record_set_obj.merge_attributes(Fog::DNS::AzureRM::RecordSet.parse(record_set))
+          record_set_obj = RecordSet.new(service: service)
+          record_set_obj.merge_attributes(RecordSet.parse(record_set))
         end
       end
     end

data/lib/fog/azurerm/models/dns/zones.rb

@@ -1,26 +1,23 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/dns/zone'
-
 module Fog
   module DNS
     class AzureRM
       # This class is giving implementation of
       # all/get for Zones.
       class Zones < Fog::Collection
-        model Fog::DNS::AzureRM::Zone
+        model Zone
 
         def all
           zones = []
           service.list_zones.each do |z|
-            zones << Fog::DNS::AzureRM::Zone.parse(z)
+            zones << Zone.parse(z)
           end
           load(zones)
         end
 
         def get(resource_group, name)
           zone = service.get_zone(resource_group, name)
-          zone_obj = Fog::DNS::AzureRM::Zone.new(service: service)
-          zone_obj.merge_attributes(Fog::DNS::AzureRM::Zone.parse(zone))
+          zone_obj = Zone.new(service: service)
+          zone_obj.merge_attributes(Zone.parse(zone))
         end
 
         def check_for_zone(resource_group, name)

data/lib/fog/azurerm/models/network/express_route_circuit_authorizations.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/express_route_circuit_authorization'
-
 module Fog
   module Network
     class AzureRM

data/lib/fog/azurerm/models/network/express_route_circuit_peerings.rb

@@ -1,29 +1,25 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/express_route_circuit_peering'
-
 module Fog
   module Network
     class AzureRM
       # ExpressRouteCircuitPeering collection class for Network Service
       class ExpressRouteCircuitPeerings < Fog::Collection
-        model Fog::Network::AzureRM::ExpressRouteCircuitPeering
+        model ExpressRouteCircuitPeering
         attribute :resource_group
         attribute :circuit_name
 
         def all
-          requires :resource_group
-          requires :circuit_name
+          requires :resource_group, :circuit_name
           circuit_peerings = []
           service.list_express_route_circuit_peerings(resource_group, circuit_name).each do |circuit_peering|
-            circuit_peerings << Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(circuit_peering)
+            circuit_peerings << ExpressRouteCircuitPeering.parse(circuit_peering)
           end
           load(circuit_peerings)
         end
 
         def get(resource_group_name, peering_name, circuit_name)
           circuit_peering = service.get_express_route_circuit_peering(resource_group_name, peering_name, circuit_name)
-          express_route_circuit_peering = Fog::Network::AzureRM::ExpressRouteCircuitPeering.new(service: service)
-          express_route_circuit_peering.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuitPeering.parse(circuit_peering))
+          express_route_circuit_peering = ExpressRouteCircuitPeering.new(service: service)
+          express_route_circuit_peering.merge_attributes(ExpressRouteCircuitPeering.parse(circuit_peering))
         end
       end
     end

data/lib/fog/azurerm/models/network/express_route_circuits.rb

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/express_route_circuit'
-
 module Fog
   module Network
     class AzureRM
       # ExpressRouteCircuit collection class for Network Service
       class ExpressRouteCircuits < Fog::Collection
-        model Fog::Network::AzureRM::ExpressRouteCircuit
+        model ExpressRouteCircuit
         attribute :resource_group
 
         def all
           requires :resource_group
           express_route_circuits = []
           service.list_express_route_circuits(resource_group).each do |circuit|
-            express_route_circuits << Fog::Network::AzureRM::ExpressRouteCircuit.parse(circuit)
+            express_route_circuits << ExpressRouteCircuit.parse(circuit)
           end
           load(express_route_circuits)
         end
 
         def get(resource_group_name, name)
           circuit = service.get_express_route_circuit(resource_group_name, name)
-          express_route_circuit = Fog::Network::AzureRM::ExpressRouteCircuit.new(service: service)
-          express_route_circuit.merge_attributes(Fog::Network::AzureRM::ExpressRouteCircuit.parse(circuit))
+          express_route_circuit = ExpressRouteCircuit.new(service: service)
+          express_route_circuit.merge_attributes(ExpressRouteCircuit.parse(circuit))
         end
       end
     end