fog-azure-rm 0.0.9 → 0.1.0

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

@@ -1,17 +1,14 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/express_route_service_provider'
-
 module Fog
   module Network
     class AzureRM
       # ExpressRouteServiceProvider collection class for Network Service
       class ExpressRouteServiceProviders < Fog::Collection
-        model Fog::Network::AzureRM::ExpressRouteServiceProvider
+        model ExpressRouteServiceProvider
 
         def all
           express_route_service_providers = []
           service.list_express_route_service_providers.each do |service_provider|
-            express_route_service_providers << Fog::Network::AzureRM::ExpressRouteServiceProvider.parse(service_provider)
+            express_route_service_providers << ExpressRouteServiceProvider.parse(service_provider)
           end
           load(express_route_service_providers)
         end

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

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/load_balancer'
-
 module Fog
   module Network
     class AzureRM
       # LoadBalancers collection class for Network Service
       class LoadBalancers < Fog::Collection
-        model Fog::Network::AzureRM::LoadBalancer
+        model LoadBalancer
         attribute :resource_group
 
         def all
           requires :resource_group
           load_balancers = []
           service.list_load_balancers(resource_group).each do |load_balancer|
-            load_balancers << Fog::Network::AzureRM::LoadBalancer.parse(load_balancer)
+            load_balancers << LoadBalancer.parse(load_balancer)
           end
           load(load_balancers)
         end
 
         def get(resource_group_name, load_balancer_name)
           lb = service.get_load_balancer(resource_group_name, load_balancer_name)
-          load_balancer = Fog::Network::AzureRM::LoadBalancer.new(service: service)
-          load_balancer.merge_attributes(Fog::Network::AzureRM::LoadBalancer.parse(lb))
+          load_balancer = LoadBalancer.new(service: service)
+          load_balancer.merge_attributes(LoadBalancer.parse(lb))
         end
       end
     end

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

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

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

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/network_interface'
-
 module Fog
   module Network
     class AzureRM
       # NetworkInterfaces collection class for Network Service
       class NetworkInterfaces < Fog::Collection
-        model Fog::Network::AzureRM::NetworkInterface
+        model NetworkInterface
         attribute :resource_group
 
         def all
           requires :resource_group
           network_interfaces = []
           service.list_network_interfaces(resource_group).each do |nic|
-            network_interfaces << Fog::Network::AzureRM::NetworkInterface.parse(nic)
+            network_interfaces << NetworkInterface.parse(nic)
           end
           load(network_interfaces)
         end
 
         def get(resource_group_name, name)
           nic = service.get_network_interface(resource_group_name, name)
-          network_interface_card = Fog::Network::AzureRM::NetworkInterface.new(service: service)
-          network_interface_card.merge_attributes(Fog::Network::AzureRM::NetworkInterface.parse(nic))
+          network_interface_card = NetworkInterface.new(service: service)
+          network_interface_card.merge_attributes(NetworkInterface.parse(nic))
         end
       end
     end

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

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/network_security_group'
-
 module Fog
   module Network
     class AzureRM
       # collection class for Network Security Group
       class NetworkSecurityGroups < Fog::Collection
-        model Fog::Network::AzureRM::NetworkSecurityGroup
+        model NetworkSecurityGroup
         attribute :resource_group
 
         def all
           requires :resource_group
           network_security_groups = []
           service.list_network_security_groups(resource_group).each do |nsg|
-            network_security_groups << Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg)
+            network_security_groups << NetworkSecurityGroup.parse(nsg)
           end
           load(network_security_groups)
         end
 
         def get(resource_group, name)
           nsg = service.get_network_security_group(resource_group, name)
-          network_security_group = Fog::Network::AzureRM::NetworkSecurityGroup.new(service: service)
-          network_security_group.merge_attributes(Fog::Network::AzureRM::NetworkSecurityGroup.parse(nsg))
+          network_security_group = NetworkSecurityGroup.new(service: service)
+          network_security_group.merge_attributes(NetworkSecurityGroup.parse(nsg))
         end
       end
     end

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

@@ -1,18 +1,14 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/network_security_rule'
-
 module Fog
   module Network
     class AzureRM
       # collection class for Network Security Rule
       class NetworkSecurityRules < Fog::Collection
-        model Fog::Network::AzureRM::NetworkSecurityRule
+        model NetworkSecurityRule
         attribute :resource_group
         attribute :network_security_group_name
 
         def all
-          requires :resource_group
-          requires :network_security_group_name
+          requires :resource_group, :network_security_group_name
           network_security_rules = []
           service.list_network_security_rules(resource_group, network_security_group_name).each do |nsr|
             network_security_rules << NetworkSecurityRule.parse(nsr)

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

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/public_ip'
-
 module Fog
   module Network
     class AzureRM
       # PublicIPs collection class for Network Service
       class PublicIps < Fog::Collection
-        model Fog::Network::AzureRM::PublicIp
+        model PublicIp
         attribute :resource_group
 
         def all
           requires :resource_group
           public_ips = []
           service.list_public_ips(resource_group).each do |pip|
-            public_ips << Fog::Network::AzureRM::PublicIp.parse(pip)
+            public_ips << PublicIp.parse(pip)
           end
           load(public_ips)
         end
 
         def get(resource_group_name, public_ip_name)
           public_ip = service.get_public_ip(resource_group_name, public_ip_name)
-          public_ip_object = Fog::Network::AzureRM::PublicIp.new(service: service)
-          public_ip_object.merge_attributes(Fog::Network::AzureRM::PublicIp.parse(public_ip))
+          public_ip_object = PublicIp.new(service: service)
+          public_ip_object.merge_attributes(PublicIp.parse(public_ip))
         end
 
         def check_if_exists(resource_group, name)

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

@@ -1,29 +1,25 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/subnet'
-
 module Fog
   module Network
     class AzureRM
       # Subnet collection for network service
       class Subnets < Fog::Collection
-        model Fog::Network::AzureRM::Subnet
+        model Subnet
         attribute :resource_group
         attribute :virtual_network_name
 
         def all
-          requires :resource_group
-          requires :virtual_network_name
+          requires :resource_group, :virtual_network_name
           subnets = []
           service.list_subnets(resource_group, virtual_network_name).each do |subnet|
-            subnets << Fog::Network::AzureRM::Subnet.parse(subnet)
+            subnets << Subnet.parse(subnet)
           end
           load(subnets)
         end
 
         def get(resource_group, virtual_network_name, subnet_name)
           subnet = service.get_subnet(resource_group, virtual_network_name, subnet_name)
-          subnet_object = Fog::Network::AzureRM::Subnet.new(service: service)
-          subnet_object.merge_attributes(Fog::Network::AzureRM::Subnet.parse(subnet))
+          subnet_object = Subnet.new(service: service)
+          subnet_object.merge_attributes(Subnet.parse(subnet))
         end
       end
     end

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

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

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

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/virtual_network_gateway'
-
 module Fog
   module Network
     class AzureRM
       # VirtualNetworkGateways collection class for Network Service
       class VirtualNetworkGateways < Fog::Collection
-        model Fog::Network::AzureRM::VirtualNetworkGateway
+        model VirtualNetworkGateway
         attribute :resource_group
 
         def all
           requires :resource_group
           network_gateways = []
           service.list_virtual_network_gateways(resource_group).each do |gateway|
-            network_gateways << Fog::Network::AzureRM::VirtualNetworkGateway.parse(gateway)
+            network_gateways << VirtualNetworkGateway.parse(gateway)
           end
           load(network_gateways)
         end
 
         def get(resource_group_name, name)
           network_gateway = service.get_virtual_network_gateway(resource_group_name, name)
-          virtual_network_gateway = Fog::Network::AzureRM::VirtualNetworkGateway.new(service: service)
-          virtual_network_gateway.merge_attributes(Fog::Network::AzureRM::VirtualNetworkGateway.parse(network_gateway))
+          virtual_network_gateway = VirtualNetworkGateway.new(service: service)
+          virtual_network_gateway.merge_attributes(VirtualNetworkGateway.parse(network_gateway))
         end
       end
     end

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

@@ -1,28 +1,25 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/network/virtual_network'
-
 module Fog
   module Network
     class AzureRM
       # This class is giving implementation of all/list, get and
       # check name availability for virtual network.
       class VirtualNetworks < Fog::Collection
-        model Fog::Network::AzureRM::VirtualNetwork
+        model VirtualNetwork
         attribute :resource_group
 
         def all
           requires :resource_group
           virtual_networks = []
           service.list_virtual_networks(resource_group).each do |vnet|
-            virtual_networks << Fog::Network::AzureRM::VirtualNetwork.parse(vnet)
+            virtual_networks << VirtualNetwork.parse(vnet)
           end
           load(virtual_networks)
         end
 
         def get(resource_group_name, virtual_network_name)
           virtual_network = service.get_virtual_network(resource_group_name, virtual_network_name)
-          virtual_network_object = Fog::Network::AzureRM::VirtualNetwork.new(service: service)
-          virtual_network_object.merge_attributes(Fog::Network::AzureRM::VirtualNetwork.parse(virtual_network))
+          virtual_network_object = VirtualNetwork.new(service: service)
+          virtual_network_object.merge_attributes(VirtualNetwork.parse(virtual_network))
         end
 
         def check_if_exists(resource_group, name)

data/lib/fog/azurerm/models/resources/azure_resources.rb

@@ -1,6 +1,3 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/resources/azure_resource'
-
 module Fog
   module Resources
     class AzureRM
@@ -8,13 +5,13 @@ module Fog
       class AzureResources < Fog::Collection
         attribute :tag_name
         attribute :tag_value
-        model Fog::Resources::AzureRM::AzureResource
+        model AzureResource
 
         def all
           unless tag_name.nil? && tag_value.nil?
             resources = []
             service.list_tagged_resources(tag_name, tag_value).each do |resource|
-              resources << Fog::Resources::AzureRM::AzureResource.parse(resource)
+              resources << AzureResource.parse(resource)
             end
             resources.inspect
             return load(resources)

data/lib/fog/azurerm/models/resources/deployments.rb

@@ -1,27 +1,24 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/resources/deployment'
-
 module Fog
   module Resources
     class AzureRM
       # Deployments collection class
       class Deployments < Fog::Collection
         attribute :resource_group
-        model Fog::Resources::AzureRM::Deployment
+        model Deployment
 
         def all
           requires :resource_group
           deployments = []
           service.list_deployments(resource_group).each do |deployment|
-            deployments << Fog::Resources::AzureRM::Deployment.parse(deployment)
+            deployments << Deployment.parse(deployment)
           end
           load(deployments)
         end
 
         def get(resource_group_name, deployment_name)
           deployment = service.get_deployment(resource_group_name, deployment_name)
-          deployment_object = Fog::Resources::AzureRM::Deployment.new(service: service)
-          deployment_object.merge_attributes(Fog::Resources::AzureRM::Deployment.parse(deployment))
+          deployment_object = Deployment.new(service: service)
+          deployment_object.merge_attributes(Deployment.parse(deployment))
         end
       end
     end

data/lib/fog/azurerm/models/resources/resource_groups.rb

@@ -1,26 +1,23 @@
-require 'fog/core/collection'
-require 'fog/azurerm/models/resources/resource_group'
-
 module Fog
   module Resources
     class AzureRM
       # This class is giving implementation of all/list, get and
       # check name availability for resource groups.
       class ResourceGroups < Fog::Collection
-        model Fog::Resources::AzureRM::ResourceGroup
+        model ResourceGroup
 
         def all
           resource_groups = []
           service.list_resource_groups.each do |resource_group|
-            resource_groups.push(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
+            resource_groups.push(ResourceGroup.parse(resource_group))
           end
           load(resource_groups)
         end
 
         def get(resource_group_name)
           resource_group = service.get_resource_group(resource_group_name)
-          resource_group_object = Fog::Resources::AzureRM::ResourceGroup.new(service: service)
-          resource_group_object.merge_attributes(Fog::Resources::AzureRM::ResourceGroup.parse(resource_group))
+          resource_group_object = ResourceGroup.new(service: service)
+          resource_group_object.merge_attributes(ResourceGroup.parse(resource_group))
         end
       end
     end

data/lib/fog/azurerm/models/sql/firewall_rule.rb

@@ -0,0 +1,52 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Server model for Server Firewall Rule Service
+      class FirewallRule < Fog::Model
+        identity :name
+        attribute :id
+        attribute :type
+        attribute :resource_group
+        attribute :location
+        attribute :start_ip
+        attribute :end_ip
+        attribute :server_name
+
+        def self.parse(firewall)
+          {
+            id: firewall['id'],
+            type: firewall['type'],
+            name: firewall['name'],
+            location: firewall['location'],
+            resource_group: get_resource_group_from_id(firewall['id']),
+            server_name: get_server_name_from_id(firewall['id']),
+            start_ip: firewall['properties']['startIpAddress'],
+            end_ip: firewall['properties']['endIpAddress']
+          }
+        end
+
+        def save
+          requires :resource_group, :server_name, :name, :start_ip, :end_ip
+          firewall_rule = service.create_or_update_firewall_rule(firewall_params)
+          merge_attributes(FirewallRule.parse(firewall_rule))
+        end
+
+        def destroy
+          service.delete_firewall_rule(resource_group, server_name, name)
+        end
+
+        private
+
+        def firewall_params
+          {
+            resource_group: resource_group,
+            server_name: server_name,
+            name: name,
+            start_ip: start_ip,
+            end_ip: end_ip
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/sql/firewall_rules.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Sql
+    class AzureRM
+      # Sql Server Collection for Firewall Rules Service
+      class FirewallRules < Fog::Collection
+        attribute :resource_group
+        attribute :server_name
+        model FirewallRule
+
+        def all
+          requires :resource_group, :server_name
+
+          firewall_rules = []
+          service.list_firewall_rules(resource_group, server_name).each do |firewall_rule|
+            firewall_rules << FirewallRule.parse(firewall_rule)
+          end
+          load(firewall_rules)
+        end
+
+        def get(resource_group, server_name, rule_name)
+          firewall_rule = service.get_firewall_rule(resource_group, server_name, rule_name)
+          firewall_rule_obj = FirewallRule.new(service: service)
+          firewall_rule_obj.merge_attributes(FirewallRule.parse(firewall_rule))
+        end
+      end
+    end
+  end
+end